source: git/factory/facFqBivar.cc @ 14e634

jengelh-datetimespielwiese
Last change on this file since 14e634 was 14e634, checked in by Martin Lee <martinlee84@…>, 10 years ago
fix: bug in factorization over Q(a)
  • Property mode set to 100644
File size: 224.0 KB
Line 
1/*****************************************************************************\
2 * Computer Algebra System SINGULAR
3\*****************************************************************************/
4/** @file facFqBivar.cc
5 *
6 * This file provides functions for factorizing a bivariate polynomial over
7 * \f$ F_{p} \f$ , \f$ F_{p}(\alpha ) \f$ or GF, based on "Modern Computer
8 * Algebra, Chapter 15" by J. von zur Gathen & J. Gerhard and "Factoring
9 * multivariate polynomials over a finite field" by L. Bernardin.
10 * Factor Recombination is described in "Factoring polynomials over global
11 * fields" by K. Belabas, M. van Hoeij, J. Klueners, A. Steel
12 *
13 *
14 * @author Martin Lee
15 *
16 **/
17/*****************************************************************************/
18
19#include "config.h"
20
21#include "cf_assert.h"
22#include "debug.h"
23#include "timing.h"
24
25#include "canonicalform.h"
26#include "cf_defs.h"
27#include "cf_map_ext.h"
28#include "cf_random.h"
29#include "facHensel.h"
30#include "facMul.h"
31#include "cf_map.h"
32#include "cf_gcd_smallp.h"
33#include "facFqBivarUtil.h"
34#include "facFqBivar.h"
35#include "cfNewtonPolygon.h"
36#include "algext.h"
37
38#ifdef HAVE_NTL
39#include "NTLconvert.h"
40
41#ifdef HAVE_FLINT
42#include "FLINTconvert.h"
43#endif
44
45TIMING_DEFINE_PRINT(fac_fq_uni_factorizer)
46TIMING_DEFINE_PRINT(fac_fq_bi_hensel_lift)
47TIMING_DEFINE_PRINT(fac_fq_bi_factor_recombination)
48TIMING_DEFINE_PRINT(fac_fq_bi_evaluation)
49TIMING_DEFINE_PRINT(fac_fq_bi_shift_to_zero)
50
51CanonicalForm prodMod0 (const CFList& L, const CanonicalForm& M, const modpk& b)
52{
53  if (L.isEmpty())
54    return 1;
55  else if (L.length() == 1)
56    return mod (L.getFirst()(0, 1) , M);
57  else if (L.length() == 2)
58    return mod (mulNTL (L.getFirst()(0, 1),L.getLast()(0, 1), b), M);
59  else
60  {
61    int l= L.length()/2;
62    CFListIterator i= L;
63    CFList tmp1, tmp2;
64    CanonicalForm buf1, buf2;
65    for (int j= 1; j <= l; j++, i++)
66      tmp1.append (i.getItem());
67    tmp2= Difference (L, tmp1);
68    buf1= prodMod0 (tmp1, M, b);
69    buf2= prodMod0 (tmp2, M, b);
70    return mod (mulNTL (buf1,buf2, b), M);
71  }
72}
73
74CanonicalForm evalPoint (const CanonicalForm& F, CanonicalForm & eval,
75                         const Variable& alpha, CFList& list, const bool& GF,
76                         bool& fail)
77{
78  fail= false;
79  Variable x= Variable(2);
80  Variable y= Variable(1);
81  FFRandom genFF;
82  GFRandom genGF;
83  CanonicalForm random, mipo;
84  double bound;
85  int p= getCharacteristic ();
86  if (alpha.level() != 1)
87  {
88    mipo= getMipo (alpha);
89    int d= degree (mipo);
90    bound= ipower (p, d);
91  }
92  else if (GF)
93  {
94    int d= getGFDegree();
95    bound= ipower (p, d);
96  }
97  else
98    bound= p;
99
100  random= 0;
101  do
102  {
103    if (list.length() >= bound)
104    {
105      fail= true;
106      break;
107    }
108    if (list.isEmpty())
109      random= 0;
110    else if (GF)
111    {
112      if (list.length() == 1)
113        random= getGFGenerator();
114      else
115        random= genGF.generate();
116    }
117    else if (list.length() < p || alpha.level() == 1)
118      random= genFF.generate();
119    else if (alpha != x && list.length() >= p)
120    {
121      if (list.length() == p)
122        random= alpha;
123      else
124      {
125        AlgExtRandomF genAlgExt (alpha);
126        random= genAlgExt.generate();
127      }
128    }
129    if (find (list, random)) continue;
130    eval= F (random, x);
131    if (degree (eval) != degree (F, y))
132    { //leading coeff vanishes
133      if (!find (list, random))
134        list.append (random);
135      continue;
136    }
137    if (degree (gcd (deriv (eval, eval.mvar()), eval), eval.mvar()) > 0)
138    { //evaluated polynomial is not squarefree
139      if (!find (list, random))
140        list.append (random);
141      continue;
142    }
143  } while (find (list, random));
144
145  return random;
146}
147
148CFList
149uniFactorizer (const CanonicalForm& A, const Variable& alpha, const bool& GF)
150{
151  Variable x= A.mvar();
152  if (A.inCoeffDomain())
153    return CFList();
154  ASSERT (A.isUnivariate(),
155          "univariate polynomial expected or constant expected");
156  CFFList factorsA;
157  if (fac_NTL_char != getCharacteristic())
158  {
159    fac_NTL_char= getCharacteristic();
160    zz_p::init (getCharacteristic());
161  }
162  if (GF)
163  {
164    int k= getGFDegree();
165    char cGFName= gf_name;
166    CanonicalForm mipo= gf_mipo;
167    setCharacteristic (getCharacteristic());
168    Variable beta= rootOf (mipo.mapinto());
169    CanonicalForm buf= GF2FalphaRep (A, beta);
170    if (getCharacteristic() > 2)
171    {
172      zz_pX NTLMipo= convertFacCF2NTLzzpX (mipo.mapinto());
173      zz_pE::init (NTLMipo);
174      zz_pEX NTLA= convertFacCF2NTLzz_pEX (buf, NTLMipo);
175      MakeMonic (NTLA);
176      vec_pair_zz_pEX_long NTLFactorsA= CanZass (NTLA);
177      zz_pE multi= to_zz_pE (1);
178      factorsA= convertNTLvec_pair_zzpEX_long2FacCFFList (NTLFactorsA, multi,
179                                                         x, beta);
180    }
181    else
182    {
183      GF2X NTLMipo= convertFacCF2NTLGF2X (mipo.mapinto());
184      GF2E::init (NTLMipo);
185      GF2EX NTLA= convertFacCF2NTLGF2EX (buf, NTLMipo);
186      MakeMonic (NTLA);
187      vec_pair_GF2EX_long NTLFactorsA= CanZass (NTLA);
188      GF2E multi= to_GF2E (1);
189      factorsA= convertNTLvec_pair_GF2EX_long2FacCFFList (NTLFactorsA, multi,
190                                                           x, beta);
191    }
192    setCharacteristic (getCharacteristic(), k, cGFName);
193    for (CFFListIterator i= factorsA; i.hasItem(); i++)
194    {
195      buf= i.getItem().factor();
196      buf= Falpha2GFRep (buf);
197      i.getItem()= CFFactor (buf, i.getItem().exp());
198    }
199  }
200  else if (alpha.level() != 1)
201  {
202    if (getCharacteristic() > 2)
203    {
204      zz_pX NTLMipo= convertFacCF2NTLzzpX (getMipo (alpha));
205      zz_pE::init (NTLMipo);
206      zz_pEX NTLA= convertFacCF2NTLzz_pEX (A, NTLMipo);
207      MakeMonic (NTLA);
208      vec_pair_zz_pEX_long NTLFactorsA= CanZass (NTLA);
209      zz_pE multi= to_zz_pE (1);
210      factorsA= convertNTLvec_pair_zzpEX_long2FacCFFList (NTLFactorsA, multi,
211                                                           x, alpha);
212    }
213    else
214    {
215      GF2X NTLMipo= convertFacCF2NTLGF2X (getMipo (alpha));
216      GF2E::init (NTLMipo);
217      GF2EX NTLA= convertFacCF2NTLGF2EX (A, NTLMipo);
218      MakeMonic (NTLA);
219      vec_pair_GF2EX_long NTLFactorsA= CanZass (NTLA);
220      GF2E multi= to_GF2E (1);
221      factorsA= convertNTLvec_pair_GF2EX_long2FacCFFList (NTLFactorsA, multi,
222                                                           x, alpha);
223    }
224  }
225  else
226  {
227#ifdef HAVE_FLINT
228    nmod_poly_t FLINTA;
229    convertFacCF2nmod_poly_t (FLINTA, A);
230    nmod_poly_factor_t result;
231    nmod_poly_factor_init (result);
232    mp_limb_t leadingCoeff= nmod_poly_factor (result, FLINTA);
233    factorsA= convertFLINTnmod_poly_factor2FacCFFList (result, leadingCoeff, x);
234    if (factorsA.getFirst().factor().inCoeffDomain())
235      factorsA.removeFirst();
236    nmod_poly_factor_clear (result);
237    nmod_poly_clear (FLINTA);
238#else
239    if (getCharacteristic() > 2)
240    {
241      zz_pX NTLA= convertFacCF2NTLzzpX (A);
242      MakeMonic (NTLA);
243      vec_pair_zz_pX_long NTLFactorsA= CanZass (NTLA);
244      zz_p multi= to_zz_p (1);
245      factorsA= convertNTLvec_pair_zzpX_long2FacCFFList (NTLFactorsA, multi,
246                                                          x);
247    }
248    else
249    {
250      GF2X NTLA= convertFacCF2NTLGF2X (A);
251      vec_pair_GF2X_long NTLFactorsA= CanZass (NTLA);
252      GF2 multi= to_GF2 (1);
253      factorsA= convertNTLvec_pair_GF2X_long2FacCFFList (NTLFactorsA, multi,
254                                                          x);
255    }
256#endif
257  }
258  CFList uniFactors;
259  for (CFFListIterator i= factorsA; i.hasItem(); i++)
260    uniFactors.append (i.getItem().factor());
261  return uniFactors;
262}
263
264/// naive factor recombination as decribed in "Factoring
265/// multivariate polynomials over a finite field" by L Bernardin.
266CFList
267extFactorRecombination (CFList& factors, CanonicalForm& F,
268                        const CanonicalForm& N, const ExtensionInfo& info,
269                        DegreePattern& degs, const CanonicalForm& eval, int s,
270                        int thres)
271{
272  if (factors.length() == 0)
273  {
274    F= 1;
275    return CFList();
276  }
277  if (F.inCoeffDomain())
278    return CFList();
279
280  Variable alpha= info.getAlpha();
281  Variable beta= info.getBeta();
282  CanonicalForm gamma= info.getGamma();
283  CanonicalForm delta= info.getDelta();
284  int k= info.getGFDegree();
285
286  CanonicalForm M= N;
287  int l= degree (N);
288  Variable y= F.mvar();
289  Variable x= Variable (1);
290  CFList source, dest;
291  if (degs.getLength() <= 1 || factors.length() == 1)
292  {
293    CFList result= CFList(mapDown (F(y-eval, y), info, source, dest));
294    F= 1;
295    return result;
296  }
297
298  DEBOUTLN (cerr, "LC (F, 1)*prodMod (factors, M) == F " <<
299            (mod (LC (F, 1)*prodMod (factors, M), M)/Lc (mod (LC (F, 1)*prodMod (factors, M), M)) == F/Lc (F)));
300  int degMipoBeta= 1;
301  if (!k && beta.level() != 1)
302    degMipoBeta= degree (getMipo (beta));
303
304  CFList T, S, Diff;
305  T= factors;
306
307  CFList result;
308  CanonicalForm buf, buf2, quot;
309
310  buf= F;
311
312  CanonicalForm g, LCBuf= LC (buf, x);
313  int * v= new int [T.length()];
314  for (int i= 0; i < T.length(); i++)
315    v[i]= 0;
316
317  CFArray TT;
318  DegreePattern bufDegs1, bufDegs2;
319  bufDegs1= degs;
320  int subsetDeg;
321  TT= copy (factors);
322  bool nosubset= false;
323  bool recombination= false;
324  bool trueFactor= false;
325  CanonicalForm test;
326  CanonicalForm buf0= buf (0, x)*LCBuf;
327  while (T.length() >= 2*s && s <= thres)
328  {
329    while (nosubset == false)
330    {
331      if (T.length() == s)
332      {
333        delete [] v;
334        if (recombination)
335        {
336          T.insert (LCBuf);
337          g= prodMod (T, M);
338          T.removeFirst();
339          g /= content(g);
340          g= g (y - eval, y);
341          g /= Lc (g);
342          appendTestMapDown (result, g, info, source, dest);
343          F= 1;
344          return result;
345        }
346        else
347        {
348          appendMapDown (result, F (y - eval, y), info, source, dest);
349          F= 1;
350          return result;
351        }
352      }
353      S= subset (v, s, TT, nosubset);
354      if (nosubset) break;
355      subsetDeg= subsetDegree (S);
356      // skip those combinations that are not possible
357      if (!degs.find (subsetDeg))
358        continue;
359      else
360      {
361        test= prodMod0 (S, M);
362        test *= LCBuf;
363        test = mod (test, M);
364        if (fdivides (test, buf0))
365        {
366          S.insert (LCBuf);
367          g= prodMod (S, M);
368          S.removeFirst();
369          g /= content (g, x);
370          if (fdivides (g, buf, quot))
371          {
372            buf2= g (y - eval, y);
373            buf2 /= Lc (buf2);
374
375            if (!k && beta.level() == 1)
376            {
377              if (degree (buf2, alpha) < degMipoBeta)
378              {
379                buf= quot;
380                LCBuf= LC (buf, x);
381                recombination= true;
382                appendTestMapDown (result, buf2, info, source, dest);
383                trueFactor= true;
384              }
385            }
386            else
387            {
388              if (!isInExtension (buf2, gamma, k, delta, source, dest))
389              {
390                buf= quot;
391                LCBuf= LC (buf, x);
392                recombination= true;
393                appendTestMapDown (result, buf2, info, source, dest);
394                trueFactor= true;
395              }
396            }
397            if (trueFactor)
398            {
399              T= Difference (T, S);
400              l -= degree (g);
401              M= power (y, l);
402              buf0= buf (0, x)*LCBuf;
403
404              // compute new possible degree pattern
405              bufDegs2= DegreePattern (T);
406              bufDegs1.intersect (bufDegs2);
407              bufDegs1.refine ();
408              if (T.length() < 2*s || T.length() == s ||
409                  bufDegs1.getLength() == 1)
410              {
411                delete [] v;
412                if (recombination)
413                {
414                  buf= buf (y-eval,y);
415                  buf /= Lc (buf);
416                  appendTestMapDown (result, buf, info, source,
417                                      dest);
418                  F= 1;
419                  return result;
420                }
421                else
422                {
423                  appendMapDown (result, F (y - eval, y), info, source, dest);
424                  F= 1;
425                  return result;
426                }
427              }
428              trueFactor= false;
429              TT= copy (T);
430              indexUpdate (v, s, T.length(), nosubset);
431              if (nosubset) break;
432            }
433          }
434        }
435      }
436    }
437    s++;
438    if (T.length() < 2*s || T.length() == s)
439    {
440      delete [] v;
441      if (recombination)
442      {
443        buf= buf (y-eval,y);
444        buf /= Lc (buf);
445        appendTestMapDown (result, buf, info, source, dest);
446        F= 1;
447        return result;
448      }
449      else
450      {
451        appendMapDown (result, F (y - eval, y), info, source, dest);
452        F= 1;
453        return result;
454      }
455    }
456    for (int i= 0; i < T.length(); i++)
457      v[i]= 0;
458    nosubset= false;
459  }
460  if (T.length() < 2*s)
461  {
462    appendMapDown (result, F (y - eval, y), info, source, dest);
463    F= 1;
464    delete [] v;
465    return result;
466  }
467
468  if (s > thres)
469  {
470    factors= T;
471    F= buf;
472    degs= bufDegs1;
473  }
474
475  delete [] v;
476  return result;
477}
478
479/// naive factor recombination as decribed in "Factoring
480/// multivariate polynomials over a finite field" by L Bernardin.
481CFList
482factorRecombination (CFList& factors, CanonicalForm& F,
483                     const CanonicalForm& N, DegreePattern& degs, int s,
484                     int thres, const modpk& b, const CanonicalForm& den
485                    )
486{
487  if (factors.length() == 0)
488  {
489    F= 1;
490    return CFList ();
491  }
492  if (F.inCoeffDomain())
493    return CFList();
494  if (degs.getLength() <= 1 || factors.length() == 1)
495  {
496    CFList result= CFList (F);
497    F= 1;
498    return result;
499  }
500#ifdef DEBUGOUTPUT
501  if (b.getp() == 0)
502    DEBOUTLN (cerr, "LC (F, 1)*prodMod (factors, N) == F " <<
503              (mod (LC (F, 1)*prodMod (factors, N),N)/Lc (mod (LC (F, 1)*prodMod (factors, N),N)) == F/Lc(F)));
504  else
505    DEBOUTLN (cerr, "LC (F, 1)*prodMod (factors, N) == F " <<
506              (mod (b(LC (F, 1)*prodMod (factors, N)),N)/Lc (mod (b(LC (F, 1)*prodMod (factors, N)),N)) == F/Lc(F)));
507#endif
508
509  CFList T, S;
510
511  CanonicalForm M= N;
512  int l= degree (N);
513  T= factors;
514  CFList result;
515  Variable y= Variable (2);
516  Variable x= Variable (1);
517  CanonicalForm denom= den, denQuot;
518  CanonicalForm LCBuf= LC (F, x)*denom;
519  CanonicalForm g, quot, buf= F;
520  int * v= new int [T.length()];
521  for (int i= 0; i < T.length(); i++)
522    v[i]= 0;
523  bool nosubset= false;
524  CFArray TT;
525  DegreePattern bufDegs1, bufDegs2;
526  bufDegs1= degs;
527  int subsetDeg;
528  TT= copy (factors);
529  bool recombination= false;
530  CanonicalForm test;
531  bool isRat= (isOn (SW_RATIONAL) && getCharacteristic() == 0) ||
532               getCharacteristic() > 0;
533  if (!isRat)
534    On (SW_RATIONAL);
535  CanonicalForm buf0= mulNTL (buf (0, x), LCBuf);
536  if (!isRat)
537    Off (SW_RATIONAL);
538  while (T.length() >= 2*s && s <= thres)
539  {
540    while (nosubset == false)
541    {
542      if (T.length() == s)
543      {
544        delete [] v;
545        if (recombination)
546        {
547          T.insert (LCBuf);
548          g= prodMod (T, M);
549          if (b.getp() != 0)
550            g= b(g);
551          T.removeFirst();
552          result.append (g/content (g, x));
553          F= 1;
554          return result;
555        }
556        else
557        {
558          result= CFList (F);
559          F= 1;
560          return result;
561        }
562      }
563      S= subset (v, s, TT, nosubset);
564      if (nosubset) break;
565      subsetDeg= subsetDegree (S);
566      // skip those combinations that are not possible
567      if (!degs.find (subsetDeg))
568        continue;
569      else
570      {
571        if (!isRat)
572          On (SW_RATIONAL);
573        test= prodMod0 (S, M);
574        if (!isRat)
575        {
576          test *= bCommonDen (test);
577          Off (SW_RATIONAL);
578        }
579        test= mulNTL (test, LCBuf, b);
580        test= mod (test, M);
581        if (uniFdivides (test, buf0))
582        {
583          if (!isRat)
584            On (SW_RATIONAL);
585          S.insert (LCBuf);
586          g= prodMod (S, M);
587          S.removeFirst();
588          if (!isRat)
589          {
590            g *= bCommonDen(g);
591            Off (SW_RATIONAL);
592          }
593          if (b.getp() != 0)
594            g= b(g);
595          if (!isRat)
596            On (SW_RATIONAL);
597          g /= content (g, x);
598          if (!isRat)
599          {
600            On (SW_RATIONAL);
601            if (!Lc (g).inBaseDomain())
602              g /= Lc (g);
603            g *= bCommonDen (g);
604            Off (SW_RATIONAL);
605            g /= icontent (g);
606            On (SW_RATIONAL);
607          }
608          if (fdivides (g, buf, quot))
609          {
610            denom *= abs (lc (g));
611            recombination= true;
612            result.append (g);
613            if (b.getp() != 0)
614            {
615              denQuot= bCommonDen (quot);
616              buf= quot*denQuot;
617              Off (SW_RATIONAL);
618              denom /= gcd (denom, denQuot);
619              On (SW_RATIONAL);
620            }
621            else
622              buf= quot;
623            LCBuf= LC (buf, x)*denom;
624            T= Difference (T, S);
625            l -= degree (g);
626            M= power (y, l);
627            buf0= mulNTL (buf (0, x), LCBuf);
628            if (!isRat)
629              Off (SW_RATIONAL);
630            // compute new possible degree pattern
631            bufDegs2= DegreePattern (T);
632            bufDegs1.intersect (bufDegs2);
633            bufDegs1.refine ();
634            if (T.length() < 2*s || T.length() == s ||
635                bufDegs1.getLength() == 1)
636            {
637              delete [] v;
638              if (recombination)
639              {
640                result.append (buf);
641                F= 1;
642                return result;
643              }
644              else
645              {
646                result= CFList (F);
647                F= 1;
648                return result;
649              }
650            }
651            TT= copy (T);
652            indexUpdate (v, s, T.length(), nosubset);
653            if (nosubset) break;
654          }
655          if (!isRat)
656            Off (SW_RATIONAL);
657        }
658      }
659    }
660    s++;
661    if (T.length() < 2*s || T.length() == s)
662    {
663      delete [] v;
664      if (recombination)
665      {
666        result.append (buf);
667        F= 1;
668        return result;
669      }
670      else
671      {
672        result= CFList (F);
673        F= 1;
674        return result;
675      }
676    }
677    for (int i= 0; i < T.length(); i++)
678      v[i]= 0;
679    nosubset= false;
680  }
681  delete [] v;
682  if (T.length() < 2*s)
683  {
684    result.append (F);
685    F= 1;
686    return result;
687  }
688
689  if (s > thres)
690  {
691    factors= T;
692    F= buf;
693    degs= bufDegs1;
694  }
695
696  return result;
697}
698
699Variable chooseExtension (const Variable & alpha, const Variable& beta, int k)
700{
701  if (fac_NTL_char != getCharacteristic())
702  {
703    fac_NTL_char= getCharacteristic();
704    zz_p::init (getCharacteristic());
705  }
706  zz_pX NTLIrredpoly;
707  int i=1, m= 2;
708  // extension of F_p needed
709  if (alpha.level() == 1 && beta.level() == 1 && k == 1)
710  {
711    i= 1;
712    m= 2;
713  } //extension of F_p(alpha) needed but want to factorize over F_p
714  else if (alpha.level() != 1 && beta.level() == 1 && k == 1)
715  {
716    i= 1;
717    m= degree (getMipo (alpha)) + 1;
718  } //extension of F_p(alpha) needed for first time
719  else if (alpha.level() != 1 && beta.level() == 1 && k != 1)
720  {
721    i= 2;
722    m= degree (getMipo (alpha));
723  }
724  else if (alpha.level() != 1 && beta.level() != 1 && k != 1)
725  {
726    m= degree (getMipo (beta));
727    i= degree (getMipo (alpha))/m + 1;
728  }
729  BuildIrred (NTLIrredpoly, i*m);
730  CanonicalForm newMipo= convertNTLzzpX2CF (NTLIrredpoly, Variable (1));
731  return rootOf (newMipo);
732}
733
734void
735earlyFactorDetection (CFList& reconstructedFactors, CanonicalForm& F, CFList&
736                      factors, int& adaptedLiftBound, int*& factorsFoundIndex,
737                      DegreePattern& degs, bool& success, int deg,
738                      const modpk& b, CanonicalForm& den)
739{
740  DegreePattern bufDegs1= degs;
741  DegreePattern bufDegs2;
742  CFList T= factors;
743  CanonicalForm buf= F;
744  Variable x= Variable (1);
745  CanonicalForm g, quot;
746  CanonicalForm M= power (F.mvar(), deg);
747  adaptedLiftBound= 0;
748  int d= degree (F), l= 0;
749  bool isRat= (isOn (SW_RATIONAL) && getCharacteristic() == 0) || getCharacteristic() > 0;
750  if (!isRat)
751    On (SW_RATIONAL);
752  if (b.getp() != 0)
753    buf *= bCommonDen (buf);
754  CanonicalForm LCBuf= LC (buf, x)*den;
755  CanonicalForm buf0= mulNTL (buf (0,x), LCBuf);
756  CanonicalForm buf1= mulNTL (buf (1,x), LCBuf);
757  if (!isRat)
758    Off (SW_RATIONAL);
759  CanonicalForm test0, test1;
760  CanonicalForm denQuot;
761
762  for (CFListIterator i= factors; i.hasItem(); i++, l++)
763  {
764    if (!bufDegs1.find (degree (i.getItem(), 1)) || factorsFoundIndex[l] == 1)
765      continue;
766    else
767    {
768      test1= mod (mulNTL (i.getItem() (1,x), LCBuf, b), M);
769      if (uniFdivides (test1, buf1))
770      {
771        test0= mod (mulNTL (i.getItem() (0,x), LCBuf, b), M);
772        if (uniFdivides (test0, buf0))
773        {
774          if (!isRat)
775            On (SW_RATIONAL);
776          g= mulMod2 (i.getItem(), LCBuf, M);
777          if (!isRat)
778          {
779            g *= bCommonDen(g);
780            Off (SW_RATIONAL);
781          }
782          if (b.getp() != 0)
783            g= b(g);
784          if (!isRat)
785            On (SW_RATIONAL);
786          g /= content (g, x);
787          if (!isRat)
788          {
789            On (SW_RATIONAL);
790            if (!Lc (g).inBaseDomain())
791              g /= Lc (g);
792            g *= bCommonDen (g);
793            Off (SW_RATIONAL);
794            g /= icontent (g);
795            On (SW_RATIONAL);
796          }
797          if (fdivides (g, buf, quot))
798          {
799            den *= abs (lc (g));
800            reconstructedFactors.append (g);
801            factorsFoundIndex[l]= 1;
802            if (b.getp() != 0)
803            {
804              denQuot= bCommonDen (quot);
805              buf= quot*denQuot;
806              Off (SW_RATIONAL);
807              den /= gcd (den, denQuot);
808              On (SW_RATIONAL);
809            }
810            else
811              buf= quot;
812            d -= degree (g);
813            LCBuf= LC (buf, x)*den;
814            buf0= mulNTL (buf (0,x), LCBuf);
815            buf1= mulNTL (buf (1,x), LCBuf);
816            if (!isRat)
817              Off (SW_RATIONAL);
818            T= Difference (T, CFList (i.getItem()));
819            F= buf;
820
821            // compute new possible degree pattern
822            bufDegs2= DegreePattern (T);
823            bufDegs1.intersect (bufDegs2);
824            bufDegs1.refine ();
825            if (bufDegs1.getLength() <= 1)
826            {
827              if (!buf.inCoeffDomain())
828              {
829                reconstructedFactors.append (buf);
830                F= 1;
831              }
832              break;
833            }
834          }
835          if (!isRat)
836            Off (SW_RATIONAL);
837        }
838      }
839    }
840  }
841  adaptedLiftBound= d + 1;
842  if (adaptedLiftBound < deg)
843  {
844    degs= bufDegs1;
845    success= true;
846  }
847  if (bufDegs1.getLength() <= 1)
848    degs= bufDegs1;
849}
850
851void
852earlyFactorDetection (CFList& reconstructedFactors, CanonicalForm& F, CFList&
853                      factors, int& adaptedLiftBound, int*& factorsFoundIndex,
854                      DegreePattern& degs, bool& success, int deg,
855                      const modpk& b)
856{
857  CanonicalForm den= 1;
858  earlyFactorDetection (reconstructedFactors, F, factors, adaptedLiftBound, factorsFoundIndex, degs, success, deg,b, den);
859}
860
861void
862extEarlyFactorDetection (CFList& reconstructedFactors, CanonicalForm& F, CFList&
863                         factors,int& adaptedLiftBound, int*& factorsFoundIndex,
864                         DegreePattern& degs, bool& success, const
865                         ExtensionInfo& info, const CanonicalForm& eval, int deg
866                        )
867{
868  Variable alpha= info.getAlpha();
869  Variable beta= info.getBeta();
870  CanonicalForm gamma= info.getGamma();
871  CanonicalForm delta= info.getDelta();
872  int k= info.getGFDegree();
873  DegreePattern bufDegs1= degs, bufDegs2;
874  CFList result;
875  CFList T= factors;
876  Variable y= F.mvar();
877  Variable x= Variable (1);
878  CanonicalForm buf= F, LCBuf= LC (buf, x), g, buf2;
879  CanonicalForm M= power (y, deg);
880  adaptedLiftBound= 0;
881  bool trueFactor= false;
882  int d= degree (F), l= 0;
883  CFList source, dest;
884  int degMipoBeta= 1;
885  if (!k && beta.level() != 1)
886    degMipoBeta= degree (getMipo (beta));
887  CanonicalForm quot;
888  for (CFListIterator i= factors; i.hasItem(); i++, l++)
889  {
890    if (!bufDegs1.find (degree (i.getItem(), 1)) || factorsFoundIndex[l] == 1)
891      continue;
892    else
893    {
894      g= mulMod2 (i.getItem(), LCBuf, M);
895      g /= content (g, x);
896      if (fdivides (g, buf, quot))
897      {
898        buf2= g (y - eval, y);
899        buf2 /= Lc (buf2);
900
901        if (!k && beta == x)
902        {
903          if (degree (buf2, alpha) < degMipoBeta)
904          {
905            appendTestMapDown (reconstructedFactors, buf2, info, source, dest);
906            factorsFoundIndex[l]= 1;
907            buf= quot;
908            d -= degree (g);
909            LCBuf= LC (buf, x);
910            trueFactor= true;
911          }
912        }
913        else
914        {
915          if (!isInExtension (buf2, gamma, k, delta, source, dest))
916          {
917            appendTestMapDown (reconstructedFactors, buf2, info, source, dest);
918            factorsFoundIndex[l]= 1;
919            buf= quot;
920            d -= degree (g);
921            LCBuf= LC (buf, x);
922            trueFactor= true;
923          }
924        }
925        if (trueFactor)
926        {
927          T= Difference (T, CFList (i.getItem()));
928          F= buf;
929
930          // compute new possible degree pattern
931          bufDegs2= DegreePattern (T);
932          bufDegs1.intersect (bufDegs2);
933          bufDegs1.refine ();
934          trueFactor= false;
935          if (bufDegs1.getLength() <= 1)
936          {
937            if (!buf.inCoeffDomain())
938            {
939              buf= buf (y - eval, y);
940              buf /= Lc (buf);
941              appendMapDown (reconstructedFactors, buf, info, source, dest);
942              F= 1;
943            }
944            break;
945          }
946        }
947      }
948    }
949  }
950  adaptedLiftBound= d + 1;
951  if (adaptedLiftBound < deg)
952  {
953    degs= bufDegs1;
954    success= true;
955  }
956  if (bufDegs1.getLength() <= 1)
957    degs= bufDegs1;
958}
959
960int*
961getCombinations (int * rightSide, int sizeOfRightSide, int& sizeOfOutput,
962                 int degreeLC)
963{
964  Variable x= Variable (1);
965  int p= getCharacteristic();
966  int d= getGFDegree();
967  char cGFName= gf_name;
968  setCharacteristic(0);
969  CanonicalForm buf= 1;
970  for (int i= 0; i < sizeOfRightSide; i++)
971    buf *= (power (x, rightSide [i]) + 1);
972
973  int j= 0;
974  for (CFIterator i= buf; i.hasTerms(); i++, j++)
975  {
976    if (i.exp() < degreeLC)
977    {
978      j++;
979      break;
980    }
981  }
982
983  ASSERT ( j > 1, "j > 1 expected" );
984
985  int* result = new int  [j - 1];
986  sizeOfOutput= j - 1;
987
988  int i= 0;
989  for (CFIterator m = buf; i < j - 1; i++, m++)
990    result [i]= m.exp();
991
992  if (d > 1)
993    setCharacteristic (p, d, cGFName);
994  else
995    setCharacteristic (p);
996  return result;
997}
998
999int *
1000getLiftPrecisions (const CanonicalForm& F, int& sizeOfOutput, int degreeLC)
1001{
1002  int sizeOfNewtonPoly;
1003  int ** newtonPolyg= newtonPolygon (F, sizeOfNewtonPoly);
1004  int sizeOfRightSide;
1005  int * rightSide= getRightSide(newtonPolyg, sizeOfNewtonPoly, sizeOfRightSide);
1006  int * result= getCombinations(rightSide, sizeOfRightSide, sizeOfOutput,
1007                                degreeLC);
1008  delete [] rightSide;
1009  for (int i= 0; i < sizeOfNewtonPoly; i++)
1010    delete [] newtonPolyg[i];
1011  delete [] newtonPolyg;
1012  return result;
1013}
1014
1015void
1016deleteFactors (CFList& factors, int* factorsFoundIndex)
1017{
1018  CFList result;
1019  int i= 0;
1020  for (CFListIterator iter= factors; iter.hasItem(); iter++, i++)
1021  {
1022    if (factorsFoundIndex[i] == 1)
1023      continue;
1024    else
1025      result.append (iter.getItem());
1026  }
1027  factors= result;
1028}
1029
1030CFList
1031henselLiftAndEarly (CanonicalForm& A, bool& earlySuccess, CFList&
1032                    earlyFactors, DegreePattern& degs, int& liftBound,
1033                    const CFList& uniFactors, const ExtensionInfo& info,
1034                    const CanonicalForm& eval,modpk& b, CanonicalForm& den)
1035{
1036  Variable alpha= info.getAlpha();
1037  Variable beta= info.getBeta();
1038  CanonicalForm gamma= info.getGamma();
1039  CanonicalForm delta= info.getDelta();
1040  bool extension= info.isInExtension();
1041
1042  int sizeOfLiftPre;
1043  int * liftPre= getLiftPrecisions (A, sizeOfLiftPre, degree (LC (A, 1), 2));
1044
1045  Variable x= Variable (1);
1046  Variable y= Variable (2);
1047  CFArray Pi;
1048  CFList diophant;
1049  CFList bufUniFactors= uniFactors;
1050  On (SW_RATIONAL);
1051  CanonicalForm bufA= A;
1052  if (!Lc (A).inBaseDomain())
1053  {
1054    bufA /= Lc (A);
1055    CanonicalForm denBufA= bCommonDen (bufA);
1056    bufA *= denBufA;
1057    Off (SW_RATIONAL);
1058    den /= gcd (den, denBufA);
1059  }
1060  else
1061  {
1062    bufA= A;
1063    Off (SW_RATIONAL);
1064    den /= gcd (den, Lc (A));
1065  }
1066  CanonicalForm lcA0= 0;
1067  bool mipoHasDen= false;
1068  if (getCharacteristic() == 0 && b.getp() != 0)
1069  {
1070    if (alpha.level() == 1)
1071    {
1072      lcA0= lc (A (0, 2));
1073      A *= b.inverse (lcA0);
1074      A= b (A);
1075      for (CFListIterator i= bufUniFactors; i.hasItem(); i++)
1076        i.getItem()= b (i.getItem()*b.inverse (lc (i.getItem())));
1077    }
1078    else
1079    {
1080      lcA0= Lc (A (0,2));
1081      On (SW_RATIONAL);
1082      mipoHasDen= !bCommonDen(getMipo(alpha)).isOne();
1083      Off (SW_RATIONAL);
1084      CanonicalForm lcA0inverse= b.inverse (lcA0);
1085      A *= lcA0inverse;
1086      A= b (A);
1087      // Lc of bufUniFactors is in Z
1088      for (CFListIterator i= bufUniFactors; i.hasItem(); i++)
1089        i.getItem()= b (i.getItem()*b.inverse (lc (i.getItem())));
1090    }
1091  }
1092  bufUniFactors.insert (LC (A, x));
1093  CFMatrix M= CFMatrix (liftBound, bufUniFactors.length() - 1);
1094  earlySuccess= false;
1095  int newLiftBound= 0;
1096
1097  int smallFactorDeg= tmin (11, liftPre [sizeOfLiftPre- 1] + 1);//this is a tunable parameter
1098  int dummy;
1099  int * factorsFoundIndex= new int [uniFactors.length()];
1100  for (int i= 0; i < uniFactors.length(); i++)
1101    factorsFoundIndex [i]= 0;
1102
1103  CFList bufBufUniFactors;
1104  Variable v= alpha;
1105  if (smallFactorDeg >= liftBound || degree (A,y) <= 4)
1106    henselLift12 (A, bufUniFactors, liftBound, Pi, diophant, M, b, true);
1107  else if (sizeOfLiftPre > 1 && sizeOfLiftPre < 30)
1108  {
1109    henselLift12 (A, bufUniFactors, smallFactorDeg, Pi, diophant, M, b, true);
1110    if (mipoHasDen)
1111    {
1112      for (CFListIterator iter= bufUniFactors; iter.hasItem(); iter++)
1113        if (hasFirstAlgVar (iter.getItem(), v))
1114          break;
1115      if (v != alpha)
1116      {
1117        bufBufUniFactors= bufUniFactors;
1118        for (CFListIterator iter= bufBufUniFactors; iter.hasItem(); iter++)
1119          iter.getItem()= replacevar (iter.getItem(), v, alpha);
1120        A= replacevar (A, alpha, v);
1121      }
1122    }
1123
1124    if (!extension)
1125    {
1126      if (v==alpha)
1127        earlyFactorDetection (earlyFactors, bufA, bufUniFactors, newLiftBound,
1128                              factorsFoundIndex, degs, earlySuccess,
1129                              smallFactorDeg, b, den);
1130      else
1131        earlyFactorDetection(earlyFactors, bufA, bufBufUniFactors, newLiftBound,
1132                             factorsFoundIndex, degs, earlySuccess,
1133                             smallFactorDeg, b, den);
1134    }
1135    else
1136      extEarlyFactorDetection (earlyFactors, bufA, bufUniFactors, newLiftBound,
1137                               factorsFoundIndex, degs, earlySuccess, info,
1138                               eval, smallFactorDeg);
1139    if (degs.getLength() > 1 && !earlySuccess &&
1140        smallFactorDeg != liftPre [sizeOfLiftPre-1] + 1)
1141    {
1142      if (newLiftBound >= liftPre[sizeOfLiftPre-1]+1)
1143      {
1144        bufUniFactors.insert (LC (A, x));
1145        henselLiftResume12 (A, bufUniFactors, smallFactorDeg,
1146                            liftPre[sizeOfLiftPre-1] + 1, Pi, diophant, M, b);
1147        if (v!=alpha)
1148        {
1149          bufBufUniFactors= bufUniFactors;
1150          for (CFListIterator iter= bufBufUniFactors; iter.hasItem(); iter++)
1151            iter.getItem()= replacevar (iter.getItem(), v, alpha);
1152        }
1153        if (!extension)
1154        {
1155          if (v==alpha)
1156          earlyFactorDetection (earlyFactors, bufA, bufUniFactors, newLiftBound,
1157                                factorsFoundIndex, degs, earlySuccess,
1158                                liftPre[sizeOfLiftPre-1] + 1, b, den);
1159          else
1160          earlyFactorDetection (earlyFactors,bufA,bufBufUniFactors,newLiftBound,
1161                                factorsFoundIndex, degs, earlySuccess,
1162                                liftPre[sizeOfLiftPre-1] + 1, b, den);
1163        }
1164        else
1165          extEarlyFactorDetection (earlyFactors,bufA,bufUniFactors,newLiftBound,
1166                                   factorsFoundIndex, degs, earlySuccess, info,
1167                                   eval, liftPre[sizeOfLiftPre-1] + 1);
1168      }
1169    }
1170    else if (earlySuccess)
1171      liftBound= newLiftBound;
1172
1173    int i= sizeOfLiftPre - 1;
1174    while (degs.getLength() > 1 && !earlySuccess && i - 1 >= 0)
1175    {
1176      if (newLiftBound >= liftPre[i] + 1)
1177      {
1178        bufUniFactors.insert (LC (A, x));
1179        henselLiftResume12 (A, bufUniFactors, liftPre[i] + 1,
1180                            liftPre[i-1] + 1, Pi, diophant, M, b);
1181        if (v!=alpha)
1182        {
1183          bufBufUniFactors= bufUniFactors;
1184          for (CFListIterator iter= bufBufUniFactors; iter.hasItem(); iter++)
1185            iter.getItem()= replacevar (iter.getItem(), v, alpha);
1186        }
1187        if (!extension)
1188        {
1189          if (v==alpha)
1190          earlyFactorDetection (earlyFactors, bufA, bufUniFactors, newLiftBound,
1191                                factorsFoundIndex, degs, earlySuccess,
1192                                liftPre[i-1] + 1, b, den);
1193          else
1194          earlyFactorDetection (earlyFactors,bufA,bufBufUniFactors,newLiftBound,
1195                                factorsFoundIndex, degs, earlySuccess,
1196                                liftPre[i-1] + 1, b, den);
1197        }
1198        else
1199          extEarlyFactorDetection (earlyFactors,bufA,bufUniFactors,newLiftBound,
1200                                   factorsFoundIndex, degs, earlySuccess, info,
1201                                   eval, liftPre[i-1] + 1);
1202      }
1203      else
1204      {
1205        liftBound= newLiftBound;
1206        break;
1207      }
1208      i--;
1209    }
1210    if (earlySuccess)
1211      liftBound= newLiftBound;
1212    //after here all factors are lifted to liftPre[sizeOfLiftPre-1]
1213  }
1214  else
1215  {
1216    henselLift12 (A, bufUniFactors, smallFactorDeg, Pi, diophant, M, b, true);
1217    if (mipoHasDen)
1218    {
1219      for (CFListIterator iter= bufUniFactors; iter.hasItem(); iter++)
1220        if (hasFirstAlgVar (iter.getItem(), v))
1221          break;
1222      if (v != alpha)
1223      {
1224        bufBufUniFactors= bufUniFactors;
1225        for (CFListIterator iter= bufBufUniFactors; iter.hasItem(); iter++)
1226          iter.getItem()= replacevar (iter.getItem(), v, alpha);
1227        A= replacevar (A, alpha, v);
1228      }
1229    }
1230    if (!extension)
1231    {
1232      if (v==alpha)
1233      earlyFactorDetection (earlyFactors, bufA, bufUniFactors, newLiftBound,
1234                            factorsFoundIndex, degs, earlySuccess,
1235                            smallFactorDeg, b, den);
1236      else
1237      earlyFactorDetection (earlyFactors, bufA, bufBufUniFactors, newLiftBound,
1238                            factorsFoundIndex, degs, earlySuccess,
1239                            smallFactorDeg, b, den);
1240    }
1241    else
1242      extEarlyFactorDetection (earlyFactors, bufA, bufUniFactors, newLiftBound,
1243                               factorsFoundIndex, degs, earlySuccess, info,
1244                               eval, smallFactorDeg);
1245    int i= 1;
1246    while ((degree (A,y)/4)*i + 4 <= smallFactorDeg)
1247      i++;
1248    dummy= tmin (degree (A,y)+1, (degree (A,y)/4)*i+4);
1249    if (degs.getLength() > 1 && !earlySuccess && dummy > smallFactorDeg)
1250    {
1251      bufUniFactors.insert (LC (A, x));
1252      henselLiftResume12 (A, bufUniFactors, smallFactorDeg,
1253                          dummy, Pi, diophant, M, b);
1254      if (v!=alpha)
1255      {
1256        bufBufUniFactors= bufUniFactors;
1257        for (CFListIterator iter= bufBufUniFactors; iter.hasItem(); iter++)
1258          iter.getItem()= replacevar (iter.getItem(), v, alpha);
1259      }
1260      if (!extension)
1261      {
1262        if (v==alpha)
1263        earlyFactorDetection (earlyFactors, bufA, bufUniFactors, newLiftBound,
1264                              factorsFoundIndex, degs, earlySuccess, dummy, b,
1265                              den);
1266        else
1267        earlyFactorDetection (earlyFactors, bufA,bufBufUniFactors, newLiftBound,
1268                              factorsFoundIndex, degs, earlySuccess, dummy, b,
1269                              den);
1270      }
1271      else
1272        extEarlyFactorDetection (earlyFactors, bufA,bufUniFactors, newLiftBound,
1273                                 factorsFoundIndex, degs, earlySuccess, info,
1274                                 eval, dummy);
1275    }
1276    while (degs.getLength() > 1 && !earlySuccess && i < 4)
1277    {
1278      if (newLiftBound >= dummy)
1279      {
1280        bufUniFactors.insert (LC (A, x));
1281        dummy= tmin (degree (A,y)+1, (degree (A,y)/4)*(i+1)+4);
1282        henselLiftResume12 (A, bufUniFactors, (degree (A,y)/4)*i + 4,
1283                            dummy, Pi, diophant, M, b);
1284        if (v!=alpha)
1285        {
1286          bufBufUniFactors= bufUniFactors;
1287          for (CFListIterator iter= bufBufUniFactors; iter.hasItem(); iter++)
1288            iter.getItem()= replacevar (iter.getItem(), v, alpha);
1289        }
1290        if (!extension)
1291        {
1292          if (v==alpha)
1293          earlyFactorDetection (earlyFactors, bufA, bufUniFactors, newLiftBound,
1294                                factorsFoundIndex, degs, earlySuccess, dummy,b,
1295                                den);
1296          else
1297          earlyFactorDetection (earlyFactors,bufA,bufBufUniFactors,newLiftBound,
1298                                factorsFoundIndex, degs, earlySuccess, dummy,b,
1299                                den);
1300        }
1301        else
1302          extEarlyFactorDetection (earlyFactors,bufA,bufUniFactors,newLiftBound,
1303                                   factorsFoundIndex, degs, earlySuccess, info,
1304                                   eval, dummy);
1305      }
1306      else
1307      {
1308        liftBound= newLiftBound;
1309        break;
1310      }
1311      i++;
1312    }
1313    if (earlySuccess)
1314      liftBound= newLiftBound;
1315  }
1316
1317  A= bufA;
1318  if (earlyFactors.length() > 0 && degs.getLength() > 1)
1319  {
1320    liftBound= degree (A,y) + 1;
1321    earlySuccess= true;
1322    deleteFactors (bufUniFactors, factorsFoundIndex);
1323  }
1324
1325  delete [] factorsFoundIndex;
1326  delete [] liftPre;
1327
1328  return bufUniFactors;
1329}
1330
1331CFList
1332henselLiftAndEarly (CanonicalForm& A, bool& earlySuccess, CFList&
1333                    earlyFactors, DegreePattern& degs, int& liftBound,
1334                    const CFList& uniFactors, const ExtensionInfo& info,
1335                    const CanonicalForm& eval)
1336{
1337  modpk dummy= modpk();
1338  CanonicalForm den= 1;
1339  return henselLiftAndEarly (A, earlySuccess, earlyFactors, degs, liftBound,
1340                             uniFactors, info, eval, dummy, den);
1341}
1342
1343long isReduced (const mat_zz_p& M)
1344{
1345  long i, j, nonZero;
1346  for (i = 1; i <= M.NumRows(); i++)
1347  {
1348    nonZero= 0;
1349    for (j = 1; j <= M.NumCols(); j++)
1350    {
1351      if (!IsZero (M (i,j)))
1352        nonZero++;
1353    }
1354    if (nonZero != 1)
1355      return 0;
1356  }
1357  return 1;
1358}
1359
1360#ifdef HAVE_FLINT
1361long isReduced (const nmod_mat_t M)
1362{
1363  long i, j, nonZero;
1364  for (i = 1; i <= nmod_mat_nrows(M); i++)
1365  {
1366    nonZero= 0;
1367    for (j = 1; j <= nmod_mat_ncols (M); j++)
1368    {
1369      if (!(nmod_mat_entry (M, i-1, j-1)==0))
1370        nonZero++;
1371    }
1372    if (nonZero != 1)
1373      return 0;
1374  }
1375  return 1;
1376}
1377#endif
1378
1379long isReduced (const mat_zz_pE& M)
1380{
1381  long i, j, nonZero;
1382  for (i = 1; i <= M.NumRows(); i++)
1383  {
1384    nonZero= 0;
1385    for (j = 1; j <= M.NumCols(); j++)
1386    {
1387      if (!IsZero (M (i,j)))
1388        nonZero++;
1389    }
1390    if (nonZero != 1)
1391      return 0;
1392  }
1393  return 1;
1394}
1395
1396int * extractZeroOneVecs (const mat_zz_p& M)
1397{
1398  long i, j;
1399  bool nonZeroOne= false;
1400  int * result= new int [M.NumCols()];
1401  for (i = 1; i <= M.NumCols(); i++)
1402  {
1403    for (j = 1; j <= M.NumRows(); j++)
1404    {
1405      if (!(IsOne (M (j,i)) || IsZero (M (j,i))))
1406      {
1407        nonZeroOne= true;
1408        break;
1409      }
1410    }
1411    if (!nonZeroOne)
1412      result [i - 1]= 1;
1413    else
1414      result [i - 1]= 0;
1415    nonZeroOne= false;
1416  }
1417  return result;
1418}
1419
1420#ifdef HAVE_FLINT
1421int * extractZeroOneVecs (const nmod_mat_t M)
1422{
1423  long i, j;
1424  bool nonZeroOne= false;
1425  int * result= new int [nmod_mat_ncols (M)];
1426  for (i = 0; i < nmod_mat_ncols (M); i++)
1427  {
1428    for (j = 0; j < nmod_mat_nrows (M); j++)
1429    {
1430      if (!((nmod_mat_entry (M, j, i) == 1) || (nmod_mat_entry (M, j,i) == 0)))
1431      {
1432        nonZeroOne= true;
1433        break;
1434      }
1435    }
1436    if (!nonZeroOne)
1437      result [i]= 1;
1438    else
1439      result [i]= 0;
1440    nonZeroOne= false;
1441  }
1442  return result;
1443}
1444#endif
1445
1446int * extractZeroOneVecs (const mat_zz_pE& M)
1447{
1448  long i, j;
1449  bool nonZeroOne= false;
1450  int * result= new int [M.NumCols()];
1451  for (i = 1; i <= M.NumCols(); i++)
1452  {
1453    for (j = 1; j <= M.NumRows(); j++)
1454    {
1455      if (!(IsOne (M (j,i)) || IsZero (M (j,i))))
1456      {
1457        nonZeroOne= true;
1458        break;
1459      }
1460    }
1461    if (!nonZeroOne)
1462      result [i - 1]= 1;
1463    else
1464      result [i - 1]= 0;
1465    nonZeroOne= false;
1466  }
1467  return result;
1468}
1469
1470void
1471reconstructionTry (CFList& reconstructedFactors, CanonicalForm& F, const CFList&
1472                   factors, const int liftBound, int& factorsFound, int*&
1473                   factorsFoundIndex, mat_zz_pE& N, bool beenInThres
1474                  )
1475{
1476  Variable y= Variable (2);
1477  Variable x= Variable (1);
1478  CanonicalForm yToL= power (y, liftBound);
1479  if (factors.length() == 2)
1480  {
1481    CanonicalForm tmp1, tmp2, tmp3;
1482    tmp1= factors.getFirst();
1483    tmp2= factors.getLast();
1484    tmp1 *= LC (F, x);
1485    tmp1= mod (tmp1, yToL);
1486    tmp1 /= content (tmp1, x);
1487    tmp2 *= LC (F, x);
1488    tmp2= mod (tmp2, yToL);
1489    tmp2 /= content (tmp2, x);
1490    tmp3 = tmp1*tmp2;
1491    if (tmp3/Lc (tmp3) == F/Lc (F))
1492    {
1493      factorsFound++;
1494      F= 1;
1495      reconstructedFactors.append (tmp1);
1496      reconstructedFactors.append (tmp2);
1497      return;
1498    }
1499  }
1500  CanonicalForm quot, buf;
1501  CFListIterator iter;
1502  for (long i= 1; i <= N.NumCols(); i++)
1503  {
1504    if (factorsFoundIndex [i - 1] == 1)
1505      continue;
1506    iter= factors;
1507    if (beenInThres)
1508    {
1509      int count= 1;
1510      while (count < i)
1511      {
1512        count++;
1513        iter++;
1514      }
1515      buf= iter.getItem();
1516    }
1517    else
1518    {
1519      buf= 1;
1520      for (long j= 1; j <= N.NumRows(); j++, iter++)
1521      {
1522        if (!IsZero (N (j,i)))
1523          buf= mulMod2 (buf, iter.getItem(), yToL);
1524      }
1525    }
1526    buf *= LC (F, x);
1527    buf= mod (buf, yToL);
1528    buf /= content (buf, x);
1529    if (fdivides (buf, F, quot))
1530    {
1531      factorsFoundIndex[i - 1]= 1;
1532      factorsFound++;
1533      F= quot;
1534      F /= Lc (F);
1535      reconstructedFactors.append (buf);
1536    }
1537    if (degree (F) <= 0)
1538      return;
1539    if (factorsFound + 1 == N.NumCols())
1540    {
1541      reconstructedFactors.append (F);
1542      return;
1543    }
1544  }
1545}
1546
1547void
1548reconstructionTry (CFList& reconstructedFactors, CanonicalForm& F, const CFList&
1549                   factors, const int liftBound, int& factorsFound, int*&
1550                   factorsFoundIndex, mat_zz_p& N, bool beenInThres
1551                  )
1552{
1553  Variable y= Variable (2);
1554  Variable x= Variable (1);
1555  CanonicalForm yToL= power (y, liftBound);
1556  if (factors.length() == 2)
1557  {
1558    CanonicalForm tmp1, tmp2, tmp3;
1559    tmp1= factors.getFirst();
1560    tmp2= factors.getLast();
1561    tmp1 *= LC (F, x);
1562    tmp1= mod (tmp1, yToL);
1563    tmp1 /= content (tmp1, x);
1564    tmp2 *= LC (F, x);
1565    tmp2= mod (tmp2, yToL);
1566    tmp2 /= content (tmp2, x);
1567    tmp3 = tmp1*tmp2;
1568    if (tmp3/Lc (tmp3) == F/Lc (F))
1569    {
1570      factorsFound++;
1571      F= 1;
1572      reconstructedFactors.append (tmp1);
1573      reconstructedFactors.append (tmp2);
1574      return;
1575    }
1576  }
1577  CanonicalForm quot, buf;
1578  CFListIterator iter;
1579  for (long i= 1; i <= N.NumCols(); i++)
1580  {
1581    if (factorsFoundIndex [i - 1] == 1)
1582      continue;
1583    iter= factors;
1584    if (beenInThres)
1585    {
1586      int count= 1;
1587      while (count < i)
1588      {
1589        count++;
1590        iter++;
1591      }
1592      buf= iter.getItem();
1593    }
1594    else
1595    {
1596      buf= 1;
1597      for (long j= 1; j <= N.NumRows(); j++, iter++)
1598      {
1599        if (!IsZero (N (j,i)))
1600          buf= mulMod2 (buf, iter.getItem(), yToL);
1601      }
1602    }
1603    buf *= LC (F, x);
1604    buf= mod (buf, yToL);
1605    buf /= content (buf, x);
1606    if (fdivides (buf, F, quot))
1607    {
1608      factorsFoundIndex[i - 1]= 1;
1609      factorsFound++;
1610      F= quot;
1611      F /= Lc (F);
1612      reconstructedFactors.append (buf);
1613    }
1614    if (degree (F) <= 0)
1615      return;
1616    if (factorsFound + 1 == N.NumCols())
1617    {
1618      reconstructedFactors.append (F);
1619      return;
1620    }
1621  }
1622}
1623
1624#ifdef HAVE_FLINT
1625void
1626reconstructionTry (CFList& reconstructedFactors, CanonicalForm& F, const CFList&
1627                   factors, const int liftBound, int& factorsFound, int*&
1628                   factorsFoundIndex, nmod_mat_t N, bool beenInThres
1629                  )
1630{
1631  Variable y= Variable (2);
1632  Variable x= Variable (1);
1633  CanonicalForm yToL= power (y, liftBound);
1634  if (factors.length() == 2)
1635  {
1636    CanonicalForm tmp1, tmp2, tmp3;
1637    tmp1= factors.getFirst();
1638    tmp2= factors.getLast();
1639    tmp1 *= LC (F, x);
1640    tmp1= mod (tmp1, yToL);
1641    tmp1 /= content (tmp1, x);
1642    tmp2 *= LC (F, x);
1643    tmp2= mod (tmp2, yToL);
1644    tmp2 /= content (tmp2, x);
1645    tmp3 = tmp1*tmp2;
1646    if (tmp3/Lc (tmp3) == F/Lc (F))
1647    {
1648      factorsFound++;
1649      F= 1;
1650      reconstructedFactors.append (tmp1);
1651      reconstructedFactors.append (tmp2);
1652      return;
1653    }
1654  }
1655  CanonicalForm quot, buf;
1656  CFListIterator iter;
1657  for (long i= 0; i < nmod_mat_ncols (N); i++)
1658  {
1659    if (factorsFoundIndex [i] == 1)
1660      continue;
1661    iter= factors;
1662    if (beenInThres)
1663    {
1664      int count= 0;
1665      while (count < i)
1666      {
1667        count++;
1668        iter++;
1669      }
1670      buf= iter.getItem();
1671    }
1672    else
1673    {
1674      buf= 1;
1675      for (long j= 0; j < nmod_mat_nrows (N); j++, iter++)
1676      {
1677        if (!(nmod_mat_entry (N, j, i) == 0))
1678          buf= mulMod2 (buf, iter.getItem(), yToL);
1679      }
1680    }
1681    buf *= LC (F, x);
1682    buf= mod (buf, yToL);
1683    buf /= content (buf, x);
1684    if (fdivides (buf, F, quot))
1685    {
1686      factorsFoundIndex[i]= 1;
1687      factorsFound++;
1688      F= quot;
1689      F /= Lc (F);
1690      reconstructedFactors.append (buf);
1691    }
1692    if (degree (F) <= 0)
1693      return;
1694    if (factorsFound + 1 == nmod_mat_ncols (N))
1695    {
1696      reconstructedFactors.append (F);
1697      return;
1698    }
1699  }
1700}
1701#endif
1702
1703CFList
1704reconstruction (CanonicalForm& G, CFList& factors, int* zeroOneVecs, int
1705                precision, const mat_zz_pE& N
1706               )
1707{
1708  Variable y= Variable (2);
1709  Variable x= Variable (1);
1710  CanonicalForm F= G;
1711  CanonicalForm yToL= power (y, precision);
1712  CanonicalForm quot, buf;
1713  CFList result, factorsConsidered;
1714  CFList bufFactors= factors;
1715  CFListIterator iter;
1716  for (long i= 1; i <= N.NumCols(); i++)
1717  {
1718    if (zeroOneVecs [i - 1] == 0)
1719      continue;
1720    iter= factors;
1721    buf= 1;
1722    factorsConsidered= CFList();
1723    for (long j= 1; j <= N.NumRows(); j++, iter++)
1724    {
1725      if (!IsZero (N (j,i)))
1726      {
1727        factorsConsidered.append (iter.getItem());
1728        buf= mulMod2 (buf, iter.getItem(), yToL);
1729      }
1730    }
1731    buf *= LC (F, x);
1732    buf= mod (buf, yToL);
1733    buf /= content (buf, x);
1734    if (fdivides (buf, F, quot))
1735    {
1736      F= quot;
1737      F /= Lc (F);
1738      result.append (buf);
1739      bufFactors= Difference (bufFactors, factorsConsidered);
1740    }
1741    if (degree (F) <= 0)
1742    {
1743      G= F;
1744      factors= bufFactors;
1745      return result;
1746    }
1747  }
1748  G= F;
1749  factors= bufFactors;
1750  return result;
1751}
1752
1753CFList
1754monicReconstruction (CanonicalForm& G, CFList& factors, int* zeroOneVecs,
1755                     int precision, const mat_zz_pE& N
1756                    )
1757{
1758  Variable y= Variable (2);
1759  Variable x= Variable (1);
1760  CanonicalForm F= G;
1761  CanonicalForm yToL= power (y, precision);
1762  CanonicalForm quot, buf, buf2;
1763  CFList result;
1764  CFList bufFactors= factors;
1765  CFList factorsConsidered;
1766  CFListIterator iter;
1767  for (long i= 1; i <= N.NumCols(); i++)
1768  {
1769    if (zeroOneVecs [i - 1] == 0)
1770      continue;
1771    iter= factors;
1772    buf= 1;
1773    factorsConsidered= CFList();
1774    for (long j= 1; j <= N.NumRows(); j++, iter++)
1775    {
1776      if (!IsZero (N (j,i)))
1777      {
1778        factorsConsidered.append (iter.getItem());
1779        buf= mulMod2 (buf, iter.getItem(), yToL);
1780      }
1781    }
1782    buf2= buf;
1783    buf *= LC (F, x);
1784    buf= mod (buf, yToL);
1785    buf /= content (buf, x);
1786    if (fdivides (buf, F, quot))
1787    {
1788      F= quot;
1789      F /= Lc (F);
1790      result.append (buf2);
1791      bufFactors= Difference (bufFactors, factorsConsidered);
1792    }
1793    if (degree (F) <= 0)
1794    {
1795      G= F;
1796      factors= bufFactors;
1797      return result;
1798    }
1799  }
1800  G= F;
1801  factors= bufFactors;
1802  return result;
1803}
1804
1805CFList
1806extReconstruction (CanonicalForm& G, CFList& factors, int* zeroOneVecs, int
1807                   precision, const mat_zz_p& N, const ExtensionInfo& info,
1808                   const CanonicalForm& evaluation
1809                  )
1810{
1811  Variable y= Variable (2);
1812  Variable x= Variable (1);
1813  Variable alpha= info.getAlpha();
1814  Variable beta= info.getBeta();
1815  int k= info.getGFDegree();
1816  CanonicalForm gamma= info.getGamma();
1817  CanonicalForm delta= info.getDelta();
1818  CanonicalForm F= G;
1819  CanonicalForm yToL= power (y, precision);
1820  CFList result;
1821  CFList bufFactors= factors;
1822  CFList factorsConsidered;
1823  CanonicalForm buf2, quot, buf;
1824  CFListIterator iter;
1825  for (long i= 1; i <= N.NumCols(); i++)
1826  {
1827    if (zeroOneVecs [i - 1] == 0)
1828      continue;
1829    iter= factors;
1830    buf= 1;
1831    factorsConsidered= CFList();
1832    for (long j= 1; j <= N.NumRows(); j++, iter++)
1833    {
1834      if (!IsZero (N (j,i)))
1835      {
1836        factorsConsidered.append (iter.getItem());
1837        buf= mulMod2 (buf, iter.getItem(), yToL);
1838      }
1839    }
1840    buf *= LC (F, x);
1841    buf= mod (buf, yToL);
1842    buf /= content (buf, x);
1843    buf2= buf (y-evaluation, y);
1844    buf2 /= Lc (buf2);
1845    if (!k && beta == x)
1846    {
1847      if (degree (buf2, alpha) < 1)
1848      {
1849        if (fdivides (buf, F, quot))
1850        {
1851          F= quot;
1852          F /= Lc (F);
1853          result.append (buf2);
1854          bufFactors= Difference (bufFactors, factorsConsidered);
1855        }
1856      }
1857    }
1858    else
1859    {
1860      CFList source, dest;
1861
1862      if (!isInExtension (buf2, gamma, k, delta, source, dest))
1863      {
1864        if (fdivides (buf, F, quot))
1865        {
1866          F= quot;
1867          F /= Lc (F);
1868          result.append (buf2);
1869          bufFactors= Difference (bufFactors, factorsConsidered);
1870        }
1871      }
1872    }
1873    if (degree (F) <= 0)
1874    {
1875      G= F;
1876      factors= bufFactors;
1877      return result;
1878    }
1879  }
1880  G= F;
1881  factors= bufFactors;
1882  return result;
1883}
1884
1885#ifdef HAVE_FLINT
1886CFList
1887extReconstruction (CanonicalForm& G, CFList& factors, int* zeroOneVecs, int
1888                   precision, const nmod_mat_t N, const ExtensionInfo& info,
1889                   const CanonicalForm& evaluation
1890                  )
1891{
1892  Variable y= Variable (2);
1893  Variable x= Variable (1);
1894  Variable alpha= info.getAlpha();
1895  Variable beta= info.getBeta();
1896  int k= info.getGFDegree();
1897  CanonicalForm gamma= info.getGamma();
1898  CanonicalForm delta= info.getDelta();
1899  CanonicalForm F= G;
1900  CanonicalForm yToL= power (y, precision);
1901  CFList result;
1902  CFList bufFactors= factors;
1903  CFList factorsConsidered;
1904  CanonicalForm buf2, quot, buf;
1905  CFListIterator iter;
1906  for (long i= 0; i < nmod_mat_ncols(N); i++)
1907  {
1908    if (zeroOneVecs [i] == 0)
1909      continue;
1910    iter= factors;
1911    buf= 1;
1912    factorsConsidered= CFList();
1913    for (long j= 0; j < nmod_mat_ncols(N); j++, iter++)
1914    {
1915      if (!(nmod_mat_entry (N, j, i) == 0))
1916      {
1917        factorsConsidered.append (iter.getItem());
1918        buf= mulMod2 (buf, iter.getItem(), yToL);
1919      }
1920    }
1921    buf *= LC (F, x);
1922    buf= mod (buf, yToL);
1923    buf /= content (buf, x);
1924    buf2= buf (y-evaluation, y);
1925    buf2 /= Lc (buf2);
1926    if (!k && beta == x)
1927    {
1928      if (degree (buf2, alpha) < 1)
1929      {
1930        if (fdivides (buf, F, quot))
1931        {
1932          F= quot;
1933          F /= Lc (F);
1934          result.append (buf2);
1935          bufFactors= Difference (bufFactors, factorsConsidered);
1936        }
1937      }
1938    }
1939    else
1940    {
1941      CFList source, dest;
1942
1943      if (!isInExtension (buf2, gamma, k, delta, source, dest))
1944      {
1945        if (fdivides (buf, F, quot))
1946        {
1947          F= quot;
1948          F /= Lc (F);
1949          result.append (buf2);
1950          bufFactors= Difference (bufFactors, factorsConsidered);
1951        }
1952      }
1953    }
1954    if (degree (F) <= 0)
1955    {
1956      G= F;
1957      factors= bufFactors;
1958      return result;
1959    }
1960  }
1961  G= F;
1962  factors= bufFactors;
1963  return result;
1964}
1965#endif
1966
1967CFList
1968reconstruction (CanonicalForm& G, CFList& factors, int* zeroOneVecs,
1969                int precision, const mat_zz_p& N)
1970{
1971  Variable y= Variable (2);
1972  Variable x= Variable (1);
1973  CanonicalForm F= G;
1974  CanonicalForm yToL= power (y, precision);
1975  CanonicalForm quot, buf;
1976  CFList result;
1977  CFList bufFactors= factors;
1978  CFList factorsConsidered;
1979  CFListIterator iter;
1980  for (long i= 1; i <= N.NumCols(); i++)
1981  {
1982    if (zeroOneVecs [i - 1] == 0)
1983      continue;
1984    iter= factors;
1985    buf= 1;
1986    factorsConsidered= CFList();
1987    for (long j= 1; j <= N.NumRows(); j++, iter++)
1988    {
1989      if (!IsZero (N (j,i)))
1990      {
1991        factorsConsidered.append (iter.getItem());
1992        buf= mulMod2 (buf, iter.getItem(), yToL);
1993      }
1994    }
1995    buf *= LC (F, x);
1996    buf= mod (buf, yToL);
1997    buf /= content (buf, x);
1998    if (fdivides (buf, F, quot))
1999    {
2000      F= quot;
2001      F /= Lc (F);
2002      result.append (buf);
2003      bufFactors= Difference (bufFactors, factorsConsidered);
2004    }
2005    if (degree (F) <= 0)
2006    {
2007      G= F;
2008      factors= bufFactors;
2009      return result;
2010    }
2011  }
2012  G= F;
2013  factors= bufFactors;
2014  return result;
2015}
2016
2017#ifdef HAVE_FLINT
2018CFList
2019reconstruction (CanonicalForm& G, CFList& factors, int* zeroOneVecs,
2020                int precision, const nmod_mat_t N)
2021{
2022  Variable y= Variable (2);
2023  Variable x= Variable (1);
2024  CanonicalForm F= G;
2025  CanonicalForm yToL= power (y, precision);
2026  CanonicalForm quot, buf;
2027  CFList result;
2028  CFList bufFactors= factors;
2029  CFList factorsConsidered;
2030  CFListIterator iter;
2031  for (long i= 0; i < nmod_mat_ncols (N); i++)
2032  {
2033    if (zeroOneVecs [i] == 0)
2034      continue;
2035    iter= factors;
2036    buf= 1;
2037    factorsConsidered= CFList();
2038    for (long j= 0; j < nmod_mat_nrows (N); j++, iter++)
2039    {
2040      if (!(nmod_mat_entry (N, j, i) == 0))
2041      {
2042        factorsConsidered.append (iter.getItem());
2043        buf= mulMod2 (buf, iter.getItem(), yToL);
2044      }
2045    }
2046    buf *= LC (F, x);
2047    buf= mod (buf, yToL);
2048    buf /= content (buf, x);
2049    if (fdivides (buf, F, quot))
2050    {
2051      F= quot;
2052      F /= Lc (F);
2053      result.append (buf);
2054      bufFactors= Difference (bufFactors, factorsConsidered);
2055    }
2056    if (degree (F) <= 0)
2057    {
2058      G= F;
2059      factors= bufFactors;
2060      return result;
2061    }
2062  }
2063  G= F;
2064  factors= bufFactors;
2065  return result;
2066}
2067#endif
2068
2069void
2070extReconstructionTry (CFList& reconstructedFactors, CanonicalForm& F, const
2071                      CFList& factors, const int liftBound, int& factorsFound,
2072                      int*& factorsFoundIndex, mat_zz_p& N, bool beenInThres,
2073                      const ExtensionInfo& info, const CanonicalForm& evaluation
2074                     )
2075{
2076  Variable y= Variable (2);
2077  Variable x= Variable (1);
2078  Variable alpha= info.getAlpha();
2079  Variable beta= info.getBeta();
2080  int k= info.getGFDegree();
2081  CanonicalForm gamma= info.getGamma();
2082  CanonicalForm delta= info.getDelta();
2083  CanonicalForm yToL= power (y, liftBound);
2084  CFList source, dest;
2085  if (factors.length() == 2)
2086  {
2087    CanonicalForm tmp1, tmp2, tmp3;
2088    tmp1= factors.getFirst();
2089    tmp2= factors.getLast();
2090    tmp1 *= LC (F, x);
2091    tmp1= mod (tmp1, yToL);
2092    tmp1 /= content (tmp1, x);
2093    tmp2 *= LC (F, x);
2094    tmp2= mod (tmp2, yToL);
2095    tmp2 /= content (tmp2, x);
2096    tmp3 = tmp1*tmp2;
2097    if (tmp3/Lc (tmp3) == F/Lc (F))
2098    {
2099      tmp1= tmp1 (y - evaluation, y);
2100      tmp2= tmp2 (y - evaluation, y);
2101      tmp1 /= Lc (tmp1);
2102      tmp2 /= Lc (tmp2);
2103      if (!k && beta == x && degree (tmp2, alpha) < 1 &&
2104          degree (tmp1, alpha) < 1)
2105      {
2106        factorsFound++;
2107        F= 1;
2108        tmp1= mapDown (tmp1, info, source, dest);
2109        tmp2= mapDown (tmp2, info, source, dest);
2110        reconstructedFactors.append (tmp1);
2111        reconstructedFactors.append (tmp2);
2112        return;
2113      }
2114      else if (!isInExtension (tmp2, gamma, k, delta, source, dest) &&
2115               !isInExtension (tmp1, gamma, k, delta, source, dest))
2116      {
2117        factorsFound++;
2118        F= 1;
2119        tmp1= mapDown (tmp1, info, source, dest);
2120        tmp2= mapDown (tmp2, info, source, dest);
2121        reconstructedFactors.append (tmp1);
2122        reconstructedFactors.append (tmp2);
2123        return;
2124      }
2125    }
2126  }
2127  CanonicalForm quot, buf, buf2;
2128  CFListIterator iter;
2129  for (long i= 1; i <= N.NumCols(); i++)
2130  {
2131    if (factorsFoundIndex [i - 1] == 1)
2132      continue;
2133    iter= factors;
2134    if (beenInThres)
2135    {
2136      int count= 1;
2137      while (count < i)
2138      {
2139        count++;
2140        iter++;
2141      }
2142      buf= iter.getItem();
2143    }
2144    else
2145    {
2146      buf= 1;
2147      for (long j= 1; j <= N.NumRows(); j++, iter++)
2148      {
2149        if (!IsZero (N (j,i)))
2150          buf= mulMod2 (buf, iter.getItem(), yToL);
2151      }
2152    }
2153    buf *= LC (F, x);
2154    buf= mod (buf, yToL);
2155    buf /= content (buf, x);
2156    buf2= buf (y - evaluation, y);
2157    buf2 /= Lc (buf2);
2158    if (!k && beta == x)
2159    {
2160      if (degree (buf2, alpha) < 1)
2161      {
2162        if (fdivides (buf, F, quot))
2163        {
2164          factorsFoundIndex[i - 1]= 1;
2165          factorsFound++;
2166          F= quot;
2167          F /= Lc (F);
2168          buf2= mapDown (buf2, info, source, dest);
2169          reconstructedFactors.append (buf2);
2170        }
2171      }
2172    }
2173    else
2174    {
2175      if (!isInExtension (buf2, gamma, k, delta, source, dest))
2176      {
2177        if (fdivides (buf, F, quot))
2178        {
2179          factorsFoundIndex[i - 1]= 1;
2180          factorsFound++;
2181          F= quot;
2182          F /= Lc (F);
2183          buf2= mapDown (buf2, info, source, dest);
2184          reconstructedFactors.append (buf2);
2185        }
2186      }
2187    }
2188    if (degree (F) <= 0)
2189      return;
2190    if (factorsFound + 1 == N.NumCols())
2191    {
2192      CanonicalForm tmp= F (y - evaluation, y);
2193      tmp= mapDown (tmp, info, source, dest);
2194      reconstructedFactors.append (tmp);
2195      return;
2196    }
2197  }
2198}
2199
2200#ifdef HAVE_FLINT
2201void
2202extReconstructionTry (CFList& reconstructedFactors, CanonicalForm& F, const
2203                      CFList& factors, const int liftBound, int& factorsFound,
2204                      int*& factorsFoundIndex, nmod_mat_t N, bool beenInThres,
2205                      const ExtensionInfo& info, const CanonicalForm& evaluation
2206                     )
2207{
2208  Variable y= Variable (2);
2209  Variable x= Variable (1);
2210  Variable alpha= info.getAlpha();
2211  Variable beta= info.getBeta();
2212  int k= info.getGFDegree();
2213  CanonicalForm gamma= info.getGamma();
2214  CanonicalForm delta= info.getDelta();
2215  CanonicalForm yToL= power (y, liftBound);
2216  CFList source, dest;
2217  if (factors.length() == 2)
2218  {
2219    CanonicalForm tmp1, tmp2, tmp3;
2220    tmp1= factors.getFirst();
2221    tmp2= factors.getLast();
2222    tmp1 *= LC (F, x);
2223    tmp1= mod (tmp1, yToL);
2224    tmp1 /= content (tmp1, x);
2225    tmp2 *= LC (F, x);
2226    tmp2= mod (tmp2, yToL);
2227    tmp2 /= content (tmp2, x);
2228    tmp3 = tmp1*tmp2;
2229    if (tmp3/Lc (tmp3) == F/Lc (F))
2230    {
2231      tmp1= tmp1 (y - evaluation, y);
2232      tmp2= tmp2 (y - evaluation, y);
2233      tmp1 /= Lc (tmp1);
2234      tmp2 /= Lc (tmp2);
2235      if (!k && beta == x && degree (tmp2, alpha) < 1 &&
2236          degree (tmp1, alpha) < 1)
2237      {
2238        factorsFound++;
2239        F= 1;
2240        tmp1= mapDown (tmp1, info, source, dest);
2241        tmp2= mapDown (tmp2, info, source, dest);
2242        reconstructedFactors.append (tmp1);
2243        reconstructedFactors.append (tmp2);
2244        return;
2245      }
2246      else if (!isInExtension (tmp2, gamma, k, delta, source, dest) &&
2247               !isInExtension (tmp1, gamma, k, delta, source, dest))
2248      {
2249        factorsFound++;
2250        F= 1;
2251        tmp1= mapDown (tmp1, info, source, dest);
2252        tmp2= mapDown (tmp2, info, source, dest);
2253        reconstructedFactors.append (tmp1);
2254        reconstructedFactors.append (tmp2);
2255        return;
2256      }
2257    }
2258  }
2259  CanonicalForm quot, buf, buf2;
2260  CFListIterator iter;
2261  for (long i= 0; i < nmod_mat_ncols (N); i++)
2262  {
2263    if (factorsFoundIndex [i] == 1)
2264      continue;
2265    iter= factors;
2266    if (beenInThres)
2267    {
2268      int count= 0;
2269      while (count < i)
2270      {
2271        count++;
2272        iter++;
2273      }
2274      buf= iter.getItem();
2275    }
2276    else
2277    {
2278      buf= 1;
2279      for (long j= 0; j < nmod_mat_nrows (N); j++, iter++)
2280      {
2281        if (!(nmod_mat_entry (N, j, i) == 0))
2282          buf= mulMod2 (buf, iter.getItem(), yToL);
2283      }
2284    }
2285    buf *= LC (F, x);
2286    buf= mod (buf, yToL);
2287    buf /= content (buf, x);
2288    buf2= buf (y - evaluation, y);
2289    buf2 /= Lc (buf2);
2290    if (!k && beta == x)
2291    {
2292      if (degree (buf2, alpha) < 1)
2293      {
2294        if (fdivides (buf, F, quot))
2295        {
2296          factorsFoundIndex[i]= 1;
2297          factorsFound++;
2298          F= quot;
2299          F /= Lc (F);
2300          buf2= mapDown (buf2, info, source, dest);
2301          reconstructedFactors.append (buf2);
2302        }
2303      }
2304    }
2305    else
2306    {
2307      if (!isInExtension (buf2, gamma, k, delta, source, dest))
2308      {
2309        if (fdivides (buf, F, quot))
2310        {
2311          factorsFoundIndex[i]= 1;
2312          factorsFound++;
2313          F= quot;
2314          F /= Lc (F);
2315          buf2= mapDown (buf2, info, source, dest);
2316          reconstructedFactors.append (buf2);
2317        }
2318      }
2319    }
2320    if (degree (F) <= 0)
2321      return;
2322    if (factorsFound + 1 == nmod_mat_nrows (N))
2323    {
2324      CanonicalForm tmp= F (y - evaluation, y);
2325      tmp= mapDown (tmp, info, source, dest);
2326      reconstructedFactors.append (tmp);
2327      return;
2328    }
2329  }
2330}
2331#endif
2332
2333//over Fp
2334int
2335liftAndComputeLattice (const CanonicalForm& F, int* bounds, int sizeBounds, int
2336                       start, int liftBound, int minBound, CFList& factors,
2337                       mat_zz_p& NTLN, CFList& diophant, CFMatrix& M, CFArray&
2338                       Pi, CFArray& bufQ, bool& irreducible
2339                      )
2340{
2341  CanonicalForm LCF= LC (F, 1);
2342  CFArray *A= new CFArray [factors.length() - 1];
2343  bool wasInBounds= false;
2344  bool hitBound= false;
2345  int l= (minBound+1)*2;
2346  int stepSize= 2;
2347  int oldL= l/2;
2348  bool reduced= false;
2349  mat_zz_p NTLK, *NTLC;
2350  CFMatrix C;
2351  CFArray buf;
2352  CFListIterator j;
2353  CanonicalForm truncF;
2354  Variable y= F.mvar();
2355  while (l <= liftBound)
2356  {
2357    if (start)
2358    {
2359      henselLiftResume12 (F, factors, start, l, Pi, diophant, M);
2360      start= 0;
2361    }
2362    else
2363    {
2364      if (wasInBounds)
2365        henselLiftResume12 (F, factors, oldL, l, Pi, diophant, M);
2366      else
2367        henselLift12 (F, factors, l, Pi, diophant, M);
2368    }
2369
2370    factors.insert (LCF);
2371    j= factors;
2372    j++;
2373
2374    truncF= mod (F, power (y, l));
2375    for (int i= 0; i < factors.length() - 1; i++, j++)
2376    {
2377      if (!wasInBounds)
2378        A[i]= logarithmicDerivative (truncF, j.getItem(), l, bufQ[i]);
2379      else
2380        A[i]= logarithmicDerivative (truncF, j.getItem(), l, oldL, bufQ[i],
2381                                     bufQ[i]);
2382    }
2383
2384    for (int i= 0; i < sizeBounds; i++)
2385    {
2386      if (bounds [i] + 1 <= l/2)
2387      {
2388        wasInBounds= true;
2389        int k= tmin (bounds [i] + 1, l/2);
2390        C= CFMatrix (l - k, factors.length() - 1);
2391        for (int ii= 0; ii < factors.length() - 1; ii++)
2392        {
2393          if (A[ii].size() - 1 >= i)
2394          {
2395            buf= getCoeffs (A[ii] [i], k);
2396            writeInMatrix (C, buf, ii + 1, 0);
2397          }
2398        }
2399        NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
2400        NTLK= (*NTLC)*NTLN;
2401        transpose (NTLK, NTLK);
2402        kernel (NTLK, NTLK);
2403        transpose (NTLK, NTLK);
2404        NTLN *= NTLK;
2405
2406        if (NTLN.NumCols() == 1)
2407        {
2408          irreducible= true;
2409          break;
2410        }
2411        if (isReduced (NTLN) && l > (minBound+1)*2)
2412        {
2413          reduced= true;
2414          break;
2415        }
2416      }
2417    }
2418
2419    if (irreducible)
2420      break;
2421    if (reduced)
2422      break;
2423    oldL= l;
2424    l += stepSize;
2425    stepSize *= 2;
2426    if (l > liftBound)
2427    {
2428      if (!hitBound)
2429      {
2430        l= liftBound;
2431        hitBound= true;
2432      }
2433      else
2434        break;
2435    }
2436  }
2437  delete [] A;
2438  if (!wasInBounds)
2439  {
2440    if (start)
2441      henselLiftResume12 (F, factors, start, degree (F) + 1, Pi, diophant, M);
2442    else
2443      henselLift12 (F, factors, degree (F) + 1, Pi, diophant, M);
2444    factors.insert (LCF);
2445  }
2446  return l;
2447}
2448
2449#ifdef HAVE_FLINT
2450int
2451liftAndComputeLattice (const CanonicalForm& F, int* bounds, int sizeBounds, int
2452                       start, int liftBound, int minBound, CFList& factors,
2453                       nmod_mat_t FLINTN, CFList& diophant, CFMatrix& M,CFArray&
2454                       Pi, CFArray& bufQ, bool& irreducible
2455                      )
2456{
2457  CanonicalForm LCF= LC (F, 1);
2458  CFArray *A= new CFArray [factors.length() - 1];
2459  bool wasInBounds= false;
2460  bool hitBound= false;
2461  int l= (minBound+1)*2;
2462  int stepSize= 2;
2463  int oldL= l/2;
2464  bool reduced= false;
2465  long rank;
2466  nmod_mat_t FLINTK, FLINTC, null;
2467  CFMatrix C;
2468  CFArray buf;
2469  CFListIterator j;
2470  CanonicalForm truncF;
2471  Variable y= F.mvar();
2472  while (l <= liftBound)
2473  {
2474    if (start)
2475    {
2476      henselLiftResume12 (F, factors, start, l, Pi, diophant, M);
2477      start= 0;
2478    }
2479    else
2480    {
2481      if (wasInBounds)
2482        henselLiftResume12 (F, factors, oldL, l, Pi, diophant, M);
2483      else
2484        henselLift12 (F, factors, l, Pi, diophant, M);
2485    }
2486
2487    factors.insert (LCF);
2488    j= factors;
2489    j++;
2490
2491    truncF= mod (F, power (y, l));
2492    for (int i= 0; i < factors.length() - 1; i++, j++)
2493    {
2494      if (!wasInBounds)
2495        A[i]= logarithmicDerivative (truncF, j.getItem(), l, bufQ[i]);
2496      else
2497        A[i]= logarithmicDerivative (truncF, j.getItem(), l, oldL, bufQ[i],
2498                                     bufQ[i]);
2499    }
2500
2501    for (int i= 0; i < sizeBounds; i++)
2502    {
2503      if (bounds [i] + 1 <= l/2)
2504      {
2505        wasInBounds= true;
2506        int k= tmin (bounds [i] + 1, l/2);
2507        C= CFMatrix (l - k, factors.length() - 1);
2508        for (int ii= 0; ii < factors.length() - 1; ii++)
2509        {
2510          if (A[ii].size() - 1 >= i)
2511          {
2512            buf= getCoeffs (A[ii] [i], k);
2513            writeInMatrix (C, buf, ii + 1, 0);
2514          }
2515        }
2516
2517        convertFacCFMatrix2nmod_mat_t (FLINTC, C);
2518        nmod_mat_init (FLINTK, nmod_mat_nrows (FLINTC), nmod_mat_ncols (FLINTN),
2519                       getCharacteristic());
2520        nmod_mat_mul (FLINTK, FLINTC, FLINTN);
2521        nmod_mat_init (null, nmod_mat_ncols (FLINTK), nmod_mat_ncols (FLINTK),
2522                       getCharacteristic());
2523        rank= nmod_mat_nullspace (null, FLINTK);
2524        nmod_mat_clear (FLINTK);
2525        nmod_mat_window_init (FLINTK, null, 0, 0, nmod_mat_nrows(null), rank);
2526        nmod_mat_clear (FLINTC);
2527        nmod_mat_init_set (FLINTC, FLINTN);
2528        nmod_mat_clear (FLINTN);
2529        nmod_mat_init (FLINTN, nmod_mat_nrows (FLINTC), nmod_mat_ncols (FLINTK),
2530                       getCharacteristic());
2531        nmod_mat_mul (FLINTN, FLINTC, FLINTK); //no aliasing allowed!!
2532
2533        nmod_mat_clear (FLINTC);
2534        nmod_mat_window_clear (FLINTK);
2535        nmod_mat_clear (null);
2536        if (nmod_mat_ncols (FLINTN) == 1)
2537        {
2538          irreducible= true;
2539          break;
2540        }
2541        if (isReduced (FLINTN) && l > (minBound+1)*2)
2542        {
2543          reduced= true;
2544          break;
2545        }
2546      }
2547    }
2548
2549    if (irreducible)
2550      break;
2551    if (reduced)
2552      break;
2553    oldL= l;
2554    l += stepSize;
2555    stepSize *= 2;
2556    if (l > liftBound)
2557    {
2558      if (!hitBound)
2559      {
2560        l= liftBound;
2561        hitBound= true;
2562      }
2563      else
2564        break;
2565    }
2566  }
2567  delete [] A;
2568  if (!wasInBounds)
2569  {
2570    if (start)
2571      henselLiftResume12 (F, factors, start, degree (F) + 1, Pi, diophant, M);
2572    else
2573      henselLift12 (F, factors, degree (F) + 1, Pi, diophant, M);
2574    factors.insert (LCF);
2575  }
2576  return l;
2577}
2578#endif
2579
2580//over field extension
2581int
2582extLiftAndComputeLattice (const CanonicalForm& F, int* bounds, int sizeBounds,
2583                          int liftBound, int minBound, int start, CFList&
2584                          factors, mat_zz_p& NTLN, CFList& diophant,
2585                          CFMatrix& M, CFArray& Pi, CFArray& bufQ, bool&
2586                          irreducible, const CanonicalForm& evaluation, const
2587                          ExtensionInfo& info, CFList& source, CFList& dest
2588                         )
2589{
2590  bool GF= (CFFactory::gettype()==GaloisFieldDomain);
2591  CanonicalForm LCF= LC (F, 1);
2592  CFArray *A= new CFArray [factors.length() - 1];
2593  bool wasInBounds= false;
2594  bool hitBound= false;
2595  int degMipo;
2596  Variable alpha;
2597  alpha= info.getAlpha();
2598  degMipo= degree (getMipo (alpha));
2599
2600  Variable gamma= info.getBeta();
2601  CanonicalForm primElemAlpha= info.getGamma();
2602  CanonicalForm imPrimElemAlpha= info.getDelta();
2603
2604  int stepSize= 2;
2605  int l= ((minBound+1)/degMipo+1)*2;
2606  l= tmax (l, 2);
2607  if (start > l)
2608    l= start;
2609  int oldL= l/2;
2610  bool reduced= false;
2611  Variable y= F.mvar();
2612  Variable x= Variable (1);
2613  CanonicalForm powX, imBasis, truncF;
2614  CFMatrix Mat, C;
2615  CFArray buf;
2616  CFIterator iter;
2617  mat_zz_p* NTLMat, *NTLC, NTLK;
2618  CFListIterator j;
2619  while (l <= liftBound)
2620  {
2621    if (start)
2622    {
2623      henselLiftResume12 (F, factors, start, l, Pi, diophant, M);
2624      start= 0;
2625    }
2626    else
2627    {
2628      if (wasInBounds)
2629        henselLiftResume12 (F, factors, oldL, l, Pi, diophant, M);
2630      else
2631        henselLift12 (F, factors, l, Pi, diophant, M);
2632    }
2633
2634    factors.insert (LCF);
2635
2636    if (GF)
2637      setCharacteristic (getCharacteristic());
2638
2639    powX= power (y-gamma, l);
2640    Mat= CFMatrix (l*degMipo, l*degMipo);
2641    for (int i= 0; i < l*degMipo; i++)
2642    {
2643      imBasis= mod (power (y, i), powX);
2644      imBasis= imBasis (power (y, degMipo), y);
2645      imBasis= imBasis (y, gamma);
2646      iter= imBasis;
2647      for (; iter.hasTerms(); iter++)
2648        Mat (iter.exp()+ 1, i+1)= iter.coeff();
2649    }
2650
2651    NTLMat= convertFacCFMatrix2NTLmat_zz_p (Mat);
2652    *NTLMat= inv (*NTLMat);
2653
2654    if (GF)
2655      setCharacteristic (getCharacteristic(), degMipo, info.getGFName());
2656
2657    j= factors;
2658    j++;
2659
2660    truncF= mod (F, power (y, l));
2661    for (int i= 0; i < factors.length() - 1; i++, j++)
2662    {
2663      if (!wasInBounds)
2664        A[i]= logarithmicDerivative (truncF, j.getItem(), l, bufQ[i]);
2665      else
2666        A[i]= logarithmicDerivative (truncF, j.getItem(), l, oldL, bufQ[i],
2667                                     bufQ[i]);
2668    }
2669
2670    for (int i= 0; i < sizeBounds; i++)
2671    {
2672      if (bounds [i] + 1 <= (l/2)*degMipo)
2673      {
2674        wasInBounds= true;
2675        int k= tmin (bounds [i] + 1, (l/2)*degMipo);
2676        C= CFMatrix (l*degMipo - k, factors.length() - 1);
2677
2678        for (int ii= 0; ii < factors.length() - 1; ii++)
2679        {
2680          if (A[ii].size() - 1 >= i)
2681          {
2682            if (GF)
2683            {
2684              A [ii] [i]= A [ii] [i] (y-evaluation, y);
2685              setCharacteristic (getCharacteristic());
2686              A[ii] [i]= GF2FalphaRep (A[ii] [i], alpha);
2687              if (alpha != gamma)
2688                A [ii] [i]= mapDown (A[ii] [i], imPrimElemAlpha, primElemAlpha,
2689                                     gamma, source, dest
2690                                    );
2691              buf= getCoeffs (A[ii] [i], k, l, degMipo, gamma, 0, *NTLMat);
2692            }
2693            else
2694            {
2695              A [ii] [i]= A [ii] [i] (y-evaluation, y);
2696              if (alpha != gamma)
2697                A[ii] [i]= mapDown (A[ii] [i], imPrimElemAlpha, primElemAlpha,
2698                                    gamma, source, dest
2699                                   );
2700              buf= getCoeffs (A[ii] [i], k, l, degMipo, gamma, 0, *NTLMat);
2701            }
2702            writeInMatrix (C, buf, ii + 1, 0);
2703          }
2704          if (GF)
2705            setCharacteristic (getCharacteristic(), degMipo, info.getGFName());
2706        }
2707
2708        if (GF)
2709          setCharacteristic(getCharacteristic());
2710
2711        NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
2712        NTLK= (*NTLC)*NTLN;
2713        transpose (NTLK, NTLK);
2714        kernel (NTLK, NTLK);
2715        transpose (NTLK, NTLK);
2716        NTLN *= NTLK;
2717
2718        if (GF)
2719          setCharacteristic (getCharacteristic(), degMipo, info.getGFName());
2720
2721        if (NTLN.NumCols() == 1)
2722        {
2723          irreducible= true;
2724          break;
2725        }
2726        if (isReduced (NTLN))
2727        {
2728          reduced= true;
2729          break;
2730        }
2731      }
2732    }
2733
2734    if (NTLN.NumCols() == 1)
2735    {
2736      irreducible= true;
2737      break;
2738    }
2739    if (reduced)
2740      break;
2741    oldL= l;
2742    l += stepSize;
2743    stepSize *= 2;
2744    if (l > liftBound)
2745    {
2746      if (!hitBound)
2747      {
2748        l= liftBound;
2749        hitBound= true;
2750      }
2751      else
2752        break;
2753    }
2754  }
2755  delete [] A;
2756  if (!wasInBounds)
2757  {
2758    if (start)
2759      henselLiftResume12 (F, factors, start, degree (F) + 1, Pi, diophant, M);
2760    else
2761      henselLift12 (F, factors, degree (F) + 1, Pi, diophant, M);
2762    factors.insert (LCF);
2763  }
2764  return l;
2765}
2766
2767/*#ifdef HAVE_FLINT
2768//over field extension
2769int
2770extLiftAndComputeLattice (const CanonicalForm& F, int* bounds, int sizeBounds,
2771                          int liftBound, int minBound, int start, CFList&
2772                          factors, nmod_mat_t FLINTN, CFList& diophant,
2773                          CFMatrix& M, CFArray& Pi, CFArray& bufQ, bool&
2774                          irreducible, const CanonicalForm& evaluation, const
2775                          ExtensionInfo& info, CFList& source, CFList& dest
2776                         )
2777{
2778  bool GF= (CFFactory::gettype()==GaloisFieldDomain);
2779  CanonicalForm LCF= LC (F, 1);
2780  CFArray *A= new CFArray [factors.length() - 1];
2781  bool wasInBounds= false;
2782  bool hitBound= false;
2783  int degMipo;
2784  Variable alpha;
2785  alpha= info.getAlpha();
2786  degMipo= degree (getMipo (alpha));
2787
2788  Variable gamma= info.getBeta();
2789  CanonicalForm primElemAlpha= info.getGamma();
2790  CanonicalForm imPrimElemAlpha= info.getDelta();
2791
2792  int stepSize= 2;
2793  int l= ((minBound+1)/degMipo+1)*2;
2794  l= tmax (l, 2);
2795  if (start > l)
2796    l= start;
2797  int oldL= l/2;
2798  bool reduced= false;
2799  Variable y= F.mvar();
2800  Variable x= Variable (1);
2801  CanonicalForm powX, imBasis, truncF;
2802  CFMatrix Mat, C;
2803  CFArray buf;
2804  CFIterator iter;
2805  long rank;
2806  nmod_mat_t FLINTMat, FLINTMatInv, FLINTC, FLINTK, null;
2807  CFListIterator j;
2808  while (l <= liftBound)
2809  {
2810    if (start)
2811    {
2812      henselLiftResume12 (F, factors, start, l, Pi, diophant, M);
2813      start= 0;
2814    }
2815    else
2816    {
2817      if (wasInBounds)
2818        henselLiftResume12 (F, factors, oldL, l, Pi, diophant, M);
2819      else
2820        henselLift12 (F, factors, l, Pi, diophant, M);
2821    }
2822
2823    factors.insert (LCF);
2824
2825    if (GF)
2826      setCharacteristic (getCharacteristic());
2827
2828    powX= power (y-gamma, l);
2829    Mat= CFMatrix (l*degMipo, l*degMipo);
2830    for (int i= 0; i < l*degMipo; i++)
2831    {
2832      imBasis= mod (power (y, i), powX);
2833      imBasis= imBasis (power (y, degMipo), y);
2834      imBasis= imBasis (y, gamma);
2835      iter= imBasis;
2836      for (; iter.hasTerms(); iter++)
2837        Mat (iter.exp()+ 1, i+1)= iter.coeff();
2838    }
2839
2840    convertFacCFMatrix2nmod_mat_t (FLINTMat, Mat);
2841    nmod_mat_init (FLINTMatInv, nmod_mat_nrows (FLINTMat),
2842                   nmod_mat_nrows (FLINTMat), getCharacteristic());
2843    nmod_mat_inv (FLINTMatInv, FLINTMat);
2844
2845    if (GF)
2846      setCharacteristic (getCharacteristic(), degMipo, info.getGFName());
2847
2848    j= factors;
2849    j++;
2850
2851    truncF= mod (F, power (y, l));
2852    for (int i= 0; i < factors.length() - 1; i++, j++)
2853    {
2854      if (!wasInBounds)
2855        A[i]= logarithmicDerivative (truncF, j.getItem(), l, bufQ[i]);
2856      else
2857        A[i]= logarithmicDerivative (truncF, j.getItem(), l, oldL, bufQ[i],
2858                                     bufQ[i]);
2859    }
2860
2861    for (int i= 0; i < sizeBounds; i++)
2862    {
2863      if (bounds [i] + 1 <= (l/2)*degMipo)
2864      {
2865        wasInBounds= true;
2866        int k= tmin (bounds [i] + 1, (l/2)*degMipo);
2867        C= CFMatrix (l*degMipo - k, factors.length() - 1);
2868
2869        for (int ii= 0; ii < factors.length() - 1; ii++)
2870        {
2871          if (A[ii].size() - 1 >= i)
2872          {
2873            if (GF)
2874            {
2875              A [ii] [i]= A [ii] [i] (y-evaluation, y);
2876              setCharacteristic (getCharacteristic());
2877              A[ii] [i]= GF2FalphaRep (A[ii] [i], alpha);
2878              if (alpha != gamma)
2879                A [ii] [i]= mapDown (A[ii] [i], imPrimElemAlpha, primElemAlpha,
2880                                     gamma, source, dest
2881                                    );
2882              buf= getCoeffs (A[ii] [i], k, l, degMipo, gamma, 0, FLINTMatInv); //TODO
2883            }
2884            else
2885            {
2886              A [ii] [i]= A [ii] [i] (y-evaluation, y);
2887              if (alpha != gamma)
2888                A[ii] [i]= mapDown (A[ii] [i], imPrimElemAlpha, primElemAlpha,
2889                                    gamma, source, dest
2890                                   );
2891              buf= getCoeffs (A[ii] [i], k, l, degMipo, gamma, 0, FLINTMatInv); //TODO
2892            }
2893            writeInMatrix (C, buf, ii + 1, 0);
2894          }
2895          if (GF)
2896            setCharacteristic (getCharacteristic(), degMipo, info.getGFName());
2897        }
2898
2899        if (GF)
2900          setCharacteristic(getCharacteristic());
2901
2902        convertFacCFMatrix2nmod_mat_t (FLINTC, C);
2903        nmod_mat_init (FLINTK, nmod_mat_nrows (FLINTC), nmod_mat_ncols (FLINTN),
2904                       getCharacteristic());
2905        nmod_mat_mul (FLINTK, FLINTC, FLINTN);
2906        nmod_mat_init (null, nmod_mat_ncols (FLINTK), nmod_mat_ncols (FLINTK),
2907                       getCharacteristic());
2908        rank= nmod_mat_nullspace (null, FLINTK);
2909        nmod_mat_clear (FLINTK);
2910        nmod_mat_window_init (FLINTK, null, 0, 0, nmod_mat_nrows(null), rank);
2911        nmod_mat_clear (FLINTC);
2912        nmod_mat_init_set (FLINTC, FLINTN);
2913        nmod_mat_clear (FLINTN);
2914        nmod_mat_init (FLINTN, nmod_mat_nrows (FLINTC), nmod_mat_ncols (FLINTK),
2915                       getCharacteristic());
2916        nmod_mat_mul (FLINTN, FLINTC, FLINTK); //no aliasing allowed!!
2917
2918        nmod_mat_clear (FLINTC);
2919        nmod_mat_window_clear (FLINTK);
2920        nmod_mat_clear (null);
2921
2922        if (GF)
2923          setCharacteristic (getCharacteristic(), degMipo, info.getGFName());
2924
2925        if (nmod_mat_ncols (FLINTN) == 1)
2926        {
2927          irreducible= true;
2928          break;
2929        }
2930        if (isReduced (FLINTN))
2931        {
2932          reduced= true;
2933          break;
2934        }
2935      }
2936    }
2937
2938    nmod_mat_clear (FLINTMat);
2939    nmod_mat_clear (FLINTMatInv);
2940
2941    if (nmod_mat_ncols (FLINTN) == 1)
2942    {
2943      irreducible= true;
2944      break;
2945    }
2946    if (reduced)
2947      break;
2948    oldL= l;
2949    l += stepSize;
2950    stepSize *= 2;
2951    if (l > liftBound)
2952    {
2953      if (!hitBound)
2954      {
2955        l= liftBound;
2956        hitBound= true;
2957      }
2958      else
2959        break;
2960    }
2961  }
2962  delete [] A;
2963  if (!wasInBounds)
2964  {
2965    if (start)
2966      henselLiftResume12 (F, factors, start, degree (F) + 1, Pi, diophant, M);
2967    else
2968      henselLift12 (F, factors, degree (F) + 1, Pi, diophant, M);
2969    factors.insert (LCF);
2970  }
2971  return l;
2972}
2973#endif*/
2974
2975// over Fq
2976int
2977liftAndComputeLattice (const CanonicalForm& F, int* bounds, int sizeBounds,
2978                       int start, int liftBound, int minBound, CFList& factors,
2979                       mat_zz_pE& NTLN, CFList& diophant, CFMatrix& M, CFArray&
2980                       Pi, CFArray& bufQ, bool& irreducible
2981                      )
2982{
2983  CanonicalForm LCF= LC (F, 1);
2984  CFArray *A= new CFArray [factors.length() - 1];
2985  bool wasInBounds= false;
2986  bool hitBound= false;
2987  int l= (minBound+1)*2;
2988  int stepSize= 2;
2989  int oldL= l/2;
2990  bool reduced= false;
2991  CFListIterator j;
2992  mat_zz_pE* NTLC, NTLK;
2993  CFArray buf;
2994  CFMatrix C;
2995  Variable y= F.mvar();
2996  CanonicalForm truncF;
2997  while (l <= liftBound)
2998  {
2999    if (start)
3000    {
3001      henselLiftResume12 (F, factors, start, l, Pi, diophant, M);
3002      start= 0;
3003    }
3004    else
3005    {
3006      if (wasInBounds)
3007        henselLiftResume12 (F, factors, oldL, l, Pi, diophant, M);
3008      else
3009        henselLift12 (F, factors, l, Pi, diophant, M);
3010    }
3011
3012    factors.insert (LCF);
3013    j= factors;
3014    j++;
3015
3016    truncF= mod (F, power (y,l));
3017    for (int i= 0; i < factors.length() - 1; i++, j++)
3018    {
3019      if (l == (minBound+1)*2)
3020      {
3021        A[i]= logarithmicDerivative (truncF, j.getItem(), l, bufQ[i]);
3022      }
3023      else
3024      {
3025        A[i]= logarithmicDerivative (truncF, j.getItem(), l, oldL, bufQ[i],
3026                                     bufQ[i]
3027                                    );
3028      }
3029    }
3030
3031    for (int i= 0; i < sizeBounds; i++)
3032    {
3033      if (bounds [i] + 1 <= l/2)
3034      {
3035        wasInBounds= true;
3036        int k= tmin (bounds [i] + 1, l/2);
3037        C= CFMatrix (l - k, factors.length() - 1);
3038        for (int ii= 0; ii < factors.length() - 1; ii++)
3039        {
3040
3041          if (A[ii].size() - 1 >= i)
3042          {
3043            buf= getCoeffs (A[ii] [i], k);
3044            writeInMatrix (C, buf, ii + 1, 0);
3045          }
3046        }
3047
3048        NTLC= convertFacCFMatrix2NTLmat_zz_pE(C);
3049        NTLK= (*NTLC)*NTLN;
3050        transpose (NTLK, NTLK);
3051        kernel (NTLK, NTLK);
3052        transpose (NTLK, NTLK);
3053        NTLN *= NTLK;
3054
3055        if (NTLN.NumCols() == 1)
3056        {
3057          irreducible= true;
3058          break;
3059        }
3060        if (isReduced (NTLN) && l > (minBound+1)*2)
3061        {
3062          reduced= true;
3063          break;
3064        }
3065      }
3066    }
3067
3068    if (NTLN.NumCols() == 1)
3069    {
3070      irreducible= true;
3071      break;
3072    }
3073    if (reduced)
3074      break;
3075    oldL= l;
3076    l += stepSize;
3077    stepSize *= 2;
3078    if (l > liftBound)
3079    {
3080      if (!hitBound)
3081      {
3082        l= liftBound;
3083        hitBound= true;
3084      }
3085      else
3086        break;
3087    }
3088  }
3089  delete [] A;
3090  if (!wasInBounds)
3091  {
3092    if (start)
3093      henselLiftResume12 (F, factors, start, degree (F) + 1, Pi, diophant, M);
3094    else
3095      henselLift12 (F, factors, degree (F) + 1, Pi, diophant, M);
3096    factors.insert (LCF);
3097  }
3098  return l;
3099}
3100
3101#ifdef HAVE_FLINT
3102int
3103liftAndComputeLatticeFq2Fp (const CanonicalForm& F, int* bounds, int sizeBounds,
3104                            int start, int liftBound, int minBound, CFList&
3105                            factors, nmod_mat_t FLINTN, CFList& diophant,
3106                            CFMatrix& M, CFArray& Pi, CFArray& bufQ, bool&
3107                            irreducible, const Variable& alpha
3108                           )
3109#else
3110int
3111liftAndComputeLatticeFq2Fp (const CanonicalForm& F, int* bounds, int sizeBounds,
3112                            int start, int liftBound, int minBound, CFList&
3113                            factors, mat_zz_p& NTLN, CFList& diophant, CFMatrix&
3114                            M, CFArray& Pi, CFArray& bufQ, bool& irreducible,
3115                            const Variable& alpha
3116                           )
3117#endif
3118{
3119  CanonicalForm LCF= LC (F, 1);
3120  CFArray *A= new CFArray [factors.length() - 1];
3121  bool wasInBounds= false;
3122  int l= (minBound+1)*2;
3123  int oldL= l/2;
3124  int stepSize= 2;
3125  bool hitBound= false;
3126  int extensionDeg= degree (getMipo (alpha));
3127  bool reduced= false;
3128  CFListIterator j;
3129  CFMatrix C;
3130  CFArray buf;
3131#ifdef HAVE_FLINT
3132  long rank;
3133  nmod_mat_t FLINTC, FLINTK, null;
3134#else
3135  mat_zz_p* NTLC, NTLK;
3136#endif
3137  Variable y= F.mvar();
3138  CanonicalForm truncF;
3139  while (l <= liftBound)
3140  {
3141    if (start)
3142    {
3143      henselLiftResume12 (F, factors, start, l, Pi, diophant, M);
3144      start= 0;
3145    }
3146    else
3147    {
3148      if (wasInBounds)
3149        henselLiftResume12 (F, factors, oldL, l, Pi, diophant, M);
3150      else
3151        henselLift12 (F, factors, l, Pi, diophant, M);
3152    }
3153
3154    factors.insert (LCF);
3155    j= factors;
3156    j++;
3157
3158    truncF= mod (F, power (y,l));
3159    for (int i= 0; i < factors.length() - 1; i++, j++)
3160    {
3161      if (l == (minBound+1)*2)
3162      {
3163        A[i]= logarithmicDerivative (truncF, j.getItem(), l, bufQ[i]);
3164      }
3165      else
3166      {
3167        A[i]= logarithmicDerivative (truncF, j.getItem(), l, oldL, bufQ[i],
3168                                     bufQ[i]
3169                                    );
3170      }
3171    }
3172
3173    for (int i= 0; i < sizeBounds; i++)
3174    {
3175      if (bounds [i] + 1 <= l/2)
3176      {
3177        wasInBounds= true;
3178        int k= tmin (bounds [i] + 1, l/2);
3179        C= CFMatrix ((l - k)*extensionDeg, factors.length() - 1);
3180        for (int ii= 0; ii < factors.length() - 1; ii++)
3181        {
3182          if (A[ii].size() - 1 >= i)
3183          {
3184            buf= getCoeffs (A[ii] [i], k, alpha);
3185            writeInMatrix (C, buf, ii + 1, 0);
3186          }
3187        }
3188
3189#ifdef HAVE_FLINT
3190        convertFacCFMatrix2nmod_mat_t (FLINTC, C);
3191        nmod_mat_init (FLINTK, nmod_mat_nrows (FLINTC), nmod_mat_ncols (FLINTN),
3192                       getCharacteristic());
3193        nmod_mat_mul (FLINTK, FLINTC, FLINTN);
3194        nmod_mat_init (null, nmod_mat_ncols (FLINTK), nmod_mat_ncols (FLINTK),
3195                       getCharacteristic());
3196        rank= nmod_mat_nullspace (null, FLINTK);
3197        nmod_mat_clear (FLINTK);
3198        nmod_mat_window_init (FLINTK, null, 0, 0, nmod_mat_nrows(null), rank);
3199        nmod_mat_clear (FLINTC);
3200        nmod_mat_init_set (FLINTC, FLINTN);
3201        nmod_mat_clear (FLINTN);
3202        nmod_mat_init (FLINTN, nmod_mat_nrows (FLINTC), nmod_mat_ncols (FLINTK),
3203                       getCharacteristic());
3204        nmod_mat_mul (FLINTN, FLINTC, FLINTK); //no aliasing allowed!!
3205
3206        nmod_mat_clear (FLINTC);
3207        nmod_mat_window_clear (FLINTK);
3208        nmod_mat_clear (null);
3209#else
3210        NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
3211        NTLK= (*NTLC)*NTLN;
3212        transpose (NTLK, NTLK);
3213        kernel (NTLK, NTLK);
3214        transpose (NTLK, NTLK);
3215        NTLN *= NTLK;
3216#endif
3217
3218#ifdef HAVE_FLINT
3219        if (nmod_mat_nrows (FLINTN) == 1)
3220#else
3221        if (NTLN.NumCols() == 1)
3222#endif
3223        {
3224          irreducible= true;
3225          break;
3226        }
3227#ifdef HAVE_FLINT
3228        if (isReduced (FLINTN) && l > (minBound+1)*2)
3229#else
3230        if (isReduced (NTLN) && l > (minBound+1)*2)
3231#endif
3232        {
3233          reduced= true;
3234          break;
3235        }
3236      }
3237    }
3238
3239#ifdef HAVE_FLINT
3240    if (nmod_mat_ncols (FLINTN) == 1)
3241#else
3242    if (NTLN.NumCols() == 1)
3243#endif
3244    {
3245      irreducible= true;
3246      break;
3247    }
3248    if (reduced)
3249      break;
3250    oldL= l;
3251    l += stepSize;
3252    stepSize *= 2;
3253    if (l > liftBound)
3254    {
3255      if (!hitBound)
3256      {
3257        l= liftBound;
3258        hitBound= true;
3259      }
3260      else
3261        break;
3262    }
3263  }
3264  delete [] A;
3265  if (!wasInBounds)
3266  {
3267    if (start)
3268      henselLiftResume12 (F, factors, start, degree (F) + 1, Pi, diophant, M);
3269    else
3270      henselLift12 (F, factors, degree (F) + 1, Pi, diophant, M);
3271    factors.insert (LCF);
3272  }
3273  return l;
3274}
3275
3276CFList
3277increasePrecision (CanonicalForm& F, CFList& factors, int factorsFound,
3278                   int oldNumCols, int oldL, int precision
3279                  )
3280{
3281  int d;
3282  bool isIrreducible= false;
3283  int* bounds= computeBounds (F, d, isIrreducible);
3284  if (isIrreducible)
3285  {
3286    delete [] bounds;
3287    CanonicalForm G= F;
3288    F= 1;
3289    return CFList (G);
3290  }
3291  CFArray * A= new CFArray [factors.length()];
3292  CFArray bufQ= CFArray (factors.length());
3293#ifdef HAVE_FLINT
3294  nmod_mat_t FLINTN;
3295  nmod_mat_init (FLINTN,factors.length(),factors.length(), getCharacteristic());
3296  for (long i=factors.length()-1; i >= 0; i--)
3297    nmod_mat_entry (FLINTN, i, i)= 1;
3298#else
3299  mat_zz_p NTLN;
3300  ident (NTLN, factors.length());
3301#endif
3302  int minBound= bounds[0];
3303  for (int i= 1; i < d; i++)
3304  {
3305    if (bounds[i] != 0)
3306      minBound= tmin (minBound, bounds[i]);
3307  }
3308  int l= tmax (2*(minBound + 1), oldL);
3309  int oldL2= l/2;
3310  int stepSize= 2;
3311  bool useOldQs= false;
3312  bool hitBound= false;
3313  CFListIterator j;
3314  CFMatrix C;
3315  CFArray buf;
3316#ifdef HAVE_FLINT
3317  long rank;
3318  nmod_mat_t FLINTC, FLINTK, null;
3319#else
3320  mat_zz_p* NTLC, NTLK;
3321#endif
3322  Variable y= F.mvar();
3323  CanonicalForm truncF;
3324  while (l <= precision)
3325  {
3326    j= factors;
3327    truncF= mod (F, power (y,l));
3328    if (useOldQs)
3329    {
3330      for (int i= 0; i < factors.length(); i++, j++)
3331        A[i]= logarithmicDerivative (truncF, j.getItem(), l, oldL2, bufQ[i],
3332                                     bufQ[i]
3333                                    );
3334    }
3335    else
3336    {
3337      for (int i= 0; i < factors.length(); i++, j++)
3338        A[i]= logarithmicDerivative (truncF, j.getItem(), l, bufQ [i]);
3339    }
3340    useOldQs= true;
3341    for (int i= 0; i < d; i++)
3342    {
3343      if (bounds [i] + 1 <= l/2)
3344      {
3345        int k= tmin (bounds [i] + 1, l/2);
3346        C= CFMatrix (l - k, factors.length());
3347        for (int ii= 0; ii < factors.length(); ii++)
3348        {
3349          if (A[ii].size() - 1 >= i)
3350          {
3351            buf= getCoeffs (A[ii] [i], k);
3352            writeInMatrix (C, buf, ii + 1, 0);
3353          }
3354        }
3355#ifdef HAVE_FLINT
3356        convertFacCFMatrix2nmod_mat_t (FLINTC, C);
3357        nmod_mat_init (FLINTK, nmod_mat_nrows (FLINTC), nmod_mat_ncols (FLINTN),
3358                       getCharacteristic());
3359        nmod_mat_mul (FLINTK, FLINTC, FLINTN);
3360        nmod_mat_init (null, nmod_mat_ncols (FLINTK), nmod_mat_ncols (FLINTK),
3361                       getCharacteristic());
3362        rank= nmod_mat_nullspace (null, FLINTK);
3363        nmod_mat_clear (FLINTK);
3364        nmod_mat_window_init (FLINTK, null, 0, 0, nmod_mat_nrows(null), rank);
3365        nmod_mat_clear (FLINTC);
3366        nmod_mat_init_set (FLINTC, FLINTN);
3367        nmod_mat_clear (FLINTN);
3368        nmod_mat_init (FLINTN, nmod_mat_nrows (FLINTC), nmod_mat_ncols (FLINTK),
3369                       getCharacteristic());
3370        nmod_mat_mul (FLINTN, FLINTC, FLINTK); //no aliasing allowed!!
3371
3372        nmod_mat_clear (FLINTC);
3373        nmod_mat_window_clear (FLINTK);
3374        nmod_mat_clear (null);
3375#else
3376        NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
3377        NTLK= (*NTLC)*NTLN;
3378        transpose (NTLK, NTLK);
3379        kernel (NTLK, NTLK);
3380        transpose (NTLK, NTLK);
3381        NTLN *= NTLK;
3382#endif
3383#ifdef HAVE_FLINT
3384        if (nmod_mat_ncols (FLINTN) == 1)
3385        {
3386          nmod_mat_clear (FLINTN);
3387#else
3388        if (NTLN.NumCols() == 1)
3389        {
3390#endif
3391          delete [] A;
3392          delete [] bounds;
3393          CanonicalForm G= F;
3394          F= 1;
3395          return CFList (G);
3396        }
3397      }
3398    }
3399
3400#ifdef HAVE_FLINT
3401    if (nmod_mat_ncols (FLINTN) < oldNumCols - factorsFound)
3402    {
3403      if (isReduced (FLINTN))
3404      {
3405        int * factorsFoundIndex= new int [nmod_mat_ncols (FLINTN)];
3406        for (long i= 0; i < nmod_mat_ncols (FLINTN); i++)
3407#else
3408    if (NTLN.NumCols() < oldNumCols - factorsFound)
3409    {
3410      if (isReduced (NTLN))
3411      {
3412        int * factorsFoundIndex= new int [NTLN.NumCols()];
3413        for (long i= 0; i < NTLN.NumCols(); i++)
3414#endif
3415          factorsFoundIndex[i]= 0;
3416        int factorsFound2= 0;
3417        CFList result;
3418        CanonicalForm bufF= F;
3419#ifdef HAVE_FLINT
3420        reconstructionTry (result, bufF, factors, degree (F) + 1, factorsFound2,
3421                           factorsFoundIndex, FLINTN, false
3422                          );
3423        if (result.length() == nmod_mat_ncols (FLINTN))
3424        {
3425          nmod_mat_clear (FLINTN);
3426#else
3427        reconstructionTry (result, bufF, factors, degree (F) + 1, factorsFound2,
3428                           factorsFoundIndex, NTLN, false
3429                          );
3430        if (result.length() == NTLN.NumCols())
3431        {
3432#endif
3433          delete [] factorsFoundIndex;
3434          delete [] A;
3435          delete [] bounds;
3436          F= 1;
3437          return result;
3438        }
3439        delete [] factorsFoundIndex;
3440      }
3441      else if (l == precision)
3442      {
3443        CanonicalForm bufF= F;
3444#ifdef HAVE_FLINT
3445        int * zeroOne= extractZeroOneVecs (FLINTN);
3446        CFList result= reconstruction (bufF,factors,zeroOne,precision,FLINTN);
3447        nmod_mat_clear (FLINTN);
3448#else
3449        int * zeroOne= extractZeroOneVecs (NTLN);
3450        CFList result= reconstruction (bufF, factors, zeroOne, precision, NTLN);
3451#endif
3452        F= bufF;
3453        delete [] zeroOne;
3454        delete [] A;
3455        delete [] bounds;
3456        return result;
3457      }
3458    }
3459    oldL2= l;
3460    l += stepSize;
3461    stepSize *= 2;
3462    if (l > precision)
3463    {
3464      if (!hitBound)
3465      {
3466        l= precision;
3467        hitBound= true;
3468      }
3469      else
3470        break;
3471    }
3472  }
3473#ifdef HAVE_FLINT
3474  nmod_mat_clear (FLINTN);
3475#endif
3476  delete [] bounds;
3477  delete [] A;
3478  return CFList();
3479}
3480
3481CFList
3482increasePrecision (CanonicalForm& F, CFList& factors, int factorsFound,
3483                   int oldNumCols, int oldL, const Variable&,
3484                   int precision
3485                  )
3486{
3487  int d;
3488  bool isIrreducible= false;
3489  int* bounds= computeBounds (F, d, isIrreducible);
3490  if (isIrreducible)
3491  {
3492    delete [] bounds;
3493    CanonicalForm G= F;
3494    F= 1;
3495    return CFList (G);
3496  }
3497  CFArray * A= new CFArray [factors.length()];
3498  CFArray bufQ= CFArray (factors.length());
3499  mat_zz_pE NTLN;
3500  ident (NTLN, factors.length());
3501  int minBound= bounds[0];
3502  for (int i= 1; i < d; i++)
3503  {
3504    if (bounds[i] != 0)
3505      minBound= tmin (minBound, bounds[i]);
3506  }
3507  int l= tmax (2*(minBound + 1), oldL);
3508  int oldL2= l/2;
3509  int stepSize= 2;
3510  bool useOldQs= false;
3511  bool hitBound= false;
3512  CFListIterator j;
3513  CFMatrix C;
3514  mat_zz_pE* NTLC, NTLK;
3515  CFArray buf;
3516  Variable y= F.mvar();
3517  CanonicalForm truncF;
3518  while (l <= precision)
3519  {
3520    j= factors;
3521    truncF= mod (F, power (y,l));
3522    if (useOldQs)
3523    {
3524      for (int i= 0; i < factors.length(); i++, j++)
3525        A[i]= logarithmicDerivative (truncF, j.getItem(), l, oldL2, bufQ[i],
3526                                     bufQ[i]
3527                                    );
3528    }
3529    else
3530    {
3531      for (int i= 0; i < factors.length(); i++, j++)
3532        A[i]= logarithmicDerivative (truncF, j.getItem(), l, bufQ [i]);
3533    }
3534    useOldQs= true;
3535    for (int i= 0; i < d; i++)
3536    {
3537      if (bounds [i] + 1 <= l/2)
3538      {
3539        int k= tmin (bounds [i] + 1, l/2);
3540        C= CFMatrix (l - k, factors.length());
3541        for (int ii= 0; ii < factors.length(); ii++)
3542        {
3543          if (A[ii].size() - 1 >= i)
3544          {
3545            buf= getCoeffs (A[ii] [i], k);
3546            writeInMatrix (C, buf, ii + 1, 0);
3547          }
3548        }
3549        NTLC= convertFacCFMatrix2NTLmat_zz_pE(C);
3550        NTLK= (*NTLC)*NTLN;
3551        transpose (NTLK, NTLK);
3552        kernel (NTLK, NTLK);
3553        transpose (NTLK, NTLK);
3554        NTLN *= NTLK;
3555        if (NTLN.NumCols() == 1)
3556        {
3557          delete [] A;
3558          delete [] bounds;
3559          CanonicalForm G= F;
3560          F= 1;
3561          return CFList (G);
3562        }
3563      }
3564    }
3565
3566    if (NTLN.NumCols() < oldNumCols - factorsFound)
3567    {
3568      if (isReduced (NTLN))
3569      {
3570        int * factorsFoundIndex= new int [NTLN.NumCols()];
3571        for (long i= 0; i < NTLN.NumCols(); i++)
3572          factorsFoundIndex[i]= 0;
3573        int factorsFound2= 0;
3574        CFList result;
3575        CanonicalForm bufF= F;
3576        reconstructionTry (result, bufF, factors, degree (F) + 1, factorsFound2,
3577                           factorsFoundIndex, NTLN, false);
3578        if (result.length() == NTLN.NumCols())
3579        {
3580          delete [] factorsFoundIndex;
3581          delete [] A;
3582          delete [] bounds;
3583          F= 1;
3584          return result;
3585        }
3586        delete [] factorsFoundIndex;
3587      }
3588      else if (l == precision)
3589      {
3590        CanonicalForm bufF= F;
3591        int * zeroOne= extractZeroOneVecs (NTLN);
3592        CFList result= reconstruction (bufF, factors, zeroOne, precision, NTLN);
3593        F= bufF;
3594        delete [] zeroOne;
3595        delete [] A;
3596        delete [] bounds;
3597        return result;
3598      }
3599    }
3600    oldL2= l;
3601    l += stepSize;
3602    stepSize *= 2;
3603    if (l > precision)
3604    {
3605      if (!hitBound)
3606      {
3607        l= precision;
3608        hitBound= true;
3609      }
3610      else
3611        break;
3612    }
3613  }
3614  delete [] bounds;
3615  delete [] A;
3616  return CFList();
3617}
3618
3619//over field extension
3620CFList
3621extIncreasePrecision (CanonicalForm& F, CFList& factors, int factorsFound,
3622                      int oldNumCols, int oldL, const CanonicalForm& evaluation,
3623                      const ExtensionInfo& info, CFList& source, CFList& dest,
3624                      int precision
3625                     )
3626{
3627  bool GF= (CFFactory::gettype()==GaloisFieldDomain);
3628  int degMipo= degree (getMipo (info.getAlpha()));
3629  Variable alpha= info.getAlpha();
3630  int d;
3631  bool isIrreducible= false;
3632  int* bounds= computeBounds (F, d, isIrreducible);
3633  if (isIrreducible)
3634  {
3635    delete [] bounds;
3636    Variable y= Variable (2);
3637    CanonicalForm tmp= F (y - evaluation, y);
3638    CFList source, dest;
3639    tmp= mapDown (tmp, info, source, dest);
3640    F= 1;
3641    return CFList (tmp);
3642  }
3643
3644  CFArray * A= new CFArray [factors.length()];
3645  CFArray bufQ= CFArray (factors.length());
3646  if (fac_NTL_char != getCharacteristic())
3647  {
3648    fac_NTL_char= getCharacteristic();
3649    zz_p::init (getCharacteristic());
3650  }
3651  mat_zz_p NTLN;
3652  ident (NTLN, factors.length());
3653  int minBound= bounds[0];
3654  for (int i= 1; i < d; i++)
3655  {
3656    if (bounds[i] != 0)
3657      minBound= tmin (minBound, bounds[i]);
3658  }
3659  int l= tmax (oldL, 2*((minBound+1)/degMipo+1));
3660  int oldL2= l/2;
3661  int stepSize= 2;
3662  bool useOldQs= false;
3663  bool hitBound= false;
3664  Variable gamma= info.getBeta();
3665  CanonicalForm primElemAlpha= info.getGamma();
3666  CanonicalForm imPrimElemAlpha= info.getDelta();
3667  CFListIterator j;
3668  Variable y= F.mvar();
3669  CanonicalForm powX, imBasis, truncF;
3670  CFMatrix Mat, C;
3671  CFIterator iter;
3672  mat_zz_p* NTLMat,*NTLC, NTLK;
3673  CFArray buf;
3674  while (l <= precision)
3675  {
3676    j= factors;
3677    if (GF)
3678      setCharacteristic (getCharacteristic());
3679    powX= power (y-gamma, l);
3680    Mat= CFMatrix (l*degMipo, l*degMipo);
3681    for (int i= 0; i < l*degMipo; i++)
3682    {
3683      imBasis= mod (power (y, i), powX);
3684      imBasis= imBasis (power (y, degMipo), y);
3685      imBasis= imBasis (y, gamma);
3686      iter= imBasis;
3687      for (; iter.hasTerms(); iter++)
3688          Mat (iter.exp()+ 1, i+1)= iter.coeff();
3689    }
3690
3691    NTLMat= convertFacCFMatrix2NTLmat_zz_p (Mat);
3692    *NTLMat= inv (*NTLMat);
3693    if (GF)
3694      setCharacteristic (getCharacteristic(), degMipo, info.getGFName());
3695
3696    truncF= mod (F, power (y, l));
3697    if (useOldQs)
3698    {
3699      for (int i= 0; i < factors.length(); i++, j++)
3700        A[i]= logarithmicDerivative (truncF, j.getItem(), l, oldL2, bufQ[i],
3701                                     bufQ[i]
3702                                    );
3703    }
3704    else
3705    {
3706      for (int i= 0; i < factors.length(); i++, j++)
3707        A[i]= logarithmicDerivative (truncF, j.getItem(), l, bufQ [i]);
3708    }
3709    useOldQs= true;
3710    for (int i= 0; i < d; i++)
3711    {
3712      if (bounds [i] + 1 <= (l/2)*degMipo)
3713      {
3714        int k= tmin (bounds [i] + 1, (l/2)*degMipo);
3715        C= CFMatrix (l*degMipo - k, factors.length());
3716        for (int ii= 0; ii < factors.length(); ii++)
3717        {
3718          if (A[ii].size() - 1 >= i)
3719          {
3720            if (GF)
3721            {
3722              A[ii] [i]= A [ii] [i] (y-evaluation, y);
3723              setCharacteristic (getCharacteristic());
3724              A[ii] [i]= GF2FalphaRep (A[ii] [i], alpha);
3725              if (alpha != gamma)
3726                A [ii] [i]= mapDown (A[ii] [i], imPrimElemAlpha, primElemAlpha,
3727                                     gamma, source, dest
3728                                    );
3729              buf= getCoeffs (A[ii] [i], k, l, degMipo, gamma, 0, *NTLMat);
3730            }
3731            else
3732            {
3733              A [ii] [i]= A [ii] [i] (y-evaluation, y);
3734              if (alpha != gamma)
3735                A[ii] [i]= mapDown (A[ii] [i], imPrimElemAlpha, primElemAlpha,
3736                                    gamma, source, dest
3737                                   );
3738              buf= getCoeffs (A[ii] [i], k, l, degMipo, gamma, 0, *NTLMat);
3739            }
3740            writeInMatrix (C, buf, ii + 1, 0);
3741          }
3742          if (GF)
3743            setCharacteristic (getCharacteristic(), degMipo, info.getGFName());
3744        }
3745
3746        if (GF)
3747          setCharacteristic(getCharacteristic());
3748
3749        NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
3750        NTLK= (*NTLC)*NTLN;
3751        transpose (NTLK, NTLK);
3752        kernel (NTLK, NTLK);
3753        transpose (NTLK, NTLK);
3754        NTLN *= NTLK;
3755
3756        if (GF)
3757          setCharacteristic (getCharacteristic(), degMipo, info.getGFName());
3758
3759        if (NTLN.NumCols() == 1)
3760        {
3761          Variable y= Variable (2);
3762          CanonicalForm tmp= F (y - evaluation, y);
3763          CFList source, dest;
3764          tmp= mapDown (tmp, info, source, dest);
3765          delete [] A;
3766          delete [] bounds;
3767          F= 1;
3768          return CFList (tmp);
3769        }
3770      }
3771    }
3772
3773    if (NTLN.NumCols() < oldNumCols - factorsFound)
3774    {
3775      if (isReduced (NTLN))
3776      {
3777        int * factorsFoundIndex= new int [NTLN.NumCols()];
3778        for (long i= 0; i < NTLN.NumCols(); i++)
3779          factorsFoundIndex[i]= 0;
3780        int factorsFound2= 0;
3781        CFList result;
3782        CanonicalForm bufF= F;
3783        extReconstructionTry (result, bufF, factors,degree (F)+1, factorsFound2,
3784                              factorsFoundIndex, NTLN, false, info, evaluation
3785                             );
3786        if (result.length() == NTLN.NumCols())
3787        {
3788          delete [] factorsFoundIndex;
3789          delete [] A;
3790          delete [] bounds;
3791          F= 1;
3792          return result;
3793        }
3794        delete [] factorsFoundIndex;
3795      }
3796      else if (l == precision)
3797      {
3798        CanonicalForm bufF= F;
3799        int * zeroOne= extractZeroOneVecs (NTLN);
3800        CFList result= extReconstruction (bufF, factors, zeroOne, precision,
3801                                          NTLN, info, evaluation
3802                                         );
3803        F= bufF;
3804        delete [] zeroOne;
3805        delete [] A;
3806        delete [] bounds;
3807        return result;
3808      }
3809    }
3810    oldL2= l;
3811    l += stepSize;
3812    stepSize *= 2;
3813    if (l > precision)
3814    {
3815      if (!hitBound)
3816      {
3817        hitBound= true;
3818        l= precision;
3819      }
3820      else
3821        break;
3822    }
3823  }
3824  delete [] bounds;
3825  delete [] A;
3826  return CFList();
3827}
3828
3829CFList
3830increasePrecision2 (const CanonicalForm& F, CFList& factors,
3831                    const Variable& alpha, int precision)
3832{
3833  int d;
3834  bool isIrreducible= false;
3835  int* bounds= computeBounds (F, d, isIrreducible);
3836  if (isIrreducible)
3837  {
3838    delete [] bounds;
3839    return CFList (F);
3840  }
3841  CFArray * A= new CFArray [factors.length()];
3842  CFArray bufQ= CFArray (factors.length());
3843  if (fac_NTL_char != getCharacteristic())
3844  {
3845    fac_NTL_char= getCharacteristic();
3846    zz_p::init (getCharacteristic());
3847  }
3848  zz_pX NTLMipo= convertFacCF2NTLzzpX (getMipo (alpha));
3849  zz_pE::init (NTLMipo);
3850  mat_zz_pE NTLN;
3851  ident (NTLN, factors.length());
3852  int minBound= bounds[0];
3853  for (int i= 1; i < d; i++)
3854  {
3855    if (bounds[i] != 0)
3856      minBound= tmin (minBound, bounds[i]);
3857  }
3858  int l= tmin (2*(minBound + 1), precision);
3859  int oldL= l/2;
3860  int stepSize= 2;
3861  bool useOldQs= false;
3862  bool hitBound= false;
3863  CFListIterator j;
3864  CFMatrix C;
3865  CFArray buf;
3866  mat_zz_pE* NTLC, NTLK;
3867  Variable y= F.mvar();
3868  CanonicalForm truncF;
3869  while (l <= precision)
3870  {
3871    j= factors;
3872    truncF= mod (F, power (y, l));
3873    if (useOldQs)
3874    {
3875      for (int i= 0; i < factors.length(); i++, j++)
3876        A[i]= logarithmicDerivative (truncF, j.getItem(), l, oldL, bufQ[i], bufQ[i]);
3877    }
3878    else
3879    {
3880      for (int i= 0; i < factors.length(); i++, j++)
3881        A[i]= logarithmicDerivative (truncF, j.getItem(), l, bufQ [i]);
3882    }
3883    useOldQs= true;
3884    for (int i= 0; i < d; i++)
3885    {
3886      if (bounds [i] + 1 <= l/2)
3887      {
3888        int k= tmin (bounds [i] + 1, l/2);
3889        C= CFMatrix (l - k, factors.length());
3890        for (int ii= 0; ii < factors.length(); ii++)
3891        {
3892          if (A[ii].size() - 1 >= i)
3893          {
3894            buf= getCoeffs (A[ii] [i], k);
3895            writeInMatrix (C, buf, ii + 1, 0);
3896          }
3897        }
3898        NTLC= convertFacCFMatrix2NTLmat_zz_pE(C);
3899        NTLK= (*NTLC)*NTLN;
3900        transpose (NTLK, NTLK);
3901        kernel (NTLK, NTLK);
3902        transpose (NTLK, NTLK);
3903        NTLN *= NTLK;
3904        if (NTLN.NumCols() == 1)
3905        {
3906          delete [] A;
3907          delete [] bounds;
3908          return CFList (F);
3909        }
3910      }
3911    }
3912
3913    if (isReduced (NTLN) || l == precision)
3914    {
3915      CanonicalForm bufF= F;
3916      int * zeroOne= extractZeroOneVecs (NTLN);
3917      CFList bufFactors= factors;
3918      CFList result= monicReconstruction (bufF, factors, zeroOne, precision,
3919                                          NTLN
3920                                         );
3921      if (result.length() != NTLN.NumCols() && l != precision)
3922        factors= bufFactors;
3923      if (result.length() == NTLN.NumCols())
3924      {
3925        delete [] zeroOne;
3926        delete [] A;
3927        delete [] bounds;
3928        return result;
3929      }
3930      if (l == precision)
3931      {
3932        delete [] zeroOne;
3933        delete [] A;
3934        delete [] bounds;
3935        return Union (result, factors);
3936      }
3937    }
3938    oldL= l;
3939    l += stepSize;
3940    stepSize *= 2;
3941    if (l > precision)
3942    {
3943      if (!hitBound)
3944      {
3945        l= precision;
3946        hitBound= true;
3947      }
3948      else
3949        break;
3950    }
3951  }
3952  delete [] bounds;
3953  delete [] A;
3954  return CFList();
3955}
3956
3957CFList
3958increasePrecisionFq2Fp (CanonicalForm& F, CFList& factors, int factorsFound,
3959                        int oldNumCols, int oldL, const Variable& alpha,
3960                        int precision
3961                       )
3962{
3963  int d;
3964  bool isIrreducible= false;
3965  int* bounds= computeBounds (F, d, isIrreducible);
3966  if (isIrreducible)
3967  {
3968    delete [] bounds;
3969    CanonicalForm G= F;
3970    F= 1;
3971    return CFList (G);
3972  }
3973  int extensionDeg= degree (getMipo (alpha));
3974  CFArray * A= new CFArray [factors.length()];
3975  CFArray bufQ= CFArray (factors.length());
3976#ifdef HAVE_FLINT
3977  nmod_mat_t FLINTN;
3978  nmod_mat_init (FLINTN,factors.length(),factors.length(), getCharacteristic());
3979  for (long i=factors.length()-1; i >= 0; i--)
3980    nmod_mat_entry (FLINTN, i, i)= 1;
3981#else
3982  mat_zz_p NTLN;
3983  ident (NTLN, factors.length());
3984#endif
3985  int minBound= bounds[0];
3986  for (int i= 1; i < d; i++)
3987  {
3988    if (bounds[i] != 0)
3989      minBound= tmin (minBound, bounds[i]);
3990  }
3991  int l= tmax (2*(minBound + 1), oldL);
3992  int oldL2= l/2;
3993  int stepSize= 2;
3994  bool useOldQs= false;
3995  bool hitBound= false;
3996  CFListIterator j;
3997  CFMatrix C;
3998#ifdef HAVE_FLINT
3999  long rank;
4000  nmod_mat_t FLINTC, FLINTK, null;
4001#else
4002  mat_zz_p* NTLC, NTLK;
4003#endif
4004  CFArray buf;
4005  Variable y= F.mvar();
4006  CanonicalForm truncF;
4007  while (l <= precision)
4008  {
4009    j= factors;
4010    truncF= mod (F, power (y, l));
4011    if (useOldQs)
4012    {
4013      for (int i= 0; i < factors.length(); i++, j++)
4014        A[i]= logarithmicDerivative (truncF, j.getItem(), l, oldL2, bufQ[i],
4015                                     bufQ[i]
4016                                    );
4017    }
4018    else
4019    {
4020      for (int i= 0; i < factors.length(); i++, j++)
4021        A[i]= logarithmicDerivative (truncF, j.getItem(), l, bufQ [i]);
4022    }
4023    useOldQs= true;
4024    for (int i= 0; i < d; i++)
4025    {
4026      if (bounds [i] + 1 <= l/2)
4027      {
4028        int k= tmin (bounds [i] + 1, l/2);
4029        C= CFMatrix ((l - k)*extensionDeg, factors.length());
4030        for (int ii= 0; ii < factors.length(); ii++)
4031        {
4032          if (A[ii].size() - 1 >= i)
4033          {
4034            buf= getCoeffs (A[ii] [i], k, alpha);
4035            writeInMatrix (C, buf, ii + 1, 0);
4036          }
4037        }
4038#ifdef HAVE_FLINT
4039        convertFacCFMatrix2nmod_mat_t (FLINTC, C);
4040        nmod_mat_init (FLINTK, nmod_mat_nrows (FLINTC), nmod_mat_ncols (FLINTN),
4041                       getCharacteristic());
4042        nmod_mat_mul (FLINTK, FLINTC, FLINTN);
4043        nmod_mat_init (null, nmod_mat_ncols (FLINTK), nmod_mat_ncols (FLINTK),
4044                       getCharacteristic());
4045        rank= nmod_mat_nullspace (null, FLINTK);
4046        nmod_mat_clear (FLINTK);
4047        nmod_mat_window_init (FLINTK, null, 0, 0, nmod_mat_nrows(null), rank);
4048        nmod_mat_clear (FLINTC);
4049        nmod_mat_init_set (FLINTC, FLINTN);
4050        nmod_mat_clear (FLINTN);
4051        nmod_mat_init (FLINTN, nmod_mat_nrows (FLINTC), nmod_mat_ncols (FLINTK),
4052                       getCharacteristic());
4053        nmod_mat_mul (FLINTN, FLINTC, FLINTK); //no aliasing allowed!!
4054
4055        nmod_mat_clear (FLINTC);
4056        nmod_mat_window_clear (FLINTK);
4057        nmod_mat_clear (null);
4058#else
4059        NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
4060        NTLK= (*NTLC)*NTLN;
4061        transpose (NTLK, NTLK);
4062        kernel (NTLK, NTLK);
4063        transpose (NTLK, NTLK);
4064        NTLN *= NTLK;
4065#endif
4066#ifdef HAVE_FLINT
4067        if (nmod_mat_ncols (FLINTN) == 1)
4068        {
4069          nmod_mat_clear (FLINTN);
4070#else
4071        if (NTLN.NumCols() == 1)
4072        {
4073#endif
4074          delete [] A;
4075          delete [] bounds;
4076          CanonicalForm G= F;
4077          F= 1;
4078          return CFList (G);
4079        }
4080      }
4081    }
4082
4083#ifdef HAVE_FLINT
4084    if (nmod_mat_ncols (FLINTN) < oldNumCols - factorsFound)
4085    {
4086      if (isReduced (FLINTN))
4087      {
4088        int * factorsFoundIndex= new int [nmod_mat_ncols (FLINTN)];
4089        for (long i= 0; i < nmod_mat_ncols (FLINTN); i++)
4090#else
4091    if (NTLN.NumCols() < oldNumCols - factorsFound)
4092    {
4093      if (isReduced (NTLN))
4094      {
4095        int * factorsFoundIndex= new int [NTLN.NumCols()];
4096        for (long i= 0; i < NTLN.NumCols(); i++)
4097#endif
4098          factorsFoundIndex[i]= 0;
4099        int factorsFound2= 0;
4100        CFList result;
4101        CanonicalForm bufF= F;
4102#ifdef HAVE_FLINT
4103        reconstructionTry (result, bufF, factors, degree (F) + 1, factorsFound2,
4104                           factorsFoundIndex, FLINTN, false
4105                          );
4106        if (result.length() == nmod_mat_ncols (FLINTN))
4107        {
4108          nmod_mat_clear (FLINTN);
4109#else
4110        reconstructionTry (result, bufF, factors, degree (F) + 1, factorsFound2,
4111                           factorsFoundIndex, NTLN, false
4112                          );
4113        if (result.length() == NTLN.NumCols())
4114        {
4115#endif
4116          delete [] factorsFoundIndex;
4117          delete [] A;
4118          delete [] bounds;
4119          F= 1;
4120          return result;
4121        }
4122        delete [] factorsFoundIndex;
4123      }
4124      else if (l == precision)
4125      {
4126        CanonicalForm bufF= F;
4127#ifdef HAVE_FLINT
4128        int * zeroOne= extractZeroOneVecs (FLINTN);
4129        CFList result= reconstruction (bufF,factors,zeroOne,precision,FLINTN);
4130        nmod_mat_clear (FLINTN);
4131#else
4132        int * zeroOne= extractZeroOneVecs (NTLN);
4133        CFList result= reconstruction (bufF, factors, zeroOne, precision, NTLN);
4134#endif
4135        F= bufF;
4136        delete [] zeroOne;
4137        delete [] A;
4138        delete [] bounds;
4139        return result;
4140      }
4141    }
4142    oldL2= l;
4143    l += stepSize;
4144    stepSize *= 2;
4145    if (l > precision)
4146    {
4147      if (!hitBound)
4148      {
4149        hitBound= true;
4150        l= precision;
4151      }
4152      else
4153        break;
4154    }
4155  }
4156#ifdef HAVE_FLINT
4157  nmod_mat_clear (FLINTN);
4158#endif
4159  delete [] bounds;
4160  delete [] A;
4161  return CFList();
4162}
4163
4164#ifdef HAVE_FLINT
4165CFList
4166increasePrecision (CanonicalForm& F, CFList& factors, int oldL, int
4167                   l, int d, int* bounds, CFArray& bufQ, nmod_mat_t FLINTN
4168                  )
4169#else
4170CFList
4171increasePrecision (CanonicalForm& F, CFList& factors, int oldL, int
4172                   l, int d, int* bounds, CFArray& bufQ, mat_zz_p& NTLN
4173                  )
4174#endif
4175{
4176  CFList result= CFList();
4177  CFArray * A= new CFArray [factors.length()];
4178  int oldL2= oldL/2;
4179  bool hitBound= false;
4180#ifdef HAVE_FLINT
4181  if (nmod_mat_nrows (FLINTN) != factors.length()) //refined factors
4182  {
4183    nmod_mat_clear (FLINTN);
4184    nmod_mat_init(FLINTN,factors.length(),factors.length(),getCharacteristic());
4185    for (long i=factors.length()-1; i >= 0; i--)
4186      nmod_mat_entry (FLINTN, i, i)= 1;
4187    bufQ= CFArray (factors.length());
4188  }
4189#else
4190  if (NTLN.NumRows() != factors.length()) //refined factors
4191  {
4192    ident (NTLN, factors.length());
4193    bufQ= CFArray (factors.length());
4194  }
4195#endif
4196  bool useOldQs= false;
4197  CFListIterator j;
4198  CFMatrix C;
4199  CFArray buf;
4200#ifdef HAVE_FLINT
4201  long rank;
4202  nmod_mat_t FLINTC, FLINTK, null;
4203#else
4204  mat_zz_p* NTLC, NTLK;
4205#endif
4206  CanonicalForm bufF, truncF;
4207  CFList bufUniFactors;
4208  Variable y= F.mvar();
4209  while (oldL <= l)
4210  {
4211    j= factors;
4212    truncF= mod (F, power (y, oldL));
4213    if (useOldQs)
4214    {
4215      for (int i= 0; i < factors.length(); i++, j++)
4216        A[i]= logarithmicDerivative (truncF, j.getItem(), oldL, oldL2, bufQ[i],
4217                                     bufQ[i]
4218                                    );
4219    }
4220    else
4221    {
4222      for (int i= 0; i < factors.length(); i++, j++)
4223        A[i]= logarithmicDerivative (truncF, j.getItem(), oldL, bufQ [i]);
4224    }
4225    useOldQs= true;
4226
4227    for (int i= 0; i < d; i++)
4228    {
4229      if (bounds [i] + 1 <= oldL/2)
4230      {
4231        int k= tmin (bounds [i] + 1, oldL/2);
4232        C= CFMatrix (oldL - k, factors.length());
4233        for (int ii= 0; ii < factors.length(); ii++)
4234        {
4235          if (A[ii].size() - 1 >= i)
4236          {
4237            buf= getCoeffs (A[ii] [i], k);
4238            writeInMatrix (C, buf, ii + 1, 0);
4239          }
4240        }
4241#ifdef HAVE_FLINT
4242        convertFacCFMatrix2nmod_mat_t (FLINTC, C);
4243        nmod_mat_init (FLINTK, nmod_mat_nrows (FLINTC), nmod_mat_ncols (FLINTN),
4244                       getCharacteristic());
4245        nmod_mat_mul (FLINTK, FLINTC, FLINTN);
4246        nmod_mat_init (null, nmod_mat_ncols (FLINTK), nmod_mat_ncols (FLINTK),
4247                       getCharacteristic());
4248        rank= nmod_mat_nullspace (null, FLINTK);
4249        nmod_mat_clear (FLINTK);
4250        nmod_mat_window_init (FLINTK, null, 0, 0, nmod_mat_nrows(null), rank);
4251        nmod_mat_clear (FLINTC);
4252        nmod_mat_init_set (FLINTC, FLINTN);
4253        nmod_mat_clear (FLINTN);
4254        nmod_mat_init (FLINTN, nmod_mat_nrows (FLINTC), nmod_mat_ncols (FLINTK),
4255                       getCharacteristic());
4256        nmod_mat_mul (FLINTN, FLINTC, FLINTK); //no aliasing allowed!!
4257
4258        nmod_mat_clear (FLINTC);
4259        nmod_mat_window_clear (FLINTK);
4260        nmod_mat_clear (null);
4261#else
4262        NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
4263        NTLK= (*NTLC)*NTLN;
4264        transpose (NTLK, NTLK);
4265        kernel (NTLK, NTLK);
4266        transpose (NTLK, NTLK);
4267        NTLN *= NTLK;
4268#endif
4269#ifdef HAVE_FLINT
4270        if (nmod_mat_ncols (FLINTN) == 1)
4271#else
4272        if (NTLN.NumCols() == 1)
4273#endif
4274        {
4275          delete [] A;
4276          return CFList (F);
4277        }
4278      }
4279    }
4280#ifdef HAVE_FLINT
4281    if (nmod_mat_ncols (FLINTN) == 1)
4282#else
4283    if (NTLN.NumCols() == 1)
4284#endif
4285    {
4286      delete [] A;
4287      return CFList (F);
4288    }
4289    int * zeroOneVecs;
4290#ifdef HAVE_FLINT
4291    zeroOneVecs= extractZeroOneVecs (FLINTN);
4292#else
4293    zeroOneVecs= extractZeroOneVecs (NTLN);
4294#endif
4295    bufF= F;
4296    bufUniFactors= factors;
4297#ifdef HAVE_FLINT
4298    result= reconstruction (bufF, bufUniFactors, zeroOneVecs, oldL, FLINTN);
4299#else
4300    result= reconstruction (bufF, bufUniFactors, zeroOneVecs, oldL, NTLN);
4301#endif
4302    delete [] zeroOneVecs;
4303    if (degree (bufF) + 1 + degree (LC (bufF, 1)) < oldL && result.length() > 0)
4304    {
4305      F= bufF;
4306      factors= bufUniFactors;
4307      delete [] A;
4308      return result;
4309    }
4310
4311    result= CFList();
4312    oldL2= oldL;
4313    oldL *= 2;
4314    if (oldL > l)
4315    {
4316      if (!hitBound)
4317      {
4318        oldL= l;
4319        hitBound= true;
4320      }
4321      else
4322        break;
4323    }
4324  }
4325  delete [] A;
4326  return result;
4327}
4328
4329CFList
4330increasePrecision (CanonicalForm& F, CFList& factors, int oldL, int
4331                   l, int d, int* bounds, CFArray& bufQ, mat_zz_pE& NTLN
4332                  )
4333{
4334  CFList result= CFList();
4335  CFArray * A= new CFArray [factors.length()];
4336  int oldL2= oldL/2;
4337  bool hitBound= false;
4338  bool useOldQs= false;
4339  if (NTLN.NumRows() != factors.length()) //refined factors
4340    ident (NTLN, factors.length());
4341  CFListIterator j;
4342  CFMatrix C;
4343  CFArray buf;
4344  mat_zz_pE* NTLC, NTLK;
4345  CanonicalForm bufF, truncF;
4346  CFList bufUniFactors;
4347  Variable y= F.mvar();
4348  while (oldL <= l)
4349  {
4350    j= factors;
4351    truncF= mod (F, power (y, oldL));
4352    if (useOldQs)
4353    {
4354      for (int i= 0; i < factors.length(); i++, j++)
4355        A[i]= logarithmicDerivative (truncF, j.getItem(), oldL, oldL2, bufQ[i],
4356                                     bufQ[i]
4357                                    );
4358    }
4359    else
4360    {
4361      for (int i= 0; i < factors.length(); i++, j++)
4362        A[i]= logarithmicDerivative (truncF, j.getItem(), oldL, bufQ [i]);
4363    }
4364    useOldQs= true;
4365
4366    for (int i= 0; i < d; i++)
4367    {
4368      if (bounds [i] + 1 <= oldL/2)
4369      {
4370        int k= tmin (bounds [i] + 1, oldL/2);
4371        C= CFMatrix (oldL - k, factors.length());
4372        for (int ii= 0; ii < factors.length(); ii++)
4373        {
4374          if (A[ii].size() - 1 >= i)
4375          {
4376            buf= getCoeffs (A[ii] [i], k);
4377            writeInMatrix (C, buf, ii + 1, 0);
4378          }
4379        }
4380        NTLC= convertFacCFMatrix2NTLmat_zz_pE(C);
4381        NTLK= (*NTLC)*NTLN;
4382        transpose (NTLK, NTLK);
4383        kernel (NTLK, NTLK);
4384        transpose (NTLK, NTLK);
4385        NTLN *= NTLK;
4386        if (NTLN.NumCols() == 1)
4387        {
4388          delete [] A;
4389          return CFList (F);
4390        }
4391      }
4392    }
4393    if (NTLN.NumCols() == 1)
4394    {
4395      delete [] A;
4396      return CFList (F);
4397    }
4398
4399    int * zeroOneVecs;
4400    zeroOneVecs= extractZeroOneVecs (NTLN);
4401    bufF= F;
4402    bufUniFactors= factors;
4403    result= reconstruction (bufF, bufUniFactors, zeroOneVecs, oldL, NTLN);
4404    delete [] zeroOneVecs;
4405    if (degree (bufF) + 1 + degree (LC (bufF, 1)) < l && result.length() > 0)
4406    {
4407      F= bufF;
4408      factors= bufUniFactors;
4409      delete [] A;
4410      return result;
4411    }
4412
4413    result= CFList();
4414    oldL2= oldL;
4415    oldL *= 2;
4416    if (oldL > l)
4417    {
4418      if (!hitBound)
4419      {
4420        oldL= l;
4421        hitBound= true;
4422      }
4423      else
4424        break;
4425    }
4426  }
4427  delete [] A;
4428  return result;
4429}
4430
4431//over field extension
4432CFList
4433extIncreasePrecision (CanonicalForm& F, CFList& factors, int oldL, int l, int d,
4434                      int* bounds, CFArray& bufQ, mat_zz_p& NTLN, const
4435                      CanonicalForm& evaluation, const ExtensionInfo& info,
4436                      CFList& source, CFList& dest
4437                     )
4438{
4439  CFList result= CFList();
4440  CFArray * A= new CFArray [factors.length()];
4441  int oldL2= oldL/2; //be careful
4442  bool hitBound= false;
4443  bool useOldQs= false;
4444  bool GF= (CFFactory::gettype()==GaloisFieldDomain);
4445  int degMipo= degree (getMipo (info.getAlpha()));
4446  Variable alpha= info.getAlpha();
4447
4448  Variable gamma= info.getBeta();
4449  CanonicalForm primElemAlpha= info.getGamma();
4450  CanonicalForm imPrimElemAlpha= info.getDelta();
4451  if (NTLN.NumRows() != factors.length()) //refined factors
4452    ident (NTLN, factors.length());
4453  Variable y= F.mvar();
4454  CFListIterator j;
4455  CanonicalForm powX, imBasis, bufF, truncF;
4456  CFMatrix Mat, C;
4457  CFIterator iter;
4458  mat_zz_p* NTLMat;
4459  CFArray buf;
4460  mat_zz_p* NTLC, NTLK;
4461  CFList bufUniFactors;
4462  while (oldL <= l)
4463  {
4464    j= factors;
4465    if (GF)
4466      setCharacteristic (getCharacteristic());
4467
4468    powX= power (y-gamma, oldL);
4469    Mat= CFMatrix (oldL*degMipo, oldL*degMipo);
4470    for (int i= 0; i < oldL*degMipo; i++)
4471    {
4472      imBasis= mod (power (y, i), powX);
4473      imBasis= imBasis (power (y, degMipo), y);
4474      imBasis= imBasis (y, gamma);
4475      iter= imBasis;
4476      for (; iter.hasTerms(); iter++)
4477        Mat (iter.exp()+ 1, i+1)= iter.coeff();
4478    }
4479
4480    NTLMat= convertFacCFMatrix2NTLmat_zz_p (Mat);
4481    *NTLMat= inv (*NTLMat);
4482    if (GF)
4483      setCharacteristic (getCharacteristic(), degMipo, info.getGFName());
4484
4485    truncF= mod (F, power (y, oldL));
4486    if (useOldQs)
4487    {
4488      for (int i= 0; i < factors.length(); i++, j++)
4489        A[i]= logarithmicDerivative (truncF, j.getItem(), oldL, oldL2, bufQ[i],
4490                                     bufQ[i]);
4491    }
4492    else
4493    {
4494      for (int i= 0; i < factors.length(); i++, j++)
4495        A[i]= logarithmicDerivative (truncF, j.getItem(), oldL, bufQ [i]);
4496    }
4497    useOldQs= true;
4498
4499    for (int i= 0; i < d; i++)
4500    {
4501      if (bounds [i] + 1 <= oldL/2)
4502      {
4503        int k= tmin (bounds [i] + 1, oldL/2);
4504        C= CFMatrix (oldL*degMipo - k, factors.length());
4505        for (int ii= 0; ii < factors.length(); ii++)
4506        {
4507          if (A[ii].size() - 1 >= i)
4508          {
4509            if (GF)
4510            {
4511              A [ii] [i]= A [ii] [i] (y-evaluation, y);
4512              setCharacteristic (getCharacteristic());
4513              A[ii] [i]= GF2FalphaRep (A[ii] [i], alpha);
4514              if (alpha != gamma)
4515                A [ii] [i]= mapDown (A[ii] [i], imPrimElemAlpha, primElemAlpha,
4516                                     gamma, source, dest
4517                                    );
4518              buf= getCoeffs (A[ii] [i], k, oldL, degMipo, gamma, 0, *NTLMat);
4519            }
4520            else
4521            {
4522              A [ii] [i]= A [ii] [i] (y-evaluation, y);
4523              if (alpha != gamma)
4524                A[ii] [i]= mapDown (A[ii] [i], imPrimElemAlpha, primElemAlpha,
4525                                    gamma, source, dest
4526                                   );
4527              buf= getCoeffs (A[ii] [i], k, oldL, degMipo, gamma, 0, *NTLMat);
4528            }
4529            writeInMatrix (C, buf, ii + 1, 0);
4530          }
4531          if (GF)
4532            setCharacteristic (getCharacteristic(), degMipo, info.getGFName());
4533        }
4534
4535        if (GF)
4536          setCharacteristic(getCharacteristic());
4537
4538        NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
4539        NTLK= (*NTLC)*NTLN;
4540        transpose (NTLK, NTLK);
4541        kernel (NTLK, NTLK);
4542        transpose (NTLK, NTLK);
4543        NTLN *= NTLK;
4544
4545        if (GF)
4546          setCharacteristic (getCharacteristic(), degMipo, info.getGFName());
4547
4548        if (NTLN.NumCols() == 1)
4549        {
4550          Variable y= Variable (2);
4551          CanonicalForm tmp= F (y - evaluation, y);
4552          CFList source, dest;
4553          tmp= mapDown (tmp, info, source, dest);
4554          delete [] A;
4555          return CFList (tmp);
4556        }
4557      }
4558    }
4559    if (NTLN.NumCols() == 1)
4560    {
4561      Variable y= Variable (2);
4562      CanonicalForm tmp= F (y - evaluation, y);
4563      CFList source, dest;
4564      tmp= mapDown (tmp, info, source, dest);
4565      delete [] A;
4566      return CFList (tmp);
4567    }
4568
4569    int * zeroOneVecs;
4570    zeroOneVecs= extractZeroOneVecs (NTLN);
4571    bufF= F;
4572    bufUniFactors= factors;
4573    result= extReconstruction (bufF, bufUniFactors, zeroOneVecs, oldL, NTLN,
4574                               info, evaluation
4575                              );
4576    delete [] zeroOneVecs;
4577    if (degree (bufF) + 1 + degree (LC (bufF, 1)) < l && result.length() > 0)
4578    {
4579      F= bufF;
4580      factors= bufUniFactors;
4581      return result;
4582    }
4583
4584    result= CFList();
4585    oldL2= oldL;
4586    oldL *= 2;
4587    if (oldL > l)
4588    {
4589      if (!hitBound)
4590      {
4591        oldL= l;
4592        hitBound= true;
4593      }
4594      else
4595        break;
4596    }
4597  }
4598  delete [] A;
4599  return result;
4600}
4601
4602#ifdef HAVE_FLINT
4603CFList
4604increasePrecisionFq2Fp (CanonicalForm& F, CFList& factors, int oldL, int l,
4605                        int d, int* bounds, CFArray& bufQ, nmod_mat_t FLINTN,
4606                        const Variable& alpha
4607                       )
4608#else
4609CFList
4610increasePrecisionFq2Fp (CanonicalForm& F, CFList& factors, int oldL, int l,
4611                        int d, int* bounds, CFArray& bufQ, mat_zz_p& NTLN,
4612                        const Variable& alpha
4613                       )
4614#endif
4615{
4616  CFList result= CFList();
4617  CFArray * A= new CFArray [factors.length()];
4618  int extensionDeg= degree (getMipo (alpha));
4619  int oldL2= oldL/2;
4620  bool hitBound= false;
4621  bool useOldQs= false;
4622#ifdef HAVE_FLINT
4623  if (nmod_mat_nrows (FLINTN) != factors.length()) //refined factors
4624  {
4625    nmod_mat_clear (FLINTN);
4626    nmod_mat_init(FLINTN,factors.length(),factors.length(),getCharacteristic());
4627    for (long i=factors.length()-1; i >= 0; i--)
4628      nmod_mat_entry (FLINTN, i, i)= 1;
4629  }
4630#else
4631  if (NTLN.NumRows() != factors.length()) //refined factors
4632    ident (NTLN, factors.length());
4633#endif
4634  CFListIterator j;
4635  CFMatrix C;
4636  CFArray buf;
4637#ifdef HAVE_FLINT
4638  long rank;
4639  nmod_mat_t FLINTC, FLINTK, null;
4640#else
4641  mat_zz_p* NTLC, NTLK;
4642#endif
4643  CanonicalForm bufF, truncF;
4644  CFList bufUniFactors;
4645  Variable y= F.mvar();
4646  while (oldL <= l)
4647  {
4648    j= factors;
4649    truncF= mod (F, power (y, oldL));
4650    if (useOldQs)
4651    {
4652      for (int i= 0; i < factors.length(); i++, j++)
4653        A[i]= logarithmicDerivative (truncF, j.getItem(), oldL, oldL2, bufQ[i],
4654                                     bufQ[i]
4655                                    );
4656    }
4657    else
4658    {
4659      for (int i= 0; i < factors.length(); i++, j++)
4660        A[i]= logarithmicDerivative (truncF, j.getItem(), oldL, bufQ [i]);
4661    }
4662    useOldQs= true;
4663
4664    for (int i= 0; i < d; i++)
4665    {
4666      if (bounds [i] + 1 <= oldL/2)
4667      {
4668        int k= tmin (bounds [i] + 1, oldL/2);
4669        C= CFMatrix ((oldL - k)*extensionDeg, factors.length());
4670        for (int ii= 0; ii < factors.length(); ii++)
4671        {
4672          if (A[ii].size() - 1 >= i)
4673          {
4674            buf= getCoeffs (A[ii] [i], k, alpha);
4675            writeInMatrix (C, buf, ii + 1, 0);
4676          }
4677        }
4678#ifdef HAVE_FLINT
4679        convertFacCFMatrix2nmod_mat_t (FLINTC, C);
4680        nmod_mat_init (FLINTK, nmod_mat_nrows (FLINTC), nmod_mat_ncols (FLINTN),
4681                       getCharacteristic());
4682        nmod_mat_mul (FLINTK, FLINTC, FLINTN);
4683        nmod_mat_init (null, nmod_mat_ncols (FLINTK), nmod_mat_ncols (FLINTK),
4684                       getCharacteristic());
4685        rank= nmod_mat_nullspace (null, FLINTK);
4686        nmod_mat_clear (FLINTK);
4687        nmod_mat_window_init (FLINTK, null, 0, 0, nmod_mat_nrows(null), rank);
4688        nmod_mat_clear (FLINTC);
4689        nmod_mat_init_set (FLINTC, FLINTN);
4690        nmod_mat_clear (FLINTN);
4691        nmod_mat_init (FLINTN, nmod_mat_nrows (FLINTC), nmod_mat_ncols (FLINTK),
4692                       getCharacteristic());
4693        nmod_mat_mul (FLINTN, FLINTC, FLINTK); //no aliasing allowed!!
4694
4695        nmod_mat_clear (FLINTC);
4696        nmod_mat_window_clear (FLINTK);
4697        nmod_mat_clear (null);
4698#else
4699        NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
4700        NTLK= (*NTLC)*NTLN;
4701        transpose (NTLK, NTLK);
4702        kernel (NTLK, NTLK);
4703        transpose (NTLK, NTLK);
4704        NTLN *= NTLK;
4705#endif
4706#ifdef HAVE_FLINT
4707        if (nmod_mat_ncols (FLINTN) == 1)
4708#else
4709        if (NTLN.NumCols() == 1)
4710#endif
4711        {
4712          delete [] A;
4713          return CFList (F);
4714        }
4715      }
4716    }
4717
4718    int * zeroOneVecs;
4719#ifdef HAVE_FLINT
4720    zeroOneVecs= extractZeroOneVecs (FLINTN);
4721#else
4722    zeroOneVecs= extractZeroOneVecs (NTLN);
4723#endif
4724
4725    bufF= F;
4726    bufUniFactors= factors;
4727#ifdef HAVE_FLINT
4728    result= reconstruction (bufF, bufUniFactors, zeroOneVecs, oldL, FLINTN);
4729#else
4730    result= reconstruction (bufF, bufUniFactors, zeroOneVecs, oldL, NTLN);
4731#endif
4732    delete [] zeroOneVecs;
4733    if (degree (bufF) + 1 + degree (LC (bufF, 1)) < l && result.length() > 0)
4734    {
4735      F= bufF;
4736      factors= bufUniFactors;
4737      delete [] A;
4738      return result;
4739    }
4740
4741    result= CFList();
4742    oldL2= oldL;
4743    oldL *= 2;
4744    if (oldL > l)
4745    {
4746      if (!hitBound)
4747      {
4748        oldL= l;
4749        hitBound= true;
4750      }
4751      else
4752        break;
4753    }
4754  }
4755  delete [] A;
4756  return result;
4757}
4758
4759#ifdef HAVE_FLINT
4760CFList
4761furtherLiftingAndIncreasePrecision (CanonicalForm& F, CFList&
4762                                    factors, int l, int liftBound, int d, int*
4763                                    bounds, nmod_mat_t FLINTN, CFList& diophant,
4764                                    CFMatrix& M, CFArray& Pi, CFArray& bufQ
4765                                   )
4766#else
4767CFList
4768furtherLiftingAndIncreasePrecision (CanonicalForm& F, CFList&
4769                                    factors, int l, int liftBound, int d, int*
4770                                    bounds, mat_zz_p& NTLN, CFList& diophant,
4771                                    CFMatrix& M, CFArray& Pi, CFArray& bufQ
4772                                   )
4773#endif
4774{
4775  CanonicalForm LCF= LC (F, 1);
4776  CFList result;
4777  bool irreducible= false;
4778  CFList bufFactors= factors;
4779  CFArray *A = new CFArray [bufFactors.length()];
4780  bool useOldQs= false;
4781  bool hitBound= false;
4782  int oldL= l;
4783  int stepSize= 8; //TODO choose better step size?
4784  l += tmax (tmin (8, degree (F) + 1 + degree (LC (F, 1))-l), 2);
4785#ifdef HAVE_FLINT
4786  if (nmod_mat_nrows (FLINTN) != factors.length()) //refined factors
4787  {
4788    nmod_mat_clear (FLINTN);
4789    nmod_mat_init(FLINTN,factors.length(),factors.length(),getCharacteristic());
4790    for (long i=factors.length()-1; i >= 0; i--)
4791      nmod_mat_entry (FLINTN, i, i)= 1;
4792  }
4793#else
4794  if (NTLN.NumRows() != factors.length()) //refined factors
4795    ident (NTLN, factors.length());
4796#endif
4797  CFListIterator j;
4798  CFMatrix C;
4799  CFArray buf;
4800#ifdef HAVE_FLINT
4801  long rank;
4802  nmod_mat_t FLINTC, FLINTK, null;
4803#else
4804  mat_zz_p* NTLC, NTLK;
4805#endif
4806  CanonicalForm bufF, truncF;
4807  Variable y= F.mvar();
4808  while (l <= liftBound)
4809  {
4810    bufFactors.insert (LCF);
4811    henselLiftResume12 (F, bufFactors, oldL, l, Pi, diophant, M);
4812    bufFactors.insert (LCF);
4813    bufFactors.removeFirst();
4814    j= bufFactors;
4815    truncF= mod (F, power (y, l));
4816    if (useOldQs)
4817    {
4818      for (int i= 0; i < bufFactors.length(); i++, j++)
4819        A[i]= logarithmicDerivative (truncF, j.getItem(), l, oldL, bufQ[i],
4820                                     bufQ[i]);
4821    }
4822    else
4823    {
4824      for (int i= 0; i < bufFactors.length(); i++, j++)
4825        A[i]= logarithmicDerivative (truncF, j.getItem(), l, bufQ [i]);
4826    }
4827    for (int i= 0; i < d; i++)
4828    {
4829      if (bounds [i] + 1 <= l/2)
4830      {
4831        int k= tmin (bounds [i] + 1, l/2);
4832        C= CFMatrix (l - k, bufFactors.length());
4833        for (int ii= 0; ii < bufFactors.length(); ii++)
4834        {
4835          if (A[ii].size() - 1 >= i)
4836          {
4837            buf= getCoeffs (A[ii] [i], k);
4838            writeInMatrix (C, buf, ii + 1, 0);
4839          }
4840        }
4841#ifdef HAVE_FLINT
4842        convertFacCFMatrix2nmod_mat_t (FLINTC, C);
4843        nmod_mat_init (FLINTK, nmod_mat_nrows (FLINTC), nmod_mat_ncols (FLINTN),
4844                       getCharacteristic());
4845        nmod_mat_mul (FLINTK, FLINTC, FLINTN);
4846        nmod_mat_init (null, nmod_mat_ncols (FLINTK), nmod_mat_ncols (FLINTK),
4847                       getCharacteristic());
4848        rank= nmod_mat_nullspace (null, FLINTK);
4849        nmod_mat_clear (FLINTK);
4850        nmod_mat_window_init (FLINTK, null, 0, 0, nmod_mat_nrows(null), rank);
4851        nmod_mat_clear (FLINTC);
4852        nmod_mat_init_set (FLINTC, FLINTN);
4853        nmod_mat_clear (FLINTN);
4854        nmod_mat_init (FLINTN, nmod_mat_nrows (FLINTC), nmod_mat_ncols (FLINTK),
4855                       getCharacteristic());
4856        nmod_mat_mul (FLINTN, FLINTC, FLINTK); //no aliasing allowed!!
4857
4858        nmod_mat_clear (FLINTC);
4859        nmod_mat_window_clear (FLINTK);
4860        nmod_mat_clear (null);
4861#else
4862        NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
4863        NTLK= (*NTLC)*NTLN;
4864        transpose (NTLK, NTLK);
4865        kernel (NTLK, NTLK);
4866        transpose (NTLK, NTLK);
4867        NTLN *= NTLK;
4868#endif
4869#ifdef HAVE_FLINT
4870        if (nmod_mat_ncols (FLINTN) == 1)
4871#else
4872        if (NTLN.NumCols() == 1)
4873#endif
4874        {
4875          irreducible= true;
4876          break;
4877        }
4878      }
4879    }
4880
4881#ifdef HAVE_FLINT
4882    if (nmod_mat_ncols (FLINTN) == 1)
4883#else
4884    if (NTLN.NumCols() == 1)
4885#endif
4886    {
4887      irreducible= true;
4888      break;
4889    }
4890
4891#ifdef HAVE_FLINT
4892    int * zeroOneVecs= extractZeroOneVecs (FLINTN);
4893#else
4894    int * zeroOneVecs= extractZeroOneVecs (NTLN);
4895#endif
4896    bufF= F;
4897#ifdef HAVE_FLINT
4898    result= reconstruction (bufF, bufFactors, zeroOneVecs, l, FLINTN);
4899#else
4900    result= reconstruction (bufF, bufFactors, zeroOneVecs, l, NTLN);
4901#endif
4902    delete [] zeroOneVecs;
4903    if (result.length() > 0 && degree (bufF) + 1 + degree (LC (bufF, 1)) <= l)
4904    {
4905      F= bufF;
4906      factors= bufFactors;
4907      delete [] A;
4908      return result;
4909    }
4910
4911#ifdef HAVE_FLINT
4912    if (isReduced (FLINTN))
4913#else
4914    if (isReduced (NTLN))
4915#endif
4916    {
4917      int factorsFound= 0;
4918      bufF= F;
4919#ifdef HAVE_FLINT
4920      int* factorsFoundIndex= new int [nmod_mat_ncols (FLINTN)];
4921      for (long i= 0; i < nmod_mat_ncols (FLINTN); i++)
4922#else
4923      int* factorsFoundIndex= new int [NTLN.NumCols()];
4924      for (long i= 0; i < NTLN.NumCols(); i++)
4925#endif
4926        factorsFoundIndex[i]= 0;
4927#ifdef HAVE_FLINT
4928      if (l < liftBound)
4929        reconstructionTry (result, bufF, bufFactors, l, factorsFound,
4930                           factorsFoundIndex, FLINTN, false
4931                          );
4932      else
4933        reconstructionTry (result, bufF, bufFactors, degree (bufF) + 1 +
4934                           degree (LCF), factorsFound, factorsFoundIndex,
4935                           FLINTN, false
4936                          );
4937
4938      if (nmod_mat_ncols (FLINTN) == result.length())
4939#else
4940      if (l < liftBound)
4941        reconstructionTry (result, bufF, bufFactors, l, factorsFound,
4942                           factorsFoundIndex, NTLN, false
4943                          );
4944      else
4945        reconstructionTry (result, bufF, bufFactors, degree (bufF) + 1 +
4946                           degree (LCF), factorsFound, factorsFoundIndex,
4947                           NTLN, false
4948                          );
4949
4950      if (NTLN.NumCols() == result.length())
4951#endif
4952      {
4953        delete [] A;
4954        delete [] factorsFoundIndex;
4955        return result;
4956      }
4957      delete [] factorsFoundIndex;
4958    }
4959    result= CFList();
4960    oldL= l;
4961    stepSize *= 2;
4962    l += stepSize;
4963    if (l > liftBound)
4964    {
4965      if (!hitBound)
4966      {
4967        l= liftBound;
4968        hitBound= true;
4969      }
4970      else
4971        break;
4972    }
4973  }
4974  if (irreducible)
4975  {
4976    delete [] A;
4977    return CFList (F);
4978  }
4979  delete [] A;
4980  factors= bufFactors;
4981  return CFList();
4982}
4983
4984//Fq
4985CFList
4986furtherLiftingAndIncreasePrecision (CanonicalForm& F, CFList&
4987                                    factors, int l, int liftBound, int d, int*
4988                                    bounds, mat_zz_pE& NTLN, CFList& diophant,
4989                                    CFMatrix& M, CFArray& Pi, CFArray& bufQ
4990                                   )
4991{
4992  CanonicalForm LCF= LC (F, 1);
4993  CFList result;
4994  bool irreducible= false;
4995  CFList bufFactors= factors;
4996  CFArray *A = new CFArray [bufFactors.length()];
4997  bool useOldQs= false;
4998  bool hitBound= false;
4999  int oldL= l;
5000  int stepSize= 8; //TODO choose better step size?
5001  l += tmax (tmin (8, degree (F) + 1 + degree (LC (F, 1))-l), 2);
5002  if (NTLN.NumRows() != factors.length()) //refined factors
5003    ident (NTLN, factors.length());
5004  CFListIterator j;
5005  CFArray buf;
5006  mat_zz_pE* NTLC, NTLK;
5007  CanonicalForm bufF, truncF;
5008  Variable y= F.mvar();
5009  while (l <= liftBound)
5010  {
5011    bufFactors.insert (LCF);
5012    henselLiftResume12 (F, bufFactors, oldL, l, Pi, diophant, M);
5013    j= bufFactors;
5014    truncF= mod (F, power (y, l));
5015    if (useOldQs)
5016    {
5017      for (int i= 0; i < bufFactors.length(); i++, j++)
5018        A[i]= logarithmicDerivative (truncF, j.getItem(), l, oldL, bufQ[i],
5019                                     bufQ[i]);
5020    }
5021    else
5022    {
5023      for (int i= 0; i < bufFactors.length(); i++, j++)
5024        A[i]= logarithmicDerivative (truncF, j.getItem(), l, bufQ [i]);
5025    }
5026    for (int i= 0; i < d; i++)
5027    {
5028      if (bounds [i] + 1 <= l/2)
5029      {
5030        int k= tmin (bounds [i] + 1, l/2);
5031        CFMatrix C= CFMatrix (l - k, bufFactors.length());
5032        for (int ii= 0; ii < bufFactors.length(); ii++)
5033        {
5034          if (A[ii].size() - 1 >= i)
5035          {
5036            buf= getCoeffs (A[ii] [i], k);
5037            writeInMatrix (C, buf, ii + 1, 0);
5038          }
5039        }
5040        NTLC= convertFacCFMatrix2NTLmat_zz_pE(C);
5041        NTLK= (*NTLC)*NTLN;
5042        transpose (NTLK, NTLK);
5043        kernel (NTLK, NTLK);
5044        transpose (NTLK, NTLK);
5045        NTLN *= NTLK;
5046        if (NTLN.NumCols() == 1)
5047        {
5048          irreducible= true;
5049          break;
5050        }
5051      }
5052    }
5053    if (NTLN.NumCols() == 1)
5054    {
5055      irreducible= true;
5056      break;
5057    }
5058
5059    int * zeroOneVecs= extractZeroOneVecs (NTLN);
5060    bufF= F;
5061    result= reconstruction (bufF, bufFactors, zeroOneVecs, l, NTLN);
5062    delete [] zeroOneVecs;
5063    if (result.length() > 0 && degree (bufF) + 1 + degree (LC (bufF, 1)) <= l)
5064    {
5065      F= bufF;
5066      factors= bufFactors;
5067      delete [] A;
5068      return result;
5069    }
5070
5071    if (isReduced (NTLN))
5072    {
5073      int factorsFound= 0;
5074      bufF= F;
5075      int* factorsFoundIndex= new int [NTLN.NumCols()];
5076      for (long i= 0; i < NTLN.NumCols(); i++)
5077        factorsFoundIndex[i]= 0;
5078      if (l < liftBound)
5079        reconstructionTry (result, bufF, bufFactors, l, factorsFound,
5080                           factorsFoundIndex, NTLN, false
5081                          );
5082      else
5083        reconstructionTry (result, bufF, bufFactors, degree (bufF) + 1 +
5084                           degree (LCF), factorsFound, factorsFoundIndex,
5085                           NTLN, false
5086                          );
5087      if (NTLN.NumCols() == result.length())
5088      {
5089        delete [] A;
5090        delete [] factorsFoundIndex;
5091        return result;
5092      }
5093      delete [] factorsFoundIndex;
5094    }
5095    result= CFList();
5096    oldL= l;
5097    stepSize *= 2;
5098    l += stepSize;
5099    if (l > liftBound)
5100    {
5101      if (!hitBound)
5102      {
5103        l= liftBound;
5104        hitBound= true;
5105      }
5106      else
5107        break;
5108    }
5109  }
5110  if (irreducible)
5111  {
5112    delete [] A;
5113    return CFList (F);
5114  }
5115  delete [] A;
5116  factors= bufFactors;
5117  return CFList();
5118}
5119
5120//over field extension
5121CFList
5122extFurtherLiftingAndIncreasePrecision (CanonicalForm& F, CFList& factors, int l,
5123                                       int liftBound, int d, int* bounds,
5124                                       mat_zz_p& NTLN, CFList& diophant,
5125                                       CFMatrix& M, CFArray& Pi, CFArray& bufQ,
5126                                       const CanonicalForm& evaluation, const
5127                                       ExtensionInfo& info, CFList& source,
5128                                       CFList& dest
5129                                      )
5130{
5131  CanonicalForm LCF= LC (F, 1);
5132  CFList result;
5133  bool irreducible= false;
5134  CFList bufFactors= factors;
5135  CFArray *A = new CFArray [bufFactors.length()];
5136  bool useOldQs= false;
5137  bool hitBound= false;
5138  bool GF= (CFFactory::gettype()==GaloisFieldDomain);
5139  int degMipo= degree (getMipo (info.getAlpha()));
5140  Variable alpha= info.getAlpha();
5141  int oldL= l; //be careful
5142  int stepSize= 8;
5143  l += tmax (tmin (8, degree (F) + 1 + degree (LC (F, 1))-l),2);
5144  Variable gamma= info.getBeta();
5145  CanonicalForm primElemAlpha= info.getGamma();
5146  CanonicalForm imPrimElemAlpha= info.getDelta();
5147  if (NTLN.NumRows() != factors.length()) //refined factors
5148    ident (NTLN, factors.length());
5149  Variable y= F.mvar();
5150  CanonicalForm powX, imBasis, bufF, truncF;
5151  CFMatrix Mat, C;
5152  CFIterator iter;
5153  mat_zz_p* NTLMat,*NTLC, NTLK;
5154  CFListIterator j;
5155  CFArray buf;
5156  while (l <= liftBound)
5157  {
5158    bufFactors.insert (LCF);
5159    henselLiftResume12 (F, bufFactors, oldL, l, Pi, diophant, M);
5160
5161    if (GF)
5162      setCharacteristic (getCharacteristic());
5163
5164    powX= power (y-gamma, l);
5165    Mat= CFMatrix (l*degMipo, l*degMipo);
5166    for (int i= 0; i < l*degMipo; i++)
5167    {
5168
5169      imBasis= mod (power (y, i), powX);
5170      imBasis= imBasis (power (y, degMipo), y);
5171      imBasis= imBasis (y, gamma);
5172      iter= imBasis;
5173      for (; iter.hasTerms(); iter++)
5174        Mat (iter.exp()+ 1, i+1)= iter.coeff();
5175    }
5176
5177    NTLMat= convertFacCFMatrix2NTLmat_zz_p (Mat);
5178    *NTLMat= inv (*NTLMat);
5179
5180    if (GF)
5181      setCharacteristic (getCharacteristic(), degMipo, info.getGFName());
5182
5183    j= bufFactors;
5184    truncF= mod (F, power (y, l));
5185    if (useOldQs)
5186    {
5187      for (int i= 0; i < bufFactors.length(); i++, j++)
5188        A[i]= logarithmicDerivative (truncF, j.getItem(), l, oldL, bufQ[i],
5189                                     bufQ[i]);
5190    }
5191    else
5192    {
5193      for (int i= 0; i < bufFactors.length(); i++, j++)
5194        A[i]= logarithmicDerivative (truncF, j.getItem(), l, bufQ [i]);
5195    }
5196    for (int i= 0; i < d; i++)
5197    {
5198      if (bounds [i] + 1 <= l/2)
5199      {
5200        int k= tmin (bounds [i] + 1, l/2);
5201        C= CFMatrix (l*degMipo - k, bufFactors.length());
5202        for (int ii= 0; ii < bufFactors.length(); ii++)
5203        {
5204          if (A[ii].size() - 1 >= i)
5205          {
5206            if (GF)
5207            {
5208              A [ii] [i]= A [ii] [i] (y-evaluation, y);
5209              setCharacteristic (getCharacteristic());
5210              A[ii] [i]= GF2FalphaRep (A[ii] [i], alpha);
5211              if (alpha != gamma)
5212                A [ii] [i]= mapDown (A[ii] [i], imPrimElemAlpha, primElemAlpha,
5213                                     gamma, source, dest
5214                                    );
5215              buf= getCoeffs (A[ii] [i], k, l, degMipo, gamma, 0, *NTLMat);
5216            }
5217            else
5218            {
5219              A [ii] [i]= A [ii] [i] (y-evaluation, y);
5220              if (alpha != gamma)
5221                A[ii] [i]= mapDown (A[ii] [i], imPrimElemAlpha, primElemAlpha,
5222                                    gamma, source, dest
5223                                   );
5224              buf= getCoeffs (A[ii] [i], k, l, degMipo, gamma, 0, *NTLMat);
5225            }
5226            writeInMatrix (C, buf, ii + 1, 0);
5227          }
5228          if (GF)
5229            setCharacteristic (getCharacteristic(), degMipo, info.getGFName());
5230        }
5231
5232        if (GF)
5233          setCharacteristic(getCharacteristic());
5234        NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
5235        NTLK= (*NTLC)*NTLN;
5236        transpose (NTLK, NTLK);
5237        kernel (NTLK, NTLK);
5238        transpose (NTLK, NTLK);
5239        NTLN *= NTLK;
5240        if (GF)
5241          setCharacteristic (getCharacteristic(), degMipo, info.getGFName());
5242
5243        if (NTLN.NumCols() == 1)
5244        {
5245          irreducible= true;
5246          break;
5247        }
5248      }
5249    }
5250    if (NTLN.NumCols() == 1)
5251    {
5252      irreducible= true;
5253      break;
5254    }
5255
5256    int * zeroOneVecs= extractZeroOneVecs (NTLN);
5257    bufF= F;
5258    result= extReconstruction (bufF, bufFactors, zeroOneVecs, l, NTLN, info,
5259                               evaluation
5260                              );
5261    delete [] zeroOneVecs;
5262    if (result.length() > 0 && degree (bufF) + 1 + degree (LC (bufF, 1)) <= l)
5263    {
5264      F= bufF;
5265      factors= bufFactors;
5266      delete [] A;
5267      return result;
5268    }
5269
5270    if (isReduced (NTLN))
5271    {
5272      int factorsFound= 0;
5273      bufF= F;
5274      int* factorsFoundIndex= new int [NTLN.NumCols()];
5275      for (long i= 0; i < NTLN.NumCols(); i++)
5276        factorsFoundIndex[i]= 0;
5277      if (l < degree (bufF) + 1 + degree (LCF))
5278        extReconstructionTry (result, bufF, bufFactors, l, factorsFound,
5279                              factorsFoundIndex, NTLN, false, info, evaluation
5280                             );
5281      else
5282        extReconstructionTry (result, bufF, bufFactors, degree (bufF) + 1 +
5283                              degree (LCF), factorsFound, factorsFoundIndex,
5284                              NTLN, false, info, evaluation
5285                             );
5286      if (NTLN.NumCols() == result.length())
5287      {
5288        delete [] A;
5289        delete [] factorsFoundIndex;
5290        return result;
5291      }
5292      delete [] factorsFoundIndex;
5293    }
5294    result= CFList();
5295    oldL= l;
5296    stepSize *= 2;
5297    l += stepSize;
5298    if (l > liftBound)
5299    {
5300      if (!hitBound)
5301      {
5302        l= liftBound;
5303        hitBound= true;
5304      }
5305      else
5306        break;
5307    }
5308  }
5309  if (irreducible)
5310  {
5311    delete [] A;
5312    Variable y= Variable (2);
5313    CanonicalForm tmp= F (y - evaluation, y);
5314    CFList source, dest;
5315    tmp= mapDown (tmp, info, source, dest);
5316    return CFList (tmp);
5317  }
5318  delete [] A;
5319  factors= bufFactors;
5320  return CFList();
5321}
5322
5323#ifdef HAVE_FLINT
5324CFList
5325furtherLiftingAndIncreasePrecisionFq2Fp (CanonicalForm& F, CFList& factors, int
5326                                         l, int liftBound, int d, int* bounds,
5327                                         nmod_mat_t FLINTN, CFList& diophant,
5328                                         CFMatrix& M, CFArray& Pi, CFArray& bufQ,
5329                                         const Variable& alpha
5330                                        )
5331#else
5332CFList
5333furtherLiftingAndIncreasePrecisionFq2Fp (CanonicalForm& F, CFList& factors, int
5334                                         l, int liftBound, int d, int* bounds,
5335                                         mat_zz_p& NTLN, CFList& diophant,
5336                                         CFMatrix& M, CFArray& Pi, CFArray& bufQ,
5337                                         const Variable& alpha
5338                                        )
5339#endif
5340{
5341  CanonicalForm LCF= LC (F, 1);
5342  CFList result;
5343  bool irreducible= false;
5344  CFList bufFactors= factors;
5345  CFArray *A = new CFArray [bufFactors.length()];
5346  bool useOldQs= false;
5347  int extensionDeg= degree (getMipo (alpha));
5348  bool hitBound= false;
5349  int oldL= l;
5350  int stepSize= 8; //TODO choose better step size?
5351  l += tmax (tmin (8, degree (F) + 1 + degree (LC (F, 1))-l), 2);
5352#ifdef HAVE_FLINT
5353  if (nmod_mat_nrows (FLINTN) != factors.length()) //refined factors
5354  {
5355    nmod_mat_clear (FLINTN);
5356    nmod_mat_init(FLINTN,factors.length(),factors.length(),getCharacteristic());
5357    for (long i=factors.length()-1; i >= 0; i--)
5358      nmod_mat_entry (FLINTN, i, i)= 1;
5359  }
5360#else
5361  if (NTLN.NumRows() != factors.length()) //refined factors
5362    ident (NTLN, factors.length());
5363#endif
5364  CFListIterator j;
5365  CFMatrix C;
5366#ifdef HAVE_FLINT
5367  long rank;
5368  nmod_mat_t FLINTC, FLINTK, null;
5369#else
5370  mat_zz_p* NTLC, NTLK;
5371#endif
5372  CanonicalForm bufF, truncF;
5373  Variable y= F.mvar();
5374  while (l <= liftBound)
5375  {
5376    bufFactors.insert (LCF);
5377    henselLiftResume12 (F, bufFactors, oldL, l, Pi, diophant, M);
5378    j= bufFactors;
5379    truncF= mod (F, power (y, l));
5380    if (useOldQs)
5381    {
5382      for (int i= 0; i < bufFactors.length(); i++, j++)
5383        A[i]= logarithmicDerivative (truncF, j.getItem(), l, oldL, bufQ[i],
5384                                     bufQ[i]);
5385    }
5386    else
5387    {
5388      for (int i= 0; i < bufFactors.length(); i++, j++)
5389        A[i]= logarithmicDerivative (truncF, j.getItem(), l, bufQ [i]);
5390    }
5391    for (int i= 0; i < d; i++)
5392    {
5393      if (bounds [i] + 1 <= l/2)
5394      {
5395        int k= tmin (bounds [i] + 1, l/2);
5396        C= CFMatrix ((l - k)*extensionDeg, bufFactors.length());
5397        for (int ii= 0; ii < bufFactors.length(); ii++)
5398        {
5399          CFArray buf;
5400          if (A[ii].size() - 1 >= i)
5401          {
5402            buf= getCoeffs (A[ii] [i], k, alpha);
5403            writeInMatrix (C, buf, ii + 1, 0);
5404          }
5405        }
5406#ifdef HAVE_FLINT
5407        convertFacCFMatrix2nmod_mat_t (FLINTC, C);
5408        nmod_mat_init (FLINTK, nmod_mat_nrows (FLINTC), nmod_mat_ncols (FLINTN),
5409                       getCharacteristic());
5410        nmod_mat_mul (FLINTK, FLINTC, FLINTN);
5411        nmod_mat_init (null, nmod_mat_ncols (FLINTK), nmod_mat_ncols (FLINTK),
5412                       getCharacteristic());
5413        rank= nmod_mat_nullspace (null, FLINTK);
5414        nmod_mat_clear (FLINTK);
5415        nmod_mat_window_init (FLINTK, null, 0, 0, nmod_mat_nrows(null), rank);
5416        nmod_mat_clear (FLINTC);
5417        nmod_mat_init_set (FLINTC, FLINTN);
5418        nmod_mat_clear (FLINTN);
5419        nmod_mat_init (FLINTN, nmod_mat_nrows (FLINTC), nmod_mat_ncols (FLINTK),
5420                       getCharacteristic());
5421        nmod_mat_mul (FLINTN, FLINTC, FLINTK); //no aliasing allowed!!
5422
5423        nmod_mat_clear (FLINTC);
5424        nmod_mat_window_clear (FLINTK);
5425        nmod_mat_clear (null);
5426#else
5427        NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
5428        NTLK= (*NTLC)*NTLN;
5429        transpose (NTLK, NTLK);
5430        kernel (NTLK, NTLK);
5431        transpose (NTLK, NTLK);
5432        NTLN *= NTLK;
5433#endif
5434#ifdef HAVE_FLINT
5435        if (nmod_mat_ncols (FLINTN) == 1)
5436#else
5437        if (NTLN.NumCols() == 1)
5438#endif
5439        {
5440          irreducible= true;
5441          break;
5442        }
5443      }
5444    }
5445#ifdef HAVE_FLINT
5446    if (nmod_mat_ncols (FLINTN) == 1)
5447#else
5448    if (NTLN.NumCols() == 1)
5449#endif
5450    {
5451      irreducible= true;
5452      break;
5453    }
5454
5455#ifdef HAVE_FLINT
5456    int * zeroOneVecs= extractZeroOneVecs (FLINTN);
5457#else
5458    int * zeroOneVecs= extractZeroOneVecs (NTLN);
5459#endif
5460    CanonicalForm bufF= F;
5461#ifdef HAVE_FLINT
5462    result= reconstruction (bufF, bufFactors, zeroOneVecs, l, FLINTN);
5463#else
5464    result= reconstruction (bufF, bufFactors, zeroOneVecs, l, NTLN);
5465#endif
5466    delete [] zeroOneVecs;
5467    if (result.length() > 0 && degree (bufF) + 1 + degree (LC (bufF, 1)) <= l)
5468    {
5469      F= bufF;
5470      factors= bufFactors;
5471      delete [] A;
5472      return result;
5473    }
5474
5475#ifdef HAVE_FLINT
5476    if (isReduced (FLINTN))
5477#else
5478    if (isReduced (NTLN))
5479#endif
5480    {
5481      int factorsFound= 0;
5482      bufF= F;
5483#ifdef HAVE_FLINT
5484      int* factorsFoundIndex= new int [nmod_mat_ncols (FLINTN)];
5485      for (long i= 0; i < nmod_mat_ncols (FLINTN); i++)
5486#else
5487      int* factorsFoundIndex= new int [NTLN.NumCols()];
5488      for (long i= 0; i < NTLN.NumCols(); i++)
5489#endif
5490        factorsFoundIndex[i]= 0;
5491#ifdef HAVE_FLINT
5492      if (l < degree (bufF) + 1 + degree (LCF))
5493        reconstructionTry (result, bufF, bufFactors, l, factorsFound,
5494                           factorsFoundIndex, FLINTN, false
5495                          );
5496      else
5497        reconstructionTry (result, bufF, bufFactors, degree (bufF) + 1 +
5498                           degree (LCF), factorsFound, factorsFoundIndex,
5499                           FLINTN, false
5500                          );
5501      if (nmod_mat_ncols (FLINTN) == result.length())
5502#else
5503      if (l < degree (bufF) + 1 + degree (LCF))
5504        reconstructionTry (result, bufF, bufFactors, l, factorsFound,
5505                           factorsFoundIndex, NTLN, false
5506                          );
5507      else
5508        reconstructionTry (result, bufF, bufFactors, degree (bufF) + 1 +
5509                           degree (LCF), factorsFound, factorsFoundIndex,
5510                           NTLN, false
5511                          );
5512      if (NTLN.NumCols() == result.length())
5513#endif
5514      {
5515        delete [] A;
5516        delete [] factorsFoundIndex;
5517        return result;
5518      }
5519      delete [] factorsFoundIndex;
5520    }
5521    result= CFList();
5522    oldL= l;
5523    stepSize *= 2;
5524    l += stepSize;
5525    if (l > liftBound)
5526    {
5527      if (!hitBound)
5528      {
5529        l= liftBound;
5530        hitBound= true;
5531      }
5532      else
5533        break;
5534    }
5535  }
5536  if (irreducible)
5537  {
5538    delete [] A;
5539    return CFList (F);
5540  }
5541  delete [] A;
5542  factors= bufFactors;
5543  return CFList();
5544}
5545
5546void
5547refineAndRestartLift (const CanonicalForm& F, const mat_zz_p& NTLN, int
5548                      liftBound, int l, CFList& factors, CFMatrix& M, CFArray&
5549                      Pi, CFList& diophant
5550                     )
5551{
5552  CFList bufFactors;
5553  Variable y= Variable (2);
5554  CanonicalForm LCF= LC (F, 1);
5555  CFListIterator iter;
5556  CanonicalForm buf;
5557  for (long i= 1; i <= NTLN.NumCols(); i++)
5558  {
5559    iter= factors;
5560    buf= 1;
5561    for (long j= 1; j <= NTLN.NumRows(); j++, iter++)
5562    {
5563      if (!IsZero (NTLN (j,i)))
5564        buf= mulNTL (buf, mod (iter.getItem(), y));
5565    }
5566    bufFactors.append (buf);
5567  }
5568  factors= bufFactors;
5569  M= CFMatrix (liftBound, factors.length());
5570  Pi= CFArray();
5571  diophant= CFList();
5572  factors.insert (LCF);
5573  henselLift12 (F, factors, l, Pi, diophant, M);
5574}
5575
5576#ifdef HAVE_FLINT
5577void
5578refineAndRestartLift (const CanonicalForm& F, const nmod_mat_t FLINTN, int
5579                      liftBound, int l, CFList& factors, CFMatrix& M, CFArray&
5580                      Pi, CFList& diophant
5581                     )
5582{
5583  CFList bufFactors;
5584  Variable y= Variable (2);
5585  CanonicalForm LCF= LC (F, 1);
5586  CFListIterator iter;
5587  CanonicalForm buf;
5588  for (long i= 0; i < nmod_mat_ncols (FLINTN); i++)
5589  {
5590    iter= factors;
5591    buf= 1;
5592    for (long j= 0; j < nmod_mat_nrows (FLINTN); j++, iter++)
5593    {
5594      if (!(nmod_mat_entry (FLINTN,j,i) == 0))
5595        buf= mulNTL (buf, mod (iter.getItem(), y));
5596    }
5597    bufFactors.append (buf);
5598  }
5599  factors= bufFactors;
5600  M= CFMatrix (liftBound, factors.length());
5601  Pi= CFArray();
5602  diophant= CFList();
5603  factors.insert (LCF);
5604  henselLift12 (F, factors, l, Pi, diophant, M);
5605}
5606#endif
5607
5608void
5609refineAndRestartLift (const CanonicalForm& F, const mat_zz_pE& NTLN, int
5610                      liftBound, int l, CFList& factors, CFMatrix& M, CFArray&
5611                      Pi, CFList& diophant
5612                     )
5613{
5614  CFList bufFactors;
5615  Variable y= Variable (2);
5616  CanonicalForm LCF= LC (F, 1);
5617  CFListIterator iter;
5618  CanonicalForm buf;
5619  for (long i= 1; i <= NTLN.NumCols(); i++)
5620  {
5621    iter= factors;
5622    buf= 1;
5623    for (long j= 1; j <= NTLN.NumRows(); j++, iter++)
5624    {
5625      if (!IsZero (NTLN (j,i)))
5626        buf= mulNTL (buf, mod (iter.getItem(), y));
5627    }
5628    bufFactors.append (buf);
5629  }
5630  factors= bufFactors;
5631  M= CFMatrix (liftBound, factors.length());
5632  Pi= CFArray();
5633  diophant= CFList();
5634  factors.insert (LCF);
5635  henselLift12 (F, factors, l, Pi, diophant, M);
5636}
5637
5638#ifdef HAVE_FLINT
5639CFList
5640earlyReconstructionAndLifting (const CanonicalForm& F, const nmod_mat_t N,
5641                               CanonicalForm& bufF, CFList& factors, int& l,
5642                               int& factorsFound, bool beenInThres, CFMatrix& M,
5643                               CFArray& Pi, CFList& diophant, bool symmetric,
5644                               const CanonicalForm& evaluation
5645                              )
5646#else
5647CFList
5648earlyReconstructionAndLifting (const CanonicalForm& F, const mat_zz_p& N,
5649                               CanonicalForm& bufF, CFList& factors, int& l,
5650                               int& factorsFound, bool beenInThres, CFMatrix& M,
5651                               CFArray& Pi, CFList& diophant, bool symmetric,
5652                               const CanonicalForm& evaluation
5653                              )
5654#endif
5655{
5656  int sizeOfLiftPre;
5657  int * liftPre= getLiftPrecisions (F, sizeOfLiftPre, degree (LC (F, 1), 2));
5658
5659  Variable y= F.mvar();
5660  factorsFound= 0;
5661  CanonicalForm LCF= LC (F, 1);
5662  CFList result;
5663  int smallFactorDeg= tmin (11, liftPre [sizeOfLiftPre- 1] + 1);
5664#ifdef HAVE_FLINT
5665  nmod_mat_t FLINTN;
5666  nmod_mat_init_set (FLINTN, N);
5667  int * factorsFoundIndex= new int [nmod_mat_ncols (FLINTN)];
5668  for (long i= 0; i < nmod_mat_ncols (FLINTN); i++)
5669#else
5670  mat_zz_p NTLN= N;
5671  int * factorsFoundIndex= new int [NTLN.NumCols()];
5672  for (long i= 0; i < NTLN.NumCols(); i++)
5673#endif
5674    factorsFoundIndex [i]= 0;
5675
5676  if (degree (F) + 1 > smallFactorDeg)
5677  {
5678    if (l < smallFactorDeg)
5679    {
5680      factors.insert (LCF);
5681      henselLiftResume12 (F, factors, l, smallFactorDeg, Pi, diophant, M);
5682      l= smallFactorDeg;
5683    }
5684#ifdef HAVE_FLINT
5685    reconstructionTry (result, bufF, factors, smallFactorDeg, factorsFound,
5686                       factorsFoundIndex, FLINTN, beenInThres
5687                      );
5688    if (result.length() == nmod_mat_ncols (FLINTN))
5689    {
5690      nmod_mat_clear (FLINTN);
5691#else
5692    reconstructionTry (result, bufF, factors, smallFactorDeg, factorsFound,
5693                       factorsFoundIndex, NTLN, beenInThres
5694                      );
5695    if (result.length() == NTLN.NumCols())
5696    {
5697#endif
5698      delete [] liftPre;
5699      delete [] factorsFoundIndex;
5700      return result;
5701    }
5702  }
5703
5704  int i= sizeOfLiftPre - 1;
5705  int dummy= 1;
5706  if (sizeOfLiftPre > 1 && sizeOfLiftPre < 30)
5707  {
5708    while (i > 0)
5709    {
5710      if (l < liftPre[i-1] + 1)
5711      {
5712        factors.insert (LCF);
5713        henselLiftResume12 (F, factors, l, liftPre[i-1] + 1, Pi, diophant, M);
5714        l= liftPre[i-1] + 1;
5715      }
5716      else
5717      {
5718        i--;
5719        if (i != 0)
5720          continue;
5721      }
5722#ifdef HAVE_FLINT
5723      reconstructionTry (result, bufF, factors, l, factorsFound,
5724                         factorsFoundIndex, FLINTN, beenInThres
5725                        );
5726      if (result.length() == nmod_mat_ncols (FLINTN))
5727      {
5728        nmod_mat_clear (FLINTN);
5729#else
5730      reconstructionTry (result, bufF, factors, l, factorsFound,
5731                         factorsFoundIndex, NTLN, beenInThres
5732                        );
5733      if (result.length() == NTLN.NumCols())
5734      {
5735#endif
5736        delete [] liftPre;
5737        delete [] factorsFoundIndex;
5738        return result;
5739      }
5740      i--;
5741    }
5742  }
5743  else
5744  {
5745    i= 1;
5746    while (((degree (F,y)/4)*i+1) + 4 <= smallFactorDeg)
5747      i++;
5748    while (i < 5)
5749    {
5750      dummy= tmin (degree (F,y)+1, ((degree (F,y)/4)+1)*i+4);
5751      if (l < dummy)
5752      {
5753        factors.insert (LCF);
5754        henselLiftResume12 (F, factors, l, dummy, Pi, diophant, M);
5755        l= dummy;
5756        if (i == 1 && degree (F)%4==0 && symmetric && factors.length() == 2 &&
5757            LC (F,1).inCoeffDomain() &&
5758           (degree (factors.getFirst(), 1) == degree (factors.getLast(),1)))
5759        {
5760          Variable x= Variable (1);
5761          CanonicalForm g, h, gg, hh, multiplier1, multiplier2, check1, check2;
5762          int m= degree (F)/4+1;
5763          g= factors.getFirst();
5764          h= factors.getLast();
5765          g= mod (g, power (y,m));
5766          h= mod (h, power (y,m));
5767          g= g (y-evaluation, y);
5768          h= h (y-evaluation, y);
5769          gg= mod (swapvar (g,x,y),power (x,m));
5770          gg= gg (y + evaluation, y);
5771          multiplier1= factors.getLast()[m-1][0]/gg[m-1][0];
5772          gg= div (gg, power (y,m));
5773          gg= gg*power (y,m);
5774          hh= mod (swapvar (h,x,y),power (x,m));
5775          hh= hh (y + evaluation, y);
5776          multiplier2= factors.getFirst()[m-1][0]/hh[m-1][0];
5777          hh= div (hh, power (y,m));
5778          hh= hh*power (y,m);
5779          gg= multiplier1*gg+mod (factors.getLast(), power (y,m));
5780          hh= multiplier2*hh+mod (factors.getFirst(), power (y,m));
5781          check1= gg (y-evaluation,y);
5782          check2= hh (y-evaluation,y);
5783          check1= swapvar (check1, x, y);
5784          if (check1/Lc (check1) == check2/Lc (check2))
5785          {
5786#ifdef HAVE_FLINT
5787            nmod_mat_clear (FLINTN);
5788#endif
5789            result.append (gg);
5790            result.append (hh);
5791            delete [] liftPre;
5792            delete [] factorsFoundIndex;
5793            return result;
5794          }
5795        }
5796      }
5797      else
5798      {
5799        i++;
5800        if (i < 5)
5801          continue;
5802      }
5803#ifdef HAVE_FLINT
5804      reconstructionTry (result, bufF, factors, l, factorsFound,
5805                         factorsFoundIndex, FLINTN, beenInThres
5806                        );
5807      if (result.length() == nmod_mat_ncols (FLINTN))
5808      {
5809        nmod_mat_clear (FLINTN);
5810#else
5811      reconstructionTry (result, bufF, factors, l, factorsFound,
5812                         factorsFoundIndex, NTLN, beenInThres
5813                        );
5814      if (result.length() == NTLN.NumCols())
5815      {
5816#endif
5817        delete [] liftPre;
5818        delete [] factorsFoundIndex;
5819        return result;
5820      }
5821      i++;
5822    }
5823  }
5824
5825#ifdef HAVE_FLINT
5826  nmod_mat_clear (FLINTN);
5827#endif
5828  delete [] liftPre;
5829  delete [] factorsFoundIndex;
5830  return result;
5831}
5832
5833CFList
5834earlyReconstructionAndLifting (const CanonicalForm& F, const mat_zz_pE& N,
5835                               CanonicalForm& bufF, CFList& factors, int& l,
5836                               int& factorsFound, bool beenInThres, CFMatrix& M,
5837                               CFArray& Pi, CFList& diophant, bool symmetric,
5838                               const CanonicalForm& evaluation
5839                              )
5840{
5841  int sizeOfLiftPre;
5842  int * liftPre= getLiftPrecisions (F, sizeOfLiftPre, degree (LC (F, 1), 2));
5843  Variable y= F.mvar();
5844  factorsFound= 0;
5845  CanonicalForm LCF= LC (F, 1);
5846  CFList result;
5847  int smallFactorDeg= 11;
5848  mat_zz_pE NTLN= N;
5849  int * factorsFoundIndex= new int [NTLN.NumCols()];
5850  for (long i= 0; i < NTLN.NumCols(); i++)
5851    factorsFoundIndex [i]= 0;
5852
5853  if (degree (F) + 1 > smallFactorDeg)
5854  {
5855    if (l < smallFactorDeg)
5856    {
5857      factors.insert (LCF);
5858      henselLiftResume12 (F, factors, l, smallFactorDeg, Pi, diophant, M);
5859      l= smallFactorDeg;
5860    }
5861    reconstructionTry (result, bufF, factors, smallFactorDeg, factorsFound,
5862                       factorsFoundIndex, NTLN, beenInThres
5863                      );
5864    if (result.length() == NTLN.NumCols())
5865    {
5866      delete [] liftPre;
5867      delete [] factorsFoundIndex;
5868      return result;
5869    }
5870  }
5871
5872  int i= sizeOfLiftPre - 1;
5873  int dummy= 1;
5874  if (sizeOfLiftPre > 1 && sizeOfLiftPre < 30)
5875  {
5876    while (i > 0)
5877    {
5878      if (l < liftPre[i-1] + 1)
5879      {
5880        factors.insert (LCF);
5881        henselLiftResume12 (F, factors, l, liftPre[i-1] + 1, Pi, diophant, M);
5882        l= liftPre[i-1] + 1;
5883      }
5884      else
5885      {
5886        i--;
5887        if (i != 0)
5888          continue;
5889      }
5890      reconstructionTry (result, bufF, factors, l, factorsFound,
5891                         factorsFoundIndex, NTLN, beenInThres
5892                        );
5893      if (result.length() == NTLN.NumCols())
5894      {
5895        delete [] liftPre;
5896        delete [] factorsFoundIndex;
5897        return result;
5898      }
5899      i--;
5900    }
5901  }
5902  else
5903  {
5904    i= 1;
5905    while ((degree (F,y)/4+1)*i + 4 <= smallFactorDeg)
5906      i++;
5907    while (i < 5)
5908    {
5909      dummy= tmin (degree (F,y)+1, (degree (F,y)/4+1)*i+4);
5910      if (l < dummy)
5911      {
5912        factors.insert (LCF);
5913        henselLiftResume12 (F, factors, l, dummy, Pi, diophant, M);
5914        l= dummy;
5915        if (i == 1 && degree (F)%4==0 && symmetric && factors.length() == 2 &&
5916            LC (F,1).inCoeffDomain() &&
5917           (degree (factors.getFirst(), 1) == degree (factors.getLast(),1)))
5918        {
5919          Variable x= Variable (1);
5920          CanonicalForm g, h, gg, hh, multiplier1, multiplier2, check1, check2;
5921          int m= degree (F)/4+1;
5922          g= factors.getFirst();
5923          h= factors.getLast();
5924          g= mod (g, power (y,m));
5925          h= mod (h, power (y,m));
5926          g= g (y-evaluation, y);
5927          h= h (y-evaluation, y);
5928          gg= mod (swapvar (g,x,y),power (x,m));
5929          gg= gg (y + evaluation, y);
5930          multiplier1= factors.getLast()[m-1][0]/gg[m-1][0];
5931          gg= div (gg, power (y,m));
5932          gg= gg*power (y,m);
5933          hh= mod (swapvar (h,x,y),power (x,m));
5934          hh= hh (y + evaluation, y);
5935          multiplier2= factors.getFirst()[m-1][0]/hh[m-1][0];
5936          hh= div (hh, power (y,m));
5937          hh= hh*power (y,m);
5938          gg= multiplier1*gg+mod (factors.getLast(), power (y,m));
5939          hh= multiplier2*hh+mod (factors.getFirst(), power (y,m));
5940          check1= gg (y-evaluation,y);
5941          check2= hh (y-evaluation,y);
5942          check1= swapvar (check1, x, y);
5943          if (check1/Lc (check1) == check2/Lc (check2))
5944          {
5945            result.append (gg);
5946            result.append (hh);
5947            delete [] liftPre;
5948            delete [] factorsFoundIndex;
5949            return result;
5950          }
5951        }
5952      }
5953      else
5954      {
5955        i++;
5956        if (i < 5)
5957          continue;
5958      }
5959      reconstructionTry (result, bufF, factors, l, factorsFound,
5960                         factorsFoundIndex, NTLN, beenInThres
5961                        );
5962      if (result.length() == NTLN.NumCols())
5963      {
5964        delete [] liftPre;
5965        delete [] factorsFoundIndex;
5966        return result;
5967      }
5968      i++;
5969    }
5970  }
5971
5972  delete [] liftPre;
5973  delete [] factorsFoundIndex;
5974  return result;
5975}
5976
5977//over field extension
5978CFList
5979extEarlyReconstructionAndLifting (const CanonicalForm& F, const mat_zz_p& N,
5980                                  CanonicalForm& bufF, CFList& factors, int& l,
5981                                  int& factorsFound, bool beenInThres, CFMatrix&
5982                                  M, CFArray& Pi, CFList& diophant, const
5983                                  ExtensionInfo& info, const CanonicalForm&
5984                                  evaluation
5985                                 )
5986{
5987  int sizeOfLiftPre;
5988  int * liftPre= getLiftPrecisions (F, sizeOfLiftPre, degree (LC (F, 1), 2));
5989  Variable y= F.mvar();
5990  factorsFound= 0;
5991  CanonicalForm LCF= LC (F, 1);
5992  CFList result;
5993  int smallFactorDeg= 11;
5994  mat_zz_p NTLN= N;
5995  int * factorsFoundIndex= new int [NTLN.NumCols()];
5996  for (long i= 0; i < NTLN.NumCols(); i++)
5997    factorsFoundIndex [i]= 0;
5998
5999  if (degree (F) + 1 > smallFactorDeg)
6000  {
6001    if