Source code

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