Sm1 OX Server マニュアル

Edition : auto generated by oxgentexi on 23 February 2009

OpenXM.org

SM1 函数

この節では sm1 の ox サーバ ox_sm1_forAsir とのインタフェース関数を解説する. これらの関数はファイル `sm1.rr' で定義されている. `sm1.rr' は `$(OpenXM_HOME)/lib/asir-contrib' にある. システム sm1 は微分作用素環で計算するためのシステムである. 計算代数幾何のいろいろな不変量の計算が微分作用素の計算に帰着する. sm1 についての文書は OpenXM/doc/kan96xx にある.

とこに断りがないかぎりこの節のすべての関数は, 有理数係数の式を入力としてうけつけない. すべての多項式の係数は整数でないといけない. 


[283] sm1.deRham([x*(x-1),[x]]);
[1,2]

The author of sm1 : Nobuki Takayama, takayama@math.sci.kobe-u.ac.jp
The author of sm1 packages : Toshinori Oaku, oaku@twcu.ac.jp
Reference: [SST] Saito, M., Sturmfels, B., Takayama, N., Grobner Deformations of Hypergeometric Differential Equations, 1999, Springer. http://www.math.kobe-u.ac.jp/KAN

ox_sm1_forAsir サーバ

ox_sm1_forAsir

ox_sm1_forAsir
:: asir のための sm1 サーバ.

函数一覧

sm1.start

sm1.start()
:: localhost で ox_sm1_forAsir をスタートする.
return
整数 
[260] ord([da,a,db,b]);
[da,a,db,b,dx,dy,dz,x,y,z,dt,ds,t,s,u,v,w, 
......... omit ..................
]
[261] a*da;
a*da
[262] cc*dcc;
dcc*cc
[263] sm1.mul(da,a,[a]);     
a*da+1                  
[264] sm1.mul(a,da,[a]);
a*da
参照
ox_launch, sm1.push_int0, sm1.push_poly0, ord

sm1.sm1

sm1.sm1(p,s)
:: サーバ sm1 にコマンド列 s を実行してくれるようにたのむ.
return
なし
p
数
s
文字列 
[261] sm1.sm1(0," ( (x-1)^2 ) . ");
0
[262] ox_pop_string(0);
x^2-2*x+1
[263] sm1.sm1(0," [(x*(x-1))  [(x)]] deRham ");
0
[264] ox_pop_string(0);
[1 , 2]
参照
sm1.start, ox_push_int0, sm1.push_poly0, sm1.get_Sm1_proc().

sm1.push_int0

sm1.push_int0(p,f)
:: オブジェクト f を識別子 p のサーバへ送る.
return
なし
p
数
f
オブジェクト 
[219] P=sm1.start();
0
[220] sm1.push_int0(P,x*dx+1);
0
[221] A=ox_pop_cmo(P);
x*dx+1
[223] type(A);
7   (string)

[271] sm1.push_int0(0,[x*(x-1),[x]]);
0
[272] ox_execute_string(0," deRham ");
0
[273] ox_pop_cmo(0);
[1,2]
Reference
ox_push_cmo

sm1.gb

sm1.gb([f,v,w]|proc=p,sorted=q,dehomogenize=r)
:: v 上の微分作用素環において f のグレブナ基底を計算する.
sm1.gb_d([f,v,w]|proc=p)
:: v 上の微分作用素環において f のグレブナ基底を計算する. 結果を分散多項式のリストで戻す.
return
リスト
p, q, r
数
f, v, w
リスト 
[293] sm1.gb([[x*dx+y*dy-1,x*y*dx*dy-2],[x,y]]);
[[x*dx+y*dy-1,y^2*dy^2+2],[x*dx,y^2*dy^2]]

上の例において, 

[294] sm1.gb([[dx^2+dy^2-4,dx*dy-1],[x,y],[[dx,50,dy,2,x,1]]]);
[[dx+dy^3-4*dy,-dy^4+4*dy^2-1],[dx,-dy^4]]

上の例において二つのモノミアル 

[294] F=sm1.gb([[dx^2+dy^2-4,dx*dy-1],[x,y],[[dx,50,dy,2,x,1]]]|sorted=1);
      map(print,F[2][0])$
      map(print,F[2][1])$

[595]
   sm1.gb([["dx*(x*dx +y*dy-2)-1","dy*(x*dx + y*dy -2)-1"],
             [x,y],[[dx,1,x,-1],[dy,1]]]);

[[x*dx^2+(y*dy-h^2)*dx-h^3,x*dy*dx+y*dy^2-h^2*dy-h^3,h^3*dx-h^3*dy],
 [x*dx^2+(y*dy-h^2)*dx,x*dy*dx+y*dy^2-h^2*dy-h^3,h^3*dx]]

[596]
   sm1.gb_d([["dx (x dx +y dy-2)-1","dy (x dx + y dy -2)-1"],
             "x,y",[[dx,1,x,-1],[dy,1]]]);
[[[e0,x,y,H,E,dx,dy,h],
 [[0,-1,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,0],
  [0,1,1,1,1,1,1,0],[0,0,0,0,0,0,-1,0],[0,0,0,0,0,-1,0,0],
  [0,0,0,0,-1,0,0,0],[0,0,0,-1,0,0,0,0],[0,0,-1,0,0,0,0,0],
  [0,0,0,0,0,0,0,1]]],
[[(1)*<<0,0,1,0,0,1,1,0>>+(1)*<<0,1,0,0,0,2,0,0>>+(-1)*<<0,0,0,0,0,1,0,2>>+(-1)*
<<0,0,0,0,0,0,0,3>>,(1)*<<0,0,1,0,0,0,2,0>>+(1)*<<0,1,0,0,0,1,1,0>>+(-1)*<<0,0,0
,0,0,0,1,2>>+(-1)*<<0,0,0,0,0,0,0,3>>,(1)*<<0,0,0,0,0,1,0,3>>+(-1)*<<0,0,0,0,0,0
,1,3>>],
 [(1)*<<0,0,1,0,0,1,1,0>>+(1)*<<0,1,0,0,0,2,0,0>>+(-1)*<<0,0,0,0,0,1,0,2>>,(1)*<
<0,0,1,0,0,0,2,0>>+(1)*<<0,1,0,0,0,1,1,0>>+(-1)*<<0,0,0,0,0,0,1,2>>+(-1)*<<0,0,0
,0,0,0,0,3>>,(1)*<<0,0,0,0,0,1,0,3>>]]]
参照
sm1.reduction, sm1.rat_to_p

sm1.deRham

sm1.deRham([f,v]|proc=p)
:: 空間 C^n - (the zero set of f=0) のドラームコホモロジ群の次元を計算してくれるようにサーバに頼む.
return
リスト
p
数
f
文字列 または 多項式
v
リスト 
[332] sm1.deRham([x^3-y^2,[x,y]]);
[1,1,0]
[333] sm1.deRham([x*(x-1),[x]]);
[1,2]
参照
sm1.start, deRham (sm1 command)
Algorithm:
Oaku, Takayama, An algorithm for de Rham cohomology groups of the complement of an affine variety via D-module computation, Journal of pure and applied algebra 139 (1999), 201--233.

sm1.hilbert

sm1.hilbert([f,v]|proc=p)
:: 多項式の集合 f のヒルベルト多項式を計算する.
hilbert_polynomial(f,v)
:: 多項式の集合 f のヒルベルト多項式を計算する.
return
多項式
p
数
f, v
リスト 

[346] load("katsura")$
[351] A=hilbert_polynomial(katsura(5),[u0,u1,u2,u3,u4,u5]);
32


[279] load("katsura")$
[280] A=gr(katsura(5),[u0,u1,u2,u3,u4,u5],0)$
[281] dp_ord();
0
[282] B=map(dp_ht,map(dp_ptod,A,[u0,u1,u2,u3,u4,u5]));
[(1)*<<1,0,0,0,0,0>>,(1)*<<0,0,0,2,0,0>>,(1)*<<0,0,1,1,0,0>>,(1)*<<0,0,2,0,0,0>>,
 (1)*<<0,1,1,0,0,0>>,(1)*<<0,2,0,0,0,0>>,(1)*<<0,0,0,1,1,1>>,(1)*<<0,0,0,1,2,0>>,
 (1)*<<0,0,1,0,2,0>>,(1)*<<0,1,0,0,2,0>>,(1)*<<0,1,0,1,1,0>>,(1)*<<0,0,0,0,2,2>>,
  (1)*<<0,0,1,0,1,2>>,(1)*<<0,1,0,0,1,2>>,(1)*<<0,1,0,1,0,2>>,(1)*<<0,0,0,0,3,1>>,
  (1)*<<0,0,0,0,4,0>>,(1)*<<0,0,0,0,1,4>>,(1)*<<0,0,0,1,0,4>>,(1)*<<0,0,1,0,0,4>>,
 (1)*<<0,1,0,0,0,4>>,(1)*<<0,0,0,0,0,6>>]
[283] C=map(dp_dtop,B,[u0,u1,u2,u3,u4,u5]);
[u0,u3^2,u3*u2,u2^2,u2*u1,u1^2,u5*u4*u3,u4^2*u3,u4^2*u2,u4^2*u1,u4*u3*u1,
 u5^2*u4^2,u5^2*u4*u2,u5^2*u4*u1,u5^2*u3*u1,u5*u4^3,u4^4,u5^4*u4,u5^4*u3,
 u5^4*u2,u5^4*u1,u5^6]
[284] sm1.hilbert([C,[u0,u1,u2,u3,u4,u5]]);
32
参照
sm1.start, sm1.gb, longname

sm1.genericAnn

sm1.genericAnn([f,v]|proc=p)
:: f^s のみたす微分方程式全体をもとめる. v は変数のリストである. ここで, s は v[0] であり, f は変数 rest(v) 上の多項式である.
return
リスト
p
数
f
多項式
v
リスト 
[595] sm1.genericAnn([x^3+y^3+z^3,[s,x,y,z]]);
[-x*dx-y*dy-z*dz+3*s,z^2*dy-y^2*dz,z^2*dx-x^2*dz,y^2*dx-x^2*dy]
参照
sm1.start

sm1.wTensor0

sm1.wTensor0([f,g,v,w]|proc=p)
:: f と g の D-module としての 0 次テンソル積を 計算する.
return
リスト
p
数
f, g, v, w
リスト 
[258]  sm1.wTensor0([[x*dx -1, y*dy -4],[dx+dy,dx-dy^2],[x,y],[1,2]]);
[[-y*x*dx-y*x*dy+4*x+y],[5*x*dx^2+5*x*dx+2*y*dy^2+(-2*y-6)*dy+3],
 [-25*x*dx+(-5*y*x-2*y^2)*dy^2+((5*y+15)*x+2*y^2+16*y)*dy-20*x-8*y-15],
 [y^2*dy^2+(-y^2-8*y)*dy+4*y+20]]

sm1.reduction

sm1.reduction([f,g,v,w]|proc=p)
::
return
リスト
f
多項式
g, v, w
リスト
p
数 (ox_sm1 のプロセス番号) 
[259] sm1.reduction([x^2+y^2-4,[y^4-4*y^2+1,x+y^3-4*y],[x,y]]);
[x^2+y^2-4,1,[0,0],[y^4-4*y^2+1,x+y^3-4*y]]
[260] sm1.reduction([x^2+y^2-4,[y^4-4*y^2+1,x+y^3-4*y],[x,y],[[x,1]]]);
[0,1,[-y^2+4,-x+y^3-4*y],[y^4-4*y^2+1,x+y^3-4*y]]
参照
sm1.start, d_true_nf

sm1.xml_tree_to_prefix_string

sm1.xml_tree_to_prefix_string(s|proc=p)
:: XML で書かれた OpenMath の木表現 s を前置記法になおす.
return
String
p
Number
s
String 
[263] load("om");
1
[270] F=om_xml(x^4-1);
control: wait OX
Trying to connect to the server... Done.
<OMOBJ><OMA><OMS name="plus" cd="basic"/><OMA>
<OMS name="times" cd="basic"/><OMA>
<OMS name="power" cd="basic"/><OMV name="x"/><OMI>4</OMI></OMA>
<OMI>1</OMI></OMA><OMA><OMS name="times" cd="basic"/><OMA>
<OMS name="power" cd="basic"/><OMV name="x"/><OMI>0</OMI></OMA>
<OMI>-1</OMI></OMA></OMA></OMOBJ>
[271] sm1.xml_tree_to_prefix_string(F);
basic_plus(basic_times(basic_power(x,4),1),basic_times(basic_power(x,0),-1))
参照
om_*, OpenXM/src/OpenMath, eval_str

sm1.syz

sm1.syz([f,v,w]|proc=p)
:: v 上の微分作用素環において f の syzygy を計算する.
return
リスト
p
数
f, v, w
リスト 
[293] sm1.syz([[x*dx+y*dy-1,x*y*dx*dy-2],[x,y]]);
[[[y*x*dy*dx-2,-x*dx-y*dy+1]],    generators of the syzygy
 [[[x*dx+y*dy-1],[y^2*dy^2+2]],   grobner basis
  [[1,0],[y*dy,-1]],              transformation matrix
 [[y*x*dy*dx-2,-x*dx-y*dy+1]]]]

[294]sm1.syz([[x^2*dx^2+x*dx+y^2*dy^2+y*dy-4,x*y*dx*dy-1],[x,y],[[dx,-1,x,1]]]);
[[[y*x*dy*dx-1,-x^2*dx^2-x*dx-y^2*dy^2-y*dy+4]], generators of the syzygy
 [[[x^2*dx^2+h^2*x*dx+y^2*dy^2+h^2*y*dy-4*h^4],[y*x*dy*dx-h^4], GB
  [h^4*x*dx+y^3*dy^3+3*h^2*y^2*dy^2-3*h^4*y*dy]],
 [[1,0],[0,1],[y*dy,-x*dx]],     transformation matrix
 [[y*x*dy*dx-h^4,-x^2*dx^2-h^2*x*dx-y^2*dy^2-h^2*y*dy+4*h^4]]]]

sm1.mul

sm1.mul(f,g,v|proc=p)
:: sm1サーバ に f かける g を v 上の微分作用素環でやってくれるように頼む.
return
多項式またはリスト
p
数
f, g
多項式またはリスト
v
リスト 
[277] sm1.mul(dx,x,[x]);
x*dx+1
[278] sm1.mul([x,y],[1,2],[x,y]);
x+2*y
[279] sm1.mul([[1,2],[3,4]],[[x,y],[1,2]],[x,y]);
[[x+2,y+4],[3*x+4,3*y+8]]

sm1.distraction

sm1.distraction([f,v,x,d,s]|proc=p)
:: sm1 に f の distraction を計算してもらう.
return
リスト
p
数
f
多項式
v,x,d,s
リスト 
[280] sm1.distraction([x*dx,[x],[x],[dx],[x]]);
x
[281] sm1.distraction([dx^2,[x],[x],[dx],[x]]);
x^2-x
[282] sm1.distraction([x^2,[x],[x],[dx],[x]]);
x^2+3*x+2
[283] fctr(@);
[[1,1],[x+1,1],[x+2,1]]
[284] sm1.distraction([x*dx*y+x^2*dx^2*dy,[x,y],[x],[dx],[x]]);
(x^2-x)*dy+x*y
参照
distraction2(sm1),

sm1.gkz

sm1.gkz([A,B]|proc=p)
:: 行列 A とパラメータ B に付随した GKZ 系 (A-hypergeometric system) をもどす.
return
リスト
p
数
A, B
リスト 

[280] sm1.gkz([  [[1,1,1,1],[0,1,3,4]],  [0,2] ]);
[[x4*dx4+x3*dx3+x2*dx2+x1*dx1,4*x4*dx4+3*x3*dx3+x2*dx2-2,
 -dx1*dx4+dx2*dx3,-dx2^2*dx4+dx1*dx3^2,dx1^2*dx3-dx2^3,-dx2*dx4^2+dx3^3],
 [x1,x2,x3,x4]]

sm1.mgkz

sm1.mgkz([A,W,B]|proc=p)
:: 行列 A, weight W とパラメータ B に付随した modified GKZ 系 (A-hypergeometric system) をもどす.
return
リスト
p
数
A, W, B
リスト 

[280] sm1.mgkz([ [[1,2,3]], [1,2,1], [a/2]]);
[[6*x3*dx3+4*x2*dx2+2*x1*dx1-a,-x4*dx4+x3*dx3+2*x2*dx2+x1*dx1,
  -dx2+dx1^2,-x4^2*dx3+dx1*dx2],[x1,x2,x3,x4]]

Modified A-hypergeometric system for 
A=(1,2,3), w=(1,2,1), beta=(a/2).

sm1.appell1

sm1.appell1(a|proc=p)
:: F_1 または F_D に対応する方程式系を戻す.
return
リスト
p
数
a
リスト 

[281] sm1.appell1([1,2,3,4]);
[[((-x1+1)*x2*dx1-3*x2)*dx2+(-x1^2+x1)*dx1^2+(-5*x1+2)*dx1-3,
  (-x2^2+x2)*dx2^2+((-x1*x2+x1)*dx1-6*x2+2)*dx2-4*x1*dx1-4,
  ((-x2+x1)*dx1+3)*dx2-4*dx1],       equations
 [x1,x2]]                            the list of variables

[282] sm1.gb(@);
[[((-x2+x1)*dx1+3)*dx2-4*dx1,((-x1+1)*x2*dx1-3*x2)*dx2+(-x1^2+x1)*dx1^2
  +(-5*x1+2)*dx1-3,(-x2^2+x2)*dx2^2+((-x2^2+x1)*dx1-3*x2+2)*dx2
  +(-4*x2-4*x1)*dx1-4,
  (x2^3+(-x1-1)*x2^2+x1*x2)*dx2^2+((-x1*x2+x1^2)*dx1+6*x2^2
 +(-3*x1-2)*x2+2*x1)*dx2-4*x1^2*dx1+4*x2-4*x1],
 [x1*dx1*dx2,-x1^2*dx1^2,-x2^2*dx1*dx2,-x1*x2^2*dx2^2]]

[283] sm1.rank(sm1.appell1([1/2,3,5,-1/3]));
3

[285] Mu=2$ Beta = 1/3$
[287] sm1.rank(sm1.appell1([Mu+Beta,Mu+1,Beta,Beta,Beta]));
4

sm1.appell4

sm1.appell4(a|proc=p)
:: F_4 または F_C に対応する方程式系を戻す.
return
リスト
p
数
a
リスト 

[281] sm1.appell4([1,2,3,4]);
  [[-x2^2*dx2^2+(-2*x1*x2*dx1-4*x2)*dx2+(-x1^2+x1)*dx1^2+(-4*x1+3)*dx1-2,
  (-x2^2+x2)*dx2^2+(-2*x1*x2*dx1-4*x2+4)*dx2-x1^2*dx1^2-4*x1*dx1-2],
                                                              equations
    [x1,x2]]                                      the list of variables

[282] sm1.rank(@);
4

sm1.rank

sm1.rank(a|proc=p)
:: 微分方程式系 a の holonomic rank を戻す.
return
数
p
数
a
リスト 

[284]  sm1.gkz([  [[1,1,1,1],[0,1,3,4]],  [0,2] ]);
[[x4*dx4+x3*dx3+x2*dx2+x1*dx1,4*x4*dx4+3*x3*dx3+x2*dx2-2,
  -dx1*dx4+dx2*dx3, -dx2^2*dx4+dx1*dx3^2,dx1^2*dx3-dx2^3,-dx2*dx4^2+dx3^3],
 [x1,x2,x3,x4]]
[285] sm1.rrank(@);
4

[286]  sm1.gkz([  [[1,1,1,1],[0,1,3,4]],  [1,2]]);
[[x4*dx4+x3*dx3+x2*dx2+x1*dx1-1,4*x4*dx4+3*x3*dx3+x2*dx2-2,
 -dx1*dx4+dx2*dx3,-dx2^2*dx4+dx1*dx3^2,dx1^2*dx3-dx2^3,-dx2*dx4^2+dx3^3],
 [x1,x2,x3,x4]]
[287] sm1.rrank(@);
5

sm1.auto_reduce

sm1.auto_reduce(s|proc=p)
:: フラグ "AutoReduce" を s に設定.
戻り値
数
p
数
s
数

sm1.slope

sm1.slope(ii,v,f_filtration,v_filtration|proc=p)
:: 微分方程式系 ii の slope を戻す.
return
数
p
数
ii
リスト (方程式)
v
リスト (変数)
f_filtration
リスト (weight vector)
v_filtration
リスト (weight vector)

Algorithm: "A.Assi, F.J.Castro-Jimenez and J.M.Granger, How to calculate the slopes of a D-module, Compositio Math, 104, 1-17, 1996" をみよ. Slope の本来の定義では, 符号が負となるが, このプログラムは, Slope の絶対値を戻す. 


[284] A= sm1.gkz([  [[1,2,3]],  [-3] ]);

[285] sm1.slope(A[0],A[1],[0,0,0,1,1,1],[0,0,-1,0,0,1]);

[286] A2 = sm1.gkz([ [[1,1,1,0],[2,-3,1,-3]], [1,0]]);
     (* This is an interesting example given by Laura Matusevich, 
        June 9, 2001 *)

[287] sm1.slope(A2[0],A2[1],[0,0,0,0,1,1,1,1],[0,0,0,-1,0,0,0,1]);
参照
sm.gb

sm1.ahg

sm1.ahg(A)
: It idential with sm1.gkz(A).

sm1.bfunction

sm1.bfunction(F)
: It computes the global b-function of F.

Description:

It no longer calls sm1's original bfunction. Instead, it calls asir "bfct".

Algorithm:

M.Noro, Mathematical Software, icms 2002, pp.147--157.

Example: 

 sm1.bfunction(x^2-y^3);

sm1.call_sm1

sm1.call_sm1(F)
: It executes F on the sm1 server. See also sm1.

sm1.ecart_homogenize01Ideal

sm1.ecart_homogenize01Ideal(A)
: It (0,1)-homogenizes the ideal A[0]. Note that it is not an elementwise homogenization.

Example: 


 input1
   F=[(1-x)*dx+1]$ FF=[F,"x,y"]$
   sm1.ecart_homogenize01Ideal(FF);
 intput2
   F=sm1.appell1([1,2,3,4]);
   sm1.ecart_homogenize01Ideal(F);

sm1.ecartd_gb

sm1.ecartd_gb(A)
: It returns a standard basis of A by using a tangent cone algorithm. h[0,1](D)-homogenization is used. If the option rv="dp" (return_value="dp") is given, the answer is returned in distributed polynomials.

Example: 


 input1
   F=[2*(1-x-y)*dx+1,2*(1-x-y)*dy+1]$
   FF=[F,"x,y",[[dx,1,dy,1],[x,-1,y,-1]]]$
   sm1.ecartd_gb(FF);
 output1
   [[(-2*x-2*y+2)*dx+h,(-2*x-2*y+2)*dy+h],[(-2*x-2*y+2)*dx,(-2*x-2*y+2)*dy]]
 input2
   F=[2*(1-x-y)*dx+h,2*(1-x-y)*dy+h]$
   FF=[F,"x,y",[[dx,1,dy,1],[x,-1,y,-1,dx,1,dy,1]],["noAutoHomogenize",1]]$
   sm1.ecartd_gb(FF);

sm1.ecartd_gb_oxRingStructure

sm1.ecartd_gb_oxRingStructure()
: It returns the oxRingStructure of the most recent ecartd_gb computation.

sm1.ecartd_isSameIdeal_h

sm1.ecartd_isSameIdeal_h(F)
: Here, F=[II,JJ,V]. It compares two ideals II and JJ in h[0,1](D)_alg.

Example: 


 input
   II=[(1-x)^2*dx+h*(1-x)]$ JJ = [(1-x)*dx+h]$
   V=[x]$
   sm1.ecartd_isSameIdeal_h([II,JJ,V]);

sm1.ecartd_reduction

sm1.ecartd_reduction(F,A)
: It returns a reduced form of F in terms of A by using a tangent cone algorithm. h[0,1](D)-homogenization is used.

Example: 


 input
   F=[2*(1-x-y)*dx+h,2*(1-x-y)*dy+h]$
   FF=[F,"x,y",[[dx,1,dy,1],[x,-1,y,-1]]]$
   sm1.ecartd_reduction(dx+dy,FF);

sm1.ecartd_reduction_noh

sm1.ecartd_reduction_noh(F,A)
: It returns a reduced form of F in terms of A by using a tangent cone algorithm. h[0,1](D)-homogenization is NOT used. A[0] must not contain the variable h.

Example: 


      F=[2*(1-x-y)*dx+1,2*(1-x-y)*dy+1]$
        FF=[F,"x,y",[[dx,1,dy,1],[x,-1,y,-1]]]$
        sm1.ecartd_reduction_noh(dx+dy,FF);

sm1.ecartd_syz

sm1.ecartd_syz(A)
: It returns a syzygy of A by using a tangent cone algorithm. h[0,1](D)-homogenization is used. If the option rv="dp" (return_value="dp") is given, the answer is returned in distributed polynomials. The return value is in the format [s,[g,m,t]]. s is the generator of the syzygies, g is the Grobner basis, m is the translation matrix from the generators to g. t is the syzygy of g.

Example: 


 input1
   F=[2*(1-x-y)*dx+1,2*(1-x-y)*dy+1]$
   FF=[F,"x,y",[[dx,1,dy,1],[x,-1,y,-1]]]$
   sm1.ecartd_syz(FF);
  input2
   F=[2*(1-x-y)*dx+h,2*(1-x-y)*dy+h]$
   FF=[F,"x,y",[[dx,1,dy,1],[x,-1,y,-1,dx,1,dy,1]],["noAutoHomogenize",1]]$
   sm1.ecartd_syz(FF);

sm1.gb_oxRingStructure

sm1.gb_oxRingStructure()
: It returns the oxRingStructure of the most recent gb computation.

sm1.gb_reduction

sm1.gb_reduction(F,A)
: It returns a reduced form of F in terms of A by using a normal form algorithm. h[1,1](D)-homogenization is used.

Example: 


 input
   F=[2*(h-x-y)*dx+h^2,2*(h-x-y)*dy+h^2]$
   FF=[F,"x,y",[[dx,1,dy,1],[x,-1,y,-1,dx,1,dy,1]]]$
   sm1.gb_reduction((h-x-y)^2*dx*dy,FF);

sm1.gb_reduction_noh

sm1.gb_reduction_noh(F,A)
: It returns a reduced form of F in terms of A by using a normal form algorithm.

Example: 


 input
   F=[2*dx+1,2*dy+1]$
   FF=[F,"x,y",[[dx,1,dy,1]]]$
   sm1.gb_reduction_noh((1-x-y)^2*dx*dy,FF);

sm1.generalized_bfunction

sm1.generalized_bfunction(I,V,VD,W)
: It computes the generalized b-function (indicial equation) of I with respect to the weight W.

Description:

It no longer calls sm1's original function. Instead, it calls asir "generic_bfct".

Example: 

 sm1.generalized_bfunction([x^2*dx^2-1/2,dy^2],[x,y],[dx,dy],[-1,0,1,0]);

sm1.isSameIdeal_in_Dalg

sm1.isSameIdeal_in_Dalg(I,J,V)
: It compares two ideals I and J in D_alg (algebraic D with variables V, no homogenization).

Example: 


  Input1
    II=[(1-x)^2*dx+(1-x)]$ JJ = [(1-x)*dx+1]$ V=[x]$
    sm1.isSameIdeal_in_Dalg(II,JJ,V);

sm1.laplace

sm1.laplace(L,V,VL)
: It returns the Laplace transformation of L for VL. V is the list of space variables. The numbers in coefficients must not be rational with a non-1 denominator. cf. ptozp

Example: 


     L1=sm1.laplace(dt-(3*t^2-x),[x,t],[t,dt]);
     L2=sm1.laplace(dx+t,[x,t],[t,dt]);
     sm1.restriction([L1,L2],[t,x],[t] | degree=0);

sm1.restriction

sm1.restriction(I,V,R)
: It computes the restriction of I as a D-module to the set defined by R. V is the list of variables. When the optional variable degree=d is given, only the restrictions from 0 to d are computed. Note that, in case of vector input, RESTRICTION VARIABLES MUST APPEAR FIRST in the list of variable V. We are using wbfRoots to get the roots of b-functions, so we can use only generic weight vector for now.
sm1.restriction(I,V,R | degree=key0)
: This function allows optional variables degree

Algorithm:

T.Oaku and N.Takayama, math.AG/9805006, http://xxx.langl.gov

Example: 

 sm1.restriction([dx^2-x,dy^2-1],[x,y],[y]);

sm1.saturation

sm1.saturation(T)
: T = [I,J,V]. It returns saturation of I with respect to J^infty. V is a list of variables.

Example: 

 sm1.saturation([[x2^2,x2*x4, x2, x4^2], [x2,x4], [x2,x4]]);

sm1.ahg

sm1.ahg(A)
: It idential with sm1.gkz(A).

sm1.bfunction

sm1.bfunction(F)
: It computes the global b-function of F.

Description:

It no longer calls sm1's original bfunction. Instead, it calls asir "bfct".

Algorithm:

M.Noro, Mathematical Software, icms 2002, pp.147--157.

Example: 

 sm1.bfunction(x^2-y^3);

sm1.call_sm1

sm1.call_sm1(F)
: It executes F on the sm1 server. See also sm1.

sm1.ecart_homogenize01Ideal

sm1.ecart_homogenize01Ideal(A)
: It (0,1)-homogenizes the ideal A[0]. Note that it is not an elementwise homogenization.

Example: 


 input1
   F=[(1-x)*dx+1]$ FF=[F,"x,y"]$
   sm1.ecart_homogenize01Ideal(FF);
 intput2
   F=sm1.appell1([1,2,3,4]);
   sm1.ecart_homogenize01Ideal(F);

sm1.ecartd_gb

sm1.ecartd_gb(A)
: It returns a standard basis of A by using a tangent cone algorithm. h[0,1](D)-homogenization is used. If the option rv="dp" (return_value="dp") is given, the answer is returned in distributed polynomials.

Example: 


 input1
   F=[2*(1-x-y)*dx+1,2*(1-x-y)*dy+1]$
   FF=[F,"x,y",[[dx,1,dy,1],[x,-1,y,-1]]]$
   sm1.ecartd_gb(FF);
 output1
   [[(-2*x-2*y+2)*dx+h,(-2*x-2*y+2)*dy+h],[(-2*x-2*y+2)*dx,(-2*x-2*y+2)*dy]]
 input2
   F=[2*(1-x-y)*dx+h,2*(1-x-y)*dy+h]$
   FF=[F,"x,y",[[dx,1,dy,1],[x,-1,y,-1,dx,1,dy,1]],["noAutoHomogenize",1]]$
   sm1.ecartd_gb(FF);

sm1.ecartd_gb_oxRingStructure

sm1.ecartd_gb_oxRingStructure()
: It returns the oxRingStructure of the most recent ecartd_gb computation.

sm1.ecartd_isSameIdeal_h

sm1.ecartd_isSameIdeal_h(F)
: Here, F=[II,JJ,V]. It compares two ideals II and JJ in h[0,1](D)_alg.

Example: 


 input
   II=[(1-x)^2*dx+h*(1-x)]$ JJ = [(1-x)*dx+h]$
   V=[x]$
   sm1.ecartd_isSameIdeal_h([II,JJ,V]);

sm1.ecartd_reduction

sm1.ecartd_reduction(F,A)
: It returns a reduced form of F in terms of A by using a tangent cone algorithm. h[0,1](D)-homogenization is used.

Example: 


 input
   F=[2*(1-x-y)*dx+h,2*(1-x-y)*dy+h]$
   FF=[F,"x,y",[[dx,1,dy,1],[x,-1,y,-1]]]$
   sm1.ecartd_reduction(dx+dy,FF);

sm1.ecartd_reduction_noh

sm1.ecartd_reduction_noh(F,A)
: It returns a reduced form of F in terms of A by using a tangent cone algorithm. h[0,1](D)-homogenization is NOT used. A[0] must not contain the variable h.

Example: 


      F=[2*(1-x-y)*dx+1,2*(1-x-y)*dy+1]$
        FF=[F,"x,y",[[dx,1,dy,1],[x,-1,y,-1]]]$
        sm1.ecartd_reduction_noh(dx+dy,FF);

sm1.ecartd_syz

sm1.ecartd_syz(A)
: It returns a syzygy of A by using a tangent cone algorithm. h[0,1](D)-homogenization is used. If the option rv="dp" (return_value="dp") is given, the answer is returned in distributed polynomials. The return value is in the format [s,[g,m,t]]. s is the generator of the syzygies, g is the Grobner basis, m is the translation matrix from the generators to g. t is the syzygy of g.

Example: 


 input1
   F=[2*(1-x-y)*dx+1,2*(1-x-y)*dy+1]$
   FF=[F,"x,y",[[dx,1,dy,1],[x,-1,y,-1]]]$
   sm1.ecartd_syz(FF);
  input2
   F=[2*(1-x-y)*dx+h,2*(1-x-y)*dy+h]$
   FF=[F,"x,y",[[dx,1,dy,1],[x,-1,y,-1,dx,1,dy,1]],["noAutoHomogenize",1]]$
   sm1.ecartd_syz(FF);

sm1.gb_oxRingStructure

sm1.gb_oxRingStructure()
: It returns the oxRingStructure of the most recent gb computation.

sm1.gb_reduction

sm1.gb_reduction(F,A)
: It returns a reduced form of F in terms of A by using a normal form algorithm. h[1,1](D)-homogenization is used.

Example: 


 input
   F=[2*(h-x-y)*dx+h^2,2*(h-x-y)*dy+h^2]$
   FF=[F,"x,y",[[dx,1,dy,1],[x,-1,y,-1,dx,1,dy,1]]]$
   sm1.gb_reduction((h-x-y)^2*dx*dy,FF);

sm1.gb_reduction_noh

sm1.gb_reduction_noh(F,A)
: It returns a reduced form of F in terms of A by using a normal form algorithm.

Example: 


 input
   F=[2*dx+1,2*dy+1]$
   FF=[F,"x,y",[[dx,1,dy,1]]]$
   sm1.gb_reduction_noh((1-x-y)^2*dx*dy,FF);

sm1.generalized_bfunction

sm1.generalized_bfunction(I,V,VD,W)
: It computes the generalized b-function (indicial equation) of I with respect to the weight W.

Description:

It no longer calls sm1's original function. Instead, it calls asir "generic_bfct".

Example: 

 sm1.generalized_bfunction([x^2*dx^2-1/2,dy^2],[x,y],[dx,dy],[-1,0,1,0]);

sm1.isSameIdeal_in_Dalg

sm1.isSameIdeal_in_Dalg(I,J,V)
: It compares two ideals I and J in D_alg (algebraic D with variables V, no homogenization).

Example: 


  Input1
    II=[(1-x)^2*dx+(1-x)]$ JJ = [(1-x)*dx+1]$ V=[x]$
    sm1.isSameIdeal_in_Dalg(II,JJ,V);

sm1.laplace

sm1.laplace(L,V,VL)
: It returns the Laplace transformation of L for VL. V is the list of space variables. The numbers in coefficients must not be rational with a non-1 denominator. cf. ptozp

Example: 


     L1=sm1.laplace(dt-(3*t^2-x),[x,t],[t,dt]);
     L2=sm1.laplace(dx+t,[x,t],[t,dt]);
     sm1.restriction([L1,L2],[t,x],[t] | degree=0);

sm1.restriction

sm1.restriction(I,V,R)
: It computes the restriction of I as a D-module to the set defined by R. V is the list of variables. When the optional variable degree=d is given, only the restrictions from 0 to d are computed. Note that, in case of vector input, RESTRICTION VARIABLES MUST APPEAR FIRST in the list of variable V. We are using wbfRoots to get the roots of b-functions, so we can use only generic weight vector for now.
sm1.restriction(I,V,R | degree=key0)
: This function allows optional variables degree

Algorithm:

T.Oaku and N.Takayama, math.AG/9805006, http://xxx.langl.gov

Example: 

 sm1.restriction([dx^2-x,dy^2-1],[x,y],[y]);

sm1.saturation

sm1.saturation(T)
: T = [I,J,V]. It returns saturation of I with respect to J^infty. V is a list of variables.

Example: 

 sm1.saturation([[x2^2,x2*x4, x2, x4^2], [x2,x4], [x2,x4]]);

Index

Jump to: h - o - s

h

  • hilbert_polynomial

    • o

  • ox_sm1_forAsir

    • s

  • sm1.ahg, sm1.ahg
  • sm1.appell1
  • sm1.appell4
  • sm1.auto_reduce
  • sm1.bfunction, sm1.bfunction
  • sm1.call_sm1, sm1.call_sm1
  • sm1.deRham
  • sm1.distraction
  • sm1.ecart_homogenize01Ideal, sm1.ecart_homogenize01Ideal
  • sm1.ecartd_gb, sm1.ecartd_gb
  • sm1.ecartd_gb_oxRingStructure, sm1.ecartd_gb_oxRingStructure
  • sm1.ecartd_isSameIdeal_h, sm1.ecartd_isSameIdeal_h
  • sm1.ecartd_reduction, sm1.ecartd_reduction
  • sm1.ecartd_reduction_noh, sm1.ecartd_reduction_noh
  • sm1.ecartd_syz, sm1.ecartd_syz
  • sm1.gb
  • sm1.gb_d
  • sm1.gb_oxRingStructure, sm1.gb_oxRingStructure
  • sm1.gb_reduction, sm1.gb_reduction
  • sm1.gb_reduction_noh, sm1.gb_reduction_noh
  • sm1.generalized_bfunction, sm1.generalized_bfunction
  • sm1.genericAnn
  • sm1.gkz
  • sm1.hilbert
  • sm1.isSameIdeal_in_Dalg, sm1.isSameIdeal_in_Dalg
  • sm1.laplace, sm1.laplace
  • sm1.mgkz
  • sm1.mul
  • sm1.push_int0
  • sm1.rank
  • sm1.reduction
  • sm1.restriction, sm1.restriction
  • sm1.saturation, sm1.saturation
  • sm1.slope
  • sm1.sm1
  • sm1.start
  • sm1.syz
  • sm1.syz_d
  • sm1.wTensor0
  • sm1.xml_tree_to_prefix_string
    • Jump to:

    @vfill @eject

    This document was generated on 23 February 2009 using texi2html 1.56k.