001/*
002 * $Id: SolvableIdealTest.java 5866 2018-07-20 15:02:16Z kredel $
003 */
004
005package edu.jas.application;
006
007
008import java.util.ArrayList;
009import java.util.Collections;
010import java.util.List;
011
012
013
014import edu.jas.arith.BigRational;
015import edu.jas.gb.SolvableGroebnerBase;
016import edu.jas.gb.SolvableGroebnerBaseSeq;
017import edu.jas.kern.ComputerThreads;
018import edu.jas.poly.GenSolvablePolynomial;
019import edu.jas.poly.GenSolvablePolynomialRing;
020import edu.jas.poly.PolynomialList;
021import edu.jas.poly.RelationGenerator;
022import edu.jas.poly.TermOrder;
023import edu.jas.poly.TermOrderOptimization;
024import edu.jas.poly.WeylRelations;
025import edu.jas.poly.WeylRelationsIterated;
026import edu.jas.util.KsubSet;
027
028import junit.framework.Test;
029import junit.framework.TestCase;
030import junit.framework.TestSuite;
031
032
033/**
034 * SolvableIdeal tests with JUnit.
035 * @author Heinz Kredel
036 */
037public class SolvableIdealTest extends TestCase {
038
039
040
041
042    /**
043     * main
044     */
045    public static void main(String[] args) {
046        
047        junit.textui.TestRunner.run(suite());
048    }
049
050
051    /**
052     * Constructs a <CODE>SolvableIdealTest</CODE> object.
053     * @param name String.
054     */
055    public SolvableIdealTest(String name) {
056        super(name);
057    }
058
059
060    /**
061     * suite.
062     */
063    public static Test suite() {
064        TestSuite suite = new TestSuite(SolvableIdealTest.class);
065        return suite;
066    }
067
068
069    TermOrder to;
070
071
072    GenSolvablePolynomialRing<BigRational> fac;
073
074
075    List<GenSolvablePolynomial<BigRational>> L, M;
076
077
078    PolynomialList<BigRational> F;
079
080
081    List<GenSolvablePolynomial<BigRational>> G;
082
083
084    SolvableGroebnerBase<BigRational> bb;
085
086
087    GenSolvablePolynomial<BigRational> a, b, c, d, e;
088
089
090    int rl = 4; // even for Weyl relations
091
092
093    int kl = 2; //10
094
095
096    int ll = 3; //7
097
098
099    int el = 3;
100
101
102    float q = 0.15f; //0.4f
103
104
105    @Override
106    protected void setUp() {
107        BigRational coeff = new BigRational(17, 1);
108        to = new TermOrder(TermOrder.INVLEX);
109        String[] vars = new String[] { "w", "x", "y", "z" };
110        fac = new GenSolvablePolynomialRing<BigRational>(coeff, rl, to, vars);
111        RelationGenerator<BigRational> wl = new WeylRelations<BigRational>();
112        wl.generate(fac);
113        bb = new SolvableGroebnerBaseSeq<BigRational>();
114        //bb = GBFactory.getImplementation(coeff);
115        a = b = c = d = e = null;
116    }
117
118
119    @Override
120    protected void tearDown() {
121        a = b = c = d = e = null;
122        fac = null;
123        bb = null;
124        ComputerThreads.terminate();
125    }
126
127
128    /**
129     * Test Ideal sum.
130     */
131    public void testIdealSum() {
132        SolvableIdeal<BigRational> I, J, K;
133        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
134
135        a = fac.random(kl, ll, el, q);
136        b = fac.random(kl, ll, el, q);
137        c = fac.random(kl, ll, el, q);
138        d = fac.random(kl, ll, el, q);
139        e = d; //fac.random(kl, ll, el, q );
140
141        if (a.isZERO() || b.isZERO() || c.isZERO() || d.isZERO()) {
142            return;
143        }
144
145        assertTrue("not isZERO( a )", !a.isZERO());
146        L.add(a);
147
148        I = new SolvableIdeal<BigRational>(fac, L, true);
149        assertTrue("not isZERO( I )", !I.isZERO());
150        assertTrue("not isONE( I )", !I.isONE());
151        assertTrue("isGB( I )", I.isGB());
152
153        I = new SolvableIdeal<BigRational>(fac, L, false);
154        assertTrue("not isZERO( I )", !I.isZERO());
155        assertTrue("not isONE( I )", !I.isONE());
156        assertTrue("isGB( I )", I.isGB());
157
158        L = bb.leftGB(L);
159        assertTrue("isGB( { a } )", bb.isLeftGB(L));
160
161        I = new SolvableIdeal<BigRational>(fac, L, true);
162        assertTrue("not isZERO( I )", !I.isZERO());
163        //assertTrue("not isONE( I )", !I.isONE() );
164        assertTrue("isGB( I )", I.isGB());
165
166        I = new SolvableIdeal<BigRational>(fac, L, false);
167        assertTrue("not isZERO( I )", !I.isZERO());
168        //assertTrue("not isONE( I )", !I.isONE() );
169        assertTrue("isGB( I )", I.isGB());
170
171        assertTrue("not isZERO( b )", !b.isZERO());
172        L.add(b);
173        //System.out.println("L = " + L.size() );
174
175        I = new SolvableIdeal<BigRational>(fac, L, false);
176        assertTrue("not isZERO( I )", !I.isZERO());
177        //assertTrue("not isONE( I )", !I.isONE() );
178        //assertTrue("not isGB( I )", !I.isGB() );
179
180        L = bb.leftGB(L);
181        assertTrue("isGB( { a, b } )", bb.isLeftGB(L));
182
183        I = new SolvableIdeal<BigRational>(fac, L, true);
184        assertTrue("not isZERO( I )", !I.isZERO());
185        // assertTrue("not isONE( I )", !I.isONE() );
186        assertTrue("isGB( I )", I.isGB());
187
188        J = I;
189        K = J.sum(I);
190        assertTrue("not isZERO( K )", !K.isZERO());
191        assertTrue("isGB( K )", K.isGB());
192        assertTrue("equals( K, I )", K.equals(I));
193
194        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
195        assertTrue("not isZERO( c )", !c.isZERO());
196        L.add(c);
197        assertTrue("isGB( { c } )", bb.isLeftGB(L));
198
199        J = new SolvableIdeal<BigRational>(fac, L, true);
200        K = J.sum(I);
201        assertTrue("not isZERO( K )", !K.isZERO());
202        assertTrue("isGB( K )", K.isGB());
203        assertTrue("K contains(I)", K.contains(I));
204        assertTrue("K contains(J)", K.contains(J));
205
206        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
207        assertTrue("not isZERO( d )", !d.isZERO());
208        L.add(d);
209
210        assertTrue("isGB( { d } )", bb.isLeftGB(L));
211        J = new SolvableIdeal<BigRational>(fac, L, true);
212        I = K;
213        K = J.sum(I);
214        assertTrue("not isZERO( K )", !K.isZERO());
215        assertTrue("isGB( K )", K.isGB());
216        assertTrue("K contains(I)", K.contains(I));
217        assertTrue("K contains(J)", K.contains(J));
218
219        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
220        assertTrue("not isZERO( e )", !e.isZERO());
221        L.add(e);
222
223        assertTrue("isGB( { e } )", bb.isLeftGB(L));
224        J = new SolvableIdeal<BigRational>(fac, L, true);
225        I = K;
226        K = J.sum(I);
227        assertTrue("not isZERO( K )", !K.isZERO());
228        assertTrue("isGB( K )", K.isGB());
229        assertTrue("equals( K, I )", K.equals(I));
230        assertTrue("K contains(J)", K.contains(I));
231        assertTrue("I contains(K)", I.contains(K));
232    }
233
234
235    /**
236     * Test SolvableIdeal product.
237     */
238    public void testSolvableIdealProduct() {
239        SolvableIdeal<BigRational> I, J, K, H;
240        a = fac.random(kl, ll, el, q);
241        b = fac.random(kl, ll, el - 1, q);
242        c = fac.random(kl, ll, el - 1, q);
243        d = c; //fac.random(kl, ll, el, q);
244        e = d; //fac.random(kl, ll, el, q );
245
246        if (a.isZERO() || b.isZERO() || c.isZERO() || d.isZERO()) {
247            return;
248        }
249
250        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
251        //assertTrue("not isZERO( a )", !a.isZERO());
252        L.add(a);
253
254        I = new SolvableIdeal<BigRational>(fac, L, false);
255        assertTrue("not isZERO( I )", !I.isZERO());
256        assertTrue("not isONE( I )", !I.isONE() || a.isConstant());
257        assertTrue("isGB( I )", I.isGB());
258
259        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
260        assertTrue("not isZERO( b )", !a.isZERO());
261        L.add(b);
262
263        J = new SolvableIdeal<BigRational>(fac, L, false);
264        assertTrue("not isZERO( J )", !J.isZERO());
265        assertTrue("not isONE( J )", !J.isONE() || a.isConstant() || b.isConstant());
266        assertTrue("isGB( J )", J.isGB());
267
268        K = I.product(J);
269        //System.out.println("I = " + I);
270        //System.out.println("J = " + J);
271        //System.out.println("K = " + K);
272        assertTrue("not isZERO( K )", !K.isZERO());
273        assertTrue("isGB( K )", K.isGB());
274        //non-com assertTrue("I contains(K)", I.contains(K));
275        assertTrue("J contains(K)", J.contains(K));
276
277        H = I.intersect(J);
278        assertTrue("not isZERO( H )", !H.isZERO());
279        assertTrue("isGB( H )", H.isGB());
280        assertTrue("I contains(H)", I.contains(H));
281        assertTrue("J contains(H)", J.contains(H));
282        //non-com assertTrue("H contains(K)", H.contains(K));
283
284        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
285        assertTrue("not isZERO( a )", !a.isZERO());
286        L.add(a);
287        assertTrue("not isZERO( c )", !c.isZERO());
288        L.add(c);
289        L = bb.leftGB(L);
290
291        I = new SolvableIdeal<BigRational>(fac, L, true);
292        assertTrue("not isZERO( I )", !I.isZERO());
293        //assertTrue("not isONE( I )", !I.isONE() );
294        assertTrue("isGB( I )", I.isGB());
295
296        K = I.product(J);
297        assertTrue("not isZERO( K )", !K.isZERO());
298        assertTrue("isGB( K )", K.isGB());
299        //non-com assertTrue("I contains(K)", I.contains(K));
300        assertTrue("J contains(K)", J.contains(K));
301
302        H = I.intersect(J);
303        assertTrue("not isZERO( H )", !H.isZERO());
304        assertTrue("isGB( H )", H.isGB());
305        assertTrue("I contains(H)", I.contains(H));
306        assertTrue("J contains(H)", J.contains(H));
307        //non-com assertTrue("H contains(K)", H.contains(K));
308
309        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
310        assertTrue("not isZERO( b )", !b.isZERO());
311        L.add(b);
312        assertTrue("not isZERO( d )", !d.isZERO());
313        L.add(d);
314        L = bb.leftGB(L);
315
316        J = new SolvableIdeal<BigRational>(fac, L, true);
317        assertTrue("not isZERO( J )", !J.isZERO());
318        //assertTrue("not isONE( J )", !J.isONE() );
319        assertTrue("isGB( J )", J.isGB());
320
321        K = I.product(J);
322        assertTrue("not isZERO( K )", !K.isZERO());
323        assertTrue("isGB( K )", K.isGB());
324        //non-com assertTrue("I contains(K)", I.contains(K));
325        assertTrue("J contains(K)", J.contains(K));
326
327        H = I.intersect(J);
328        assertTrue("not isZERO( H )", !H.isZERO());
329        assertTrue("isGB( H )", H.isGB());
330        assertTrue("I contains(H)", I.contains(H));
331        assertTrue("J contains(H)", J.contains(H));
332        //non-com assertTrue("H contains(K)", H.contains(K));
333    }
334
335
336    /**
337     * Test SolvableIdeal quotient.
338     */
339    public void testSolvableIdealQuotient() {
340        SolvableIdeal<BigRational> I, J, K, H;
341        a = fac.random(kl, ll - 2, el, q);
342        b = fac.random(kl, ll, el, q / 2);
343        c = fac.random(kl, ll, el - 1, q);
344        d = c; //fac.random(kl, ll, el, q);
345        e = d; //fac.random(kl, ll, el, q );
346
347        if (a.isZERO() || b.isZERO() || c.isZERO() || d.isZERO()) {
348            return;
349        }
350
351        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
352        assertTrue("not isZERO( a )", !a.isZERO());
353        L.add(a);
354        L = bb.leftGB(L);
355
356        I = new SolvableIdeal<BigRational>(fac, L, true);
357        assertTrue("not isZERO( I )", !I.isZERO());
358        //assertTrue("not isONE( I )", !I.isONE() );
359        assertTrue("isGB( I )", I.isGB());
360
361        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
362        assertTrue("not isZERO( b )", !a.isZERO());
363        L.add(b);
364        L = bb.leftGB(L);
365
366        J = new SolvableIdeal<BigRational>(fac, L, true);
367        assertTrue("not isZERO( J )", !J.isZERO());
368        //assertTrue("not isONE( J )", !J.isONE() );
369        assertTrue("isGB( J )", J.isGB());
370
371        K = I.product(J);
372        assertTrue("not isZERO( K )", !K.isZERO());
373        assertTrue("isGB( K )", K.isGB());
374        //non-com assertTrue("I contains(K)", I.contains(K));
375        assertTrue("J contains(K)", J.contains(K));
376
377        H = K.quotient(J.getList().get(0));
378        assertTrue("not isZERO( H )", !H.isZERO());
379        assertTrue("isGB( H )", H.isGB());
380        //non-com assertTrue("equals(H,I)", H.equals(I)); // GBs only
381
382        H = K.quotient(J);
383        assertTrue("not isZERO( H )", !H.isZERO());
384        assertTrue("isGB( H )", H.isGB());
385        //non-com assertTrue("equals(H,I)", H.equals(I)); // GBs only
386
387        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
388        assertTrue("not isZERO( b )", !b.isZERO());
389        L.add(b);
390        assertTrue("not isZERO( c )", !c.isZERO());
391        L.add(c);
392        L = bb.leftGB(L);
393
394        J = new SolvableIdeal<BigRational>(fac, L, true);
395        assertTrue("not isZERO( J )", !J.isZERO());
396        //assertTrue("not isONE( J )", !J.isONE() );
397        assertTrue("isGB( J )", J.isGB());
398
399        K = I.product(J);
400        assertTrue("not isZERO( K )", !K.isZERO());
401        assertTrue("isGB( K )", K.isGB());
402        //non-com assertTrue("I contains(K)", I.contains(K));
403        assertTrue("J contains(K)", J.contains(K));
404
405        H = K.quotient(J);
406        assertTrue("not isZERO( H )", !H.isZERO());
407        assertTrue("isGB( H )", H.isGB());
408        //non-com assertTrue("equals(H,I)", H.equals(I)); // GBs only
409
410        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
411        assertTrue("not isZERO( a )", !a.isZERO());
412        L.add(a);
413        assertTrue("not isZERO( d )", !d.isZERO());
414        L.add(d);
415        L = bb.leftGB(L);
416
417        I = new SolvableIdeal<BigRational>(fac, L, true);
418        assertTrue("not isZERO( I )", !I.isZERO());
419        //assertTrue("not isONE( J )", !J.isONE() );
420        assertTrue("isGB( I )", I.isGB());
421
422        K = I.product(J);
423        assertTrue("not isZERO( K )", !K.isZERO());
424        assertTrue("isGB( K )", K.isGB());
425        //non-com assertTrue("I contains(K)", I.contains(K));
426        assertTrue("J contains(K)", J.contains(K));
427
428        H = K.quotient(J);
429        assertTrue("not isZERO( H )", !H.isZERO());
430        assertTrue("isGB( H )", H.isGB());
431        //non-com assertTrue("equals(H,I)", H.equals(I)); // GBs only
432    }
433
434
435    /**
436     * Test SolvableIdeal infinite quotient.
437     */
438    public void testSolvableIdealInfiniteQuotient() {
439        SolvableIdeal<BigRational> I, J, K;
440        a = fac.random(kl, ll - 2, el, q);
441        b = fac.random(kl, ll - 1, el - 1, q);
442        c = fac.random(kl, ll / 2, el - 1, q / 2);
443        //a = fac.parse(" -1/2 w");
444        //b = fac.parse(" y - 2/3");
445        //c = fac.parse(" -2 w * y + 4/3 w + 2");
446        //c = fac.parse(" -2 y^2 + 8/3 y - 8/9");
447        d = c; //fac.random(kl, ll, el, q);
448        e = d; //fac.random(kl, ll, el, q );
449
450        if (a.isZERO() || b.isZERO() || c.isZERO() || d.isZERO()) {
451            return;
452        }
453
454        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
455        assertTrue("not isZERO( b )", !b.isZERO());
456        L.add(b);
457        L = bb.leftGB(L);
458        I = new SolvableIdeal<BigRational>(fac, L, true);
459        assertTrue("not isZERO( I )", !I.isZERO());
460        //assertTrue("not isONE( I )", !I.isONE() );
461        assertTrue("isGB( I )", I.isGB());
462
463        J = I.infiniteQuotient(a);
464
465        assertTrue("not isZERO( c )", !c.isZERO());
466        L.add(c);
467        L = bb.leftGB(L);
468        I = new SolvableIdeal<BigRational>(fac, L, true);
469        assertTrue("not isZERO( I )", !I.isZERO());
470        //assertTrue("not isONE( I )", !I.isONE() );
471        assertTrue("isGB( I )", I.isGB());
472
473        J = I.infiniteQuotient(a);
474        assertTrue("equals(J,I)", J.equals(I)); // GBs only
475
476        assertTrue("not isZERO( d )", !d.isZERO());
477        L.add(d);
478        L = bb.leftGB(L);
479        I = new SolvableIdeal<BigRational>(fac, L, true);
480        assertTrue("not isZERO( I )", !I.isZERO());
481        //assertTrue("not isONE( I )", !I.isONE() );
482        assertTrue("isGB( I )", I.isGB());
483
484        J = I.infiniteQuotient(a);
485        assertTrue("isGB( J )", J.isGB());
486        assertTrue("equals(J,I)", J.equals(I)); // GBs only
487
488        G = new ArrayList<GenSolvablePolynomial<BigRational>>();
489        assertTrue("not isZERO( a )", !a.isZERO());
490        G.add(a);
491        G = bb.leftGB(G);
492        K = new SolvableIdeal<BigRational>(fac, G, true);
493        assertTrue("not isZERO( K )", !K.isZERO());
494        //assertTrue("not isONE( I )", !I.isONE() );
495        assertTrue("isGB( K )", K.isGB());
496
497        J = I.infiniteQuotient(K);
498        assertTrue("equals(J,I)", J.equals(I)); // GBs only
499
500        assertTrue("not isZERO( e )", !e.isZERO());
501        G.add(e);
502        G = bb.leftGB(G);
503        K = new SolvableIdeal<BigRational>(fac, G, true);
504        assertTrue("not isZERO( K )", !K.isZERO());
505        //assertTrue("not isONE( I )", !I.isONE() );
506        assertTrue("isGB( K )", K.isGB());
507
508        J = I.infiniteQuotient(K);
509        assertTrue("equals(J,I)", J.equals(I)); // GBs only
510    }
511
512
513    /**
514     * Test (commutative) SolvableIdeal infinite quotient with Rabinowich trick.
515     */
516    public void testSolvableIdealInfiniteQuotientRabi() {
517        fac = new GenSolvablePolynomialRing<BigRational>(fac.coFac, rl, fac.tord, fac.getVars());
518        SolvableIdeal<BigRational> I, J, K, JJ;
519        a = fac.random(kl - 1, ll - 1, el - 1, q / 2);
520        b = fac.random(kl - 1, ll - 1, el, q / 2);
521        c = fac.random(kl - 1, ll - 1, el, q / 2);
522        d = fac.random(kl - 1, ll - 1, el, q / 2);
523        e = a; //fac.random(kl, ll-1, el, q );
524
525        if (a.isZERO() || b.isZERO() || c.isZERO() || d.isZERO()) {
526            return;
527        }
528
529        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
530        assertTrue("not isZERO( b )", !b.isZERO());
531        L.add(b);
532        L = bb.leftGB(L);
533        I = new SolvableIdeal<BigRational>(fac, L, true);
534        assertTrue("not isZERO( I )", !I.isZERO());
535        //assertTrue("not isONE( I )", !I.isONE() );
536        assertTrue("isGB( I )", I.isGB());
537
538        J = I.infiniteQuotientRab(a);
539        JJ = I.infiniteQuotient(a);
540        assertTrue("equals(J,JJ)", J.equals(JJ)); // GBs only
541
542        assertTrue("not isZERO( c )", !c.isZERO());
543        L.add(c);
544        L = bb.leftGB(L);
545        I = new SolvableIdeal<BigRational>(fac, L, true);
546        assertTrue("not isZERO( I )", !I.isZERO());
547        //assertTrue("not isONE( I )", !I.isONE() );
548        assertTrue("isGB( I )", I.isGB());
549
550        J = I.infiniteQuotientRab(a);
551        assertTrue("equals(J,I)", J.equals(I)); // GBs only
552        JJ = I.infiniteQuotient(a);
553        assertTrue("equals(J,JJ)", J.equals(JJ)); // GBs only
554
555        assertTrue("not isZERO( d )", !d.isZERO());
556        L.add(d);
557        L = bb.leftGB(L);
558        I = new SolvableIdeal<BigRational>(fac, L, true);
559        assertTrue("not isZERO( I )", !I.isZERO());
560        //assertTrue("not isONE( I )", !I.isONE() );
561        assertTrue("isGB( I )", I.isGB());
562
563        J = I.infiniteQuotientRab(a);
564        assertTrue("isGB( J )", J.isGB());
565        assertTrue("equals(J,I)", J.equals(I)); // GBs only
566        JJ = I.infiniteQuotient(a);
567        assertTrue("equals(J,JJ)", J.equals(JJ)); // GBs only
568
569        G = new ArrayList<GenSolvablePolynomial<BigRational>>();
570        assertTrue("not isZERO( a )", !a.isZERO());
571        G.add(a);
572        G = bb.leftGB(G);
573        K = new SolvableIdeal<BigRational>(fac, G, true);
574        assertTrue("not isZERO( K )", !K.isZERO());
575        //assertTrue("not isONE( I )", !I.isONE() );
576        assertTrue("isGB( K )", K.isGB());
577
578        J = I.infiniteQuotientRab(K);
579        assertTrue("equals(J,I)", J.equals(I)); // GBs only
580        JJ = I.infiniteQuotient(a);
581        assertTrue("equals(J,JJ)", J.equals(JJ)); // GBs only
582
583        assertTrue("not isZERO( e )", !e.isZERO());
584        G.add(e);
585        G = bb.leftGB(G);
586        K = new SolvableIdeal<BigRational>(fac, G, true);
587        assertTrue("not isZERO( K )", !K.isZERO());
588        //assertTrue("not isONE( I )", !I.isONE() );
589        assertTrue("isGB( K )", K.isGB());
590
591        J = I.infiniteQuotientRab(K);
592        assertTrue("equals(J,I)", J.equals(I)); // GBs only
593        JJ = I.infiniteQuotient(a);
594        assertTrue("equals(J,JJ)", J.equals(JJ)); // GBs only
595    }
596
597
598    /**
599     * Test (commutative) SolvableIdeal radical membership.
600     */
601    public void testSolvableIdealRadicalMember() {
602        fac = new GenSolvablePolynomialRing<BigRational>(fac.coFac, rl, fac.tord, fac.getVars());
603        SolvableIdeal<BigRational> I;
604        a = fac.random(kl - 1, ll, el - 1, q);
605        b = fac.random(kl - 1, ll, el, q);
606        c = fac.random(kl - 1, ll - 1, el, q / 2);
607        //d = fac.random(kl - 1, ll - 1, el, q / 2);
608        //e = a; //fac.random(kl, ll-1, el, q );
609
610        if (a.isZERO() || b.isZERO() || c.isZERO()) {
611            return;
612        }
613
614        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
615        L.add(b);
616        L = bb.leftGB(L);
617        I = new SolvableIdeal<BigRational>(fac, L, true);
618        assertTrue("not isZERO( I )", !I.isZERO());
619        //assertTrue("not isONE( I )", !I.isONE() );
620        assertTrue("isGB( I )", I.isGB());
621
622        //System.out.println("a = " + a);
623        //System.out.println("b = " + b);
624        //System.out.println("I = " + I);
625
626        if (!I.isONE() && !a.equals(b)) {
627            assertFalse("a in radical(b)", I.isRadicalMember(a));
628            assertTrue("b in radical(b)", I.isRadicalMember(b));
629        }
630
631        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
632        L.add(b.multiply(b));
633        L = bb.leftGB(L);
634        I = new SolvableIdeal<BigRational>(fac, L, true);
635        assertTrue("not isZERO( I )", !I.isZERO());
636        //assertTrue("not isONE( I )", !I.isONE() );
637        assertTrue("isGB( I )", I.isGB());
638
639        //System.out.println("I = " + I);
640
641        if (!I.isONE() && !a.equals(b)) {
642            assertFalse("a in radical(b*b)", I.isRadicalMember(a));
643            assertTrue("b in radical(b*b)", I.isRadicalMember(b));
644        }
645
646        //System.out.println("c = " + c);
647        L.add(c);
648        L = bb.leftGB(L);
649        I = new SolvableIdeal<BigRational>(fac, L, true);
650        assertTrue("not isZERO( I )", !I.isZERO());
651        //assertTrue("not isONE( I )", !I.isONE() );
652        assertTrue("isGB( I )", I.isGB());
653
654        //System.out.println("I = " + I);
655
656        if (!I.isONE() && !a.equals(b)) {
657            assertFalse("a in radical(b*b,c)", I.isRadicalMember(a));
658            assertTrue("b in radical(b*b,c)", I.isRadicalMember(b));
659        }
660    }
661
662
663    /**
664     * Test SolvableIdeal common zeros.
665     */
666    @SuppressWarnings("unchecked")
667    public void testSolvableIdealCommonZeros() {
668        SolvableIdeal<BigRational> I;
669        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
670
671        I = new SolvableIdeal<BigRational>(fac, L, true);
672        assertEquals("commonZeroTest( I )", I.commonZeroTest(), 1);
673
674        a = fac.getZERO();
675        L.add(a);
676        I = new SolvableIdeal<BigRational>(fac, L, true);
677        assertEquals("commonZeroTest( I )", I.commonZeroTest(), 1);
678
679        b = fac.getONE();
680        L.add(b);
681        I = new SolvableIdeal<BigRational>(fac, L, true);
682        assertEquals("commonZeroTest( I )", I.commonZeroTest(), -1);
683
684        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
685        a = fac.random(kl, ll, el, q);
686        if (!a.isZERO() && !a.isConstant()) {
687            L.add(a);
688            I = new SolvableIdeal<BigRational>(fac, L, true);
689            assertEquals("commonZeroTest( I )", I.commonZeroTest(), 1);
690        }
691
692        L = (List<GenSolvablePolynomial<BigRational>>) fac.univariateList();
693        I = new SolvableIdeal<BigRational>(fac, L, true);
694        assertEquals("commonZeroTest( I )", I.commonZeroTest(), 0);
695
696        L.remove(0);
697        I = new SolvableIdeal<BigRational>(fac, L, true);
698        assertEquals("commonZeroTest( I )", I.commonZeroTest(), 1);
699    }
700
701
702    /**
703     * Test SolvableIdeal dimension.
704     */
705    @SuppressWarnings("unchecked")
706    public void testSolvableIdealDimension() {
707        SolvableIdeal<BigRational> I;
708        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
709        Dimension dim;
710
711        I = new SolvableIdeal<BigRational>(fac, L, true);
712        assertEquals("dimension( I )", rl, I.dimension().d);
713
714        a = fac.getZERO();
715        L.add(a);
716        I = new SolvableIdeal<BigRational>(fac, L, true);
717        assertEquals("dimension( I )", rl, I.dimension().d);
718
719        b = fac.getONE();
720        L.add(b);
721        I = new SolvableIdeal<BigRational>(fac, L, true);
722        assertEquals("dimension( I )", -1, I.dimension().d);
723
724        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
725        a = fac.random(kl, ll, el, q);
726        if (!a.isZERO() && !a.isConstant()) {
727            L.add(a);
728            I = new SolvableIdeal<BigRational>(fac, L, true);
729            //System.out.println("a = " + a);
730            dim = I.dimension();
731            //System.out.println("dim(I) = " + dim);
732            assertTrue("dimension( I )", dim.d >= 1);
733        }
734
735        L = (List<GenSolvablePolynomial<BigRational>>) fac.univariateList();
736        I = new SolvableIdeal<BigRational>(fac, L, true);
737        dim = I.dimension();
738        assertEquals("dimension( I )", 0, dim.d);
739
740        while (L.size() > 0) {
741            L.remove(0);
742            I = new SolvableIdeal<BigRational>(fac, L, true);
743            //System.out.println("I = " + I);
744            dim = I.dimension();
745            //System.out.println("dim(I) = " + dim);
746            assertEquals("dimension( I )", rl - L.size(), dim.d);
747        }
748
749        L = (List<GenSolvablePolynomial<BigRational>>) fac.univariateList();
750        I = new SolvableIdeal<BigRational>(fac, L, true);
751        I = I.product(I);
752        //System.out.println("I = " + I);
753        dim = I.dimension();
754        //System.out.println("dim(I) = " + dim);
755        assertTrue("dimension( I )", 0 >= dim.d);
756
757        L = I.getList();
758        while (L.size() > 0) {
759            L.remove(0);
760            I = new SolvableIdeal<BigRational>(fac, L, true);
761            //System.out.println("I = " + I);
762            dim = I.dimension();
763            //System.out.println("dim(I) = " + dim);
764            assertTrue("dimension( I )", dim.d > 0);
765        }
766    }
767
768
769    /**
770     * Test elimination SolvableIdeals.
771     */
772    public void testElimSolvableIdeal() {
773        BigRational coeff = new BigRational(17, 1);
774        String[] vars = new String[] { "w", "x", "y", "z" };
775        fac = new GenSolvablePolynomialRing<BigRational>(coeff, rl, to, vars);
776        RelationGenerator<BigRational> wli = new WeylRelationsIterated<BigRational>();
777        wli.generate(fac);
778        //String[] vars = fac.getVars();
779        //System.out.println("vars = " + Arrays.toString(vars));
780        //System.out.println("fac = " + fac);
781
782        SolvableIdeal<BigRational> I, J, K;
783        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
784        //non-com
785        a = fac.univariate(0, 3L); //fac.random(kl, ll, el, q );
786        b = fac.univariate(1, 2L); //fac.random(kl, ll, el, q );
787        c = fac.univariate(0, 1L); //fac.random(kl, ll, el, q );
788
789        L.add(a);
790        //L.add(b);
791        L.add(c);
792
793        I = new SolvableIdeal<BigRational>(fac, L);
794        I.doGB();
795        //System.out.println("I = " + I.toScript());
796        assertTrue("not isZERO( I )", !I.isZERO());
797        //assertTrue("not isONE( I )", !I.isONE());
798        assertTrue("isGB( I )", I.isGB());
799
800        List<String> sv = new ArrayList<String>(vars.length);
801        for (int i = 0; i < vars.length; i++) {
802            sv.add(vars[i]);
803        }
804        //System.out.println("sv    = " + sv);
805
806        for (int i = 2; i <= vars.length; i = i + 2) {
807            KsubSet<String> ps = new KsubSet<String>(sv, i);
808            //System.out.println("========================== ps : " + i);
809            for (List<String> ev : ps) {
810                int si = Collections.indexOfSubList(sv, ev);
811                if (si < 0 || si % 2 != 0) { // substring and iterated Weyl algebra
812                    continue;
813                }
814                //System.out.println("ev = " + ev);
815                List<String> svr = new ArrayList<String>(vars.length);
816                K = null;
817                if (si != 0) { // and substring on even index
818                    svr.addAll(ev);
819                    for (String e : sv) {
820                        if (svr.contains(e)) {
821                            continue;
822                        }
823                        svr.add(e);
824                    }
825                    //System.out.println("svr = " + svr);
826                    String[] rvars = new String[svr.size()];
827                    for (int j = 0; j < svr.size(); j++) {
828                        rvars[j] = svr.get(j);
829                    }
830                    List<Integer> P = new ArrayList<Integer>(sv.size());
831                    for (int j = 0; j < rvars.length; j++) {
832                        int k = sv.indexOf(rvars[j]);
833                        P.add(k);
834                    }
835                    //System.out.println("P = " + P);
836                    GenSolvablePolynomialRing<BigRational> rfac;
837                    rfac = (GenSolvablePolynomialRing<BigRational>) fac.permutation(P);
838                    //System.out.println("rfac = " + rfac.toScript());
839                    List<GenSolvablePolynomial<BigRational>> id = TermOrderOptimization
840                                    .<BigRational> permutation(P, rfac, I.list.castToSolvableList());
841                    K = new SolvableIdeal<BigRational>(rfac, id);
842                    //System.out.println("K = " + K.toScript());
843                    //continue;
844                }
845                String[] evars = new String[ev.size()];
846                for (int j = 0; j < ev.size(); j++) {
847                    evars[j] = ev.get(j);
848                }
849                GenSolvablePolynomialRing<BigRational> efac;
850                efac = new GenSolvablePolynomialRing<BigRational>(fac.coFac, evars.length, fac.tord, evars);
851                //RelationGenerator<BigRational> wl = new WeylRelations<BigRational>();
852                RelationGenerator<BigRational> wl = new WeylRelationsIterated<BigRational>();
853                wl.generate(efac);
854                //System.out.println("efac = " + efac.toScript());
855
856                if (K == null) {
857                    J = I.eliminate(efac);
858                } else {
859                    J = K.eliminate(efac);
860                }
861                //System.out.println("J = " + J.toScript());
862                assertTrue("isGB( J )", J.isGB());
863                assertTrue("size( J ) <=  |ev|", J.getList().size() <= ev.size());
864            }
865        }
866    }
867
868
869    /**
870     * Test univariate polynomials in ideal.
871     */
872    public void testUnivPoly() {
873        String[] vars;
874        BigRational coeff = new BigRational(17, 1);
875        to = new TermOrder(TermOrder.INVLEX);
876        vars = new String[] { "w", "x", "y", "z" };
877        fac = new GenSolvablePolynomialRing<BigRational>(coeff, rl, to, vars);
878
879        vars = fac.getVars();
880        //System.out.println("vars = " + Arrays.toString(vars));
881        //System.out.println("fac = " + fac);
882        assertTrue("vars.length == 4 ", vars.length == 4);
883
884        SolvableIdeal<BigRational> I;
885        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
886
887        a = fac.parse("( x^3 + 34/55 x^2 + 1/9 x + 99 )");
888        b = fac.parse("( y^4 - x )");
889        c = fac.parse("( z^3 - x y )");
890        d = fac.parse("( w^2 + 3 )");
891
892        if (a.isZERO() || b.isZERO() || c.isZERO()) {
893            return;
894        }
895
896        L.add(a);
897        L.add(b);
898        L.add(c);
899        L.add(d);
900        I = new SolvableIdeal<BigRational>(fac, L);
901        //I.doGB();
902        assertTrue("not isZERO( I )", !I.isZERO());
903        assertTrue("isGB( I )", I.isGB());
904        //System.out.println("I = " + I);
905
906        for (int i = 0; i < rl; i++) { // rl
907            GenSolvablePolynomial<BigRational> u = I.constructUnivariate(rl - 1 - i);
908            //System.out.println("u = " + u);
909            GenSolvablePolynomial<BigRational> U = fac.parse(u.toString());
910            //System.out.println("U = " + U + "\n");
911            assertTrue("I.contains(U) ", I.contains(U));
912        }
913
914        List<GenSolvablePolynomial<BigRational>> Us = I.constructUnivariate();
915        for (GenSolvablePolynomial<BigRational> u : Us) {
916            //System.out.println("u = " + u);
917            GenSolvablePolynomial<BigRational> U = fac.parse(u.toString());
918            //System.out.println("U = " + U + "\n");
919            assertTrue("I.contains(U) ", I.contains(U));
920        }
921    }
922
923
924    /**
925     * Test SolvableIdeal annihilator.
926     */
927    public void testAnnihilator() {
928        SolvableIdeal<BigRational> I, J, K;
929        do {
930            a = fac.random(kl, ll, el, q);
931        } while (a.isZERO() || a.isConstant());
932        b = fac.univariate(1);
933        c = fac.univariate(rl - 1);
934        //b = fac.random(kl - 1, ll, el, q);
935        //c = fac.random(kl - 1, ll - 1, el, q / 2);
936
937        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
938        L.add(a);
939        L.add(b);
940        //L.add(c);
941        //System.out.println("L = " + L);
942        L = bb.leftGB(L);
943        I = new SolvableIdeal<BigRational>(fac, L, true);
944        assertTrue("isGB( I )", I.isGB());
945        //System.out.println("I = " + I + "\n");
946
947        J = I.annihilator(c);
948        //System.out.println("J = " + J + "\n");
949        J.doGB();
950        //System.out.println("c = " + c);
951        //System.out.println("J = " + J + "\n");
952        assertTrue("isAnnihilator(c,J)", I.isAnnihilator(c, J));
953
954        d = fac.univariate(rl - 2);
955        //d = fac.random(kl - 1, ll, el, q);
956        M = new ArrayList<GenSolvablePolynomial<BigRational>>();
957        M.add(c);
958        M.add(d);
959        //System.out.println("M = " + M);
960        K = new SolvableIdeal<BigRational>(fac, M);
961        //System.out.println("K = " + K + "\n");
962
963        J = I.annihilator(K);
964        //System.out.println("J = " + J + "\n");
965        J.doGB();
966        //System.out.println("K = " + K);
967        //System.out.println("J = " + J + "\n");
968        assertTrue("isAnnihilator(M,J)", I.isAnnihilator(K, J));
969    }
970
971}