001/*
002 * $Id: GenWordPolynomialTest.java 5940 2018-10-19 08:53:13Z kredel $
003 */
004
005package edu.jas.poly;
006
007
008import java.util.List;
009import java.util.ArrayList;
010
011import junit.framework.Test;
012import junit.framework.TestCase;
013import junit.framework.TestSuite;
014
015
016import edu.jas.arith.BigInteger;
017import edu.jas.arith.BigRational;
018import edu.jas.arith.BigComplex;
019import edu.jas.structure.RingElem;
020
021
022/**
023 * GenWordPolynomial tests with JUnit.
024 * @author Heinz Kredel
025 */
026
027public class GenWordPolynomialTest extends TestCase {
028
029
030    /**
031     * main
032     */
033    public static void main(String[] args) {
034        junit.textui.TestRunner.run(suite());
035    }
036
037
038    /**
039     * Constructs a <CODE>GenWordPolynomialTest</CODE> object.
040     * @param name String.
041     */
042    public GenWordPolynomialTest(String name) {
043        super(name);
044    }
045
046
047    /**
048     * suite.
049     */
050    public static Test suite() {
051        TestSuite suite = new TestSuite(GenWordPolynomialTest.class);
052        return suite;
053    }
054
055
056    int rl = 6;
057
058
059    int kl = 10;
060
061
062    int ll = 7;
063
064
065    int el = 5;
066
067
068    @Override
069    protected void setUp() {
070    }
071
072
073    @Override
074    protected void tearDown() {
075    }
076
077
078    /**
079     * Test constructors and factory.
080     */
081    public void testConstructors() {
082        // integers
083        BigInteger rf = new BigInteger();
084        //System.out.println("rf = " + rf);
085
086        // non-commuting vars: abcdef
087        WordFactory wf = new WordFactory("abcdef");
088        //System.out.println("wf = " + wf);
089
090        // polynomials over integers
091        GenWordPolynomialRing<BigInteger> pf = new GenWordPolynomialRing<BigInteger>(rf, wf);
092        //System.out.println("pf = " + pf);
093        assertFalse("not commutative",pf.isCommutative());
094        assertTrue("associative",pf.isAssociative());
095        assertFalse("not field",pf.isField());
096
097        GenWordPolynomial<BigInteger> p = pf.getONE();
098        //System.out.println("p = " + p);
099        assertTrue("p == 1", p.isONE());
100        p = pf.getZERO();
101        assertTrue("p == 0", p.isZERO());
102        //System.out.println("p = " + p);
103        //p = pf.random(9);
104        //System.out.println("p = " + p);
105
106        List<GenWordPolynomial<BigInteger>> gens = pf.generators();
107        //System.out.println("gens = " + gens);
108        assertTrue("#gens == 7", gens.size() == 7);
109
110        RingElem<GenWordPolynomial<BigInteger>> pe = new GenWordPolynomial<BigInteger>(pf);
111        //System.out.println("pe = " + pe);
112        //System.out.println("p.equals(pe) = " + p.equals(pe) );
113        //System.out.println("p.equals(p) = " + p.equals(p) );
114        assertTrue("p.equals(pe) = ", p.equals(pe));
115        assertTrue("p.equals(p) = ", p.equals(p));
116
117        pe = pe.sum(p);
118        //System.out.println("pe = " + pe);
119        assertTrue("pe.isZERO() = ", pe.isZERO());
120        p = pf.random(9);
121        p = p.subtract(p);
122        //System.out.println("p = " + p);
123        //System.out.println("p.isZERO() = " + p.isZERO());
124        assertTrue("p.isZERO() = ", p.isZERO());
125
126        // polynomials over (polynomials over integers)
127        // non-commuting vars: xyz
128        WordFactory wf2 = new WordFactory("xyz");
129        //System.out.println("wf2 = " + wf2);
130
131        GenWordPolynomialRing<GenWordPolynomial<BigInteger>> 
132           ppf = new GenWordPolynomialRing<GenWordPolynomial<BigInteger>>(pf, wf2);
133        //System.out.println("ppf = " + ppf);
134
135        GenWordPolynomial<GenWordPolynomial<BigInteger>> pp = ppf.getONE();
136        //System.out.println("pp = " + pp);
137        assertTrue("pp == 1", pp.isONE());
138        //pp = ppf.random(2);
139        //System.out.println("pp = " + pp);
140        pp = ppf.getZERO();
141        //System.out.println("pp = " + pp);
142        assertTrue("pp == 0", pp.isZERO());
143
144        List<GenWordPolynomial<GenWordPolynomial<BigInteger>>> pgens = ppf.generators();
145        //System.out.println("pgens = " + pgens);
146        assertTrue("#pgens == 7+3", pgens.size() == 10);
147
148        RingElem<GenWordPolynomial<GenWordPolynomial<BigInteger>>> 
149            ppe = new GenWordPolynomial<GenWordPolynomial<BigInteger>>(ppf);
150        //System.out.println("ppe = " + ppe);
151        //System.out.println("pp.equals(ppe) = " + pp.equals(ppe) );
152        //System.out.println("pp.equals(pp) = " + pp.equals(pp) );
153        assertTrue("pp.equals(ppe) = ", pp.equals(ppe));
154        assertTrue("pp.equals(pp) = ", pp.equals(pp));
155
156        ppe = ppe.sum(pp); // why not pp = pp.add(ppe) ?
157        //System.out.println("ppe = " + ppe);
158        assertTrue("ppe.isZERO() = ", ppe.isZERO());
159        pp = ppf.random(2);
160        pp = pp.subtract(pp);
161        //System.out.println("pp = " + pp);
162        //System.out.println("pp.isZERO() = " + pp.isZERO());
163        assertTrue("pp.isZERO() = ", pp.isZERO());
164
165        // polynomials over (polynomials over (polynomials over integers))
166        // non-commuting vars: uvw
167        WordFactory wf3 = new WordFactory("uvw");
168        //System.out.println("wf3 = " + wf3);
169        GenWordPolynomialRing<GenWordPolynomial<GenWordPolynomial<BigInteger>>> 
170           pppf = new GenWordPolynomialRing<GenWordPolynomial<GenWordPolynomial<BigInteger>>>(ppf, wf3);
171        //System.out.println("pppf = " + pppf);
172
173        GenWordPolynomial<GenWordPolynomial<GenWordPolynomial<BigInteger>>> ppp = pppf.getONE();
174        //System.out.println("ppp = " + ppp);
175        assertTrue("ppp == 1", ppp.isONE());
176        //ppp = pppf.random(2);
177        //System.out.println("ppp = " + ppp);
178        ppp = pppf.getZERO();
179        //System.out.println("ppp = " + ppp);
180        assertTrue("ppp == 0", ppp.isZERO());
181
182        List<GenWordPolynomial<GenWordPolynomial<GenWordPolynomial<BigInteger>>>> ppgens = pppf.generators();
183        //System.out.println("ppgens = " + ppgens);
184        assertTrue("#ppgens == 7+3+3", ppgens.size() == 13);
185
186        RingElem<GenWordPolynomial<GenWordPolynomial<GenWordPolynomial<BigInteger>>>> 
187            pppe = new GenWordPolynomial<GenWordPolynomial<GenWordPolynomial<BigInteger>>>(pppf);
188        //System.out.println("pppe = " + pppe);
189        // System.out.println("ppp.equals(pppe) = " + ppp.equals(pppe) );
190        // System.out.println("ppp.equals(ppp) = " + ppp.equals(ppp) );
191        assertTrue("ppp.equals(pppe) = ", ppp.equals(pppe));
192        assertTrue("ppp.equals(ppp) = ", ppp.equals(ppp));
193
194        pppe = pppe.sum(ppp);
195        //System.out.println("pppe = " + pppe);
196        assertTrue("pppe.isZERO() = ", pppe.isZERO());
197        //ppp = pppf.random(2);
198        ppp = ppp.subtract(ppp);
199        //System.out.println("ppp = " + ppp);
200        //System.out.println("ppp.isZERO() = " + ppp.isZERO());
201        assertTrue("ppp.isZERO() = ", ppp.isZERO());
202    }
203
204
205    /**
206     * Test accessors.
207     */
208    public void testAccessors() {
209        // integers
210        BigInteger rf = new BigInteger();
211        // System.out.println("rf = " + rf);
212
213        // non-commuting vars: abcdef
214        WordFactory wf = new WordFactory("abcdef");
215        //System.out.println("wf = " + wf);
216
217        // polynomials over integers
218        GenWordPolynomialRing<BigInteger> pf = new GenWordPolynomialRing<BigInteger>(rf, wf);
219        //System.out.println("pf = " + pf);
220
221        // test 1
222        GenWordPolynomial<BigInteger> p = pf.getONE();
223        //System.out.println("p = " + p);
224
225        Word e = p.leadingWord();
226        BigInteger c = p.leadingBaseCoefficient();
227
228        GenWordPolynomial<BigInteger> f = new GenWordPolynomial<BigInteger>(pf, c, e);
229        assertEquals("1 == 1 ", p, f);
230
231        GenWordPolynomial<BigInteger> r = p.reductum();
232        assertTrue("red(1) == 0 ", r.isZERO());
233
234        // test 0
235        p = pf.getZERO();
236        // System.out.println("p = " + p);
237        e = p.leadingWord();
238        c = p.leadingBaseCoefficient();
239
240        f = new GenWordPolynomial<BigInteger>(pf, c, e);
241        assertEquals("0 == 0 ", p, f);
242
243        r = p.reductum();
244        assertTrue("red(0) == 0 ", r.isZERO());
245
246        // test random
247        p = pf.random(kl, ll, el);
248        // System.out.println("p = " + p);
249        e = p.leadingWord();
250        c = p.leadingBaseCoefficient();
251        r = p.reductum();
252
253        f = new GenWordPolynomial<BigInteger>(pf, c, e);
254        f = r.sum(f);
255        assertEquals("p == lm(f)+red(f) ", p, f);
256
257        // test iteration over random
258        GenWordPolynomial<BigInteger> g;
259        g = p;
260        f = pf.getZERO();
261        while (!g.isZERO()) {
262            e = g.leadingWord();
263            c = g.leadingBaseCoefficient();
264            //System.out.println("c e = " + c + " " + e);
265            r = g.reductum();
266            f = f.sum(c, e);
267            g = r;
268        }
269        assertEquals("p == lm(f)+lm(red(f))+... ", p, f);
270    }
271
272
273    /**
274     * Test addition.
275     */
276    public void testAddition() {
277        // integers
278        BigInteger rf = new BigInteger();
279        // System.out.println("rf = " + rf);
280
281        // non-commuting vars: abcdef
282        WordFactory wf = new WordFactory("abcdef");
283        //System.out.println("wf = " + wf);
284
285        // polynomials over integers
286        GenWordPolynomialRing<BigInteger> fac = new GenWordPolynomialRing<BigInteger>(rf, wf);
287        //System.out.println("fac = " + fac);
288
289        GenWordPolynomial<BigInteger> a = fac.random(kl, ll, el);
290        GenWordPolynomial<BigInteger> b = fac.random(kl, ll, el);
291
292        GenWordPolynomial<BigInteger> c = a.sum(b);
293        GenWordPolynomial<BigInteger> d = c.subtract(b);
294        GenWordPolynomial<BigInteger> e;
295        assertEquals("a+b-b = a", a, d);
296        //System.out.println("a = " + a);
297        //System.out.println("b = " + b);
298        //System.out.println("c = " + c);
299        //System.out.println("d = " + d);
300
301        c = fac.random(kl, ll, el);
302        //System.out.println("\nc = " + c);
303        d = a.sum(b.sum(c));
304        e = (a.sum(b)).sum(c);
305
306        //System.out.println("d = " + d);
307        //System.out.println("e = " + e);
308        //System.out.println("d-e = " + d.subtract(e) );
309        assertEquals("a+(b+c) = (a+b)+c", d, e);
310
311        Word u = wf.random(rl);
312        BigInteger x = rf.random(kl);
313
314        b = new GenWordPolynomial<BigInteger>(fac, x, u);
315        c = a.sum(b);
316        d = a.sum(x, u);
317        assertEquals("a+p(x,u) = a+(x,u)", c, d);
318        //System.out.println("\nc = " + c);
319        //System.out.println("d = " + d);
320
321        c = a.subtract(b);
322        d = a.subtract(x, u);
323        assertEquals("a-p(x,u) = a-(x,u)", c, d);
324        //System.out.println("c = " + c);
325        //System.out.println("d = " + d);
326
327        //a = new GenWordPolynomial<BigInteger>(fac);
328        b = new GenWordPolynomial<BigInteger>(fac, x, u);
329        c = b.sum(a);
330        d = a.sum(x, u);
331        assertEquals("a+p(x,u) = a+(x,u)", c, d);
332        //System.out.println("a = " + a);
333        //System.out.println("b = " + b);
334        //System.out.println("c = " + c);
335        //System.out.println("d = " + d);
336
337        c = a.subtract(b);
338        d = a.subtract(x, u);
339        assertEquals("a-p(x,u) = a-(x,u)", c, d);
340        //System.out.println("c = " + c);
341        //System.out.println("d = " + d);
342    }
343
344
345    /**
346     * Test multiplication.
347     */
348    public void testMultiplication() {
349        // integers
350        BigInteger rf = new BigInteger();
351        // System.out.println("rf = " + rf);
352
353        // non-commuting vars: abcdef
354        WordFactory wf = new WordFactory("abcdef");
355        //System.out.println("wf = " + wf);
356
357        // polynomials over integers
358        GenWordPolynomialRing<BigInteger> fac = new GenWordPolynomialRing<BigInteger>(rf, wf);
359        //System.out.println("fac = " + fac);
360
361        GenWordPolynomial<BigInteger> a = fac.random(kl, ll, el);
362        GenWordPolynomial<BigInteger> b = fac.random(kl, ll, el);
363
364        GenWordPolynomial<BigInteger> c = a.multiply(b);
365        GenWordPolynomial<BigInteger> d = b.multiply(a);
366        GenWordPolynomial<BigInteger> e;
367        assertFalse("a*b != b*a", c.equals(d));
368        //System.out.println("a = " + a);
369        //System.out.println("b = " + b);
370        //System.out.println("c = " + c);
371        //System.out.println("d = " + d);
372
373        c = fac.random(kl, ll, el);
374        //System.out.println("c = " + c);
375        d = a.multiply(b.multiply(c));
376        e = (a.multiply(b)).multiply(c);
377
378        //System.out.println("d = " + d);
379        //System.out.println("e = " + e);
380        //System.out.println("d-e = " + d.subtract(c) );
381        assertEquals("a*(b*c) = (a*b)*c", d, e);
382
383        Word u = wf.random(rl);
384        BigInteger x = rf.random(kl);
385
386        b = new GenWordPolynomial<BigInteger>(fac, x, u);
387        c = a.multiply(b);
388        d = a.multiply(x, u);
389        assertEquals("a+p(x,u) = a+(x,u)", c, d);
390        //System.out.println("c = " + c);
391        //System.out.println("d = " + d);
392
393        //a = new GenWordPolynomial<BigInteger>(fac);
394        b = new GenWordPolynomial<BigInteger>(fac, x, u);
395        c = a.multiply(b);
396        d = a.multiply(x, u);
397        assertEquals("a+p(x,u) = a+(x,u)", c, d);
398        //System.out.println("a = " + a);
399        //System.out.println("b = " + b);
400        //System.out.println("c = " + c);
401        //System.out.println("d = " + d);
402    }
403
404
405    /**
406     * Test distributive law.
407     */
408    public void testDistributive() {
409        // integers
410        BigInteger rf = new BigInteger();
411        // System.out.println("rf = " + rf);
412
413        // non-commuting vars: abcdef
414        WordFactory wf = new WordFactory("abcdef");
415        //System.out.println("wf = " + wf);
416
417        // polynomials over integers
418        GenWordPolynomialRing<BigInteger> fac = new GenWordPolynomialRing<BigInteger>(rf, wf);
419        //System.out.println("fac = " + fac);
420
421        GenWordPolynomial<BigInteger> a = fac.random(kl, ll, el);
422        GenWordPolynomial<BigInteger> b = fac.random(kl, ll, el);
423        GenWordPolynomial<BigInteger> c = fac.random(kl, ll, el);
424        GenWordPolynomial<BigInteger> d, e;
425
426        d = a.multiply(b.sum(c));
427        e = a.multiply(b).sum(a.multiply(c));
428
429        assertEquals("a(b+c) = ab+ac", d, e);
430    }
431
432
433    /**
434     * Test univariate division.
435     */
436    public void testUnivDivision() {
437        // rational numbers
438        BigRational rf = new BigRational();
439        //System.out.println("rf = " + rf);
440
441        // non-commuting vars: x
442        WordFactory wf = new WordFactory("x");
443        //System.out.println("wf = " + wf);
444
445        // polynomials over rational numbers
446        GenWordPolynomialRing<BigRational> fac = new GenWordPolynomialRing<BigRational>(rf, wf);
447        //System.out.println("fac = " + fac);
448
449        GenWordPolynomial<BigRational> a = fac.random(7, ll, el).monic();
450        GenWordPolynomial<BigRational> b = fac.random(7, ll, el).monic();
451
452        GenWordPolynomial<BigRational> c = a.multiply(b);
453        GenWordPolynomial<BigRational> d = b.multiply(a);
454        GenWordPolynomial<BigRational> e, f;
455        assertTrue("a*b == b*a", c.equals(d)); // since univariate
456        //System.out.println("a = " + a);
457        //System.out.println("b = " + b);
458        //System.out.println("c = " + c);
459        //System.out.println("d = " + d);
460
461        e = c.divide(a);
462        //System.out.println("e = " + e);
463        assertTrue("a*b/a == b", b.equals(e));
464        d = c.divide(b);
465        //System.out.println("d = " + d);
466        assertTrue("a*b/b == a", a.equals(d));
467
468        d = c.gcd(a);
469        //System.out.println("d = " + d);
470        assertTrue("gcd(a*b,a) == a", a.equals(d));
471
472        d = a.gcd(b);
473        //System.out.println("d = " + d);
474        if (d.isConstant()) {
475            assertTrue("gcd(b,a) == 1", d.isONE());
476        } else {
477            return;
478        }
479        d = a.modInverse(b);
480        //System.out.println("d = " + d);
481        e = d.multiply(a);
482        //System.out.println("e = " + e);
483        f = e.remainder(b);
484        //System.out.println("f = " + f);
485        assertTrue("d * a == 1 mod b ", f.isONE());
486    }
487
488
489    /**
490     * Test multivariate 2 division.
491     */
492    public void testMulti2Division() {
493        // rational numbers
494        BigRational rf = new BigRational();
495        // System.out.println("rf = " + rf);
496
497        // non-commuting vars: xy
498        WordFactory wf = new WordFactory("xy");
499        //System.out.println("wf = " + wf);
500
501        // polynomials over rational numbers
502        GenWordPolynomialRing<BigRational> fac = new GenWordPolynomialRing<BigRational>(rf, wf);
503        //System.out.println("fac = " + fac);
504
505        GenWordPolynomial<BigRational> a = fac.random(7, ll, el).monic();
506        GenWordPolynomial<BigRational> b = fac.random(7, ll, el).monic();
507
508        GenWordPolynomial<BigRational> c = a.multiply(b);
509        GenWordPolynomial<BigRational> d = b.multiply(a);
510        GenWordPolynomial<BigRational> e, f;
511        assertFalse("a*b == b*a", c.equals(d));
512        //System.out.println("a = " + a);
513        //System.out.println("b = " + b);
514        //System.out.println("c = " + c);
515        //System.out.println("d = " + d);
516
517        e = c.divide(a);
518        //System.out.println("e = " + e);
519        assertTrue("a*b/a == b", b.equals(e));
520        f = d.divide(b);
521        //System.out.println("f = " + f);
522        assertTrue("a*b/b == a", a.equals(f));
523
524        try {
525            f = a.divide(b);
526            //System.out.println("f = " + f);
527        } catch (RuntimeException re) {
528            System.out.println("a divide b fail: " + a + ", " + b);
529            return;
530        }
531        WordFactory.WordComparator cmp = fac.alphabet.getDescendComparator();
532        f = a.remainder(b);
533        //System.out.println("a = " + a);
534        //System.out.println("f = " + f);
535        assertTrue("a rem2 b <= a", cmp.compare(a.leadingWord(), f.leadingWord()) <= 0);
536    }
537
538
539    /**
540     * Test multivariate 3 division.
541     */
542    public void testMulti3Division() {
543        // rational numbers
544        BigRational rf = new BigRational();
545        // System.out.println("rf = " + rf);
546
547        // non-commuting vars: xyz
548        WordFactory wf = new WordFactory("xyz");
549        //System.out.println("wf = " + wf);
550
551        // polynomials over rational numbers
552        GenWordPolynomialRing<BigRational> fac = new GenWordPolynomialRing<BigRational>(rf, wf);
553        //System.out.println("fac = " + fac);
554
555        GenWordPolynomial<BigRational> a = fac.random(7, ll, el).monic();
556        GenWordPolynomial<BigRational> b = fac.random(7, ll, el).monic();
557
558        GenWordPolynomial<BigRational> c = a.multiply(b);
559        GenWordPolynomial<BigRational> d = b.multiply(a);
560        GenWordPolynomial<BigRational> e, f;
561        assertFalse("a*b == b*a", c.equals(d));
562        //System.out.println("a = " + a);
563        //System.out.println("b = " + b);
564        //System.out.println("c = " + c);
565        //System.out.println("d = " + d);
566
567        e = c.divide(a);
568        //System.out.println("e = " + e);
569        assertTrue("a*b/a == b", b.equals(e));
570        f = d.divide(b);
571        //System.out.println("f = " + f);
572        assertTrue("a*b/b == a", a.equals(f));
573
574        try {
575            f = a.divide(b);
576            //System.out.println("f = " + f);
577        } catch (RuntimeException re) {
578            System.out.println("a divide b fail: " + a + ", " + b);
579            return;
580        }
581        WordFactory.WordComparator cmp = fac.alphabet.getDescendComparator();
582        f = a.remainder(b);
583        //System.out.println("a = " + a);
584        //System.out.println("f = " + f);
585        assertTrue("a rem3 b <= a: " + a.leadingWord() + ", " + f.leadingWord(),
586                        cmp.compare(a.leadingWord(), f.leadingWord()) <= 0);
587    }
588
589
590    /**
591     * Test polynomial and solvable coefficients.
592     */
593    public void testCoefficients() {
594        // integers
595        BigComplex rf = new BigComplex();
596        //System.out.println("rf = " + rf);
597
598        // commuting vars: uvw
599        String[] cvar = new String[] { "u", "v", "w" };
600        GenPolynomialRing<BigComplex> cf = new GenPolynomialRing<BigComplex>(rf, cvar);
601        //System.out.println("cf = " + cf);
602
603        // solvable vars: x1 x2 y1 y2
604        String[] svar = new String[] { "x1", "x2", "y1", "y2" };
605        GenSolvablePolynomialRing<GenPolynomial<BigComplex>> sf;
606        sf = new GenSolvablePolynomialRing<GenPolynomial<BigComplex>>(cf, svar);
607        //System.out.println("sf = " + sf);
608        RelationGenerator<GenPolynomial<BigComplex>> wr = new WeylRelations<GenPolynomial<BigComplex>>();
609        wr.generate(sf);
610        //System.out.println("sf = " + sf);
611
612        // non-commuting vars: abcdef
613        WordFactory wf = new WordFactory("abcdef");
614        //System.out.println("wf = " + wf);
615        // non-commuting polynomials over commuting and solvable coefficients
616        GenWordPolynomialRing<GenPolynomial<GenPolynomial<BigComplex>>> nf;
617        nf = new GenWordPolynomialRing<GenPolynomial<GenPolynomial<BigComplex>>>(sf, wf);
618        //want: GenWordPolynomialRing<GenSolvablePolynomial<GenPolynomial<BigComplex>>> nf;
619        //System.out.println("nf = " + nf.toScript());
620
621        assertFalse("not commutative",nf.isCommutative());
622        assertTrue("associative",nf.isAssociative());
623        assertFalse("not field",nf.isField());
624
625        GenWordPolynomial<GenPolynomial<GenPolynomial<BigComplex>>> p = nf.getONE();
626        //System.out.println("p = " + p);
627        assertTrue("p == 1", p.isONE());
628        p = nf.getZERO();
629        //System.out.println("p = " + p);
630        assertTrue("p == 0", p.isZERO());
631        p = nf.random(3);
632        //System.out.println("p = " + p);
633        //p = p.sum(p);
634        p = p.multiply(p);
635        //System.out.println("p = " + p);
636        p = p.subtract(p);
637        //System.out.println("p = " + p);
638        assertTrue("p == 0", p.isZERO());
639
640        List<GenWordPolynomial<GenPolynomial<GenPolynomial<BigComplex>>>> gens = nf.generators();
641        //System.out.println("gens = " + gens);
642        assertTrue("#gens == 2+3+4+6", gens.size() == 15);
643    }
644
645    
646    /**
647     * Test contraction.
648     */
649    public void testContraction() {
650        // integers
651        BigInteger rf = new BigInteger();
652        //System.out.println("rf = " + rf);
653
654        // non-commuting vars: abcdef
655        WordFactory wf = new WordFactory("abcdef");
656        //System.out.println("wf = " + wf);
657        WordFactory wfs = new WordFactory("abc");
658        //System.out.println("wf = " + wf);
659
660        // polynomials over integers
661        GenWordPolynomialRing<BigInteger> pf = new GenWordPolynomialRing<BigInteger>(rf, wf);
662        //System.out.println("pf = " + pf);
663        GenWordPolynomialRing<BigInteger> pfs = new GenWordPolynomialRing<BigInteger>(rf, wfs);
664        //System.out.println("pfs = " + pfs);
665
666        List<GenWordPolynomial<BigInteger>> H = new ArrayList<GenWordPolynomial<BigInteger>>();
667
668        GenWordPolynomial<BigInteger> a = pf.random(5).abs();
669        //System.out.println("a = " + a);
670        GenWordPolynomial<BigInteger> as = pfs.random(5).abs();
671        //System.out.println("as = " + as);
672        GenWordPolynomial<BigInteger> asf = pf.valueOf(as);
673        H.add(asf);
674        H.add(asf.multiply(pf.valueOf(pfs.random(5).abs())));
675        H.add(pfs.random(5).abs());
676        //System.out.println("asf = " + asf);
677        GenWordPolynomial<BigInteger> asfc = asf.contract(pfs);
678        //System.out.println("asfc = " + asfc);
679        assertEquals("as == contract(extend(as)): ", as, asfc);
680
681        // mostly not contractable
682        GenWordPolynomial<BigInteger> ac = a.contract(pfs);
683        H.add(a);
684        //System.out.println("ac = " + ac);
685        assertTrue("contract(a) == 0: " + ac, ac.isZERO() || pf.valueOf(ac).equals(a)); 
686
687        // 1 always contractable
688        a = pf.getONE();
689        H.add(a);
690        ac = a.contract(pfs);
691        //System.out.println("ac = " + ac);
692        assertTrue("contract(1) == 1: ", ac.isONE());
693
694        // now contract lists of word polynomials
695        //System.out.println("H = " + H);
696        List<GenWordPolynomial<BigInteger>> M = PolyUtil.<BigInteger> intersect(pfs,H);
697        //System.out.println("M = " + M);
698        int i = 0;
699        for (GenWordPolynomial<BigInteger> h : H) {
700            if (!h.contract(pfs).isZERO()) {
701                assertEquals("extend(contract(h)) == h: " + h, h, pf.valueOf(M.get(i++)) ); 
702            }
703        }
704    }
705
706}