Changeset d12655 in git
 Timestamp:
 Dec 22, 2000, 4:59:36 PM (22 years ago)
 Branches:
 (u'spielwiese', '0d6b7fcd9813a1ca1ed4220cfa2b104b97a0a003')
 Children:
 50793d818ad7738eed95134de900cd96334604ad
 Parents:
 efda70a1a3dcb73477bd26bf7c45b8e867e6a6d8
 File:

 1 edited
Legend:
 Unmodified
 Added
 Removed

Singular/LIB/zeroset.lib
refda70a rd12655 1 /////////////////////////////////////////////////////////////////////////////// 2 version="Id: zeroset.lib,v 1.0 2000/05/19 12:32:15 Singular Exp $"; 1 // Last change 10.12.2000 2 /////////////////////////////////////////////////////////////////////////////// 3 4 version="$Id: zeroset.lib,v 1.5 20001222 15:59:36 greuel Exp $"; 3 5 category="Symbolicnumerical solving"; 4 6 info=" 5 LIBRARY: zeroset.lib PROCEDURES FOR ROOTS AND FACTORIZATION 6 7 AUTHOR: Thomas Bayer, email: bayert@in.tum.de 7 LIBRARY: zeroset.lib Procedures For Roots and Factorization 8 AUTHOR: Thomas Bayer, email: tbayer@mathematik.unikl.de 9 http://wwwmayr.informatik.tumuenchen.de/personen/bayert/ 10 Current Adress: Institut fuer Informatik, TU Muenchen 11 12 OVERVIEW: 13 Algorithms for finding the zeroset of a zerodim. ideal in Q(a)[x_1,..x_n], 14 Roots and Factorization of univariate polynomials over Q(a)[t] 15 where a is an algebric number. Written in the frame of the 16 diploma thesis (advisor: Prof. GertMartin Greuel) 'Computations of moduli 17 spaces of semiquasihomogenous singularities and an implementation in Singular' 18 This library is meant as a preliminary extension of the functionality 19 of Singular for univariate factorization of polynomials over simple algebraic 20 extensions in characteristic 0. 21 Subprocedures with postfix 'Main' require that the ring contains a variable 22 'a' and no parameters, and the ideal 'mpoly', where 'minpoly' from the 23 basering is stored. 8 24 9 25 PROCEDURES: 10 11 26 EGCD(f, g) gcd over an algebraic extension field of Q 12 27 Factor(f) factorization of f over an algebraic extension field 13 InvertNumber(c) inverts an element of an alge braic extension field28 InvertNumber(c) inverts an element of an algenraic extension field 14 29 LinearZeroSet(I) find the linear (partial) solution of I 15 30 Quotient(f, g) quotient q of f w.r.t. g (in f = q*g + remainder) 16 31 Remainder(f,g) remainder of the division of f by g 17 32 Roots(f) computes all roots of f in an extension field of Q 18 SQFRNorm(f) norm of f (f must be square free)33 SQFRNorm(f) norm of f (f must be squarefree) 19 34 ZeroSet(I) zeroset of the 0dim. ideal I 20 35 21 SUB PROCEDURES: 22 36 AUXILIARY PROCEDURES: 23 37 EGCDMain(f, g) gcd over an algebraic extension field of Q 24 38 FactorMain(f) factorization of f over an algebraic extension field 25 InvertNumberMain(c) inverts an element of an alge braic extension field39 InvertNumberMain(c) inverts an element of an algenraic extension field 26 40 QuotientMain(f, g) quotient of f w.r.t. g 27 41 RemainderMain(f,g) remainder of the division of f by g 28 RootsMain(f) computes all roots of f, might extend the groundfield29 SQFRNormMain(f) norm of f (f must be square free)42 RootsMain(f) computes all roots of f, might extend the groundfield 43 SQFRNormMain(f) norm of f (f must be squarefree) 30 44 ContainedQ(data, f) f in data ? 31 45 SameQ(a, b) a == b (list a,b) … … 35 49 SimplifyPoly(f) reduces coefficients of f w.r.t. mpoly 36 50 SimplifySolution(sol) reduces the entries of sol w.r.t. the ideal mpoly 37 38 NOTE: this library is meant as a preliminary extension of the functionality39 of Singular for univariate factorization of polynomials over simple algebraic40 extensions in characteristic 0.41 Subprocedures with postfix 'Main' require that the ring contains a variable42 'a' and no parameters, and the ideal 'mpoly', where 'minpoly' from the43 basering is stored.44 51 "; 45 52 46 // NOTE: This library has been written in the frame of the diploma thesis 47 // 'Computing moduli spaces of semiquasihomogeneous singularites and an 48 // implementation in Singular', Arbeitsgruppe Algebraische Geometrie, 49 // Fachbereich Mathematik, University Kaiserslautern, 50 // Advisor: Prof. GertMartin Greuel 53 LIB "primitiv.lib"; 54 LIB "primdec.lib"; 51 55 52 56 // note : return a ring : ring need not be exported !!! 53 57 54 // Ar ithmetic in Q(a)[x] without builtin procedures58 // Artihmetic in Q(a)[x] without builtin procedures 55 59 // assume basering = Q[x,a] and minpoly is represented by mpoly(a). 56 60 // the algorithms are taken from "Polynomial Algorithms in Computer Algebra", … … 59 63 60 64 // To do : 61 // square free factorization65 // squarefree factorization 62 66 // multiplicities 63 67 64 68 // Improvement : 65 69 // a main problem is the growth of the coefficients. Try Roots(x7  1) 66 // ret urn ideal mpoly !70 // retrurn ideal mpoly ! 67 71 // mpoly is not monic, comes from primitive_extra 68 72 69 // IMPLEMENTATION (last change: 10.12.2000)73 // IMPLEMENTATION 70 74 // 71 75 // In procedures with name 'procname'Main a polynomial ring over a simple … … 73 77 // 'mpoly' (attribute "isSB"). The arithmetic in the extension field is 74 78 // implemented in the procedures in the procedures 'MultPolys' (multiplication) 75 // and 'InvertNumber' (inversion). After addition and sub traction one should79 // and 'InvertNumber' (inversion). After addition and substraction one should 76 80 // apply 'SimplifyPoly' to the result to reduce the result w.r.t. 'mpoly'. 77 // This is done by reducing each coefficient sep arately, which is more81 // This is done by reducing each coefficient seperately, which is more 78 82 // efficient for polynomials with many terms. 79 83 80 81 LIB "primitiv.lib";82 LIB "primdec.lib";83 84 84 85 /////////////////////////////////////////////////////////////////////////////// … … 86 87 proc Roots(poly f) 87 88 "USAGE: Roots(f); poly f 88 PUR POSE: compute all roots of f in a finite extension of the groundfield89 PUROPSE: compute all roots of f in a finite extension of the groundfield 89 90 without multiplicities. 90 91 RETURN: ring, a polynomial ring over an extension field of the ground field, 91 92 containing a list 'roots', poly 'newA', poly 'f': 92  'roots' is the list of roots of the polynomial f (no multiplicities)93  'roots' is the list of roots of the polynomial f (no multiplicities) 93 94  if the groundfield is Q(a') and the extension field is Q(a), then 94 'newA' is the representation of a' in Q(a). If the basering95 96 97 98  'f' is the polynomial f in Q(a) (a' being substituted by newA)95 'newA' is the representation of a' in Q(a). If the basering 96 contains a parameter 'a' and the minpoly remains unchanged then 97 'newA' = 'a'. If the basering does not contain a parameter then 98 'newA' = 'a' (default). 99  'f' is the polynomial f in Q(a) (a' being substituted by newA) 99 100 ASSUME: ground field to be Q or a simple extension of Q given by a minpoly 100 101 EXAMPLE: example Roots; shows an example … … 167 168 without multiplicities. 168 169 RETURN: list, all entries are polynomials 169 _[1] = roots of f, each entry is a polynomial 170 _[2] = 'newA'  if the groundfield is Q(a') and the extension field 171 is Q(a), then 'newA' is the representation of a' in Q(a) 172 _[3] = minpoly of the algebraic extension of the groundfield 173 ASSUME: basering = Q[x,a] 174 ideal mpoly must be defined, it might be 0 ! 170 _[1] = roots of f, each entry is a polynomial 171 _[2] = 'newA'  if the groundfield is Q(a') and the extension field 172 is Q(a), then 'newA' is the representation of a' in Q(a) 173 _[3] = minpoly of the algebraic extension of the groundfield 174 ASSUME: basering = Q[x,a] ideal mpoly must be defined, it might be 0 ! 175 175 NOTE: might change the ideal mpoly !! 176 176 EXAMPLE: example Roots; shows an example … … 305 305 proc ZeroSet(ideal I, list #) 306 306 "USAGE: ZeroSetMain(ideal I [, int opt]); ideal I, int opt 307 PUR POSE: compute the zeroset of the zerodim. ideal I, in a finite extension307 PUROPSE: compute the zeroset of the zerodim. ideal I, in a finite extension 308 308 of the groundfield. 309 309 RETURN: ring, a polynomial ring over an extension field of the ground field, 310 310 containing a list 'zeroset', a polynomial 'newA', and an ideal 'id'. 311  'zeroset' is list of the zeros of the ideal 'I', each zero is311  'zeroset' is list of the zeros of the ideal 'I', each zero is 312 312 an ideal. 313 313  if the groundfield is Q(a') and the extension field is Q(a), then 314 'newA' is the representation of a' in Q(a). If the basering315 316 317 318  'id' is the ideal 'I' in Q(a)[x_1,...] (a' substituted by 'newA')319 ASSUME: dim(I) = 0, and ground field to be Q or a simple extension of Q 320 givenby a minpoly.314 'newA' is the representation of a' in Q(a). If the basering 315 contains a parameter 'a' and the minpoly remains unchanged then 316 'newA' = 'a'. If the basering does not contain a parameter then 317 'newA' = 'a' (default). 318  'id' is the ideal 'I' in Q(a)[x_1,...] (a' substituted by 'newA') 319 ASSUME: dim(I) = 0, and ground field to be Q or a simple extension of Q given 320 by a minpoly. 321 321 OPTIONS: opt = 0 no primary decomposition (default) 322 opt > 0 primary decomposition323 NOTE: If I contains an algebraic number (parameter) then 'I' must be 322 opt > 0 primary decomposition 323 NOTE: If I contains an algebraic number (parameter) then 'I' must be 324 324 transformed w.r.t. 'newA' in the new ring. 325 325 EXAMPLE: example ZeroSet; shows an example … … 410 410 polynomial in Q[a]. 411 411 RETURN: poly 1/f 412 ASSUME: basering = Q[x_1,...,x_n,a], ideal 'mpoly' must be defined and != 0 412 ASSUME: basering = Q[x_1,...,x_n,a], ideal 'mpoly' must be defined and != 0 ! 413 413 " 414 414 { … … 449 449 proc LeadTerm(poly f, int i) 450 450 "USAGE: LeadTerm(f); poly f, int i 451 PUR POSE: compute the leading coef and term of f w.r.t var(i), where the last451 PUROPSE: compute the leading coef and term of f w.r.t var(i), where the last 452 452 ring variable is treated as a parameter. 453 453 RETURN: list of polynomials … … 470 470 proc Quotient(poly f, poly g) 471 471 "USAGE: Quotient(f, g); poly f, g; 472 PUR POSE: compute the quotient q and remainder r s.t. f = g*q + r, deg(r) < g472 PUROPSE: compute the quotient q and remainder r s.t. f = g*q + r, deg(r) < g 473 473 RETURN: list of polynomials 474 474 _[1] = quotient q … … 504 504 proc QuotientMain(poly f, poly g) 505 505 "USAGE: QuotientMain(f, g); poly f, g 506 PUR POSE: compute the quotient q and remainder r s.t. f = g*q + r, deg(r) < g506 PUROPSE: compute the quotient q and remainder r s.t. f = g*q + r, deg(r) < g 507 507 RETURN: list of polynomials 508 508 _[1] = quotient q … … 528 528 proc Remainder(poly f, poly g) 529 529 "USAGE: Remainder(f, g); poly f, g 530 PUR POSE: compute the remainder of the division of f by g, i.e. a polynomial r530 PUROPSE: compute the remainder of the division of f by g, i.e. a polynomial r 531 531 s.t. f = g*q + r, deg(r) < g. 532 532 RETURN: poly … … 558 558 proc RemainderMain(poly f, poly g) 559 559 "USAGE: RemainderMain(f, g); poly f, g 560 PUR POSE: compute the remainder r s.t. f = g*q + r, deg(r) < g560 PUROPSE: compute the remainder r s.t. f = g*q + r, deg(r) < g 561 561 RETURN: poly 562 562 ASSUME: basering = Q[x,a] and ideal 'mpoly' is defined (it might be 0), … … 580 580 proc EGCD(poly f, poly g) 581 581 "USAGE: EGCDMain(f, g); poly f, g 582 PUR POSE: compute the polynomial gcd of f and g over Q(a)[x]583 RETURN: poly h s t. h is a greatest common divisor of f and g (not nec. monic)582 PUROPSE: compute the polynomial gcd of f and g over Q(a)[x] 583 RETURN: poly h s.t. h is a greatest common divisor of f and g (not nec. monic) 584 584 ASSUME: basering = Q(a)[t] 585 585 EXAMPLE: example EGCD; shows an example … … 610 610 proc EGCDMain(poly f, poly g) 611 611 "USAGE: EGCDMain(f, g); poly f, g 612 PUR POSE: compute the polynomial gcd of f and g over Q(a)[x]612 PUROPSE: compute the polynomial gcd of f and g over Q(a)[x] 613 613 RETURN: poly 614 614 ASSUME: basering = Q[x,a] and ideal 'mpoly' is defined (it might be 0), … … 636 636 proc MEGCD(poly f, poly g, int varIndex) 637 637 "USAGE: MEGCD(f, g, i); poly f, g; int i 638 PUR POSE: compute the polynomial gcd of f and g in the i'th variable638 PUROPSE: compute the polynomial gcd of f and g in the i'th variable 639 639 RETURN: poly 640 ASSUME: f, g are polynomials in var(i), last variable is the algebraic number640 ASSUME: f, g are polynomials in var(i), last variable is the algebraic number 641 641 EXAMPLE: example MEGCD; shows an example 642 642 " … … 671 671 proc SQFRNorm(poly f) 672 672 "USAGE: SQFRNorm(f); poly f 673 PUR POSE: compute the norm of the squarefree polynomial f in Q(a)[x].673 PUROPSE: compute the norm of the squarefree polynomial f in Q(a)[x]. 674 674 RETURN: list 675 675 _[1] = squarefree norm of g (poly) … … 703 703 proc SQFRNormMain(poly f) 704 704 "USAGE: SQFRNorm(f); poly f 705 PUR POSE: compute the norm of the squarefree polynomial f in Q(a)[x].705 PUROPSE: compute the norm of the squarefree polynomial f in Q(a)[x]. 706 706 RETURN: list 707 707 _[1] = squarefree norm of g (poly) 708 708 _[2] = g (= f(x  s*a)) (poly) 709 709 _[3] = s (int) 710 ASSUME: f must be squarefree, basering = Q[x,a] and ideal 'mpoly' is equal to 'minpoly',711 this represents the ring Q(a)[x] together with 'minpoly'.710 ASSUME: f must be squarefree, basering = Q[x,a] and ideal 'mpoly' is equal to 711 'minpoly',this represents the ring Q(a)[x] together with 'minpoly'. 712 712 NOTE: the norm is an element of Q[x] 713 713 EXAMPLE: example SqfrNorm; shows an example … … 753 753 proc Factor(poly f) 754 754 "USAGE: Factor(f); poly f 755 PURPOSE: compute the factorization of the squarefree poly f over Q(a)[t], 756 where minpoly = p(a). 755 PUROPSE: compute the factorization of the squarefree poly f over Q(a)[t], minpoly = p(a). 757 756 RETURN: list 758 757 _[1] = factors (monic), first entry is the leading coefficient 759 758 _[2] = multiplicities (not yet) 760 ASSUME: basering must be the univariate polynomial ring over a field which 759 ASSUME: basering must be the univariate polynomial ring over a field which 761 760 is Q or a simple extension of Q given by a minpoly. 762 761 NOTE: if basering = Q[t] then this is the builtin 'factorize'. … … 790 789 proc FactorMain(poly f) 791 790 "USAGE: FactorMain(f); poly f 792 PUR POSE: compute the factorization of the squarefree poly f over Q(a)[t],793 whereminpoly = p(a).791 PUROPSE: compute the factorization of the squarefree poly f over Q(a)[t], 792 minpoly = p(a). 794 793 RETURN: list 795 794 _[1] = factors, first is a constant 796 795 _[2] = multiplicities (not yet) 797 796 ASSUME: basering = Q[x,a], represents Q(a)[x] and minpoly. 798 ideal mpoly must be defined, it might be 0 !797 ideal mpoly must be defined, it might be 0 ! 799 798 EXAMPLE: example Factor; shows an example 800 799 " … … 846 845 proc ZeroSetMain(ideal I, int primDecQ) 847 846 "USAGE: ZeroSetMain(ideal I, int opt); ideal I, int opt 848 PUR POSE: compute the zeroset of the zerodim. ideal I, in a simple extension847 PUROPSE: compute the zeroset of the zerodim. ideal I, in a simple extension 849 848 of the groundfield. 850 849 RETURN: list 851  'f' is the polynomial f in Q(a) (a' being substituted by newA)850  'f' is the polynomial f in Q(a) (a' being substituted by newA) 852 851 _[1] = zeroset (list), is the list of the zeroset of the ideal I, 853 852 each entry is an ideal. … … 857 856 remains unchanged then 'newA' = 'a'. If the basering does not 858 857 contain a parameter then 'newA' = 'a' (default). 859 _[3] = 'mpoly' (ideal), the minimal polynomial of the simple 860 extension of the ground field. 861 ASSUME: basering = K[x_1,x_2,...,x_n] where K = Q or a simple extension of Q 862 given by a minpoly. 863 dim(I) = 0. 858 _[3] = 'mpoly' (ideal), the minimal polynomial of the simple extension 859 of the ground field. 860 ASSUME: basering = K[x_1,x_2,...,x_n] where K = Q or a simple extension of Q 861 given by a minpoly; dim(I) = 0. 864 862 NOTE: opt = 0 no primary decomposition 865 opt > 0 use a primary decomposition863 opt > 0 use a primary decomposition 866 864 EXAMPLE: example ZeroSet; shows an example 867 865 " … … 936 934 proc ZeroSetMainWork(ideal id, intvec wt, int sVars) 937 935 "USAGE: ZeroSetMainWork(I, wt, sVars); 938 PUR POSE: compute the zeroset of the zerodim. ideal I, in a finite extension936 PUROPSE: compute the zeroset of the zerodim. ideal I, in a finite extension 939 937 of the groundfield (without multiplicities). 940 938 RETURN: list, all entries are polynomials 941 939 _[1] = zeros, each entry is an ideal 942 _[2] = newA; if the groundfield is Q(a') this is the rep. of a' w rta940 _[2] = newA; if the groundfield is Q(a') this is the rep. of a' w.r.t. a 943 941 _[3] = minpoly of the algebraic extension of the groundfield (ideal) 944 942 _[4] = name of algebraic number (default = 'a') … … 1100 1098 proc NonLinearZeroSetMain(ideal I, intvec wt) 1101 1099 "USAGE: ZeroSetMainWork(I, wt, sVars); 1102 PUR POSE: solves the (nonlinear) univariate polynomials in I1100 PUROPSE: solves the (nonlinear) univariate polynomials in I 1103 1101 of the groundfield (without multiplicities). 1104 1102 RETURN: list, all entries are polynomials … … 1188 1186 static proc ExtendSolutions(list solutions, list newSolutions) 1189 1187 "USAGE: ExtendSolutions(sols, newSols); list sols, newSols; 1190 PUR POSE: extend the entries of 'sols' by the entries of 'newSols',1188 PUROPSE: extend the entries of 'sols' by the entries of 'newSols', 1191 1189 each entry of 'newSols' is a number. 1192 1190 RETURN: list … … 1226 1224 RETURN: list 1227 1225 PURPOSE: create a list of solutions of size n, each entry of 'sol2' must 1228 have size n. 'sol1' is one partial solution (from LinearZeroSetMain)1229 'sol2' is a list of partial solutions (from NonLinearZeroSetMain)1226 have size n. 'sol1' is one partial solution (from 'LinearZeroSetMain') 1227 'sol2' is a list of partial solutions (from 'NonLinearZeroSetMain') 1230 1228 ASSUME: 'sol2' is not empty 1231 NOTE: used by 'ZeroSetMainWork'1229 NOTE: used by 'ZeroSetMainWork' 1232 1230 { 1233 1231 int i, j, k, m; … … 1247 1245 static proc SubsMapIdeal(list sol, list index, int opt) 1248 1246 "USAGE: SubsMapIdeal(sol,index,opt); list sol, index; int opt; 1249 PUR POSE: built an ideal I as follows.1247 PUROPSE: built an ideal I as follows. 1250 1248 if i is contained in 'index' then set I[i] = sol[i] 1251 1249 if i is not contained in 'index' then … … 1277 1275 proc SimplifyZeroset(data) 1278 1276 "USAGE: SimplifyZeroset(data); list data 1279 PUR POSE: reduce the entries of the elements of 'data' w.r.t. the ideal 'mpoly'1277 PUROPSE: reduce the entries of the elements of 'data' w.r.t. the ideal 'mpoly' 1280 1278 'data' is a list of ideals/lists. 1281 1279 RETURN: list … … 1298 1296 proc Variables(poly f, int n) 1299 1297 "USAGE: Variables(f,n); poly f; int n; 1300 PUR POSE: list of variables among var(1),...,var(n) which occur in f.1298 PUROPSE: list of variables among var(1),...,var(n) which occur in f. 1301 1299 RETURN: list 1302 1300 ASSUME: n <= nvars(basering) … … 1317 1315 proc ContainedQ(data, f, list #) 1318 1316 "USAGE: ContainedQ(data, f [, opt]); list data; f is of any type, int opt 1319 PUR POSE: test if 'f' is an element of 'data'.1317 PUROPSE: test if 'f' is an element of 'data'. 1320 1318 RETURN: int 1321 1319 0 if 'f' not contained in 'data' … … 1348 1346 proc SameQ(a, b) 1349 1347 "USAGE: SameQ(a, b); list/intvec a, b; 1350 PUR POSE: test a == b elementwise, i.e., a[i] = b[i].1348 PUROPSE: test a == b elementwise, i.e., a[i] = b[i]. 1351 1349 RETURN: int 1352 1350 0 if a != b … … 1376 1374 static proc SimplifyPoly(poly f) 1377 1375 "USAGE: SimplifyPoly(f); poly f 1378 PUR POSE: reduces the coefficients of f w.r.t. the ideal 'moly' if they contain1376 PUROPSE: reduces the coefficients of f w.r.t. the ideal 'moly' if they contain 1379 1377 the algebraic number 'a'. 1380 1378 RETURN: poly … … 1401 1399 static proc SimplifyData(data) 1402 1400 "USAGE: SimplifyData(data); ideal/list data; 1403 PUR POSE: reduces the entries of 'data' w.r.t. the ideal 'mpoly' if they1404 contain the algebraic number 'a'.1401 PUROPSE: reduces the entries of 'data' w.r.t. the ideal 'mpoly' if they contain 1402 the algebraic number 'a' 1405 1403 RETURN: ideal/list 1406 1404 ASSUME: basering = Q[x_1,...,x_n,a] … … 1425 1423 static proc TransferRing(R) 1426 1424 "USAGE: TransferRing(R); 1427 PUR POSE: creates a new ring containing the same variables as R, but without1425 PUROPSE: creates a new ring containing the same variables as R, but without 1428 1426 parameters. If R contains a parameter then this parameter is added 1429 as the last variable and 'minpoly' is represented by the ideal 1430 'mpoly'. If the basering does not contain a parameter then 'a' will1431 be added and'mpoly' = 0.1427 as the last variable and 'minpoly' is represented by the ideal 'mpoly' 1428 If the basering does not contain a parameter then 'a' is added and 1429 'mpoly' = 0. 1432 1430 RETURN: ring 1433 1431 ASSUME: R = K[x_1,...,x_n] where K = Q or K = Q(a). … … 1459 1457 static proc NewBaseRing() 1460 1458 "USAGE: NewBaseRing(); 1461 PUR POSE: creates a new ring, the last variable is added as a parameter.1459 PUROPSE: creates a new ring, the last variable is added as a parameter. 1462 1460 minpoly is set to mpoly[1]. 1463 1461 RETURN: ring … … 1500 1498 ring S1 = 0, (s(1..3)), lp; 1501 1499 ideal I = s(2)*s(3), s(1)^2*s(2)+s(1)^2*s(3)1, s(1)^2*s(3)^2s(3), s(2)^4s(3)^4+s(1)^2, s(1)^4+s(2)^3s(3)^3, s(3)^5s(1)^2*s(3); 1500 ideal mpoly = std(0); 1502 1501 1503 1502 // order = 10 1504 1503 ring S2 = 0, (s(1..5)), lp; 1505 1504 ideal I = s(2)+s(3)s(5), s(4)^2s(5), s(1)*s(5)+s(3)*s(4)s(4)*s(5), s(1)*s(4)+s(3)s(5), s(3)^22*s(3)*s(5), s(1)*s(3)s(1)*s(5)+s(4)*s(5), s(1)^2+s(4)^22*s(5), s(1)+s(5)^3, s(3)*s(5)^2+s(4)s(5)^3, s(1)*s(5)^21; 1505 ideal mpoly = std(0); 1506 1506 1507 1507 //order = 126 1508 1508 ring S3 = 0, (s(1..5)), lp; 1509 1509 ideal I = s(3)*s(4), s(2)*s(4), s(1)*s(3), s(1)*s(2), s(3)^3+s(4)^31, s(2)^3+s(4)^31, s(1)^3s(4)^3, s(4)^4s(4), s(1)*s(4)^3s(1), s(5)^71; 1510 ideal mpoly = std(0); 1510 1511 1511 1512 // order = 192 1512 1513 ring S4 = 0, (s(1..4)), lp; 1513 1514 ideal I = s(2)*s(3)^2*s(4)+s(1)*s(3)*s(4)^2, s(2)^2*s(3)*s(4)+s(1)*s(2)*s(4)^2, s(1)*s(3)^3+s(2)*s(4)^3, s(1)*s(2)*s(3)^2+s(1)^2*s(3)*s(4), s(1)^2*s(3)^2s(2)^2*s(4)^2, s(1)*s(2)^2*s(3)+s(1)^2*s(2)*s(4), s(1)^3*s(3)+s(2)^3*s(4), s(2)^4s(3)^4, s(1)*s(2)^3+s(3)*s(4)^3, s(1)^2*s(2)^2s(3)^2*s(4)^2, s(1)^3*s(2)+s(3)^3*s(4), s(1)^4s(4)^4, s(3)^5*s(4)s(3)*s(4)^5, s(3)^8+14*s(3)^4*s(4)^4+s(4)^81, 15*s(2)*s(3)*s(4)^7s(1)*s(4)^8+s(1), 15*s(3)^4*s(4)^5+s(4)^9s(4), 16*s(3)*s(4)^9s(3)*s(4), 16*s(2)*s(4)^9s(2)*s(4), 16*s(1)*s(3)*s(4)^8s(1)*s(3), 16*s(1)*s(2)*s(4)^8s(1)*s(2), 16*s(1)*s(4)^1015*s(2)*s(3)*s(4)16*s(1)*s(4)^2, 16*s(1)^2*s(4)^915*s(1)*s(2)*s(3)16*s(1)^2*s(4), 16*s(4)^13+15*s(3)^4*s(4)16*s(4)^5; 1515 ideal mpoly = std(0); 1514 1516 1515 1517 ring R = (0,a), (x,y,z), lp; … … 1517 1519 ideal I1 = x2  1/2, a*z  1, y  2; 1518 1520 ideal I2 = x3  1/2, a*z2  3, y  2*a; 1521 1519 1522 */ 1520 1521 1522 1523 1524 1525 1526 1527
Note: See TracChangeset
for help on using the changeset viewer.