Source code

001/*
002 * $Id: HenselMultUtilTest.java 5863 2018-07-20 11:13:34Z kredel $
003 */
004
005package edu.jas.ufd;
006
007
008import java.util.ArrayList;
009import java.util.List;
010
011import junit.framework.Test;
012import junit.framework.TestCase;
013import junit.framework.TestSuite;
014
015
016import edu.jas.arith.BigInteger;
017import edu.jas.arith.ModInteger;
018import edu.jas.arith.ModIntegerRing;
019import edu.jas.arith.ModLong;
020import edu.jas.arith.ModLongRing;
021import edu.jas.arith.PrimeList;
022import edu.jas.kern.ComputerThreads;
023import edu.jas.poly.GenPolynomial;
024import edu.jas.poly.GenPolynomialRing;
025import edu.jas.poly.PolyUtil;
026import edu.jas.poly.TermOrder;
027
028
029/**
030 * HenselMultUtil tests with JUnit. Two seperate classes because of package
031 * dependency.
032 * @see edu.jas.application.HenselMultUtilTest
033 * @author Heinz Kredel
034 */
035
036public class HenselMultUtilTest extends TestCase {
037
038
039    /**
040     * main.
041     */
042    public static void main(String[] args) {
043        junit.textui.TestRunner.run(suite());
044        ComputerThreads.terminate();
045    }
046
047
048    /**
049     * Constructs a <CODE>HenselMultUtilTest</CODE> object.
050     * @param name String.
051     */
052    public HenselMultUtilTest(String name) {
053        super(name);
054    }
055
056
057    /**
058     */
059    public static Test suite() {
060        TestSuite suite = new TestSuite(HenselMultUtilTest.class);
061        return suite;
062    }
063
064
065    TermOrder tord = new TermOrder(TermOrder.INVLEX);
066
067
068    GenPolynomialRing<BigInteger> dfac;
069
070
071    GenPolynomialRing<BigInteger> cfac;
072
073
074    GenPolynomialRing<GenPolynomial<BigInteger>> rfac;
075
076
077    BigInteger ai;
078
079
080    BigInteger bi;
081
082
083    BigInteger ci;
084
085
086    BigInteger di;
087
088
089    BigInteger ei;
090
091
092    GenPolynomial<BigInteger> a;
093
094
095    GenPolynomial<BigInteger> b;
096
097
098    GenPolynomial<BigInteger> c;
099
100
101    GenPolynomial<BigInteger> d;
102
103
104    GenPolynomial<BigInteger> e;
105
106
107    int rl = 2;
108
109
110    int kl = 5;
111
112
113    int ll = 5;
114
115
116    int el = 3;
117
118
119    float q = 0.3f;
120
121
122    @Override
123    protected void setUp() {
124        a = b = c = d = e = null;
125        ai = bi = ci = di = ei = null;
126        dfac = new GenPolynomialRing<BigInteger>(new BigInteger(1), rl, tord);
127        cfac = new GenPolynomialRing<BigInteger>(new BigInteger(1), rl - 1, tord);
128        rfac = new GenPolynomialRing<GenPolynomial<BigInteger>>(cfac, 1, tord);
129    }
130
131
132    @Override
133    protected void tearDown() {
134        a = b = c = d = e = null;
135        ai = bi = ci = di = ei = null;
136        dfac = null;
137        cfac = null;
138        rfac = null;
139        ComputerThreads.terminate();
140    }
141
142
143    protected static java.math.BigInteger getPrime1() {
144        return PrimeList.getLongPrime(60, 93);
145    }
146
147
148    protected static java.math.BigInteger getPrime2() {
149        return PrimeList.getLongPrime(30, 35);
150    }
151
152
153    /**
154     * Test multivariate Hensel lifting monic case list.
155     */
156    public void testHenselLiftingMonicList() {
157        java.math.BigInteger p;
158        //p = getPrime1();
159        p = new java.math.BigInteger("19");
160        //p = new java.math.BigInteger("5");
161        BigInteger m = new BigInteger(p);
162
163        ModIntegerRing pm = new ModIntegerRing(p, false);
164        //ModLongRing pl = new ModLongRing(p, false);
165        GenPolynomialRing<ModInteger> pfac = new GenPolynomialRing<ModInteger>(pm, 4, tord, new String[] {
166                "w", "x", "y", "z" });
167        //GenPolynomialRing<BigInteger> ifac = new GenPolynomialRing<BigInteger>(new BigInteger(),pfac);
168
169        BigInteger mi = m;
170        long k = 5L;
171        //long d = 3L;
172        java.math.BigInteger pk = p.pow((int) k);
173        //m = new BigInteger(pk);
174
175        ModIntegerRing pkm = new ModIntegerRing(pk, false);
176        //ModLongRing pkl = new ModLongRing(pk, false);
177        GenPolynomialRing<ModInteger> pkfac = new GenPolynomialRing<ModInteger>(pkm, pfac);
178        dfac = new GenPolynomialRing<BigInteger>(mi, pfac);
179
180        //GreatestCommonDivisor<BigInteger> ufd = GCDFactory.getProxy(mi);
181        GreatestCommonDivisor<BigInteger> ufd = GCDFactory.getImplementation(mi);
182
183        //ModLong v = pl.fromInteger(3L);
184        ModInteger v = pkm.fromInteger(3L);
185        List<BigInteger> V = new ArrayList<BigInteger>(1);
186        V.add(new BigInteger(3L));
187        if (pkfac.nvar > 2) {
188            V.add(new BigInteger(5L)); //pkm.fromInteger(5L));
189        }
190        if (pkfac.nvar > 3) {
191            V.add(new BigInteger(7L)); //pkm.fromInteger(7L));
192        }
193        //System.out.println("V = " + V);
194
195        GenPolynomial<ModInteger> ap;
196        GenPolynomial<ModInteger> cp;
197        //GenPolynomial<ModInteger> rp;
198
199        List<GenPolynomial<BigInteger>> A = new ArrayList<GenPolynomial<BigInteger>>();
200
201        for (int i = 1; i < 2; i++) {
202            //a = dfac.random(kl + 7 * i, ll, el + 1, q).abs();
203            //b = dfac.random(kl + 7 * i, ll, el + 0, q).abs();
204            //c = dfac.random(kl + 7 * i, ll, el + 2, q).abs();
205            a = dfac.parse(" ( z^2 + y^2 + 4 x^3 - x + 1 + w ) ");
206            b = dfac.parse(" ( z + y + x^2 + 10 + w ) ");
207            //c = dfac.parse(" z + x + (y - 2)*(2 + y) ");
208
209            A.add(a);
210            A.add(b);
211            //A.add(c);
212            //System.out.println("A          = " + A);
213            A = ufd.coPrime(A);
214            //System.out.println("coprime(A) = " + A);
215            if (A.size() == 0) {
216                continue;
217            }
218            c = A.get(0).multiply(A.get(1));
219            //c = dfac.parse(" y^2 + x^2 ");
220            cp = PolyUtil.<ModInteger> fromIntegerCoefficients(pkfac, c);
221            //System.out.println("c          = " + c);
222
223            List<GenPolynomial<ModInteger>> Ap = new ArrayList<GenPolynomial<ModInteger>>(A.size());
224            for (GenPolynomial<BigInteger> ai : A) {
225                ap = PolyUtil.<ModInteger> fromIntegerCoefficients(pkfac, ai);
226                Ap.add(ap);
227            }
228            //System.out.println("A mod p^k  = " + Ap);
229            //System.out.println("v = " + v + ", vp = " + vp);
230            GenPolynomialRing<ModInteger> ckfac = pkfac.contract(1);
231            v = pkm.fromInteger( V.get(2).getVal() );
232            List<GenPolynomial<ModInteger>> Ae = new ArrayList<GenPolynomial<ModInteger>>(A.size());
233            for (GenPolynomial<ModInteger> a : Ap) {
234                GenPolynomial<ModInteger> ae = PolyUtil.<ModInteger> evaluateMain(ckfac, a, v);
235                Ae.add(ae);
236            }
237            //System.out.println("A(v) mod p^k = " + Ae);
238            ckfac = ckfac.contract(1);
239            v = pkm.fromInteger( V.get(1).getVal() );
240            List<GenPolynomial<ModInteger>> Ae1 = new ArrayList<GenPolynomial<ModInteger>>(A.size());
241            for (GenPolynomial<ModInteger> a : Ae) {
242                GenPolynomial<ModInteger> ae = PolyUtil.<ModInteger> evaluateMain(ckfac, a, v);
243                Ae1.add(ae);
244            }
245            Ae = Ae1;
246            //System.out.println("A(v,v) mod p^k = " + Ae);
247            ckfac = ckfac.contract(1);
248            v = pkm.fromInteger( V.get(0).getVal() );
249            Ae1 = new ArrayList<GenPolynomial<ModInteger>>(A.size());
250            for (GenPolynomial<ModInteger> a : Ae) {
251                GenPolynomial<ModInteger> ae = PolyUtil.<ModInteger> evaluateMain(ckfac, a, v);
252                Ae1.add(ae);
253            }
254            Ae = Ae1;
255            //System.out.println("A(v,v,v) mod p^k = " + Ae);
256
257            try {
258                List<GenPolynomial<ModInteger>> lift;
259                lift = HenselMultUtil.<ModInteger> liftHenselMonic(c, cp, Ae, V, k); // 5 is max
260                //System.out.println("\nliftMultiHensel:");
261                //System.out.println("lift   = " + lift);
262                //System.out.println("A      = " + A);
263                boolean t = HenselMultUtil.<ModInteger> isHenselLift(c, cp, Ae, lift);
264                assertTrue("isHenselLift: ", t);
265            } catch (ArithmeticException e) {
266                // ok, can happen
267            } catch (NoLiftingException e) {
268                // can now happen: fail("" + e);
269                System.out.println("e = " + e);
270            }
271        }
272    }
273
274
275    /**
276     * Test multivariate Hensel lifting list, 2 variables.
277     */
278    public void testHenselLifting2List() {
279        java.math.BigInteger p;
280        //p = getPrime1();
281        p = new java.math.BigInteger("19");
282        //p = new java.math.BigInteger("5");
283        BigInteger m = new BigInteger(p);
284
285        ModIntegerRing pm = new ModIntegerRing(p, false);
286        GenPolynomialRing<ModInteger> pfac = new GenPolynomialRing<ModInteger>(pm, 2, tord, new String[] {
287                "x", "y" });
288        GenPolynomialRing<BigInteger> ifac = new GenPolynomialRing<BigInteger>(new BigInteger(), pfac);
289        GenPolynomialRing<GenPolynomial<BigInteger>> irfac = ifac.recursive(ifac.nvar - 1);
290
291        BigInteger mi = m;
292        long k = 5L;
293        //long d = 3L;
294        java.math.BigInteger pk = p.pow((int) k);
295        //m = new BigInteger(pk);
296        //System.out.println("m = " + m + " = " + p + "^" + k);
297
298        ModIntegerRing pkm = new ModIntegerRing(pk, false);
299        //ModLongRing pkl = new ModLongRing(pk, false);
300        GenPolynomialRing<ModInteger> pkfac = new GenPolynomialRing<ModInteger>(pkm, pfac);
301        dfac = new GenPolynomialRing<BigInteger>(mi, pfac);
302
303        //GreatestCommonDivisor<BigInteger> ufd = GCDFactory.getProxy(mi);
304        GreatestCommonDivisor<BigInteger> ufd = GCDFactory.getImplementation(mi);
305
306        //ModLong v = pl.fromInteger(3L);
307        ModInteger v = pkm.fromInteger(3L);
308        List<BigInteger> V = new ArrayList<BigInteger>(1);
309        V.add(new BigInteger(3L));
310        //System.out.println("V = " + V);
311
312        GenPolynomial<ModInteger> ap;
313        GenPolynomial<ModInteger> cp;
314        //GenPolynomial<ModInteger> rp;
315
316        List<GenPolynomial<BigInteger>> A = new ArrayList<GenPolynomial<BigInteger>>();
317
318        for (int i = 1; i < 2; i++) {
319            a = dfac.parse(" ( x^3 y - 1 ) ");
320            b = dfac.parse(" ( 1 + y ) ");
321            e = dfac.parse(" ( y^2 - x ) ");
322
323            A.add(a);
324            A.add(b);
325            A.add(e);
326            //System.out.println("A          = " + A);
327            A = ufd.coPrime(A);
328            //System.out.println("coprime(A) = " + A); // polynomials are rearranged
329            if (A.size() == 0) {
330                continue;
331            }
332            c = A.get(0).multiply(A.get(1)).multiply(A.get(2));
333            //c = dfac.parse(" y^2 + x^2 ");
334            cp = PolyUtil.<ModInteger> fromIntegerCoefficients(pkfac, c);
335            //System.out.println("c          = " + c);
336            //System.out.println("cp         = " + cp);
337            GenPolynomial<GenPolynomial<BigInteger>> cr = PolyUtil.<BigInteger> recursive(irfac, c);
338            GenPolynomial<GenPolynomial<BigInteger>> crr = PolyUtil.<BigInteger> switchVariables(cr);
339            //System.out.println("crr = " + crr);
340            GenPolynomial<BigInteger> cl = crr.leadingBaseCoefficient();
341            //System.out.println("cl         = " + cl + ", cl.ring = " + cl.ring);
342
343            FactorAbstract<BigInteger> factorizer = FactorFactory.getImplementation(new BigInteger());
344            List<GenPolynomial<BigInteger>> CF = factorizer.factorsRadical(cl);
345            //System.out.println("CF         = " + CF);
346
347            List<GenPolynomial<BigInteger>> CL = new ArrayList<GenPolynomial<BigInteger>>(2);
348            CL.add(CF.get(0));
349            CL.add(CF.get(2));
350            CL.add(CF.get(1));
351            //CL.add( CF.get(0) );
352            //System.out.println("CL         = " + CL);
353
354            List<GenPolynomial<ModInteger>> Ap = new ArrayList<GenPolynomial<ModInteger>>(A.size());
355            for (GenPolynomial<BigInteger> ai : A) {
356                ap = PolyUtil.<ModInteger> fromIntegerCoefficients(pkfac, ai);
357                Ap.add(ap);
358            }
359            //System.out.println("A mod p^k  = " + Ap);
360            //System.out.println("v = " + v + ", V = " + V);
361
362            GenPolynomialRing<ModInteger> ckfac = pkfac.contract(1);
363
364            v = pkm.fromInteger( V.get(0).getVal() );
365            List<GenPolynomial<ModInteger>> Ae = new ArrayList<GenPolynomial<ModInteger>>(A.size());
366            for (GenPolynomial<ModInteger> a : Ap) { // Ap
367                GenPolynomial<ModInteger> ae = PolyUtil.<ModInteger> evaluateMain(ckfac, a, v);
368                Ae.add(ae);
369            }
370            //System.out.println("A(v) mod p^k = " + Ae);
371
372            try {
373                List<GenPolynomial<ModInteger>> lift;
374                lift = HenselMultUtil.<ModInteger> liftHensel(c, cp, Ae, V, k, CL); // 5 is max
375                //System.out.println("\nliftMultiHensel:");
376                //System.out.println("lift   = " + lift);
377                //System.out.println("A      = " + A);
378                boolean t = HenselMultUtil.<ModInteger> isHenselLift(c, cp, Ae, lift);
379                assertTrue("isHenselLift: ", t);
380            } catch (ArithmeticException e) {
381                // ok, can happen
382                System.out.println("e = " + e);
383            } catch (NoLiftingException e) {
384                // can now happen: 
385                fail("" + e);
386                System.out.println("e = " + e);
387            }
388        }
389    }
390
391
392    /**
393     * Test multivariate Hensel lifting list, 3 variables.
394     */
395    public void xtestHenselLifting3List() {
396        java.math.BigInteger p;
397        //p = getPrime1();
398        p = new java.math.BigInteger("19");
399        //p = new java.math.BigInteger("5");
400        BigInteger m = new BigInteger(p);
401
402        ModIntegerRing pm = new ModIntegerRing(p, false);
403        GenPolynomialRing<ModInteger> pfac = new GenPolynomialRing<ModInteger>(pm, 3, tord, new String[] {
404                "x", "y", "z" });
405        GenPolynomialRing<BigInteger> ifac = new GenPolynomialRing<BigInteger>(new BigInteger(), pfac);
406        GenPolynomialRing<GenPolynomial<BigInteger>> irfac = ifac.recursive(ifac.nvar - 1);
407
408        BigInteger mi = m;
409        long k = 3L;
410        //long d = 3L;
411        java.math.BigInteger pk = p.pow((int) k);
412        //m = new BigInteger(pk);
413        //System.out.println("m = " + m);
414
415        ModIntegerRing pkm = new ModIntegerRing(pk, false);
416        //ModLongRing pkl = new ModLongRing(pk, false);
417        GenPolynomialRing<ModInteger> pkfac = new GenPolynomialRing<ModInteger>(pkm, pfac);
418        dfac = new GenPolynomialRing<BigInteger>(mi, pfac);
419
420        //GreatestCommonDivisor<BigInteger> ufd = GCDFactory.getProxy(mi);
421        GreatestCommonDivisor<BigInteger> ufd = GCDFactory.getImplementation(mi);
422
423        //ModLong v = pl.fromInteger(3L);
424        ModInteger v = pkm.fromInteger(3L);
425        List<BigInteger> V = new ArrayList<BigInteger>(1);
426        V.add(new BigInteger(3L));
427        if (pkfac.nvar > 2) {
428            V.add(new BigInteger(5L)); //pkm.fromInteger(5L));
429        }
430        if (pkfac.nvar > 3) {
431            V.add(new BigInteger(7L)); //pkm.fromInteger(7L));
432        }
433        //System.out.println("V = " + V);
434
435        GenPolynomial<ModInteger> ap;
436        GenPolynomial<ModInteger> cp;
437        //GenPolynomial<ModInteger> rp;
438
439        List<GenPolynomial<BigInteger>> A = new ArrayList<GenPolynomial<BigInteger>>();
440
441        for (int i = 1; i < 2; i++) {
442            //a = dfac.random(kl + 7 * i, ll, el + 1, q).abs();
443            //b = dfac.random(kl + 7 * i, ll, el + 0, q).abs();
444            //c = dfac.random(kl + 7 * i, ll, el + 2, q).abs();
445            //a = dfac.parse(" ( z^2 + y^2 + 4 x^3 - x + 1 + w ) ");
446            //b = dfac.parse(" ( z y x + x^2 + 10 + w ) ");
447            a = dfac.parse(" ( x^3 z - y ) ");
448            //a = dfac.parse(" ( x - y ) ");
449            b = dfac.parse(" ( 1 + y + z ) ");
450            e = dfac.parse(" ( z^2 y - x ) ");
451
452            A.add(a);
453            A.add(b);
454            A.add(e);
455            //System.out.println("A          = " + A);
456            A = ufd.coPrime(A);
457            //System.out.println("coprime(A) = " + A); // polynomials are rearranged
458            if (A.size() == 0) {
459                continue;
460            }
461            c = A.get(0).multiply(A.get(1)).multiply(A.get(2));
462            //c = dfac.parse(" y^2 + x^2 ");
463            cp = PolyUtil.<ModInteger> fromIntegerCoefficients(pkfac, c);
464            //System.out.println("c          = " + c);
465            GenPolynomial<GenPolynomial<BigInteger>> cr = PolyUtil.<BigInteger> recursive(irfac, c);
466            GenPolynomial<GenPolynomial<BigInteger>> crr = PolyUtil.<BigInteger> switchVariables(cr);
467            //System.out.println("crr = " + crr);
468            GenPolynomial<BigInteger> cl = crr.leadingBaseCoefficient();
469            //System.out.println("cl         = " + cl + ", cl.ring = " + cl.ring);
470
471            FactorAbstract<BigInteger> factorizer = FactorFactory.getImplementation(new BigInteger());
472            List<GenPolynomial<BigInteger>> CF = factorizer.factorsRadical(cl);
473            //System.out.println("CF         = " + CF);
474
475            List<GenPolynomial<BigInteger>> CL = new ArrayList<GenPolynomial<BigInteger>>(2);
476            CL.add(CF.get(0));
477            CL.add(CF.get(2));
478            CL.add(CF.get(1));
479            //System.out.println("CL         = " + CL);
480
481            List<GenPolynomial<ModInteger>> Ap = new ArrayList<GenPolynomial<ModInteger>>(A.size());
482            for (GenPolynomial<BigInteger> ai : A) {
483                ap = PolyUtil.<ModInteger> fromIntegerCoefficients(pkfac, ai);
484                Ap.add(ap);
485            }
486            //System.out.println("A mod p^k  = " + Ap);
487            //System.out.println("v = " + v + ", V = " + V);
488
489            GenPolynomialRing<ModInteger> ckfac = pkfac.contract(1);
490            //v = pkm.fromInteger( V.get(2) );
491            List<GenPolynomial<ModInteger>> Ae = new ArrayList<GenPolynomial<ModInteger>>(A.size());
492            //for ( GenPolynomial<ModInteger> a : Ap ) {
493            //     GenPolynomial<ModInteger> ae = PolyUtil.<ModInteger> evaluateMain(ckfac,a,v);
494            //     Ae.add(ae);
495            //}
496            //System.out.println("A(v) mod p^k = " + Ae);
497            //ckfac = ckfac.contract(1);
498
499            Ae = Ap;
500            v = pkm.fromInteger( V.get(1).getVal() );
501            List<GenPolynomial<ModInteger>> Ae1 = new ArrayList<GenPolynomial<ModInteger>>(A.size());
502            for (GenPolynomial<ModInteger> a : Ae) {
503                GenPolynomial<ModInteger> ae = PolyUtil.<ModInteger> evaluateMain(ckfac, a, v);
504                Ae1.add(ae);
505            }
506            Ae = Ae1;
507            //System.out.println("A(v) mod p^k = " + Ae);
508            ckfac = ckfac.contract(1);
509
510            v = pkm.fromInteger( V.get(0).getVal() );
511            Ae1 = new ArrayList<GenPolynomial<ModInteger>>(A.size());
512            for (GenPolynomial<ModInteger> a : Ae) { // Ap
513                GenPolynomial<ModInteger> ae = PolyUtil.<ModInteger> evaluateMain(ckfac, a, v);
514                Ae1.add(ae);
515            }
516            Ae = Ae1;
517            //System.out.println("A(v,v) mod p^k = " + Ae);
518
519            try {
520                List<GenPolynomial<ModInteger>> lift;
521                lift = HenselMultUtil.<ModInteger> liftHensel(c, cp, Ae, V, k, CL); // 5 is max
522                //System.out.println("\nliftMultiHensel:");
523                //System.out.println("lift   = " + lift);
524                //System.out.println("A      = " + A);
525                boolean t = HenselMultUtil.<ModInteger> isHenselLift(c, cp, Ae, lift);
526                assertTrue("isHenselLift: ", t);
527            } catch (ArithmeticException e) {
528                // ok, can happen
529                System.out.println("e = " + e);
530            } catch (NoLiftingException e) {
531                // can now happen: 
532                fail("" + e);
533                System.out.println("e = " + e);
534            }
535        }
536    }
537
538
539    /**
540     * Test multivariate Hensel lifting list, 4 variables.
541     */
542    public void xtestHenselLifting4List() {
543        java.math.BigInteger p;
544        //p = getPrime1();
545        p = new java.math.BigInteger("19");
546        //p = new java.math.BigInteger("5");
547        BigInteger m = new BigInteger(p);
548
549        ModIntegerRing pm = new ModIntegerRing(p, false);
550        GenPolynomialRing<ModInteger> pfac = new GenPolynomialRing<ModInteger>(pm, 4, tord, new String[] {
551                "x", "y", "z", "w" });
552        GenPolynomialRing<BigInteger> ifac = new GenPolynomialRing<BigInteger>(new BigInteger(), pfac);
553        GenPolynomialRing<GenPolynomial<BigInteger>> irfac = ifac.recursive(ifac.nvar - 1);
554
555        BigInteger mi = m;
556        long k = 3L;
557        //long d = 3L;
558        java.math.BigInteger pk = p.pow((int) k);
559        //m = new BigInteger(pk);
560        //System.out.println("m = " + m);
561
562        ModIntegerRing pkm = new ModIntegerRing(pk, false);
563        //ModLongRing pkl = new ModLongRing(pk, false);
564        GenPolynomialRing<ModInteger> pkfac = new GenPolynomialRing<ModInteger>(pkm, pfac);
565        dfac = new GenPolynomialRing<BigInteger>(mi, pfac);
566
567        //GreatestCommonDivisor<BigInteger> ufd = GCDFactory.getProxy(mi);
568        GreatestCommonDivisor<BigInteger> ufd = GCDFactory.getImplementation(mi);
569
570        //ModLong v = pl.fromInteger(3L);
571        ModInteger v = pkm.fromInteger(3L);
572        List<BigInteger> V = new ArrayList<BigInteger>(1);
573        V.add(new BigInteger(3L));
574        if (pkfac.nvar > 2) {
575            V.add(new BigInteger(5L)); //pkm.fromInteger(5L));
576        }
577        if (pkfac.nvar > 3) {
578            V.add(new BigInteger(7L)); // pkm.fromInteger(7L));
579        }
580        //System.out.println("V = " + V);
581
582        GenPolynomial<ModInteger> ap;
583        GenPolynomial<ModInteger> cp;
584        //GenPolynomial<ModInteger> rp;
585
586        List<GenPolynomial<BigInteger>> A = new ArrayList<GenPolynomial<BigInteger>>();
587
588        for (int i = 1; i < 2; i++) {
589            a = dfac.parse(" ( x^3 w - y ) ");
590            b = dfac.parse(" ( 1 + y + z + w ) ");
591            e = dfac.parse(" ( z^2 y w - x ) ");
592
593            A.add(a);
594            A.add(b);
595            A.add(e);
596            //System.out.println("A          = " + A);
597            A = ufd.coPrime(A);
598            //System.out.println("coprime(A) = " + A); // polynomials are rearranged
599            if (A.size() == 0) {
600                continue;
601            }
602            c = A.get(0).multiply(A.get(1)).multiply(A.get(2));
603            cp = PolyUtil.<ModInteger> fromIntegerCoefficients(pkfac, c);
604            //System.out.println("c          = " + c);
605            GenPolynomial<GenPolynomial<BigInteger>> cr = PolyUtil.<BigInteger> recursive(irfac, c);
606            GenPolynomial<GenPolynomial<BigInteger>> crr = PolyUtil.<BigInteger> switchVariables(cr);
607            //System.out.println("crr = " + crr);
608            GenPolynomial<BigInteger> cl = crr.leadingBaseCoefficient();
609            //System.out.println("cl         = " + cl + ", cl.ring = " + cl.ring);
610
611            FactorAbstract<BigInteger> factorizer = FactorFactory.getImplementation(new BigInteger());
612            List<GenPolynomial<BigInteger>> CF = factorizer.factorsRadical(cl);
613            //System.out.println("CF         = " + CF);
614
615            List<GenPolynomial<BigInteger>> CL = new ArrayList<GenPolynomial<BigInteger>>(2);
616            CL.add(CF.get(0));
617            CL.add(CF.get(2));
618            CL.add(CF.get(1));
619            //System.out.println("CL         = " + CL);
620
621            List<GenPolynomial<ModInteger>> Ap = new ArrayList<GenPolynomial<ModInteger>>(A.size());
622            for (GenPolynomial<BigInteger> ai : A) {
623                ap = PolyUtil.<ModInteger> fromIntegerCoefficients(pkfac, ai);
624                Ap.add(ap);
625            }
626            //System.out.println("A mod p^k  = " + Ap);
627            //System.out.println("v = " + v + ", V = " + V);
628
629            GenPolynomialRing<ModInteger> ckfac = pkfac.contract(1);
630            v = pkm.fromInteger( V.get(2).getVal() );
631            List<GenPolynomial<ModInteger>> Ae = new ArrayList<GenPolynomial<ModInteger>>(A.size());
632            for (GenPolynomial<ModInteger> a : Ap) {
633                GenPolynomial<ModInteger> ae = PolyUtil.<ModInteger> evaluateMain(ckfac, a, v);
634                Ae.add(ae);
635            }
636            //System.out.println("A(v) mod p^k = " + Ae);
637            ckfac = ckfac.contract(1);
638
639            v = pkm.fromInteger( V.get(1).getVal() );
640            List<GenPolynomial<ModInteger>> Ae1 = new ArrayList<GenPolynomial<ModInteger>>(A.size());
641            for (GenPolynomial<ModInteger> a : Ae) {
642                GenPolynomial<ModInteger> ae = PolyUtil.<ModInteger> evaluateMain(ckfac, a, v);
643                Ae1.add(ae);
644            }
645            Ae = Ae1;
646            //System.out.println("A(v,v) mod p^k = " + Ae);
647            ckfac = ckfac.contract(1);
648
649            v = pkm.fromInteger( V.get(0).getVal() );
650            Ae1 = new ArrayList<GenPolynomial<ModInteger>>(A.size());
651            for (GenPolynomial<ModInteger> a : Ae) { // Ap
652                GenPolynomial<ModInteger> ae = PolyUtil.<ModInteger> evaluateMain(ckfac, a, v);
653                Ae1.add(ae);
654            }
655            Ae = Ae1;
656            //System.out.println("A(v,v,v) mod p^k = " + Ae);
657
658            try {
659                List<GenPolynomial<ModInteger>> lift;
660                lift = HenselMultUtil.<ModInteger> liftHensel(c, cp, Ae, V, k, CL); // 5 is max
661                //System.out.println("\nliftMultiHensel:");
662                //System.out.println("lift   = " + lift);
663                //System.out.println("A      = " + A);
664                boolean t = HenselMultUtil.<ModInteger> isHenselLift(c, cp, Ae, lift);
665                assertTrue("isHenselLift: ", t);
666            } catch (ArithmeticException e) {
667                // ok, can happen
668                System.out.println("e = " + e);
669            } catch (NoLiftingException e) {
670                // can now happen: 
671                fail("" + e);
672                System.out.println("e = " + e);
673            }
674        }
675    }
676
677
678    /**
679     * Test univariate and multivariate Hensel lifting list, 2 variables.
680     */
681    public void testHenselLifting2FullList() {
682        java.math.BigInteger p;
683        //p = getPrime1();
684        p = new java.math.BigInteger("19");
685        //p = new java.math.BigInteger("5");
686        BigInteger m = new BigInteger(p);
687
688        ModLongRing pm = new ModLongRing(p, false);
689        GenPolynomialRing<ModLong> pfac = new GenPolynomialRing<ModLong>(pm, 2, tord,
690                        new String[] { "x", "y" });
691        GenPolynomialRing<BigInteger> ifac = new GenPolynomialRing<BigInteger>(new BigInteger(), pfac);
692        GenPolynomialRing<GenPolynomial<BigInteger>> irfac = ifac.recursive(ifac.nvar - 1);
693        GenPolynomialRing<BigInteger> icfac = ifac.contract(ifac.nvar - 1);
694        GenPolynomialRing<ModLong> pcfac = pfac.contract(pfac.nvar - 1);
695
696        BigInteger mi = m;
697        long k = 5L;
698        //long d = 3L;
699        java.math.BigInteger pk = p.pow((int) k);
700        //m = new BigInteger(pk);
701        //System.out.println("m = " + m + " = " + p + "^" + k);
702
703        ModLongRing pkm = new ModLongRing(pk, false);
704        GenPolynomialRing<ModLong> pkfac = new GenPolynomialRing<ModLong>(pkm, pfac);
705        dfac = new GenPolynomialRing<BigInteger>(mi, pfac);
706
707        //GreatestCommonDivisor<BigInteger> ufd = GCDFactory.getProxy(mi);
708        GreatestCommonDivisor<BigInteger> ufd = GCDFactory.getImplementation(mi);
709
710        ModLong v = pkm.fromInteger(3L);
711        List<BigInteger> V = new ArrayList<BigInteger>(1);
712        V.add(new BigInteger(3L));
713        //System.out.println("V = " + V);
714
715        GenPolynomial<ModLong> ap;
716        GenPolynomial<ModLong> cp;
717        //GenPolynomial<ModLong> rp;
718
719        List<GenPolynomial<BigInteger>> A = new ArrayList<GenPolynomial<BigInteger>>();
720
721        for (int i = 1; i < 2; i++) {
722            a = dfac.parse(" ( x^3 y - 1 ) ");
723            b = dfac.parse(" ( 1 + y ) ");
724            e = dfac.parse(" ( y^2 - x ) ");
725
726            A.add(a);
727            A.add(b);
728            A.add(e);
729            //System.out.println("A          = " + A);
730            A = ufd.coPrime(A);
731            //System.out.println("coprime(A) = " + A); // polynomials are rearranged
732            if (A.size() == 0) {
733                continue;
734            }
735            c = A.get(0).multiply(A.get(1)).multiply(A.get(2));
736            cp = PolyUtil.<ModLong> fromIntegerCoefficients(pkfac, c);
737            //System.out.println("c          = " + c);
738            GenPolynomial<GenPolynomial<BigInteger>> cr = PolyUtil.<BigInteger> recursive(irfac, c);
739            GenPolynomial<GenPolynomial<BigInteger>> crr = PolyUtil.<BigInteger> switchVariables(cr);
740            //System.out.println("crr        = " + crr);
741            GenPolynomial<BigInteger> cl = crr.leadingBaseCoefficient();
742            //System.out.println("cl         = " + cl + ", cl.ring = " + cl.ring);
743
744            FactorAbstract<BigInteger> factorizer = FactorFactory.getImplementation(new BigInteger());
745            List<GenPolynomial<BigInteger>> CF = factorizer.factorsRadical(cl);
746            //System.out.println("CF         = " + CF);
747
748            List<GenPolynomial<BigInteger>> CL = new ArrayList<GenPolynomial<BigInteger>>(2);
749            CL.add(CF.get(0));
750            CL.add(CF.get(2));
751            CL.add(CF.get(1));
752            //CL.add( CF.get(0) );
753            //System.out.println("CL         = " + CL);
754
755            List<GenPolynomial<ModLong>> Apk = new ArrayList<GenPolynomial<ModLong>>(A.size());
756            for (GenPolynomial<BigInteger> ai : A) {
757                ap = PolyUtil.<ModLong> fromIntegerCoefficients(pkfac, ai);
758                Apk.add(ap);
759            }
760            //System.out.println("A mod p^k = " + Apk);
761            //System.out.println("v = " + v + ", V = " + V);
762
763            GenPolynomialRing<ModLong> ckfac = pkfac.contract(1);
764
765            v = pkm.fromInteger( V.get(0).getVal() );
766            List<GenPolynomial<ModLong>> Ae = new ArrayList<GenPolynomial<ModLong>>(A.size());
767            for (GenPolynomial<ModLong> a : Apk) { // Ap
768                GenPolynomial<ModLong> ae = PolyUtil.<ModLong> evaluateMain(ckfac, a, v);
769                Ae.add(ae);
770            }
771            //System.out.println("A(v) mod p^k = " + Ae);
772
773            List<GenPolynomial<ModLong>> Ap = new ArrayList<GenPolynomial<ModLong>>(A.size());
774            for (GenPolynomial<BigInteger> ai : PolyUtil.<ModLong> integerFromModularCoefficients(icfac, Ae)) {
775                ap = PolyUtil.<ModLong> fromIntegerCoefficients(pcfac, ai);
776                Ap.add(ap);
777            }
778            //System.out.println("A(v) mod p = " + Ap);
779
780            try {
781                List<GenPolynomial<ModLong>> lift;
782                lift = HenselMultUtil.<ModLong> liftHenselFull(c, Ap, V, k, CL); // 5 is max
783                //System.out.println("\nliftMultiHensel:");
784                //System.out.println("lift   = " + lift);
785                //System.out.println("A      = " + A);
786                boolean t = HenselMultUtil.<ModLong> isHenselLift(c, cp, Ap, lift);
787                assertTrue("isHenselLift: ", t);
788            } catch (ArithmeticException e) {
789                // ok, can happen
790                System.out.println("e = " + e);
791            } catch (NoLiftingException e) {
792                // can now happen: 
793                fail("" + e);
794                System.out.println("e = " + e);
795            }
796        }
797    }
798
799
800    /**
801     * Test univariate and multivariate Hensel lifting list, 3 variables.
802     */
803    public void testHenselLifting3FullList() {
804        java.math.BigInteger p;
805        //p = getPrime1();
806        p = new java.math.BigInteger("19");
807        //p = new java.math.BigInteger("5");
808        BigInteger m = new BigInteger(p);
809
810        ModLongRing pm = new ModLongRing(p, false);
811        GenPolynomialRing<ModLong> pfac = new GenPolynomialRing<ModLong>(pm, 3, tord, new String[] { "x",
812                "y", "z" });
813        GenPolynomialRing<BigInteger> ifac = new GenPolynomialRing<BigInteger>(new BigInteger(), pfac);
814        GenPolynomialRing<GenPolynomial<BigInteger>> irfac = ifac.recursive(ifac.nvar - 1);
815        GenPolynomialRing<BigInteger> icfac = ifac.contract(ifac.nvar - 1);
816        GenPolynomialRing<ModLong> pcfac = pfac.contract(pfac.nvar - 1);
817
818        BigInteger mi = m;
819        long k = 5L;
820        //long d = 3L;
821        java.math.BigInteger pk = p.pow((int) k);
822        //m = new BigInteger(pk);
823        //System.out.println("m = " + m + " = " + p + "^" + k);
824
825        ModLongRing pkm = new ModLongRing(pk, false);
826        GenPolynomialRing<ModLong> pkfac = new GenPolynomialRing<ModLong>(pkm, pfac);
827        dfac = new GenPolynomialRing<BigInteger>(mi, pfac);
828
829        //GreatestCommonDivisor<BigInteger> ufd = GCDFactory.getProxy(mi);
830        GreatestCommonDivisor<BigInteger> ufd = GCDFactory.getImplementation(mi);
831
832        ModLong v = pkm.fromInteger(3L);
833        List<BigInteger> V = new ArrayList<BigInteger>(1);
834        V.add(new BigInteger(3L));
835        if (pkfac.nvar > 2) {
836            V.add(new BigInteger(5L)); //pkm.fromInteger(5L));
837        }
838        //System.out.println("V = " + V);
839
840        GenPolynomial<ModLong> ap;
841        GenPolynomial<ModLong> cp;
842        //GenPolynomial<ModLong> rp;
843
844        List<GenPolynomial<BigInteger>> A = new ArrayList<GenPolynomial<BigInteger>>();
845
846        for (int i = 1; i < 2; i++) {
847            a = dfac.parse(" ( x^3 z - y ) ");
848            b = dfac.parse(" ( 1 + y + z ) ");
849            e = dfac.parse(" ( z^2 y - x ) ");
850
851            A.add(a);
852            A.add(b);
853            A.add(e);
854            //System.out.println("A          = " + A);
855            A = ufd.coPrime(A);
856            //System.out.println("coprime(A) = " + A); // polynomials are rearranged
857            if (A.size() == 0) {
858                continue;
859            }
860            c = A.get(0).multiply(A.get(1)).multiply(A.get(2));
861            cp = PolyUtil.<ModLong> fromIntegerCoefficients(pkfac, c);
862            //System.out.println("c          = " + c);
863            //System.out.println("cp         = " + cp);
864            GenPolynomial<GenPolynomial<BigInteger>> cr = PolyUtil.<BigInteger> recursive(irfac, c);
865            GenPolynomial<GenPolynomial<BigInteger>> crr = PolyUtil.<BigInteger> switchVariables(cr);
866            //System.out.println("crr        = " + crr);
867            GenPolynomial<BigInteger> cl = crr.leadingBaseCoefficient();
868            //System.out.println("cl         = " + cl + ", cl.ring = " + cl.ring);
869
870            FactorAbstract<BigInteger> factorizer = FactorFactory.getImplementation(new BigInteger());
871            List<GenPolynomial<BigInteger>> CF = factorizer.factorsRadical(cl);
872            //System.out.println("CF         = " + CF);
873
874            List<GenPolynomial<BigInteger>> CL = new ArrayList<GenPolynomial<BigInteger>>(2);
875            CL.add(CF.get(0));
876            CL.add(CF.get(2));
877            CL.add(CF.get(1));
878            //System.out.println("CL         = " + CL);
879
880            List<GenPolynomial<ModLong>> Apk = new ArrayList<GenPolynomial<ModLong>>(A.size());
881            for (GenPolynomial<BigInteger> ai : A) {
882                ap = PolyUtil.<ModLong> fromIntegerCoefficients(pkfac, ai);
883                Apk.add(ap);
884            }
885            //System.out.println("A mod p^k  = " + Apk);
886            //System.out.println("v = " + v + ", V = " + V);
887
888            GenPolynomialRing<ModLong> ckfac = pkfac.contract(1);
889            List<GenPolynomial<ModLong>> Ae = new ArrayList<GenPolynomial<ModLong>>(A.size());
890
891            Ae = Apk;
892            v = pkm.fromInteger( V.get(0).getVal() );
893            List<GenPolynomial<ModLong>> Ae1 = new ArrayList<GenPolynomial<ModLong>>(A.size());
894            for (GenPolynomial<ModLong> a : Ae) {
895                GenPolynomial<ModLong> ae = PolyUtil.<ModLong> evaluateMain(ckfac, a, v);
896                Ae1.add(ae);
897            }
898            Ae = Ae1;
899            //System.out.println("A(v) mod p^k = " + Ae);
900            GenPolynomial<ModLong> cpp = PolyUtil.<ModLong> evaluateMain(ckfac, cp, v);
901            //System.out.println("cpp        = " + cpp);
902            ckfac = ckfac.contract(1);
903
904            v = pkm.fromInteger( V.get(1).getVal() );
905            Ae1 = new ArrayList<GenPolynomial<ModLong>>(A.size());
906            for (GenPolynomial<ModLong> a : Ae) { // Ap
907                GenPolynomial<ModLong> ae = PolyUtil.<ModLong> evaluateMain(ckfac, a, v);
908                Ae1.add(ae);
909            }
910            Ae = Ae1;
911            //System.out.println("A(v,v) mod p^k = " + Ae);
912            GenPolynomial<ModLong> cppp = PolyUtil.<ModLong> evaluateMain(ckfac, cpp, v);
913            //System.out.println("cppp       = " + cppp);
914
915            List<GenPolynomial<ModLong>> Ap = new ArrayList<GenPolynomial<ModLong>>(A.size());
916            for (GenPolynomial<BigInteger> ai : PolyUtil.<ModLong> integerFromModularCoefficients(icfac, Ae)) {
917                ap = PolyUtil.<ModLong> fromIntegerCoefficients(pcfac, ai);
918                Ap.add(ap);
919            }
920            //System.out.println("A(v,v) mod p = " + Ap);
921            GenPolynomial<ModLong> cpppp = PolyUtil.<ModLong> fromIntegerCoefficients(pcfac,
922                            PolyUtil.<ModLong> integerFromModularCoefficients(icfac, cppp));
923            //System.out.println("cpppp      = " + cpppp);
924
925            GenPolynomial<ModLong> aa = pcfac.getONE();
926            for (GenPolynomial<ModLong> x : Ap) {
927                aa = aa.multiply(x);
928            }
929            assertTrue("prod(A(v,v)) mod p = " + aa + ", cpppp = " + cpppp + ", aa != cpppp: ",
930                            cpppp.equals(aa));
931
932            try {
933                List<GenPolynomial<ModLong>> lift;
934                lift = HenselMultUtil.<ModLong> liftHenselFull(c, Ap, V, k, CL); // 5 is max
935                //System.out.println("\nliftMultiHensel:");
936                //System.out.println("lift   = " + lift);
937                //System.out.println("A      = " + A);
938                boolean t = HenselMultUtil.<ModLong> isHenselLift(c, cp, Ap, lift);
939                assertTrue("isHenselLift: ", t);
940            } catch (ArithmeticException e) {
941                // ok, can happen
942                System.out.println("e = " + e);
943            } catch (NoLiftingException e) {
944                // can now happen: 
945                fail("" + e);
946                System.out.println("e = " + e);
947            }
948        }
949    }
950
951
952    /**
953     * Test univariate and multivariate Hensel lifting list, 3 variables.
954     */
955    public void testHenselLifting4FullList() {
956        java.math.BigInteger p;
957        //p = getPrime1();
958        p = new java.math.BigInteger("19");
959        //p = new java.math.BigInteger("5");
960        BigInteger m = new BigInteger(p);
961
962        ModLongRing pm = new ModLongRing(p, false);
963        GenPolynomialRing<ModLong> pfac = new GenPolynomialRing<ModLong>(pm, 4, tord, new String[] { "x",
964                "y", "z", "w" });
965        GenPolynomialRing<BigInteger> ifac = new GenPolynomialRing<BigInteger>(new BigInteger(), pfac);
966        GenPolynomialRing<GenPolynomial<BigInteger>> irfac = ifac.recursive(ifac.nvar - 1);
967        GenPolynomialRing<BigInteger> icfac = ifac.contract(ifac.nvar - 1);
968        GenPolynomialRing<ModLong> pcfac = pfac.contract(pfac.nvar - 1);
969
970        BigInteger mi = m;
971        long k = 5L;
972        //long d = 3L;
973        java.math.BigInteger pk = p.pow((int) k);
974        //m = new BigInteger(pk);
975        //System.out.println("m = " + m);
976
977        ModLongRing pkm = new ModLongRing(pk, false);
978        GenPolynomialRing<ModLong> pkfac = new GenPolynomialRing<ModLong>(pkm, pfac);
979        dfac = new GenPolynomialRing<BigInteger>(mi, pfac);
980
981        //GreatestCommonDivisor<BigInteger> ufd = GCDFactory.getProxy(mi);
982        GreatestCommonDivisor<BigInteger> ufd = GCDFactory.getImplementation(mi);
983
984        ModLong v = pkm.fromInteger(3L);
985        List<BigInteger> V = new ArrayList<BigInteger>(1);
986        V.add(new BigInteger(3L));
987        if (pkfac.nvar > 2) {
988            V.add(new BigInteger(5L)); //pkm.fromInteger(5L));
989        }
990        if (pkfac.nvar > 3) {
991            V.add(new BigInteger(7L)); //pkm.fromInteger(7L));
992        }
993        //System.out.println("V = " + V);
994
995        GenPolynomial<ModLong> ap;
996        GenPolynomial<ModLong> cp;
997        //GenPolynomial<ModLong> rp;
998
999        List<GenPolynomial<BigInteger>> A = new ArrayList<GenPolynomial<BigInteger>>();
1000
1001        for (int i = 1; i < 2; i++) {
1002            a = dfac.parse(" ( x^3 w - y ) ");
1003            b = dfac.parse(" ( 1 + y + z + w ) ");
1004            e = dfac.parse(" ( z^2 y w - x ) ");
1005
1006            A.add(a);
1007            A.add(b);
1008            A.add(e);
1009            //System.out.println("A          = " + A);
1010            A = ufd.coPrime(A);
1011            //System.out.println("coprime(A) = " + A); // polynomials are rearranged
1012            if (A.size() == 0) {
1013                continue;
1014            }
1015            c = A.get(0).multiply(A.get(1)).multiply(A.get(2));
1016            cp = PolyUtil.<ModLong> fromIntegerCoefficients(pkfac, c);
1017            //System.out.println("c          = " + c);
1018            GenPolynomial<GenPolynomial<BigInteger>> cr = PolyUtil.<BigInteger> recursive(irfac, c);
1019            GenPolynomial<GenPolynomial<BigInteger>> crr = PolyUtil.<BigInteger> switchVariables(cr);
1020            //System.out.println("crr = " + crr);
1021            GenPolynomial<BigInteger> cl = crr.leadingBaseCoefficient();
1022            //System.out.println("cl         = " + cl + ", cl.ring = " + cl.ring);
1023
1024            FactorAbstract<BigInteger> factorizer = FactorFactory.getImplementation(new BigInteger());
1025            List<GenPolynomial<BigInteger>> CF = factorizer.factorsRadical(cl);
1026            //System.out.println("CF         = " + CF);
1027
1028            List<GenPolynomial<BigInteger>> CL = new ArrayList<GenPolynomial<BigInteger>>(2);
1029            CL.add(CF.get(0));
1030            CL.add(CF.get(2));
1031            CL.add(CF.get(1));
1032            //System.out.println("CL         = " + CL);
1033
1034            List<GenPolynomial<ModLong>> Apk = new ArrayList<GenPolynomial<ModLong>>(A.size());
1035            for (GenPolynomial<BigInteger> ai : A) {
1036                ap = PolyUtil.<ModLong> fromIntegerCoefficients(pkfac, ai);
1037                Apk.add(ap);
1038            }
1039            //System.out.println("A mod p^k  = " + Apk);
1040            //System.out.println("v = " + v + ", V = " + V);
1041
1042            GenPolynomialRing<ModLong> ckfac = pkfac.contract(1);
1043            v = pkm.fromInteger( V.get(0).getVal() );
1044            List<GenPolynomial<ModLong>> Ae = new ArrayList<GenPolynomial<ModLong>>(A.size());
1045            for (GenPolynomial<ModLong> a : Apk) {
1046                GenPolynomial<ModLong> ae = PolyUtil.<ModLong> evaluateMain(ckfac, a, v);
1047                Ae.add(ae);
1048            }
1049            //System.out.println("A(v) mod p^k = " + Ae);
1050            ckfac = ckfac.contract(1);
1051
1052            v = pkm.fromInteger( V.get(1).getVal() );
1053            List<GenPolynomial<ModLong>> Ae1 = new ArrayList<GenPolynomial<ModLong>>(A.size());
1054            for (GenPolynomial<ModLong> a : Ae) {
1055                GenPolynomial<ModLong> ae = PolyUtil.<ModLong> evaluateMain(ckfac, a, v);
1056                Ae1.add(ae);
1057            }
1058            Ae = Ae1;
1059            //System.out.println("A(v,v) mod p^k = " + Ae);
1060            ckfac = ckfac.contract(1);
1061
1062            v = pkm.fromInteger( V.get(2).getVal() );
1063            Ae1 = new ArrayList<GenPolynomial<ModLong>>(A.size());
1064            for (GenPolynomial<ModLong> a : Ae) { // Ap
1065                GenPolynomial<ModLong> ae = PolyUtil.<ModLong> evaluateMain(ckfac, a, v);
1066                Ae1.add(ae);
1067            }
1068            Ae = Ae1;
1069            //System.out.println("A(v,v,v) mod p^k = " + Ae);
1070
1071            List<GenPolynomial<ModLong>> Ap = new ArrayList<GenPolynomial<ModLong>>(A.size());
1072            for (GenPolynomial<BigInteger> ai : PolyUtil.<ModLong> integerFromModularCoefficients(icfac, Ae)) {
1073                ap = PolyUtil.<ModLong> fromIntegerCoefficients(pcfac, ai);
1074                Ap.add(ap);
1075            }
1076            //System.out.println("A(v,v,v) mod p = " + Ap);
1077
1078            try {
1079                List<GenPolynomial<ModLong>> lift;
1080                //lift = HenselMultUtil.<ModLong> liftHensel(c, cp, Ae, V, k, CL); // 5 is max
1081                lift = HenselMultUtil.<ModLong> liftHenselFull(c, Ap, V, k, CL); // 5 is max
1082                //System.out.println("\nliftMultiHensel:");
1083                //System.out.println("lift   = " + lift);
1084                //System.out.println("A      = " + A);
1085                boolean t = HenselMultUtil.<ModLong> isHenselLift(c, cp, Ap, lift);
1086                assertTrue("isHenselLift: ", t);
1087            } catch (ArithmeticException e) {
1088                // ok, can happen
1089                System.out.println("e = " + e);
1090            } catch (NoLiftingException e) {
1091                // can now happen: 
1092                fail("" + e);
1093                System.out.println("e = " + e);
1094            }
1095        }
1096    }
1097
1098}