Source code

001/*
002 * $Id$
003 */
004
005package edu.jas.gbufd;
006
007
008import java.io.IOException;
009import java.io.Reader;
010import java.io.StringReader;
011import java.util.ArrayList;
012import java.util.List;
013
014import junit.framework.Test;
015import junit.framework.TestCase;
016import junit.framework.TestSuite;
017
018
019import edu.jas.arith.BigRational;
020import edu.jas.arith.BigQuaternion;
021import edu.jas.arith.BigQuaternionRing;
022import edu.jas.gb.SolvableGroebnerBaseAbstract;
023import edu.jas.gb.SolvableGroebnerBase;
024import edu.jas.gb.SolvableGroebnerBaseSeq;
025import edu.jas.gbufd.SGBFactory;
026import edu.jas.gbufd.SolvableSyzygyAbstract;
027import edu.jas.gbufd.SolvableSyzygySeq;
028import edu.jas.poly.GenPolynomialTokenizer;
029import edu.jas.poly.GenSolvablePolynomial;
030import edu.jas.poly.GenSolvablePolynomialRing;
031import edu.jas.poly.ModuleList;
032import edu.jas.poly.PolynomialList;
033import edu.jas.poly.RelationGenerator;
034import edu.jas.poly.RelationTable;
035import edu.jas.poly.TermOrder;
036import edu.jas.poly.WeylRelations;
037
038
039/**
040 * SolvableSyzygy tests with JUnit.
041 * @author Heinz Kredel
042 */
043
044public class SolvableSyzygyTest extends TestCase {
045
046
047    /**
048     * main.
049     */
050    public static void main(String[] args) {
051        junit.textui.TestRunner.run(suite());
052    }
053
054
055    /**
056     * Constructs a <CODE>SolvableSyzygyTest</CODE> object.
057     * @param name String.
058     */
059    public SolvableSyzygyTest(String name) {
060        super(name);
061    }
062
063
064    /**
065     */
066    public static Test suite() {
067        TestSuite suite = new TestSuite(SolvableSyzygyTest.class);
068        return suite;
069    }
070
071
072    BigRational cfac;
073
074
075    GenSolvablePolynomialRing<BigRational> fac;
076
077
078    PolynomialList<BigRational> F;
079
080
081    List<GenSolvablePolynomial<BigRational>> G;
082
083
084    GenSolvablePolynomial<BigRational> a, b, c, d, e;
085
086
087    GenSolvablePolynomial<BigRational> zero, one;
088
089
090    TermOrder tord;
091
092
093    RelationTable table;
094
095
096    List<GenSolvablePolynomial<BigRational>> L;
097
098
099    List<List<GenSolvablePolynomial<BigRational>>> K;
100
101
102    List<GenSolvablePolynomial<BigRational>> V;
103
104
105    List<List<GenSolvablePolynomial<BigRational>>> W;
106
107
108    ModuleList<BigRational> M, N, Z;
109
110
111    SolvableGroebnerBaseAbstract<BigRational> sbb;
112
113
114    SolvableGroebnerBase<BigRational> msbb;
115
116
117    SolvableSyzygyAbstract<BigRational> ssz;
118
119
120    int rl = 4; //4; //3; 
121
122
123    int kl = 3;
124
125
126    int ll = 7;
127
128
129    int el = 2;
130
131
132    float q = 0.3f; //0.4f
133
134
135    @Override
136    protected void setUp() {
137        cfac = new BigRational(1);
138        tord = new TermOrder();
139        String[] vars = new String[]{ "w", "x", "y", "z" };
140        fac = new GenSolvablePolynomialRing<BigRational>(cfac, tord, vars);
141        //RelationGenerator<BigRational> wl = new WeylRelations<BigRational>();
142        //wl.generate(fac);
143        table = fac.table;
144        a = b = c = d = e = null;
145        L = null;
146        K = null;
147        V = null;
148        do {
149            a = fac.random(kl, ll, el, q);
150        } while (a.isZERO());
151        do {
152            b = fac.random(kl, ll, el, q);
153        } while (b.isZERO());
154        do {
155            c = fac.random(kl, ll, el, q);
156        } while (c.isZERO());
157        do {
158            d = fac.random(kl, ll, el, q);
159        } while (d.isZERO());
160        e = d; //fac.random(kl, ll, el, q );
161        one = fac.getONE();
162        zero = fac.getZERO();
163        sbb = SGBFactory.getImplementation(cfac);
164        msbb = new SolvableGroebnerBaseSeq<BigRational>(); //cfac);
165        ssz = new SolvableSyzygySeq<BigRational>(cfac);
166    }
167
168
169    @Override
170    protected void tearDown() {
171        a = b = c = d = e = null;
172        L = null;
173        K = null;
174        V = null;
175        fac = null;
176        tord = null;
177        table = null;
178        sbb = null;
179        msbb = null;
180        ssz = null;
181    }
182
183
184    /**
185     * Test sequential SolvableSyzygy.
186     */
187    public void testSequentialSolvableSyzygy() {
188        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
189
190        assertTrue("not isZERO( a )", !a.isZERO());
191        L.add(a);
192        assertTrue("isGB( { a } )", sbb.isLeftGB(L));
193        K = ssz.leftZeroRelations(L);
194        assertTrue("is ZR( { a } )", ssz.isLeftZeroRelation(K, L));
195
196        assertTrue("not isZERO( b )", !b.isZERO());
197        L.add(b);
198        L = sbb.leftGB(L);
199        assertTrue("isGB( { a, b } )", sbb.isLeftGB(L));
200        //System.out.println("\nL = " + L );
201        K = ssz.leftZeroRelations(L);
202        //System.out.println("\nK = " + K );
203        assertTrue("is ZR( { a, b } )", ssz.isLeftZeroRelation(K, L));
204
205        assertTrue("not isZERO( c )", !c.isZERO());
206        L.add(c);
207        L = sbb.leftGB(L);
208        //System.out.println("\nL = " + L );
209        assertTrue("isGB( { a, b, c } )", sbb.isLeftGB(L));
210        K = ssz.leftZeroRelations(L);
211        //System.out.println("\nK = " + K );
212        assertTrue("is ZR( { a, b, c } )", ssz.isLeftZeroRelation(K, L));
213
214        assertTrue("not isZERO( d )", !d.isZERO());
215        L.add(d);
216        L = sbb.leftGB(L);
217        //System.out.println("\nL = " + L );
218        assertTrue("isGB( { a, b, c, d } )", sbb.isLeftGB(L));
219        K = ssz.leftZeroRelations(L);
220        //System.out.println("\nK = " + K );
221        assertTrue("is ZR( { a, b, c, d } )", ssz.isLeftZeroRelation(K, L));
222    }
223
224
225    /**
226     * Test sequential Weyl SolvableSyzygy.
227     */
228    public void testSequentialWeylSolvableSyzygy() {
229        int rloc = 4;
230        fac = new GenSolvablePolynomialRing<BigRational>(cfac, rloc);
231
232        RelationGenerator<BigRational> wl = new WeylRelations<BigRational>();
233        wl.generate(fac);
234        table = fac.table;
235
236        a = fac.random(kl, ll, el, q);
237        b = fac.random(kl, ll, el, q);
238        c = fac.random(kl, ll, el, q);
239        d = fac.random(kl, ll, el, q);
240        e = d; //fac.random(kl, ll, el, q );
241
242        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
243
244        assertTrue("not isZERO( a )", !a.isZERO());
245        L.add(a);
246        assertTrue("isGB( { a } )", sbb.isLeftGB(L));
247        K = ssz.leftZeroRelations(L);
248        assertTrue("is ZR( { a } )", ssz.isLeftZeroRelation(K, L));
249
250        assertTrue("not isZERO( b )", !b.isZERO());
251        L.add(b);
252        L = sbb.leftGB(L);
253        assertTrue("isGB( { a, b } )", sbb.isLeftGB(L));
254        //System.out.println("\nL = " + L );
255        K = ssz.leftZeroRelations(L);
256        //System.out.println("\nK = " + K );
257        assertTrue("is ZR( { a, b } )", ssz.isLeftZeroRelation(K, L));
258
259        // useless since 1 in GB
260        assertTrue("not isZERO( c )", !c.isZERO());
261        L.add(c);
262        L = sbb.leftGB(L);
263        //System.out.println("\nL = " + L );
264        assertTrue("isGB( { a, b, c } )", sbb.isLeftGB(L));
265        K = ssz.leftZeroRelations(L);
266        //System.out.println("\nK = " + K );
267        assertTrue("is ZR( { a, b, c } )", ssz.isLeftZeroRelation(K, L));
268
269        // useless since 1 in GB
270        assertTrue("not isZERO( d )", !d.isZERO());
271        L.add(d);
272        L = sbb.leftGB(L);
273        //System.out.println("\nL = " + L );
274        assertTrue("isGB( { a, b, c, d } )", sbb.isLeftGB(L));
275        K = ssz.leftZeroRelations(L);
276        //System.out.println("\nK = " + K );
277        assertTrue("is ZR( { a, b, c, d } )", ssz.isLeftZeroRelation(K, L));
278    }
279
280
281    /**
282     * Test sequential module SolvableSyzygy.
283     */
284    public void testSequentialModSolvableSyzygy() {
285        W = new ArrayList<List<GenSolvablePolynomial<BigRational>>>();
286
287        assertTrue("not isZERO( a )", !a.isZERO());
288        V = new ArrayList<GenSolvablePolynomial<BigRational>>();
289        V.add(a);
290        V.add(zero);
291        V.add(one);
292        W.add(V);
293        M = new ModuleList<BigRational>(fac, W);
294        assertTrue("isGB( { (a,0,1) } )", msbb.isLeftGB(M));
295
296        N = msbb.leftGB(M);
297        assertTrue("isGB( { (a,0,1) } )", msbb.isLeftGB(N));
298
299        Z = ssz.leftZeroRelations(N);
300        //System.out.println("Z = " + Z);
301        assertTrue("is ZR( { a) } )", ssz.isLeftZeroRelation(Z, N));
302
303        assertTrue("not isZERO( b )", !b.isZERO());
304        V = new ArrayList<GenSolvablePolynomial<BigRational>>();
305        V.add(b);
306        V.add(one);
307        V.add(zero);
308        W.add(V);
309        M = new ModuleList<BigRational>(fac, W);
310        //System.out.println("W = " + W.size() );
311
312        N = msbb.leftGB(M);
313        assertTrue("isGB( { a, b } )", msbb.isLeftGB(N));
314
315        Z = ssz.leftZeroRelations(N);
316        //System.out.println("Z = " + Z);
317        assertTrue("is ZR( { a, b } )", ssz.isLeftZeroRelation(Z, N));
318
319        assertTrue("not isZERO( c )", !c.isZERO());
320        V = new ArrayList<GenSolvablePolynomial<BigRational>>();
321        V.add(c);
322        V.add(one);
323        V.add(zero);
324        W.add(V);
325        M = new ModuleList<BigRational>(fac, W);
326        //System.out.println("W = " + W.size() );
327
328        N = msbb.leftGB(M);
329        //System.out.println("GB(M) = " + N);
330        assertTrue("isGB( { a,b,c) } )", msbb.isLeftGB(N));
331
332        Z = ssz.leftZeroRelations(N);
333        //System.out.println("Z = " + Z);
334        //boolean b = ssz.isLeftZeroRelation(Z,N);
335        //System.out.println("boolean = " + b);
336        assertTrue("is ZR( { a,b,c } )", ssz.isLeftZeroRelation(Z, N));
337    }
338
339
340    /**
341     * Test sequential arbitrary base Syzygy.
342     */
343    public void testSequentialArbitrarySyzygy() {
344        L = new ArrayList<GenSolvablePolynomial<BigRational>>();
345
346        assertTrue("not isZERO( a )", !a.isZERO());
347        L.add(a);
348        assertTrue("isGB( { a } )", sbb.isLeftGB(L));
349        K = ssz.leftZeroRelationsArbitrary(L);
350        assertTrue("is ZR( { a } )", ssz.isLeftZeroRelation(K, L));
351
352        assertTrue("not isZERO( b )", !b.isZERO());
353        L.add(b);
354        K = ssz.leftZeroRelationsArbitrary(L);
355        //System.out.println("\nN = " + N );
356        assertTrue("is ZR( { a, b } )", ssz.isLeftZeroRelation(K, L));
357
358        assertTrue("not isZERO( c )", !c.isZERO());
359        L.add(c);
360        K = ssz.leftZeroRelationsArbitrary(L);
361        //System.out.println("\nN = " + N );
362        assertTrue("is ZR( { a, b, c } )", ssz.isLeftZeroRelation(K, L));
363
364        assertTrue("not isZERO( d )", !d.isZERO());
365        L.add(d);
366        K = ssz.leftZeroRelationsArbitrary(L);
367        //System.out.println("\nN = " + N );
368        assertTrue("is ZR( { a, b, c, d } )", ssz.isLeftZeroRelation(K, L));
369    }
370
371
372    /**
373     * Test sequential arbitrary base Syzygy, ex CLO 2, p 214 ff.
374     */
375    @SuppressWarnings("unchecked")
376    public void testSequentialArbitrarySyzygyCLO() {
377        PolynomialList<BigRational> F = null;
378
379        String exam = "Rat(x,y) G " + "( " + "( x y + x ), " + "( y^2 + 1 ) " + ") ";
380        Reader source = new StringReader(exam);
381        GenPolynomialTokenizer parser = new GenPolynomialTokenizer(source);
382        try {
383            F = (PolynomialList<BigRational>) parser.nextSolvablePolynomialSet();
384        } catch (ClassCastException e) {
385            fail("" + e);
386        } catch (IOException e) {
387            fail("" + e);
388        }
389        //System.out.println("F = " + F);
390
391        L = F.castToSolvableList();
392        K = ssz.leftZeroRelationsArbitrary(L);
393        assertTrue("is ZR( { a, b } )", ssz.isLeftZeroRelation(K, L));
394    }
395
396
397    /**
398     * Test sequential arbitrary base Syzygy, ex WA_32.
399     */
400    @SuppressWarnings("unchecked")
401    public void testSequentialArbitrarySyzygyWA32() {
402        PolynomialList<BigRational> F = null;
403
404        String exam = "Rat(e1,e2,e3) L " + "RelationTable " + "( " + " ( e3 ), ( e1 ), ( e1 e3 - e1 ), "
405                        + " ( e3 ), ( e2 ), ( e2 e3 - e2 ) " + ")" + "( " + " ( e1 e3^3 + e2^2 ), "
406                        + " ( e1^3 e2^2 + e3 ), " + " ( e3^3 + e3^2 ) " + ") ";
407        Reader source = new StringReader(exam);
408        GenPolynomialTokenizer parser = new GenPolynomialTokenizer(source);
409        try {
410            F = (PolynomialList<BigRational>) parser.nextSolvablePolynomialSet();
411        } catch (ClassCastException e) {
412            fail("" + e);
413        } catch (IOException e) {
414            fail("" + e);
415        }
416        //System.out.println("F = " + F);
417
418        L = F.castToSolvableList();
419        K = ssz.leftZeroRelationsArbitrary(L);
420        assertTrue("is ZR( { a, b } )", ssz.isLeftZeroRelation(K, L));
421    }
422
423
424    /**
425     * Test sequential arbitrary module SolvableSyzygy.
426     */
427    public void testSequentialArbitraryModSolvableSyzygy() {
428        W = new ArrayList<List<GenSolvablePolynomial<BigRational>>>();
429
430        assertTrue("not isZERO( a )", !a.isZERO());
431        V = new ArrayList<GenSolvablePolynomial<BigRational>>();
432        V.add(a);
433        V.add(zero);
434        V.add(one);
435        W.add(V);
436        M = new ModuleList<BigRational>(fac, W);
437        assertTrue("isGB( { (a,0,1) } )", msbb.isLeftGB(M));
438
439        Z = ssz.leftZeroRelationsArbitrary(M);
440        //System.out.println("Z = " + Z);
441        assertTrue("is ZR( { a) } )", ssz.isLeftZeroRelation(Z, M));
442
443        assertTrue("not isZERO( b )", !b.isZERO());
444        V = new ArrayList<GenSolvablePolynomial<BigRational>>();
445        V.add(b);
446        V.add(one);
447        V.add(zero);
448        W.add(V);
449        M = new ModuleList<BigRational>(fac, W);
450        //System.out.println("W = " + W.size() );
451
452        Z = ssz.leftZeroRelationsArbitrary(M);
453        //System.out.println("Z = " + Z);
454        assertTrue("is ZR( { a, b } )", ssz.isLeftZeroRelation(Z, M));
455
456        assertTrue("not isZERO( c )", !c.isZERO());
457        V = new ArrayList<GenSolvablePolynomial<BigRational>>();
458        V.add(c);
459        V.add(one);
460        V.add(zero);
461        W.add(V);
462        M = new ModuleList<BigRational>(fac, W);
463        //System.out.println("W = " + W.size() );
464
465        Z = ssz.leftZeroRelationsArbitrary(M);
466        //System.out.println("Z = " + Z);
467        //boolean b = ssz.isLeftZeroRelation(Z,N);
468        //System.out.println("boolean = " + b);
469        assertTrue("is ZR( { a,b,c } )", ssz.isLeftZeroRelation(Z, M));
470    }
471
472
473    /**
474     * Test Ore conditions.
475     */
476    public void testOreConditions() {
477        RelationGenerator<BigRational> wl = new WeylRelations<BigRational>();
478        wl.generate(fac);
479        do {
480            a = fac.random(kl, ll - 1, el, q);
481        } while (a.isZERO());
482        do {
483            b = fac.random(kl, ll - 1, el, q);
484        } while (b.isZERO());
485        //System.out.println("a = " + a);
486        //System.out.println("b = " + b);
487
488        GenSolvablePolynomial<BigRational>[] oc = ssz.leftOreCond(a, b);
489        //System.out.println("oc[0] = " + oc[0]);
490        //System.out.println("oc[1] = " + oc[1]);
491        c = oc[0].multiply(a);
492        d = oc[1].multiply(b);
493        //System.out.println("c = " + c);
494        //System.out.println("d = " + d);
495        assertEquals("c_0 * a = c_1 * b: ", c, d);
496        assertTrue("left Ore condition: ", ssz.isLeftOreCond(a, b, oc));
497
498        oc = ssz.rightOreCond(a, b);
499        //System.out.println("oc[0] = " + oc[0]);
500        //System.out.println("oc[1] = " + oc[1]);
501        c = a.multiply(oc[0]);
502        d = b.multiply(oc[1]);
503        //System.out.println("c = " + c);
504        //System.out.println("d = " + d);
505        assertEquals("a * c_0 = b * c_1: ", c, d);
506        assertTrue("right Ore condition: ", ssz.isRightOreCond(a, b, oc));
507    }
508
509
510    /**
511     * Test Ore conditions for residues.
512     */
513    public void testResidueOreConditions() {
514        RelationGenerator<BigRational> wl = new WeylRelations<BigRational>();
515        wl.generate(fac);
516
517        // construct ideal { x_i^2 - i, ... } for generators x_i
518        F = new PolynomialList<BigRational>(fac, fac.generators());
519        //System.out.println("F = " + F);
520        List<GenSolvablePolynomial<BigRational>> gens = F.castToSolvableList();
521        //System.out.println("gens = " + gens);
522        L = new ArrayList<GenSolvablePolynomial<BigRational>>(gens.size() - 1);
523        long i = 2;
524        for (GenSolvablePolynomial<BigRational> g : gens) {
525            if (g.isONE()) {
526                continue;
527            }
528            GenSolvablePolynomial<BigRational> p = g.multiply(g);
529            p = (GenSolvablePolynomial<BigRational>) p.subtract(fac.fromInteger(i++));
530            L.add(p);
531        }
532        //System.out.println("L = " + L);
533
534        do {
535            a = fac.random(kl, ll - 2, el, q);
536        } while (a.isZERO());
537        do {
538            b = fac.random(kl, ll - 2, el, q);
539        } while (b.isZERO());
540        //System.out.println("a = " + a);
541        //System.out.println("b = " + b);
542
543        GenSolvablePolynomial<BigRational>[] oc = ssz.leftOreCond(a, b);
544        //System.out.println("oc[0] = " + oc[0]);
545        //System.out.println("oc[1] = " + oc[1]);
546        c = oc[0].multiply(a);
547        d = oc[1].multiply(b);
548        //System.out.println("c = " + c);
549        //System.out.println("d = " + d);
550        assertEquals("c_0 * a = c_1 * b: ", c, d);
551        assertTrue("left Ore condition: ", ssz.isLeftOreCond(a, b, oc));
552
553        // now mod ideal(L):
554        GenSolvablePolynomial<BigRational> ar, br, cr, dr, or0, or1;
555        ar = sbb.sred.leftNormalform(L, a);
556        br = sbb.sred.leftNormalform(L, b);
557        //System.out.println("ar = " + ar);
558        //System.out.println("br = " + br);
559        cr = oc[0].multiply(ar);
560        dr = oc[1].multiply(br);
561        //System.out.println("cr = " + cr);
562        //System.out.println("dr = " + dr);
563        //this is not true: assertEquals("c_0 * a = c_1 * b: ", cr, dr);
564        cr = sbb.sred.leftNormalform(L, cr);
565        dr = sbb.sred.leftNormalform(L, dr);
566        //System.out.println("cr = " + cr);
567        //System.out.println("dr = " + dr);
568        assertEquals("cr_0 * ar = cr_1 * br: ", cr, dr);
569
570        or0 = sbb.sred.leftNormalform(L, oc[0]);
571        or1 = sbb.sred.leftNormalform(L, oc[1]);
572        //System.out.println("oc0 = " + oc[0]);
573        //System.out.println("oc1 = " + oc[1]);
574        //System.out.println("or0 = " + or0);
575        //System.out.println("or1 = " + or1);
576        cr = or0.multiply(ar);
577        dr = or1.multiply(br);
578        //okay w/o: cr = sbb.sred.leftNormalform(L,cr);
579        //okay w/o: dr = sbb.sred.leftNormalform(L,dr);
580        //System.out.println("cr = " + cr);
581        //System.out.println("dr = " + dr);
582        //not okay: assertEquals("cr_0 * ar = cr_1 * br: ", cr, dr);
583        oc[0] = or0;
584        oc[1] = or1;
585        //not okay: assertTrue("left Ore condition: ", ssz.isLeftOreCond(ar,br,oc));
586
587        //System.out.println("new Ore Condition:");
588        oc = ssz.leftOreCond(ar, br);
589        //System.out.println("oc[0] = " + oc[0]);
590        //System.out.println("oc[1] = " + oc[1]);
591        cr = oc[0].multiply(ar);
592        dr = oc[1].multiply(br);
593        //System.out.println("cr = " + cr);
594        //System.out.println("dr = " + dr);
595        //this is true:
596        assertEquals("c_0 * a = c_1 * b: ", cr, dr);
597        cr = sbb.sred.leftNormalform(L, cr);
598        dr = sbb.sred.leftNormalform(L, dr);
599        //System.out.println("cr = " + cr);
600        //System.out.println("dr = " + dr);
601        assertEquals("cr_0 * ar = cr_1 * br: ", cr, dr);
602
603        /* not okay:
604        or0 = sbb.sred.leftNormalform(L,oc[0]);
605        or1 = sbb.sred.leftNormalform(L,oc[1]);
606        //System.out.println("oc0 = " + oc[0]);
607        //System.out.println("oc1 = " + oc[1]);
608        //System.out.println("or0 = " + or0);
609        //System.out.println("or1 = " + or1);
610        cr = or0.multiply(ar);
611        dr = or1.multiply(br);
612        //okay w/o: cr = sbb.sred.leftNormalform(L,cr);
613        //okay w/o: dr = sbb.sred.leftNormalform(L,dr);
614        //System.out.println("cr = " + cr);
615        //System.out.println("dr = " + dr);
616        assertEquals("cr_0 * ar = cr_1 * br: ", cr, dr);
617        oc[0] = or0;
618        oc[1] = or1;
619        assertTrue("left Ore condition: ", ssz.isLeftOreCond(ar,br,oc));
620        */
621    }
622
623
624    /**
625     * Test Ore conditions quaternion coefficients.
626     */
627    public void testOreConditionsQuat() {
628        BigQuaternionRing qri = new BigQuaternionRing();
629        GenSolvablePolynomialRing<BigQuaternion> qfac = new GenSolvablePolynomialRing<BigQuaternion>(qri, fac);
630        //System.out.println("qfac = " + qfac.toScript());
631        SolvableSyzygyAbstract<BigQuaternion> ssz = new SolvableSyzygySeq<BigQuaternion>(qri);
632
633        RelationGenerator<BigQuaternion> wl = new WeylRelations<BigQuaternion>();
634        wl.generate(qfac);
635
636        GenSolvablePolynomial<BigQuaternion> a, b, c, d;
637
638        do {
639            a = qfac.random(1, 3, el, q);
640            //a = qfac.parse(" -1i1j-2k-1 "); // wrong parse of starting -
641        } while (a.isZERO());
642        do {
643            b = qfac.random(1, 3, el, q);
644            //b = qfac.parse(" -1i1/2j1k-1/2  x +  3/2i1j-1/2k1 "); // wrong parse of starting -
645        } while (b.isZERO());
646        System.out.println("a = " + a);
647        System.out.println("b = " + b);
648
649        GenSolvablePolynomial<BigQuaternion>[] oc = ssz.leftOreCond(a, b);
650        System.out.println("oc[0] = " + oc[0]);
651        System.out.println("oc[1] = " + oc[1]);
652        c = oc[0].multiply(a);
653        d = oc[1].multiply(b);
654        //System.out.println("c = " + c);
655        //System.out.println("d = " + d);
656        assertEquals("c_0 * a = c_1 * b: " + qfac.toScript(), c, d);
657        assertTrue("left Ore condition: ", ssz.isLeftOreCond(a, b, oc));
658
659        oc = ssz.rightOreCond(a, b);
660        System.out.println("oc[0] = " + oc[0]);
661        System.out.println("oc[1] = " + oc[1]);
662        c = a.multiply(oc[0]);
663        d = b.multiply(oc[1]);
664        //System.out.println("c = " + c);
665        //System.out.println("d = " + d);
666        assertEquals("a * c_0 = b * c_1: " + qfac.toScript(), c, d);
667        assertTrue("right Ore condition: ", ssz.isRightOreCond(a, b, oc));
668    }
669
670}