Source code

001/*
002 * $Id$
003 */
004
005package edu.jas.application;
006
007
008import java.util.ArrayList;
009import java.util.Collections;
010import java.util.List;
011
012import edu.jas.arith.BigRational;
013import edu.jas.gb.SolvableGroebnerBase;
014import edu.jas.gb.SolvableGroebnerBaseSeq;
015import edu.jas.kern.ComputerThreads;
016import edu.jas.poly.GenSolvablePolynomial;
017import edu.jas.poly.GenSolvablePolynomialRing;
018import edu.jas.poly.PolynomialList;
019import edu.jas.poly.RelationGenerator;
020import edu.jas.poly.TermOrder;
021import edu.jas.poly.TermOrderOptimization;
022import edu.jas.poly.WeylRelations;
023import edu.jas.poly.WeylRelationsIterated;
024import edu.jas.util.KsubSet;
025
026import junit.framework.Test;
027import junit.framework.TestCase;
028import junit.framework.TestSuite;
029
030
031/**
032 * SolvableIdeal tests with JUnit.
033 * @author Heinz Kredel
034 */
035public class SolvableIdealTest extends TestCase {
036
037
038    /**
039     * main
040     */
041    public static void main(String[] args) {
042        junit.textui.TestRunner.run(suite());
043    }
044
045
046    /**
047     * Constructs a <CODE>SolvableIdealTest</CODE> object.
048     * @param name String.
049     */
050    public SolvableIdealTest(String name) {
051        super(name);
052    }
053
054
055    /**
056     * suite.
057     */
058    public static Test suite() {
059        TestSuite suite = new TestSuite(SolvableIdealTest.class);
060        return suite;
061    }
062
063
064    TermOrder to;
065
066
067    GenSolvablePolynomialRing<BigRational> fac;
068
069
070    List<GenSolvablePolynomial<BigRational>> L, M;
071
072
073    PolynomialList<BigRational> F;
074
075
076    List<GenSolvablePolynomial<BigRational>> G;
077
078
079    SolvableGroebnerBase<BigRational> bb;
080
081
082    GenSolvablePolynomial<BigRational> a, b, c, d, e;
083
084
085    int rl = 4; // even for Weyl relations
086
087
088    int kl = 2; //10
089
090
091    int ll = 3; //7
092
093
094    int el = 3;
095
096
097    float q = 0.15f; //0.4f
098
099
100    @Override
101    protected void setUp() {
102        BigRational coeff = new BigRational(17, 1);
103        to = new TermOrder(TermOrder.INVLEX);
104        String[] vars = new String[] { "w", "x", "y", "z" };
105        fac = new GenSolvablePolynomialRing<BigRational>(coeff, rl, to, vars);
106        RelationGenerator<BigRational> wl = new WeylRelations<BigRational>();
107        wl.generate(fac);
108        bb = new SolvableGroebnerBaseSeq<BigRational>();
109        //bb = GBFactory.getImplementation(coeff);
110        a = b = c = d = e = null;
111    }
112
113
114    @Override
115    protected void tearDown() {
116        a = b = c = d = e = null;
117        fac = null;
118        bb = null;
119        ComputerThreads.terminate();
120    }
121
122
123    /**
124     * Test left ideal sum.
125     */
126    public void testLeftIdealSum() {
127        SolvableIdeal<BigRational> I, J, K;
128        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
129
130        a = fac.random(kl, ll, el, q);
131        b = fac.random(kl, ll, el, q);
132        c = fac.random(kl, ll, el, q);
133        d = fac.random(kl, ll, el, q);
134        e = d; //fac.random(kl, ll, el, q );
135
136        L = PolynomialList.castToSolvableList(fac.generators());
137        //System.out.println("generators: " + L);
138        int k = L.size() - rl;
139        if (a.isZERO()) {
140            a = L.get(k++);
141        }
142        if (b.isZERO()) {
143            b = L.get(k++);
144        }
145        if (c.isZERO()) {
146            c = L.get(k++);
147        }
148        if (d.isZERO()) {
149            d = L.get(k++);
150            e = d;
151        }
152
153        assertTrue("not isZERO( a )", !a.isZERO());
154        L.add(a);
155
156        I = new SolvableIdeal<BigRational>(fac, L, true);
157        assertTrue("not isZERO( I )", !I.isZERO());
158        //assertTrue("not isONE( I )", !I.isONE());
159        assertTrue("isGB( I )", I.isGB());
160
161        I = new SolvableIdeal<BigRational>(fac, L, false);
162        assertTrue("not isZERO( I )", !I.isZERO());
163        //assertTrue("not isONE( I )", !I.isONE());
164        assertTrue("isGB( I ): " + I.toScript(), I.isGB());
165
166        L = bb.leftGB(L);
167        assertTrue("isGB( { a } )", bb.isLeftGB(L));
168
169        I = new SolvableIdeal<BigRational>(fac, L, true);
170        assertTrue("not isZERO( I )", !I.isZERO());
171        //assertTrue("not isONE( I )", !I.isONE() );
172        assertTrue("isGB( I )", I.isGB());
173
174        I = new SolvableIdeal<BigRational>(fac, L, false);
175        assertTrue("not isZERO( I )", !I.isZERO());
176        //assertTrue("not isONE( I )", !I.isONE() );
177        assertTrue("isGB( I )", I.isGB());
178
179        String s = I.toScript() + "\n" + I.toString();
180        //System.out.println("#s = " + s.length() + ": " + s);
181        assertTrue("#s >= 260: ", s.length() >= 260);
182
183        K = I.getZERO();
184        assertTrue("K == 0: " + K, K.isZERO());
185        K = I.getONE();
186        assertTrue("K == 1: " + K, K.isONE());
187
188        assertTrue("not isZERO( b )", !b.isZERO());
189        L.add(b);
190        //System.out.println("L = " + L.size() );
191
192        I = new SolvableIdeal<BigRational>(fac, L, false);
193        assertTrue("not isZERO( I )", !I.isZERO());
194        //assertTrue("not isONE( I )", !I.isONE() );
195        //assertTrue("not isGB( I )", !I.isGB() );
196
197        L = bb.leftGB(L);
198        assertTrue("isGB( { a, b } )", bb.isLeftGB(L));
199
200        I = new SolvableIdeal<BigRational>(fac, L, true);
201        assertTrue("not isZERO( I )", !I.isZERO());
202        // assertTrue("not isONE( I )", !I.isONE() );
203        assertTrue("isGB( I )", I.isGB());
204
205        J = I;
206        K = J.sum(I);
207        assertTrue("not isZERO( K )", !K.isZERO());
208        assertTrue("isGB( K )", K.isGB());
209        assertTrue("equals( K, I )", K.equals(I));
210
211        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
212        assertTrue("not isZERO( c )", !c.isZERO());
213        L.add(c);
214        assertTrue("isGB( { c } )", bb.isLeftGB(L));
215
216        J = new SolvableIdeal<BigRational>(fac, L, true);
217        K = J.sum(I);
218        assertTrue("not isZERO( K )", !K.isZERO());
219        assertTrue("isGB( K )", K.isGB());
220        assertTrue("K contains(I)", K.contains(I));
221        assertTrue("K contains(J)", K.contains(J));
222
223        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
224        assertTrue("not isZERO( d )", !d.isZERO());
225        L.add(d);
226
227        assertTrue("isGB( { d } )", bb.isLeftGB(L));
228        J = new SolvableIdeal<BigRational>(fac, L, true);
229        I = K;
230        K = J.sum(I);
231        assertTrue("not isZERO( K )", !K.isZERO());
232        assertTrue("isGB( K )", K.isGB());
233        assertTrue("K contains(I)", K.contains(I));
234        assertTrue("K contains(J)", K.contains(J));
235
236        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
237        assertTrue("not isZERO( e )", !e.isZERO());
238        L.add(e);
239
240        assertTrue("isGB( { e } )", bb.isLeftGB(L));
241        J = new SolvableIdeal<BigRational>(fac, L, true);
242        I = K;
243        K = J.sum(I);
244        assertTrue("not isZERO( K )", !K.isZERO());
245        assertTrue("isGB( K )", K.isGB());
246        assertTrue("equals( K, I )", K.equals(I));
247        assertTrue("K contains(J)", K.contains(I));
248        assertTrue("I contains(K)", I.contains(K));
249        L = K.normalform(I.getList());
250        I = new SolvableIdeal<BigRational>(fac, L, false);
251        //System.out.println("I = " + I);
252        assertTrue("I mod K == 0: " + I, I.isZERO());
253
254        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
255        L.add(a);
256        L.add(b);
257        I = new SolvableIdeal<BigRational>(fac, L, false);
258        I.doGB();
259        J = I.power(3);
260        J = J.power(2);
261        K = I.power(6);
262        //System.out.println("I = " + I);
263        //System.out.println("J = " + J);
264        //System.out.println("K = " + K);
265        assertEquals("equals( (I**3)**2, I**6 )", K, J);
266
267        if (I.isUnit(c)) {
268            d = I.inverse(c);
269            e = I.normalform(d.multiply(c));
270            //System.out.println("c = " + c);
271            //System.out.println("d = " + d);
272            //System.out.println("d*c mod I = " + e);
273            assertTrue("inv(c) * c mod I == 1: " + e, e.isONE());
274        }
275    }
276
277
278    /**
279     * Test right ideal sum.
280     */
281    public void testRightIdealSum() {
282        SolvableIdeal<BigRational> Ir, Jr, Kr;
283        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
284
285        a = fac.random(kl, ll, el, q);
286        b = fac.random(kl, ll, el, q);
287        c = fac.random(kl, ll, el, q);
288        d = fac.random(kl, ll, el, q);
289        e = d; //fac.random(kl, ll, el, q );
290
291        L = PolynomialList.castToSolvableList(fac.generators());
292        //System.out.println("generators: " + L);
293        int k = L.size() - rl;
294        if (a.isZERO()) {
295            a = L.get(k++);
296        }
297        if (b.isZERO()) {
298            b = L.get(k++);
299        }
300        if (c.isZERO()) {
301            c = L.get(k++);
302        }
303        if (d.isZERO()) {
304            d = L.get(k++);
305            e = d;
306        }
307
308        assertTrue("not isZERO( a )", !a.isZERO());
309        L.add(a);
310
311        Ir = new SolvableIdeal<BigRational>(fac, L, true, SolvableIdeal.Side.right);
312        assertTrue("not isZERO( Ir )", !Ir.isZERO());
313        //assertTrue("not isONE( Ir )", !Ir.isONE());
314        assertTrue("isGB( Ir )", Ir.isGB());
315
316        Ir = new SolvableIdeal<BigRational>(fac, L, false, SolvableIdeal.Side.right);
317        assertTrue("not isZERO( Ir )", !Ir.isZERO());
318        //assertTrue("not isONE( Ir )", !Ir.isONE());
319        assertTrue("isGB( Ir ): " + Ir.toScript(), Ir.isGB());
320        assertTrue("isGB( Ir )", Ir.isRightGB());
321
322        L = bb.rightGB(L);
323        assertTrue("isGB( { a } )", bb.isRightGB(L));
324
325        Ir = new SolvableIdeal<BigRational>(fac, L, true, SolvableIdeal.Side.right);
326        assertTrue("not isZERO( Ir )", !Ir.isZERO());
327        //assertTrue("not isONE( Ir )", !Ir.isONE() );
328        assertTrue("isGB( Ir )", Ir.isGB());
329        assertTrue("isGB( Ir )", Ir.isRightGB());
330
331        Ir = new SolvableIdeal<BigRational>(fac, L, false, SolvableIdeal.Side.right);
332        assertTrue("not isZERO( Ir )", !Ir.isZERO());
333        //assertTrue("not isONE( Ir )", !Ir.isONE() );
334        assertTrue("isGB( Ir )", Ir.isGB());
335        assertTrue("isGB( Ir )", Ir.isRightGB());
336
337        String s = Ir.toScript() + "\n" + Ir.toString();
338        //System.out.println("#s = " + s.length() + ": " + s);
339        assertTrue("#s >= 260: ", s.length() >= 260);
340
341        assertTrue("not isZERO( b )", !b.isZERO());
342        L.add(b);
343        //System.out.println("L = " + L.size() );
344
345        Ir = new SolvableIdeal<BigRational>(fac, L, false, SolvableIdeal.Side.right);
346        assertTrue("not isZERO( Ir )", !Ir.isZERO());
347        //assertTrue("not isONE( Ir )", !Ir.isONE() );
348        //assertTrue("not isGB( Ir )", !Ir.isGB() );
349
350        L = bb.rightGB(L);
351        assertTrue("isGB( { a, b } )", bb.isRightGB(L));
352
353        Ir = new SolvableIdeal<BigRational>(fac, L, true, SolvableIdeal.Side.right);
354        assertTrue("not isZERO( Ir )", !Ir.isZERO());
355        // assertTrue("not isONE( Ir )", !Ir.isONE() );
356        assertTrue("isGB( Ir )", Ir.isRightGB());
357        assertTrue("isGB( Ir )", Ir.isGB());
358        Jr = Ir.rightGB();
359        assertTrue("isGB( Jr )", Jr.isRightGB());
360
361        Jr = Ir;
362        Kr = Jr.sum(Ir);
363        assertTrue("not isZERO( Kr )", !Kr.isZERO());
364        assertTrue("isGB( Kr )", Kr.isGB());
365        assertTrue("isGB( Kr )", Kr.isRightGB());
366        assertTrue("equals( Kr, Ir )", Kr.equals(Ir));
367
368        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
369        assertTrue("not isZERO( c )", !c.isZERO());
370        L.add(c);
371        assertTrue("isGB( { c } )", bb.isRightGB(L));
372
373        Jr = new SolvableIdeal<BigRational>(fac, L, true, SolvableIdeal.Side.right);
374        Kr = Jr.sum(Ir);
375        assertTrue("not isZERO( Kr )", !Kr.isZERO());
376        assertTrue("isGB( Kr )", Kr.isGB());
377        assertTrue("isGB( Kr )", Kr.isRightGB());
378        assertTrue("Kr contains(Ir)", Kr.contains(Ir));
379        assertTrue("Kr contains(Jr)", Kr.contains(Jr));
380
381        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
382        assertTrue("not isZERO( d )", !d.isZERO());
383        L.add(d);
384
385        assertTrue("isGB( { d } )", bb.isRightGB(L));
386        Jr = new SolvableIdeal<BigRational>(fac, L, true, SolvableIdeal.Side.right);
387        Ir = Kr;
388        Kr = Jr.sum(Ir);
389        assertTrue("not isZERO( Kr )", !Kr.isZERO());
390        assertTrue("isGB( Kr )", Kr.isGB());
391        assertTrue("isGB( Kr )", Kr.isRightGB());
392        assertTrue("Kr contains(Ir)", Kr.contains(Ir));
393        assertTrue("Kr contains(Jr)", Kr.contains(Jr));
394
395        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
396        assertTrue("not isZERO( e )", !e.isZERO());
397        L.add(e);
398
399        assertTrue("isGB( { e } )", bb.isRightGB(L));
400        Jr = new SolvableIdeal<BigRational>(fac, L, true, SolvableIdeal.Side.right);
401        Ir = Kr;
402        Kr = Jr.sum(Ir);
403        assertTrue("not isZERO( Kr )", !Kr.isZERO());
404        assertTrue("isGB( Kr )", Kr.isGB());
405        assertTrue("isGB( Kr )", Kr.isRightGB());
406        assertTrue("equals( Kr, Ir )", Kr.equals(Ir));
407        assertTrue("Kr contains(Jr)", Kr.contains(Ir));
408        assertTrue("Ir contains(Kr)", Ir.contains(Kr));
409    }
410
411
412    /**
413     * Test twosided ideal sum.
414     */
415    public void testTwosideIdealSum() {
416        SolvableIdeal<BigRational> It, Jt, Kt;
417        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
418
419        a = fac.random(kl, ll, el, q);
420        b = fac.random(kl, ll, el, q);
421        c = fac.random(kl, ll, el, q);
422        d = fac.random(kl, ll, el, q);
423        e = d; //fac.random(kl, ll, el, q );
424
425        L = PolynomialList.castToSolvableList(fac.generators());
426        //System.out.println("generators: " + L);
427        int k = L.size() - rl;
428        if (a.isZERO()) {
429            a = L.get(k++);
430        }
431        if (b.isZERO()) {
432            b = L.get(k++);
433        }
434        if (c.isZERO()) {
435            c = L.get(k++);
436        }
437        if (d.isZERO()) {
438            d = L.get(k++);
439            e = d;
440        }
441
442        assertTrue("not isZERO( a )", !a.isZERO());
443        L.add(a);
444
445        It = new SolvableIdeal<BigRational>(fac, L, true, SolvableIdeal.Side.twosided);
446        assertTrue("not isZERO( It )", !It.isZERO());
447        //assertTrue("not isONE( It )", !It.isONE());
448        assertTrue("isGB( It )", It.isGB());
449
450        L = bb.twosidedGB(L);
451        assertTrue("isGB( { a } )", bb.isTwosidedGB(L));
452        It = new SolvableIdeal<BigRational>(fac, L, false, SolvableIdeal.Side.twosided);
453        assertTrue("not isZERO( It )", !It.isZERO());
454        //assertTrue("not isONE( It )", !It.isONE());
455        assertTrue("isGB( It ): " + It.toScript(), It.isGB());
456        assertTrue("is2sGB( It ): " + It.toScript(), It.isTwosidedGB());
457
458        It = new SolvableIdeal<BigRational>(fac, L, true, SolvableIdeal.Side.twosided);
459        assertTrue("not isZERO( It )", !It.isZERO());
460        //assertTrue("not isONE( It )", !It.isONE() );
461        assertTrue("isGB( It )", It.isGB());
462
463        String s = It.toScript() + "\n" + It.toString();
464        //System.out.println("#s = " + s.length() + ": " + s);
465        assertTrue("#s >= 260: ", s.length() >= 260);
466
467        assertTrue("not isZERO( b )", !b.isZERO());
468        L.add(b);
469        //System.out.println("L = " + L.size() );
470
471        It = new SolvableIdeal<BigRational>(fac, L, false, SolvableIdeal.Side.twosided);
472        assertTrue("not isZERO( It )", !It.isZERO());
473        //assertTrue("not isONE( It )", !It.isONE() );
474        //assertTrue("not isGB( It )", !It.isGB() );
475
476        L = bb.twosidedGB(L);
477        assertTrue("isGB( { a, b } )", bb.isTwosidedGB(L));
478        It = new SolvableIdeal<BigRational>(fac, L, true, SolvableIdeal.Side.twosided);
479        assertTrue("not isZERO( It )", !It.isZERO());
480        // assertTrue("not isONE( It )", !It.isONE() );
481        assertTrue("isGB( It )", It.isGB());
482        assertTrue("is2sGB( It ): " + It.toScript(), It.isTwosidedGB());
483
484        Jt = It;
485        Kt = Jt.sum(It);
486        assertTrue("not isZERO( Kt )", !Kt.isZERO());
487        assertTrue("isGB( Kt )", Kt.isGB());
488        assertTrue("equals( Kt, It )", Kt.equals(It));
489
490        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
491        assertTrue("not isZERO( c )", !c.isZERO());
492        L.add(c);
493        L = bb.twosidedGB(L);
494        assertTrue("isGB( { c } )", bb.isTwosidedGB(L));
495
496        Jt = new SolvableIdeal<BigRational>(fac, L, true, SolvableIdeal.Side.twosided);
497        Kt = Jt.sum(It);
498        assertTrue("not isZERO( Kt )", !Kt.isZERO());
499        assertTrue("isGB( Kt )", Kt.isGB());
500        assertTrue("Kt equals(It)", Kt.equals(It));
501        assertTrue("Kt equals(Jt)", Kt.equals(Jt));
502
503        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
504        assertTrue("not isZERO( d )", !d.isZERO());
505        L.add(d);
506        L = bb.twosidedGB(L);
507        assertTrue("isGB( { d } )", bb.isTwosidedGB(L));
508        Jt = new SolvableIdeal<BigRational>(fac, L, true, SolvableIdeal.Side.twosided);
509        assertTrue("is2sGB( Jt ): " + Jt.toScript(), Jt.isTwosidedGB());
510        It = Kt;
511        Kt = Jt.sum(It);
512        assertTrue("not isZERO( Kt )", !Kt.isZERO());
513        assertTrue("isGB( Kt )", Kt.isGB());
514        assertTrue("Kt equals(It)", Kt.equals(It));
515        assertTrue("Kt equals(Jt)", Kt.equals(Jt));
516
517        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
518        assertTrue("not isZERO( e )", !e.isZERO());
519        L.add(e);
520
521        assertTrue("isGB( { e } )", bb.isRightGB(L));
522        Jt = new SolvableIdeal<BigRational>(fac, L, true, SolvableIdeal.Side.twosided);
523        It = Kt;
524        Kt = Jt.sum(It);
525        assertTrue("not isZERO( Kt )", !Kt.isZERO());
526        assertTrue("isGB( Kt )", Kt.isGB());
527        assertTrue("equals( Kt, It )", Kt.equals(It));
528        //assertTrue("Kt contains(Jt)", Kt.contains(It));
529        //assertTrue("It contains(Kt)", It.contains(Kt));
530    }
531
532
533    /**
534     * Test SolvableIdeal product.
535     */
536    public void testSolvableIdealProduct() {
537        SolvableIdeal<BigRational> I, J, K, H;
538        a = fac.random(kl, ll, el, q);
539        b = fac.random(kl, ll, el - 1, q);
540        c = fac.random(kl, ll, el - 1, q);
541        d = c; //fac.random(kl, ll, el, q);
542        e = d; //fac.random(kl, ll, el, q );
543
544        if (a.isZERO() || b.isZERO() || c.isZERO() || d.isZERO()) {
545            return;
546        }
547
548        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
549        //assertTrue("not isZERO( a )", !a.isZERO());
550        L.add(a);
551
552        I = new SolvableIdeal<BigRational>(fac, L, false);
553        assertTrue("not isZERO( I )", !I.isZERO());
554        assertTrue("not isONE( I )", !I.isONE() || a.isConstant());
555        assertTrue("isGB( I ): " + I.toScript(), I.isGB());
556
557        H = I.leftProduct(b);
558        assertTrue("not isZERO( H )", !H.isZERO());
559        assertTrue("isGB( H )", H.isGB());
560        //non-com: left okay
561        assertTrue("I contains(H)", I.contains(H));
562        //System.out.println("I = " + I);
563        //System.out.println("b = " + b);
564        //System.out.println("H = " + H);
565
566        H = I.product(b);
567        assertTrue("not isZERO( H )", !H.isZERO());
568        assertTrue("isGB( H )", H.isGB());
569        //non-com: not left assertTrue("I contains(H)", I.contains(H));
570        //System.out.println("H = " + H);
571
572        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
573        assertTrue("not isZERO( b )", !b.isZERO());
574        L.add(b);
575
576        J = new SolvableIdeal<BigRational>(fac, L, false);
577        assertTrue("not isZERO( J )", !J.isZERO());
578        assertTrue("not isONE( J )", !J.isONE() || a.isConstant() || b.isConstant());
579        assertTrue("isGB( J ): " + J.toScript(), J.isGB());
580
581        K = I.product(J);
582        //System.out.println("I = " + I);
583        //System.out.println("J = " + J);
584        //System.out.println("K = " + K);
585        assertTrue("not isZERO( K )", !K.isZERO());
586        assertTrue("isGB( K )", K.isGB());
587        //non-com assertTrue("I contains(K)", I.contains(K));
588        assertTrue("J contains(K)", J.contains(K));
589        assertEquals("H == K: ", H, K);
590
591        H = I.intersect(J);
592        assertTrue("not isZERO( H )", !H.isZERO());
593        assertTrue("isGB( H )", H.isGB());
594        assertTrue("I contains(H)", I.contains(H));
595        assertTrue("J contains(H)", J.contains(H));
596        //non-com assertTrue("H contains(K)", H.contains(K));
597
598        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
599        assertTrue("not isZERO( a )", !a.isZERO());
600        L.add(a);
601        assertTrue("not isZERO( c )", !c.isZERO());
602        L.add(c);
603        L = bb.leftGB(L);
604
605        I = new SolvableIdeal<BigRational>(fac, L, true);
606        assertTrue("not isZERO( I )", !I.isZERO());
607        //assertTrue("not isONE( I )", !I.isONE() );
608        assertTrue("isGB( I )", I.isGB());
609
610        K = I.product(J);
611        assertTrue("not isZERO( K )", !K.isZERO());
612        assertTrue("isGB( K )", K.isGB());
613        //non-com assertTrue("I contains(K)", I.contains(K));
614        assertTrue("J contains(K)", J.contains(K));
615
616        H = I.intersect(J);
617        assertTrue("not isZERO( H )", !H.isZERO());
618        assertTrue("isGB( H )", H.isGB());
619        assertTrue("I contains(H)", I.contains(H));
620        assertTrue("J contains(H)", J.contains(H));
621        //non-com assertTrue("H contains(K)", H.contains(K));
622
623        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
624        assertTrue("not isZERO( b )", !b.isZERO());
625        L.add(b);
626        assertTrue("not isZERO( d )", !d.isZERO());
627        L.add(d);
628        L = bb.leftGB(L);
629
630        J = new SolvableIdeal<BigRational>(fac, L, true);
631        assertTrue("not isZERO( J )", !J.isZERO());
632        //assertTrue("not isONE( J )", !J.isONE() );
633        assertTrue("isGB( J )", J.isGB());
634
635        K = I.product(J);
636        assertTrue("not isZERO( K )", !K.isZERO());
637        assertTrue("isGB( K )", K.isGB());
638        //non-com assertTrue("I contains(K)", I.contains(K));
639        assertTrue("J contains(K)", J.contains(K));
640
641        H = I.intersect(J);
642        assertTrue("not isZERO( H )", !H.isZERO());
643        assertTrue("isGB( H )", H.isGB());
644        assertTrue("I contains(H)", I.contains(H));
645        assertTrue("J contains(H)", J.contains(H));
646        //non-com assertTrue("H contains(K)", H.contains(K));
647
648        List<SolvableIdeal<BigRational>> si = new ArrayList<SolvableIdeal<BigRational>>();
649        si.add(K);
650        si.add(J);
651        H = I.intersect(si);
652        //System.out.println("I = " + I);
653        //System.out.println("si = " + si);
654        //System.out.println("H = " + H);
655        assertEquals("H == K: ", H, K);
656    }
657
658
659    /**
660     * Test SolvableIdeal quotient.
661     */
662    public void testSolvableIdealQuotient() {
663        SolvableIdeal<BigRational> I, J, K, H;
664        a = fac.random(kl, ll - 2, el, q);
665        b = fac.random(kl, ll, el, q / 2);
666        c = fac.random(kl, ll, el - 1, q);
667        d = c; //fac.random(kl, ll, el, q);
668        e = d; //fac.random(kl, ll, el, q );
669
670        L = PolynomialList.castToSolvableList(fac.generators());
671        //System.out.println("generators: " + L);
672        int k = L.size() - rl;
673        if (a.isZERO()) {
674            a = L.get(k++);
675        }
676        if (b.isZERO()) {
677            b = L.get(k++);
678        }
679        if (c.isZERO()) {
680            c = L.get(k++);
681        }
682        if (d.isZERO()) {
683            d = L.get(k++);
684        }
685
686        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
687        assertTrue("not isZERO( a )", !a.isZERO());
688        L.add(a);
689        L = bb.leftGB(L);
690
691        I = new SolvableIdeal<BigRational>(fac, L, true);
692        assertTrue("not isZERO( I )", !I.isZERO());
693        //assertTrue("not isONE( I )", !I.isONE() );
694        assertTrue("isGB( I )", I.isGB());
695
696        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
697        assertTrue("not isZERO( b )", !a.isZERO());
698        L.add(b);
699        L = bb.leftGB(L);
700
701        J = new SolvableIdeal<BigRational>(fac, L, true);
702        assertTrue("not isZERO( J )", !J.isZERO());
703        //assertTrue("not isONE( J )", !J.isONE() );
704        assertTrue("isGB( J )", J.isGB());
705
706        K = I.product(J);
707        assertTrue("not isZERO( K )", !K.isZERO());
708        assertTrue("isGB( K )", K.isGB());
709        //non-com assertTrue("I contains(K)", I.contains(K));
710        assertTrue("J contains(K)", J.contains(K));
711
712        H = K.quotient(J.getList().get(0));
713        assertTrue("not isZERO( H )", !H.isZERO());
714        assertTrue("isGB( H )", H.isGB());
715        //non-com assertTrue("equals(H,I)", H.equals(I)); // GBs only
716
717        H = K.quotient(J);
718        assertTrue("not isZERO( H )", !H.isZERO());
719        assertTrue("isGB( H )", H.isGB());
720        //non-com assertTrue("equals(H,I)", H.equals(I)); // GBs only
721
722        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
723        assertTrue("not isZERO( b )", !b.isZERO());
724        L.add(b);
725        assertTrue("not isZERO( c )", !c.isZERO());
726        L.add(c);
727        L = bb.leftGB(L);
728
729        J = new SolvableIdeal<BigRational>(fac, L, true);
730        assertTrue("not isZERO( J )", !J.isZERO());
731        //assertTrue("not isONE( J )", !J.isONE() );
732        assertTrue("isGB( J )", J.isGB());
733
734        K = I.product(J);
735        assertTrue("not isZERO( K )", !K.isZERO());
736        assertTrue("isGB( K )", K.isGB());
737        //non-com assertTrue("I contains(K)", I.contains(K));
738        assertTrue("J contains(K)", J.contains(K));
739
740        H = K.quotient(J);
741        assertTrue("not isZERO( H )", !H.isZERO());
742        assertTrue("isGB( H )", H.isGB());
743        //non-com assertTrue("equals(H,I)", H.equals(I)); // GBs only
744
745        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
746        assertTrue("not isZERO( a )", !a.isZERO());
747        L.add(a);
748        assertTrue("not isZERO( d )", !d.isZERO());
749        L.add(d);
750        L = bb.leftGB(L);
751
752        I = new SolvableIdeal<BigRational>(fac, L, true);
753        assertTrue("not isZERO( I )", !I.isZERO());
754        //assertTrue("not isONE( J )", !J.isONE() );
755        assertTrue("isGB( I )", I.isGB());
756
757        K = I.product(J);
758        assertTrue("not isZERO( K )", !K.isZERO());
759        assertTrue("isGB( K )", K.isGB());
760        //non-com assertTrue("I contains(K)", I.contains(K));
761        assertTrue("J contains(K)", J.contains(K));
762
763        H = K.quotient(J);
764        assertTrue("not isZERO( H )", !H.isZERO());
765        assertTrue("isGB( H )", H.isGB());
766        //non-com assertTrue("equals(H,I)", H.equals(I)); // GBs only
767    }
768
769
770    /**
771     * Test SolvableIdeal infinite quotient.
772     */
773    public void testSolvableIdealInfiniteQuotient() {
774        SolvableIdeal<BigRational> I, J, K;
775        a = fac.random(kl, ll - 2, el, q);
776        b = fac.random(kl, ll - 1, el - 1, q);
777        c = fac.random(kl, ll / 2, el - 1, q / 2);
778        //a = fac.parse(" -1/2 w");
779        //b = fac.parse(" y - 2/3");
780        //c = fac.parse(" -2 w * y + 4/3 w + 2");
781        //c = fac.parse(" -2 y^2 + 8/3 y - 8/9");
782        d = c; //fac.random(kl, ll, el, q);
783        e = d; //fac.random(kl, ll, el, q );
784
785        L = PolynomialList.castToSolvableList(fac.generators());
786        //System.out.println("generators: " + L);
787        int k = L.size() - rl;
788        if (a.isZERO()) {
789            a = L.get(k++);
790        }
791        if (b.isZERO()) {
792            b = L.get(k++);
793        }
794        if (c.isZERO()) {
795            c = L.get(k++);
796        }
797        if (d.isZERO()) {
798            d = L.get(k++);
799            e = d;
800        }
801
802        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
803        assertTrue("not isZERO( b )", !b.isZERO());
804        L.add(b);
805        L = bb.leftGB(L);
806        I = new SolvableIdeal<BigRational>(fac, L, true);
807        assertTrue("not isZERO( I )", !I.isZERO());
808        //assertTrue("not isONE( I )", !I.isONE() );
809        assertTrue("isGB( I )", I.isGB());
810
811        J = I.infiniteQuotient(a);
812        int x = I.infiniteQuotientExponent(a, J);
813        //System.out.println("I, a, J, x: " + I.toScript() + ", " + a + ", " + J.toScript() + ", " + x);
814        assertTrue("x >= 0: " + x, x >= 0);
815
816        assertTrue("not isZERO( c )", !c.isZERO());
817        L.add(c);
818        L = bb.leftGB(L);
819        I = new SolvableIdeal<BigRational>(fac, L, true);
820        assertTrue("not isZERO( I )", !I.isZERO());
821        //assertTrue("not isONE( I )", !I.isONE() );
822        assertTrue("isGB( I )", I.isGB());
823
824        J = I.infiniteQuotient(a);
825        assertTrue("contains(J,I): " + J.toScript() + ", " + I.toScript(), J.contains(I)); // GBs only
826
827        assertTrue("not isZERO( d )", !d.isZERO());
828        L.add(d);
829        L = bb.leftGB(L);
830        I = new SolvableIdeal<BigRational>(fac, L, true);
831        assertTrue("not isZERO( I )", !I.isZERO());
832        //assertTrue("not isONE( I )", !I.isONE() );
833        assertTrue("isGB( I )", I.isGB());
834
835        J = I.infiniteQuotient(a);
836        assertTrue("isGB( J )", J.isGB());
837        assertTrue("contains(J,I)", J.contains(I)); // GBs only
838
839        G = new ArrayList<GenSolvablePolynomial<BigRational>>();
840        assertTrue("not isZERO( a )", !a.isZERO());
841        G.add(a);
842        G = bb.leftGB(G);
843        K = new SolvableIdeal<BigRational>(fac, G, true);
844        assertTrue("not isZERO( K )", !K.isZERO());
845        //assertTrue("not isONE( I )", !I.isONE() );
846        assertTrue("isGB( K )", K.isGB());
847
848        J = I.infiniteQuotient(K);
849        assertTrue("contains(J,I)", J.contains(I)); // GBs only
850
851        assertTrue("not isZERO( e ): + e", !e.isZERO());
852        G.add(e);
853        G = bb.leftGB(G);
854        K = new SolvableIdeal<BigRational>(fac, G, true);
855        assertTrue("not isZERO( K )", !K.isZERO());
856        //assertTrue("not isONE( I )", !I.isONE() );
857        assertTrue("isGB( K )", K.isGB());
858
859        J = I.infiniteQuotient(K);
860        assertTrue("contains(J,I)", J.contains(I)); // GBs only
861    }
862
863
864    /**
865     * Test (commutative) SolvableIdeal infinite quotient with Rabinowich trick.
866     */
867    public void testSolvableIdealInfiniteQuotientRab() {
868        fac = new GenSolvablePolynomialRing<BigRational>(fac.coFac, rl, fac.tord, fac.getVars());
869        SolvableIdeal<BigRational> I, J, K, JJ;
870        a = fac.random(kl - 1, ll - 1, el - 1, q / 2);
871        b = fac.random(kl - 1, ll - 1, el, q / 2);
872        c = fac.random(kl - 1, ll - 1, el, q / 2);
873        d = fac.random(kl - 1, ll - 1, el, q / 2);
874        e = a; //fac.random(kl, ll-1, el, q );
875
876        L = PolynomialList.castToSolvableList(fac.generators());
877        //System.out.println("generators: " + L);
878        int k = L.size() - rl;
879        if (a.isZERO()) {
880            a = L.get(k++);
881        }
882        if (b.isZERO()) {
883            b = L.get(k++);
884        }
885        if (c.isZERO()) {
886            c = L.get(k++);
887        }
888        if (d.isZERO()) {
889            d = L.get(k++);
890        }
891
892        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
893        assertTrue("not isZERO( b )", !b.isZERO());
894        L.add(b);
895        L = bb.leftGB(L);
896        I = new SolvableIdeal<BigRational>(fac, L, true);
897        assertTrue("not isZERO( I )", !I.isZERO());
898        //assertTrue("not isONE( I )", !I.isONE() );
899        assertTrue("isGB( I )", I.isGB());
900
901        J = I.infiniteQuotientRab(a);
902        JJ = I.infiniteQuotient(a);
903        assertTrue("equals(J,JJ)", J.equals(JJ)); // GBs only
904
905        assertTrue("not isZERO( c )", !c.isZERO());
906        L.add(c);
907        L = bb.leftGB(L);
908        I = new SolvableIdeal<BigRational>(fac, L, true);
909        assertTrue("not isZERO( I )", !I.isZERO());
910        //assertTrue("not isONE( I )", !I.isONE() );
911        assertTrue("isGB( I )", I.isGB());
912
913        J = I.infiniteQuotientRab(a);
914        assertTrue("contains(J,I): " + J + ", " + I, J.contains(I)); // GBs only
915        JJ = I.infiniteQuotient(a);
916        assertTrue("contains(J,JJ): " + J + ", " + JJ, J.contains(JJ)); // GBs only
917
918        assertTrue("not isZERO( d )", !d.isZERO());
919        L.add(d);
920        L = bb.leftGB(L);
921        I = new SolvableIdeal<BigRational>(fac, L, true);
922        assertTrue("not isZERO( I )", !I.isZERO());
923        //assertTrue("not isONE( I )", !I.isONE() );
924        assertTrue("isGB( I )", I.isGB());
925
926        J = I.infiniteQuotientRab(a);
927        assertTrue("isGB( J )", J.isGB());
928        assertTrue("contains(J,I)", J.contains(I)); // GBs only
929        JJ = I.infiniteQuotient(a);
930        assertTrue("contains(J,JJ)", J.contains(JJ)); // GBs only
931
932        G = new ArrayList<GenSolvablePolynomial<BigRational>>();
933        assertTrue("not isZERO( a )", !a.isZERO());
934        G.add(a);
935        G = bb.leftGB(G);
936        K = new SolvableIdeal<BigRational>(fac, G, true);
937        assertTrue("not isZERO( K )", !K.isZERO());
938        //assertTrue("not isONE( I )", !I.isONE() );
939        assertTrue("isGB( K )", K.isGB());
940
941        J = I.infiniteQuotientRab(K);
942        assertTrue("contains(J,I)", J.contains(I)); // GBs only
943        JJ = I.infiniteQuotient(a);
944        assertTrue("contains(J,JJ)", J.contains(JJ)); // GBs only
945
946        assertTrue("not isZERO( e ): " + e, !e.isZERO());
947        G.add(e);
948        G = bb.leftGB(G);
949        K = new SolvableIdeal<BigRational>(fac, G, true);
950        assertTrue("not isZERO( K ): " + K, !K.isZERO());
951        //assertTrue("not isONE( I )", !I.isONE() );
952        assertTrue("isGB( K )", K.isGB());
953
954        J = I.infiniteQuotientRab(K);
955        assertTrue("contains(J,I)", J.contains(I)); // GBs only
956        JJ = I.infiniteQuotient(a);
957        assertTrue("contains(J,JJ)", J.contains(JJ)); // GBs only
958    }
959
960
961    /**
962     * Test (commutative) SolvableIdeal radical membership.
963     */
964    public void testSolvableIdealRadicalMember() {
965        fac = new GenSolvablePolynomialRing<BigRational>(fac.coFac, rl, fac.tord, fac.getVars());
966        SolvableIdeal<BigRational> I;
967        a = fac.random(kl - 1, ll, el - 1, q);
968        b = fac.random(kl - 1, ll, el, q);
969        c = fac.random(kl - 1, ll - 1, el, q / 2);
970        //d = fac.random(kl - 1, ll - 1, el, q / 2);
971        //e = a; //fac.random(kl, ll-1, el, q );
972
973        L = PolynomialList.castToSolvableList(fac.generators());
974        //System.out.println("generators: " + L);
975        int k = L.size() - rl;
976        if (a.isZERO()) {
977            a = L.get(k++);
978        }
979        if (b.isZERO()) {
980            b = L.get(k++);
981        }
982        if (c.isZERO()) {
983            c = L.get(k++);
984        }
985
986        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
987        L.add(b);
988        L = bb.leftGB(L);
989        I = new SolvableIdeal<BigRational>(fac, L, true);
990        assertTrue("not isZERO( I )", !I.isZERO());
991        //assertTrue("not isONE( I )", !I.isONE() );
992        assertTrue("isGB( I )", I.isGB());
993
994        //System.out.println("a = " + a);
995        //System.out.println("b = " + b);
996        //System.out.println("I = " + I);
997
998        if (!I.isONE() && !a.equals(b)) {
999            assertFalse("a in radical(b): " + a + ", " + b, I.isRadicalMember(a));
1000            assertTrue("b in radical(b): " + a + ", " + b, I.isRadicalMember(b));
1001        }
1002
1003        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
1004        L.add(b.multiply(b));
1005        L = bb.leftGB(L);
1006        I = new SolvableIdeal<BigRational>(fac, L, true);
1007        assertTrue("not isZERO( I )", !I.isZERO());
1008        //assertTrue("not isONE( I )", !I.isONE() );
1009        assertTrue("isGB( I )", I.isGB());
1010
1011        //System.out.println("I = " + I);
1012
1013        if (!I.isONE() && !a.equals(b)) {
1014            assertFalse("a in radical(b*b)", I.isRadicalMember(a));
1015            assertTrue("b in radical(b*b)", I.isRadicalMember(b));
1016        }
1017
1018        //System.out.println("c = " + c);
1019        L.add(c);
1020        L = bb.leftGB(L);
1021        I = new SolvableIdeal<BigRational>(fac, L, true);
1022        assertTrue("not isZERO( I )", !I.isZERO());
1023        //assertTrue("not isONE( I )", !I.isONE() );
1024        assertTrue("isGB( I )", I.isGB());
1025
1026        //System.out.println("I = " + I);
1027
1028        if (!I.isONE() && !a.equals(b)) {
1029            assertFalse("a in radical(b*b,c)", I.isRadicalMember(a));
1030            assertTrue("b in radical(b*b,c)", I.isRadicalMember(b));
1031        }
1032    }
1033
1034
1035    /**
1036     * Test SolvableIdeal common zeros.
1037     */
1038    @SuppressWarnings("unchecked")
1039    public void testSolvableIdealCommonZeros() {
1040        SolvableIdeal<BigRational> I;
1041        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
1042
1043        I = new SolvableIdeal<BigRational>(fac, L, true);
1044        assertEquals("commonZeroTest( I )", I.commonZeroTest(), 1);
1045
1046        a = fac.getZERO();
1047        L.add(a);
1048        I = new SolvableIdeal<BigRational>(fac, L, true);
1049        assertEquals("commonZeroTest( I )", I.commonZeroTest(), 1);
1050
1051        b = fac.getONE();
1052        L.add(b);
1053        I = new SolvableIdeal<BigRational>(fac, L, true);
1054        assertEquals("commonZeroTest( I )", I.commonZeroTest(), -1);
1055
1056        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
1057        a = fac.random(kl, ll, el, q);
1058        if (!a.isZERO() && !a.isConstant()) {
1059            L.add(a);
1060            I = new SolvableIdeal<BigRational>(fac, L, true);
1061            assertEquals("commonZeroTest( I )", I.commonZeroTest(), 1);
1062        }
1063
1064        L = (List<GenSolvablePolynomial<BigRational>>) fac.univariateList();
1065        I = new SolvableIdeal<BigRational>(fac, L, true);
1066        assertEquals("commonZeroTest( I )", I.commonZeroTest(), 0);
1067
1068        L.remove(0);
1069        I = new SolvableIdeal<BigRational>(fac, L, true);
1070        assertEquals("commonZeroTest( I )", I.commonZeroTest(), 1);
1071    }
1072
1073
1074    /**
1075     * Test SolvableIdeal dimension.
1076     */
1077    @SuppressWarnings("unchecked")
1078    public void testSolvableIdealDimension() {
1079        SolvableIdeal<BigRational> I;
1080        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
1081        Dimension dim;
1082
1083        I = new SolvableIdeal<BigRational>(fac, L, true);
1084        assertEquals("dimension( I )", rl, I.dimension().d);
1085
1086        a = fac.getZERO();
1087        L.add(a);
1088        I = new SolvableIdeal<BigRational>(fac, L, true);
1089        assertEquals("dimension( I )", rl, I.dimension().d);
1090
1091        b = fac.getONE();
1092        L.add(b);
1093        I = new SolvableIdeal<BigRational>(fac, L, true);
1094        assertEquals("dimension( I )", -1, I.dimension().d);
1095
1096        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
1097        a = fac.random(kl, ll, el, q);
1098        if (!a.isZERO() && !a.isConstant()) {
1099            L.add(a);
1100            I = new SolvableIdeal<BigRational>(fac, L, true);
1101            //System.out.println("a = " + a);
1102            dim = I.dimension();
1103            //System.out.println("dim(I) = " + dim);
1104            assertTrue("dimension( I )", dim.d >= 1);
1105        }
1106
1107        L = (List<GenSolvablePolynomial<BigRational>>) fac.univariateList();
1108        I = new SolvableIdeal<BigRational>(fac, L, true);
1109        dim = I.dimension();
1110        assertEquals("dimension( I )", 0, dim.d);
1111
1112        while (L.size() > 0) {
1113            L.remove(0);
1114            I = new SolvableIdeal<BigRational>(fac, L, true);
1115            //System.out.println("I = " + I);
1116            dim = I.dimension();
1117            //System.out.println("dim(I) = " + dim);
1118            assertEquals("dimension( I )", rl - L.size(), dim.d);
1119        }
1120
1121        L = (List<GenSolvablePolynomial<BigRational>>) fac.univariateList();
1122        I = new SolvableIdeal<BigRational>(fac, L, true);
1123        I = I.product(I);
1124        //System.out.println("I = " + I);
1125        dim = I.dimension();
1126        //System.out.println("dim(I) = " + dim);
1127        assertTrue("dimension( I )", 0 >= dim.d);
1128
1129        L = I.getList();
1130        while (L.size() > 0) {
1131            L.remove(0);
1132            I = new SolvableIdeal<BigRational>(fac, L, true);
1133            //System.out.println("I = " + I);
1134            dim = I.dimension();
1135            //System.out.println("dim(I) = " + dim);
1136            assertTrue("dimension( I )", dim.d > 0);
1137        }
1138    }
1139
1140
1141    /**
1142     * Test elimination SolvableIdeals.
1143     */
1144    public void testElimSolvableIdeal() {
1145        BigRational coeff = new BigRational(17, 1);
1146        String[] vars = new String[] { "w", "x", "y", "z" };
1147        fac = new GenSolvablePolynomialRing<BigRational>(coeff, rl, to, vars);
1148        RelationGenerator<BigRational> wli = new WeylRelationsIterated<BigRational>();
1149        wli.generate(fac);
1150        //String[] vars = fac.getVars();
1151        //System.out.println("vars = " + Arrays.toString(vars));
1152        //System.out.println("fac = " + fac);
1153
1154        SolvableIdeal<BigRational> I, J, K;
1155        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
1156        //non-com
1157        a = fac.univariate(0, 3L); //fac.random(kl, ll, el, q );
1158        b = fac.univariate(1, 2L); //fac.random(kl, ll, el, q );
1159        c = fac.univariate(0, 1L); //fac.random(kl, ll, el, q );
1160
1161        L.add(a);
1162        //L.add(b);
1163        L.add(c);
1164
1165        I = new SolvableIdeal<BigRational>(fac, L);
1166        I.doGB();
1167        //System.out.println("I = " + I.toScript());
1168        assertTrue("not isZERO( I )", !I.isZERO());
1169        //assertTrue("not isONE( I )", !I.isONE());
1170        assertTrue("isGB( I )", I.isGB());
1171
1172        List<String> sv = new ArrayList<String>(vars.length);
1173        for (int i = 0; i < vars.length; i++) {
1174            sv.add(vars[i]);
1175        }
1176        //System.out.println("sv    = " + sv);
1177
1178        for (int i = 2; i <= vars.length; i = i + 2) {
1179            KsubSet<String> ps = new KsubSet<String>(sv, i);
1180            //System.out.println("========================== ps : " + i);
1181            for (List<String> ev : ps) {
1182                int si = Collections.indexOfSubList(sv, ev);
1183                if (si < 0 || si % 2 != 0) { // substring and iterated Weyl algebra
1184                    continue;
1185                }
1186                //System.out.println("ev = " + ev);
1187                List<String> svr = new ArrayList<String>(vars.length);
1188                K = null;
1189                if (si != 0) { // and substring on even index
1190                    svr.addAll(ev);
1191                    for (String e : sv) {
1192                        if (svr.contains(e)) {
1193                            continue;
1194                        }
1195                        svr.add(e);
1196                    }
1197                    //System.out.println("svr = " + svr);
1198                    String[] rvars = new String[svr.size()];
1199                    for (int j = 0; j < svr.size(); j++) {
1200                        rvars[j] = svr.get(j);
1201                    }
1202                    List<Integer> P = new ArrayList<Integer>(sv.size());
1203                    for (int j = 0; j < rvars.length; j++) {
1204                        int k = sv.indexOf(rvars[j]);
1205                        P.add(k);
1206                    }
1207                    //System.out.println("P = " + P);
1208                    GenSolvablePolynomialRing<BigRational> rfac;
1209                    rfac = (GenSolvablePolynomialRing<BigRational>) fac.permutation(P);
1210                    //System.out.println("rfac = " + rfac.toScript());
1211                    List<GenSolvablePolynomial<BigRational>> id = TermOrderOptimization
1212                                    .<BigRational> permutation(P, rfac, I.list.castToSolvableList());
1213                    K = new SolvableIdeal<BigRational>(rfac, id);
1214                    //System.out.println("K = " + K.toScript());
1215                    //continue;
1216                }
1217                String[] evars = new String[ev.size()];
1218                for (int j = 0; j < ev.size(); j++) {
1219                    evars[j] = ev.get(j);
1220                }
1221                GenSolvablePolynomialRing<BigRational> efac;
1222                efac = new GenSolvablePolynomialRing<BigRational>(fac.coFac, evars.length, fac.tord, evars);
1223                //RelationGenerator<BigRational> wl = new WeylRelations<BigRational>();
1224                RelationGenerator<BigRational> wl = new WeylRelationsIterated<BigRational>();
1225                wl.generate(efac);
1226                //System.out.println("efac = " + efac.toScript());
1227
1228                if (K == null) {
1229                    J = I.eliminate(efac);
1230                } else {
1231                    J = K.eliminate(efac);
1232                }
1233                //System.out.println("J = " + J.toScript());
1234                assertTrue("isGB( J ): " + J.toScript(), J.isGB());
1235                assertTrue("size( J ) <=  |ev|", J.getList().size() <= ev.size());
1236            }
1237        }
1238    }
1239
1240
1241    /**
1242     * Test univariate polynomials in ideal.
1243     */
1244    public void testUnivPoly() {
1245        String[] vars;
1246        BigRational coeff = new BigRational(17, 1);
1247        to = new TermOrder(TermOrder.INVLEX);
1248        vars = new String[] { "w", "x", "y", "z" };
1249        fac = new GenSolvablePolynomialRing<BigRational>(coeff, rl, to, vars);
1250
1251        vars = fac.getVars();
1252        //System.out.println("vars = " + Arrays.toString(vars));
1253        //System.out.println("fac = " + fac);
1254        assertTrue("vars.length == 4 ", vars.length == 4);
1255
1256        SolvableIdeal<BigRational> I;
1257        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
1258
1259        a = fac.parse("( x^3 + 34/55 x^2 + 1/9 x + 99 )");
1260        b = fac.parse("( y^4 - x )");
1261        c = fac.parse("( z^3 - x y )");
1262        d = fac.parse("( w^2 + 3 )");
1263
1264        if (a.isZERO() || b.isZERO() || c.isZERO()) {
1265            return;
1266        }
1267
1268        L.add(a);
1269        L.add(b);
1270        L.add(c);
1271        L.add(d);
1272        I = new SolvableIdeal<BigRational>(fac, L);
1273        //I.doGB();
1274        assertTrue("not isZERO( I )", !I.isZERO());
1275        assertTrue("isGB( I )", I.isGB());
1276        //System.out.println("I = " + I);
1277
1278        for (int i = 0; i < rl; i++) { // rl
1279            GenSolvablePolynomial<BigRational> u = I.constructUnivariate(rl - 1 - i);
1280            //System.out.println("u = " + u);
1281            GenSolvablePolynomial<BigRational> U = fac.parse(u.toString());
1282            //System.out.println("U = " + U + "\n");
1283            assertTrue("I.contains(U) ", I.contains(U));
1284        }
1285
1286        List<GenSolvablePolynomial<BigRational>> Us = I.constructUnivariate();
1287        for (GenSolvablePolynomial<BigRational> u : Us) {
1288            //System.out.println("u = " + u);
1289            GenSolvablePolynomial<BigRational> U = fac.parse(u.toString());
1290            //System.out.println("U = " + U + "\n");
1291            assertTrue("I.contains(U) ", I.contains(U));
1292        }
1293    }
1294
1295
1296    /**
1297     * Test SolvableIdeal annihilator.
1298     */
1299    public void testAnnihilator() {
1300        SolvableIdeal<BigRational> I, J, K;
1301        do {
1302            a = fac.random(kl, ll, el, q);
1303        } while (a.isZERO() || a.isConstant());
1304        b = fac.univariate(1);
1305        c = fac.univariate(rl - 1);
1306        //b = fac.random(kl - 1, ll, el, q);
1307        //c = fac.random(kl - 1, ll - 1, el, q / 2);
1308
1309        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
1310        L.add(a);
1311        L.add(b);
1312        //L.add(c);
1313        //System.out.println("L = " + L);
1314        L = bb.leftGB(L);
1315        I = new SolvableIdeal<BigRational>(fac, L, true);
1316        assertTrue("isGB( I )", I.isGB());
1317        //System.out.println("I = " + I + "\n");
1318
1319        J = I.annihilator(c);
1320        //System.out.println("J = " + J + "\n");
1321        J.doGB();
1322        //System.out.println("c = " + c);
1323        //System.out.println("J = " + J + "\n");
1324        assertTrue("isAnnihilator(c,J)", I.isAnnihilator(c, J));
1325
1326        d = fac.univariate(rl - 2);
1327        //d = fac.random(kl - 1, ll, el, q);
1328        M = new ArrayList<GenSolvablePolynomial<BigRational>>();
1329        M.add(c);
1330        M.add(d);
1331        //System.out.println("M = " + M);
1332        K = new SolvableIdeal<BigRational>(fac, M);
1333        //System.out.println("K = " + K + "\n");
1334
1335        J = I.annihilator(K);
1336        //System.out.println("J = " + J + "\n");
1337        J.doGB();
1338        //System.out.println("K = " + K);
1339        //System.out.println("J = " + J + "\n");
1340        assertTrue("isAnnihilator(M,J)", I.isAnnihilator(K, J));
1341    }
1342
1343}