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