[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.start
:: localhost で ox_sm1_forAsir
をスタートする.
整数
ox_sm1_forAsir
をスタートする.
サーバ ox_sm1_forAsir
の識別番号を戻す.
Xm_noX = 1
とおくとサーバ ox_sm1_forAsir
をデバッグ用の
ウィンドウなしに起動できる.
ord
を用いて変数順序を正しく設定しておく必要が
ある.
たとえば,
変数 x
と dx
上の微分作用素環
(dx
は
に対応)
で計算しているとき,
sm1
サーバは式を印刷したとき,
変数 dx
は右側に集めれ変数
x
は左側にあつめられていると仮定している.
次の例では, 変数 cc
を sm1
での計算のために用いてはいけない.
a
より z
のなかで, d
と o
を除いたもの,
それから, x0
, ..., x20
, y0
, ..., y20
,
z0
, ..., z20
は, デフォールトで微分作用素環の変数として
使える (cf. Sm1_ord_list
in sm1
).
static Sm1_proc
に格納される.
この識別番号は関数 sm1.get_Sm1_proc()
でとりだすことができる.
[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
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.sm1
:: サーバ sm1
にコマンド列 s を実行してくれるようにたのむ.
なし
数
文字列
sm1
サーバに
コマンド列 s を実行してくれるように頼む.
(次の例では, 識別番号 0)
[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()
.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.push_int0
:: オブジェクト f を識別子 p のサーバへ送る.
なし
数
オブジェクト
type(f)
が 2 (再帰多項式) のとき,
f は文字列 (type == 7) に変換されて,
ox_push_cmo
を用いてサーバへ送られる.
type(f)
が 0 (zero) のときは,
サーバ上では, 32 bit 整数と解釈される.
なお ox_push_cmo(P,0)
はサーバに対して CMO_NULL
をおくるので, サーバ側では, 32 bit 整数を受け取るわけではない.
sm1
の整数は, 32 bit 整数と bignum にわけることができる.
type(f)
が 1 (数)のとき, この関数は 32 bit integer をサーバに
おくる.
ox_push_cmo(p,1234)
は bignum の 1234 を
sm1
サーバにおくることに注意しよう.
ox_push_cmo
をデータ型の変換なしに呼び出す.
[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] |
ox_push_cmo
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.gb
:: v 上の微分作用素環において f のグレブナ基底を計算する.
:: v 上の微分作用素環において f のグレブナ基底を計算する. 結果を分散多項式のリストで戻す.
リスト
数
リスト
sm1.gb
の戻り値は f のグレブナ基底およびイニシャルモノミアル
( w がないとき ) または イニシァル多項式 ( w が与えらたとき)
のリストである.
sm1.gb_d
は結果を分散多項式のリストで戻す.
多項式の中に現れるモノミアルはグレブナ基底を計算するときに与えらた順序でソートされている.
戻り値は
[変数名のリスト, 順序をきめる行列, グレブナ基底, イニシャルモノミアルまたはイニシァル多項式]
である.
h
が結果に加わる.
[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
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.deRham
:: 空間 C^n - (the zero set of f=0) のドラームコホモロジ群の次元を計算してくれるようにサーバに頼む.
リスト
数
文字列 または 多項式
リスト
length(v)
である.
sm1.deRham
は計算機の資源を大量に使用する.
たとえば sm1.deRham(0,[x*y*z*(x+y+z-1)*(x-y),[x,y,z]])
の計算すらすでに非常に大変である.
ox_asir
が ox_sm1_forAsir
より使用されるべきである. コマンド sm1(0,"[(parse) (oxasir.sm1) pushfile] extension");
を用いて, ox_asir
との通信モジュールをあらかじめロードしておくとよい.
このコマンドは ox_asir_forAsir
のスタート時に自動的に実行されている.
sm1.deRham
を ox_reset(sm1.get_Sm1_proc());
で中断すると,
以後 sm1 サーバが非標準モードに入り予期しない動作をする場合
があるので, コマンド ox_shutdown(sm1.get_Sm1_proc());
で, ox_sm1_forAsir
を一時 shutdown してリスタートした方が安全である.
[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)
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.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.hilbert
:: 多項式の集合 f のヒルベルト多項式を計算する.
:: 多項式の集合 f のヒルベルト多項式を計算する.
多項式
数
リスト
sm1
の
多項式グレブナ基底計算は asir
より遅い.
[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
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.genericAnn
:: f^s のみたす微分方程式全体をもとめる.
v は変数のリストである. ここで, s は v[0] であり,
f は変数 rest
(v) 上の多項式である.
リスト
数
多項式
リスト
rest
(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
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.wTensor0
:: f と g の D-module としての 0 次テンソル積を 計算する.
リスト
数
リスト
sm1.wTensor0
は ox_sm1
の wRestriction0
をよんでいる.
wRestriction0
は, generic な weight ベクトル w
をもとにして制限を計算している.
Weight ベクトル w が generic でないと計算がエラーで停止する.
[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]] |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.reduction
::
リスト
多項式
リスト
数 (ox_sm1 のプロセス番号)
sm1.reduction_noH
は, Weyl algebra 用.
[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
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.xml_tree_to_prefix_string
:: XML で書かれた OpenMath の木表現 s を前置記法になおす.
String
Number
String
om_xml_to_cmo(OpenMath Tree Expression)
は CMO_TREE
を戻す. asir
はこの CMO をまだサポートしていない.
java
の実行環境が必要.
(たとえば, /usr/local/jdk1.1.8/bin をコマンドサーチパスに入れるなど.)
[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
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.syz
:: v 上の微分作用素環において f の syzygy を計算する.
リスト
数
リスト
h
が結果に加わる.
[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]]]] |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.mul
:: sm1サーバ に f かける g を v 上の微分作用素環でやってくれるように頼む.
多項式またはリスト
数
多項式またはリスト
リスト
sm1.mul_h
は homogenized Weyl 代数用.
sm1.mul(p0*dp0,1,[p0])
は
dp0*p0+1
を戻す.
d変数が後ろにくるような変数順序がはいっていないと, この関数は正しい答えを戻さない.
[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]] |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.distraction
:: sm1
に f の distraction を計算してもらう.
リスト
数
多項式
リスト
sm1
サーバに,
f の distraction を v 上の微分作用素環で計算してもらう.
[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)
,
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.gkz
:: 行列 A とパラメータ B に付随した GKZ 系 (A-hypergeometric system) をもどす.
リスト
数
リスト
[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]] |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.appell1
:: F_1 または F_D に対応する方程式系を戻す.
リスト
数
リスト
[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 |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.appell4
:: F_4 または F_C に対応する方程式系を戻す.
リスト
数
リスト
[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 |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.rank
:: 微分方程式系 a の holonomic rank を戻す.
数
数
リスト
sm1.rrank
も holonomic rank を戻す.
いっぱんにこの関数の方が sm1.rank
より早い.
[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 |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.auto_reduce
:: フラグ "AutoReduce" を s に設定.
数
数
数
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.slope
:: 微分方程式系 ii の slope を戻す.
数
数
リスト (方程式)
リスト (変数)
リスト (weight vector)
リスト (weight vector)
sm1.slope
は
微分方程式系 ii の V filtration v_filtration
で指定する超平面に沿っての (geomeric) slope を計算する.
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
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.ahg
: It idential with sm1.gkz(A).
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.bfunction
: 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); |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.call_sm1
: It executes F on the sm1 server. See also sm1.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.ecart_homogenize01Ideal
: 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); |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.ecartd_gb
: 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); |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.ecartd_gb_oxRingStructure
: It returns the oxRingStructure of the most recent ecartd_gb computation.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.ecartd_isSameIdeal_h
: 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]); |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.ecartd_reduction
: 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); |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.ecartd_reduction_noh
: 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); |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.ecartd_syz
: 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); |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.gb_oxRingStructure
: It returns the oxRingStructure of the most recent gb computation.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.gb_reduction
: 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); |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.gb_reduction_noh
: 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); |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.generalized_bfunction
: 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]); |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.isSameIdeal_in_Dalg
: 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); |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.restriction
: 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.
: 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]); |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.saturation
: 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]]); |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.ahg
: It idential with sm1.gkz(A).
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.bfunction
: 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); |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.call_sm1
: It executes F on the sm1 server. See also sm1.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.ecart_homogenize01Ideal
: 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); |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.ecartd_gb
: 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); |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.ecartd_gb_oxRingStructure
: It returns the oxRingStructure of the most recent ecartd_gb computation.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.ecartd_isSameIdeal_h
: 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]); |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.ecartd_reduction
: 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); |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.ecartd_reduction_noh
: 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); |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.ecartd_syz
: 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); |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.gb_oxRingStructure
: It returns the oxRingStructure of the most recent gb computation.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.gb_reduction
: 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); |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.gb_reduction_noh
: 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); |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.generalized_bfunction
: 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]); |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.isSameIdeal_in_Dalg
: 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); |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.restriction
: 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.
: 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]); |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
sm1.saturation
: 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]]); |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] |
This document was generated by Nobuki Takayama on January, 28 2008 using texi2html 1.76.