折れ線近似による計算

確率面積を試しに折れ線近似により計算してみる。

各時間$t$において、

¥begin{equation}
z_{t}:=x_{t}+y_{t}i
¥end{equation}
とする。
面積を¥¥
¥[
A(z_{t+1};z_{t}):=
¥begin{pmatrix}
x_{t+1} & y_{t+1} ¥¥
x_{t+1}-x_{t} & y_{t+1}-y_{t}
¥end{pmatrix}
¥]
と定義した行列の行列式として、
¥begin{equation}
a(z_{t+1};z_{t}):=det(A(z_{t+1};z_{t}))
¥end{equation}
とする。¥¥
¥[
¥Delta x_{t}:=x_{t+1}-x_{t}
¥]
¥[
¥Delta y_{t}:=y_{t+1}-y_{t}
¥]
とすると、定義より、
¥begin{equation}
a(z_{t+1};z_{t})=det(
¥begin{pmatrix}
¥sum_{s=0}^{t}¥Delta x_{s}& ¥sum_{s=0}^{t}¥Delta y_{s} ¥¥
¥Delta x_{t} & ¥Delta y_{t}
¥end{pmatrix}
)
=¥¥
¥sum_{s=0}^{t}
det(
¥begin{pmatrix}
¥Delta x_{s} & ¥Delta y_{s} ¥¥
¥Delta x_{t} & ¥Delta y_{t} ¥¥
¥end{pmatrix}
)
¥end{equation}
となる。¥¥
よって、$0$と$z=(x,y)$を時刻Nで結ぶpath
¥[
w=¥{z_{0}=0,z_{1},¥ldots,z_{N}=z¥}
¥]
の面積は、
¥begin{equation}
S(w):=¥sum_{t=0}^{N}a(z_{t+1};z_{t}) ¥¥
=¥sum_{t=0}^{N}¥sum_{s=0}^{t}det(
¥begin{pmatrix}
¥Delta x_{s} & ¥Delta y_{s} ¥¥
¥Delta x_{t} & ¥Delta y_{t} ¥¥
¥end{pmatrix}
)
¥end{equation}
となる。¥¥
ここで、pathの動きを動きの方向によって符号化する。¥¥
¥[
(1,1),(-1,1),(-1,-1),(1,-1)
¥]
をそれぞれ1,2,3,4とラベル付けすると、¥¥
原点を出発するpathは、¥¥
1,2,3,4の組み合わせで符号化される。
¥[
¥epsilon(1,2):=det
¥begin{pmatrix}
1 & 1 ¥¥
-1 & 1 ¥¥
¥end{pmatrix}
=2
¥]
とすると、¥¥
¥[
¥epsilon(1,2)=¥epsilon(2,3)=¥epsilon(3,4)=¥epsilon(4,1)=2
¥]
¥[
¥epsilon(2,1)=¥epsilon(3,2)=¥epsilon(4,3)=¥epsilon(1,4)=-2
¥]
となり、それ以外の組み合わせは0となる。
¥[
w=¥{w_0,w_1,¥ldots,w_{N-1}¥}
¥]
と符号化して、
¥begin{equation}
S(w)
=¥sum_{t=0}^{N-1}¥sum_{s=0}^{t}¥epsilon(w_{s},w_{t})
¥end{equation}
となる。¥¥
ペア
¥[
{1,2},{2,3},{3,4},{4,1}
¥]
について各項を分けて、
¥[
S(w)=S_{12}(w)+S_{23}(w)+S_{34}(w)+S_{41}(w)
¥]
とする。

1,2,3,4のwにおける出現回数を
¥[
N_{1},N_{2},N_{3},N_{4}
¥]
として、
¥[
z=x+yi
¥]
とすると、
¥begin{equation}
N=N_{1}+N_{2}+N_{3}+N_{4}
¥end{equation}
で、
¥[
(x,y)=N_{1}(1,1)+N_{2}(-1,1)+N_{3}(-1,-1)+N_{4}(1,-1)
¥]
より、
¥[
(x,y)=
(N_{1}-N_{2}-N_{3}+N_{4}, N_{1}+N_{2}-N_{3}-N_{4})
¥]
となる。
¥begin{equation}
¥frac{x+y}{2}=N_{1}-N_{3}
¥end{equation}
¥begin{equation}
¥frac{x-y}{2}=-N_{2}+N_{4}
¥end{equation}
であるから、¥¥
$N$および終点$(x,y)$をfixした条件のもと、pathは、
¥[
N_{1},N_{2},N_{3},N_{4}
¥]
の出現回数(これは、$N_{1}$を指定すると他は決まる)を決めて、¥¥
さらに順番を指定したものになる。¥¥

$A=N_{1},B=N_{2}$
を与えて、
$q^{S_{12}(w)}$
の総和を求めてみる。¥¥
それには、{1,2}からなる列
¥[
p=¥{p1,p2,¥ldots,p_{M}¥}
¥]
について、¥¥
縦$A$、横$B$の箱の左下から、¥¥
1が出現したら右へ、2が出現したら上へ進む、¥¥
というルールで線を書くと、¥¥
出現回数が決まっているから、¥¥
箱の右上にたどり着くが、¥¥
その線で分けられた左上の面積-右下の部分の面積 ¥¥
が${S_{12}(p)}$に対応する。¥¥
よって、
¥[
¥sum_{p}q^{S_{12}(p)}
=¥frac{q^{AB+1} - q^{-(AB+1)}}{q-q^{-1}}
¥]
となる。

このことから、
$N$および終点$z=(x,y)$をfixした条件のもと、
¥[
¥bf{E}[¥rm q^{S(w)} | w(N)=z]=¥sum_{w}q^{S(w)}
¥]
は、
¥begin{equation}
¥sum_{w}q^{S(w)}=¥sum_{N_{1},N_{2},N_{3},N_{4}}
¥frac{q^{N_{1}N_{2}+1} - q^{-(N_{1}N_{2}+1)}}{q-q^{-1}}
¥frac{q^{N_{2}N_{3}+1} - q^{-(N_{2}N_{3}+1)}}{q-q^{-1}}
¥frac{q^{N_{3}N_{4}+1} - q^{-(N_{3}N_{4}+1)}}{q-q^{-1}}
¥frac{q^{N_{4}N_{1}+1} - q^{-(N_{4}N_{1}+1)}}{q-q^{-1}}
¥end{equation}
となる。

ここから、無限積による表示にたどり着くには、まだ一工夫必要のようだ。

箱玉系その4

* 周期的箱玉系
BETHE ANSATZ AND INVERSE SCATTERING TRANSFORM IN A PERIODIC BOX-BALL SYSTEM
(http://arxiv.org/abs/math/0602481)
には、周期的箱玉系に関する逆散乱の話がされている。

N-aolitonの場合は、N個の通常２重点を持つ射影直線の
generalizedJacobianの上の運動だった。
周期的KdVは超楕円曲線のJacobianの上の運動で、
両者は分岐点の移動による退化によって結びついていた。

- 箱玉系の場合、通常の箱玉系の運動と周期的箱玉系の運動を結びつける
空間の変形はあるのだろうか？
- 1-ソリトンを特異射影直線の上で見たとき、これをBerkovich空間上の幾何とみると、special fiberには自然に1-loopグラフがでてくる。
このグラフの意味でのJacobianの上で等速直線運動を考えると、
それは箱玉系と関係づけることができるだろうか？

ソリトンの超離散化

箱玉系では、超離散化した後に、ソリトンやタウ関数を考えていた。
では、
先にソリトンを超離散化するとどうなるか？
という疑問がわくが、
[Kdm]KP solitons and total positivity for the Grassmannian
(http://arxiv.org/abs/1106.0023)
では、N-ソリトンのタウ関数(すなわちWronskian)
を超離散化して、組み合わせ論的な対応をみている。
ここでの超離散化は、指数和で書かれているタウ関数についてのもので、
指数の肩の最大値をとる場所を見ている。
そうすると、区分的線形関数が現れ、変化を区切る直線、
すなわちtropical varietyがでてくる。
そのような超離散化をうまく進めるために、total positivityが有効である。
タウ関数をBinet-Cauchyの公式で展開してそれぞれの項をみるので、
そのすべての係数が正、という性質がtotal positivityになり、
有限次元のGrassmannianのtotal positive partへの埋め込み
と
超離散化の結果の離散構造の対応
ができる。

ただ、
ここででてきた離散構造(generic fiber)
と、
箱玉系における離散構造(special fiber)
との間には、双方でヤング図形が現れるものの意味が異なり、
そのままでは直接的な対応がない。
そもそも、
N-ソリトンではWronskianが定義されるためには、
振幅はすべて異なっているが、
箱玉系では、同じ振幅のソリトンが複数個存在していて、
後者のヤング図形は振幅の個数を表している。
そのため、振幅のクラスタリングを考える必要があるとも思える。

----
ベーテ仮説と組合せ論6.4 超離散広田三輪方程式の証明
の項では、
N-ソリトン解と次のように対比していた。
(型1^L,n=1でA_{1}^{1}の場合のみ見る。)
ソリトンの個数N<->μのヤング図の台の深さをN
時間発展の変数(t1,t3,...)<->{1,...,N}
それぞれのstringをソリトンと見なすので、
(μ_{i},J_{i})(i=1,...,N)に対して
(ソリトンの数理§3.3頂点作用素の記号で)ソリトン解で用いられる(p,q,ξ)を、対応させる。
ただ、[Kdm]では、時間変数として3変数(x,y,t)を取って議論しているので、
組み合わせの対象が異なるのは確か。

箱玉系その3

ベーテ仮説と組合せ論1.3の例で見てみると、確かに等速直線運動をしている。

python soliton_config.py
path [ 20 ]: [1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 2, 1, 2, 2, 1, 1, 1, 2, 2, 1]
type: 20
4 *** 0
6 ** 5
6 ** 4
12 * 7

path [ 21 ]: [1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 2, 1, 1, 2, 2, 1, 1, 1, 2, 2]
type: 21
5 *** 3
7 ** 7
7 ** 6
13 * 8

path [ 23 ]: [1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2, 2, 1, 1, 2, 2, 1, 1, 1, 2, 2]
type: 23
7 *** 6
9 ** 9
9 ** 8
15 * 9

path [ 25 ]: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 2, 2, 1, 1, 2, 2, 2, 1, 1, 2, 2]
type: 25
9 *** 9
11 ** 11
11 ** 10
17 * 10

path [ 28 ]: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 2, 2, 1, 1, 1, 2, 2, 1, 1, 2, 2, 2]
type: 28
12 *** 12
14 ** 13
14 ** 12
20 * 11

path [ 31 ]: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 2, 1, 1, 1, 2, 2, 1, 1, 1, 2, 2, 2]
type: 31
15 *** 15
17 ** 15
17 ** 14
23 * 12

path [ 34 ]: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 2, 2, 1, 1, 1, 1, 2, 2, 2]
type: 34
18 *** 18
20 ** 17
20 ** 16
26 * 13

path [ 37 ]: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 2, 2, 1, 1, 1, 1, 1, 2, 2, 2]
type: 37
21 *** 21
23 ** 19
23 ** 18
29 * 14

#!/usr/bin/python

class YoungDiagram:
    def __init__(self):
        self.shape = []
    def depth(self):
        return len(self.shape)
    def total(self):
        return sum(self.shape)
    def transpose_shape(self):
        list = []
        for i in range(self.shape[0]):
            list.append(len(filter(lambda x: x>i, self.shape)))
        return list
    def first(self):
        if len(self.shape) == 0:
            return 0
        return self.shape[0]
    def m(self,j):
        return len(filter(lambda x: x == j, self.shape))
    def q(self, j):
        if len(self.shape) == 0:
            return 0
        s = 0
        for k in range(self.shape[0]+1):
            s += min(j, k)*self.m(k)
        return s
    def __str__(self):
        for i in self.shape:
            print "\t","*"*i
        return ""

# n=1 type(1^L) only
class Configuration:
    def __init__(self):
        self.type = 0
        self.u1 = YoungDiagram()
        self.update_vacancy()
        self.rigging = []
    def p(self, j):
        return self.type - 2 * self.u1.q(j)
    def update_vacancy(self):
        self.vacancy = []
        list = []
        for j in range(self.u1.first()+1):
            list.append(self.p(j))
        for j in self.u1.shape:
            self.vacancy.append(list[j])
    def sort_rigging(self):
        i = 0
        while i < len(self.u1.shape):
            l = len(filter(lambda x: x == self.u1.shape[i], self.u1.shape))
            self.rigging[i:i+l] = sorted(self.rigging[i:i+l], reverse=True)
            i += l
    def singular_test(self):
        list = []
        for i in range(len(self.vacancy)):
            list.append(self.vacancy[i] == self.rigging[i])
        return list
    def add_1(self):
        self.type += 1
        self.update_vacancy()
    def add_2(self):
        list = self.singular_test()
        try:
            i = list.index(True) # index of a singular string
            self.type += 1
            self.u1.shape[i] += 1 # extend the singular string
            m = map(lambda x: x < self.u1.shape[i] , self.u1.shape)
            try:
                j = m.index(True)
                if j < i:
                    self.u1.shape[i],self.u1.shape[j] =self.u1.shape[j],self.u1.shape[i]
                    self.rigging[i],self.rigging[j] = self.rigging[j],self.rigging[i]
                    i = j
            except ValueError:
                0 #nothing to do
            self.update_vacancy()
            self.rigging[i] = self.vacancy[i]
        except ValueError: # no singular string, add 1-string
            self.type += 1
            self.u1.shape.append(1)
            self.update_vacancy()
            try:
                i = self.u1.shape.index(1)
                self.rigging.insert(i, self.vacancy[-1])
            except ValueError:
                self.rigging.append(self.vacancy[-1])
        self.sort_rigging()
    def add(self, list):
        c = 0
        self.path = list
        for v in list:
            if v == 1:
                self.add_1()
            else:
                self.add_2()
            c+= 1
    def __str__(self):
        print "path [", len(self.path),"]:",self.path
        print "type:",self.type
        for i in range(len(self.vacancy)):
            print "\t",self.vacancy[i], "*"*self.u1.shape[i], self.rigging[i]
        return ""
def move(l, ball):
    while True: 
        try:
            n = l.index(ball)
            l[n] = 'done'
            m = l[n+1:]
            try:
                n2 = m.index(1)
                m[n2] = 'new'
            except ValueError:
                m.append('new')
            l[n+1:] = m
        except ValueError:
            break
    for i in range(len(l)):
        if l[i] == 'new':
            l[i] = ball
        elif l[i] == 'done':
            l[i] = 1        

##test
l=[1,1,1,2,2,2,1,1,1,1,2,1,2,2,1,1,1,2,2,1]

for i in range(8):
    c = Configuration()
    c.add(l)
    print c
    move(l, 2)

箱玉系その2

ベーテ仮説と組合せ論 例5.5(p107)のパスとrigged configuration
の対応をチェックするためのpythonスクリプト

前回のスクリプトと合わせると、
ソリトン->rigged configuration
による時間発展の線形化が確認できるはず。(後日に記載予定)

python soliton_config.py
path [1, 2, 1, 2, 1, 1, 2, 2]
type: 8
0 ** 0
2 * 0
2 * 0

path [1, 2, 1, 1, 2, 1, 2, 2]
type: 8
0 ** 0
2 * 1
2 * 0

path [1, 2, 1, 1, 2, 2, 1, 2]
type: 8
0 ** 0
2 * 2
2 * 0

path [1, 1, 2, 1, 2, 1, 2, 2]
type: 8
0 ** 0
2 * 1
2 * 1

path [1, 1, 2, 1, 2, 2, 1, 2]
type: 8
0 ** 0
2 * 2
2 * 1

path [1, 1, 2, 2, 1, 2, 1, 2]
type: 8
0 ** 0
2 * 2
2 * 2

#!/usr/bin/python

class YoungDiagram:
    def __init__(self):
        self.shape = []
    def __init__(self, shape):
        self.shape = shape
    def depth(self):
        return len(self.shape)
    def total(self):
        return sum(self.shape)
    def transpose_shape(self):
        list = []
        for i in range(self.shape[0]):
            list.append(len(filter(lambda x: x>i, self.shape)))
        return list
    def first(self):
        if len(self.shape) == 0:
            return 0
        return self.shape[0]
    def m(self,j):
        return len(filter(lambda x: x == j, self.shape))
    def q(self, j):
        if len(self.shape) == 0:
            return 0
        s = 0
        for k in range(self.shape[0]+1):
            s += min(j, k)*self.m(k)
        return s
    def __str__(self):
        for i in self.shape:
            print "\t","*"*i
        return ""

# n=1 type(1^L) only
class Configuration:
    def __init__(self, type, shape):
        self.type = type
        self.u1 = YoungDiagram(shape)
        self.update_vacancy()
        self.rigging = []
    def p(self, j):
        return self.type - 2 * self.u1.q(j)
    def update_vacancy(self):
        self.vacancy = []
        list = []
        for j in range(self.u1.first()+1):
            list.append(self.p(j))
        for j in self.u1.shape:
            self.vacancy.append(list[j])
    def singular_test(self):
        list = []
        for i in range(len(self.vacancy)):
            list.append(self.vacancy[i] == self.rigging[i])
        return list
    def add_1(self):
        self.type += 1
        self.update_vacancy()
    def add_2(self):
        list = self.singular_test()
        try:
            i = list.index(True) # index of a singular string
            self.type += 1
            self.u1.shape[i] += 1 # extend the singular string
            self.update_vacancy()
            self.rigging[i] = self.vacancy[i]
        except ValueError: # no singular string, add 1-string
            self.type += 1
            self.u1.shape.append(1)
            self.update_vacancy()
            try:
                i = self.u1.shape.index(1)
                self.rigging.insert(i, self.vacancy[-1])
            except ValueError:
                self.rigging.append(self.vacancy[-1])
    def add(self, list):
        self.path = list
        for v in list:
            if v == 1:
                self.add_1()
            else:
                self.add_2()
    def __str__(self):
        print "path", self.path
        print "type:",self.type
        for i in range(len(self.vacancy)):
            print "\t",self.vacancy[i], "*"*self.u1.shape[i], self.rigging[i]
        return ""
##test
c = Configuration(0, [])
c.add([1,2,1,2,1,1,2,2])
print c
c = Configuration(0, [])
c.add([1,2,1,1,2,1,2,2])
print c
c = Configuration(0, [])
c.add([1,2,1,1,2,2,1,2])
print c
c = Configuration(0, [])
c.add([1,1,2,1,2,1,2,2])
print c
c = Configuration(0, [])
c.add([1,1,2,1,2,2,1,2])
print c
c = Configuration(0, [])
c.add([1,1,2,2,1,2,1,2])
print c

箱玉系

n色の箱玉系の動作確認のためのpythonスクリプト

結果は、ベーテ仮説と組合わせ論p134の例になる
python soliton.py
[2, 2, 2, 1, 1, 1, 1, 2]
[1, 1, 1, 2, 2, 2, 1, 1, 2]
[1, 1, 1, 1, 1, 1, 2, 2, 1, 2, 2]
[1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 2, 2, 2]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 2, 2]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 2, 2]

2色の例7.4については、
[1, 3, 2, 2, 1, 1, 3, 2]
[1, 1, 1, 1, 3, 2, 2, 1, 3, 2]
[1, 1, 1, 1, 1, 1, 1, 3, 2, 1, 3, 2, 2]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 2, 1, 1, 3, 2, 2]

#!/usr/bin/python

def move(l, ball):
    while True: 
        try:
            n = l.index(ball)
            l[n] = 'done'
            m = l[n+1:]
            try:
                n2 = m.index(1)
                m[n2] = 'new'
            except ValueError:
                m.append('new')
            l[n+1:] = m
        except ValueError:
            break
    for i in range(len(l)):
        if l[i] == 'new':
            l[i] = ball
        elif l[i] == 'done':
            l[i] = 1  
#p134
l = [2,2,2,1,1,1,1,2]
print l
for i in range(5):
    move(l, 2)
    print l
#p137 例7.4
l = [1,3,2,2,1,1,3,2]
print l
for i in range(3):
    move(l, 3)
    move(l, 2)
    print l

トーリック多様体

* トーリック多様体上の直線束の計量
Arithmetic geometry of toric varieties. Metrics, measures and heights
(http://arxiv.org/abs/1105.5584)
に、トーリック多様体上の直線束の計量と、
Legendre変換の話がまとまっている。
とくに有限素点の場合も書かれている。

* トーリック多様体の特異点解消
トーリックの世界
(http://www.math.kyoto-u.ac.jp/~fujino/TW-HP.pdf)
に特異点解消のコンパクトな説明があった。

* 疑問点
- トーリック多様体上のトーラス作用同変なリーマン計量から定まるブラウン運動
、あるいはラプラシアン、を扇の言葉で書くこと。
- 特異点を持つ場合にブラウン運動が定義できるか？
その場合、同変ブローアップ上のブラウン運動との違いはなにか？

- LDPの話をトーリック多様体上で展開できるか？
まずは、random gaussian analytic function
が定義できることをみなくてはならない。
Random zeros on complex manifolds: conditional expectations
(http://arxiv.org/abs/1005.4166)
次に、ケーラー計量、Bergman核について知っていないといけない。
BERGMAN METRICS AND GEODESICS IN THE SPACE OF KA ̈HLER METRICS ON TORIC VARIETIES
(http://mathnt.mat.jhu.edu/zelditch/Preprints/geotoricrevMar1.pdf)