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