Fix some pedantic compiler warnings.
[ginac.git] / ginac / factor.cpp
1 /** @file factor.cpp
2  *
3  *  Polynomial factorization (implementation).
4  *
5  *  The interface function factor() at the end of this file is defined in the
6  *  GiNaC namespace. All other utility functions and classes are defined in an
7  *  additional anonymous namespace.
8  *
9  *  Factorization starts by doing a square free factorization and making the
10  *  coefficients integer. Then, depending on the number of free variables it
11  *  proceeds either in dedicated univariate or multivariate factorization code.
12  *
13  *  Univariate factorization does a modular factorization via Berlekamp's
14  *  algorithm and distinct degree factorization. Hensel lifting is used at the
15  *  end.
16  *  
17  *  Multivariate factorization uses the univariate factorization (applying a
18  *  evaluation homomorphism first) and Hensel lifting raises the answer to the
19  *  multivariate domain. The Hensel lifting code is completely distinct from the
20  *  code used by the univariate factorization.
21  *
22  *  Algorithms used can be found in
23  *    [Wan] An Improved Multivariate Polynomial Factoring Algorithm,
24  *          P.S.Wang,
25  *          Mathematics of Computation, Vol. 32, No. 144 (1978) 1215--1231.
26  *    [GCL] Algorithms for Computer Algebra,
27  *          K.O.Geddes, S.R.Czapor, G.Labahn,
28  *          Springer Verlag, 1992.
29  *    [Mig] Some Useful Bounds,
30  *          M.Mignotte, 
31  *          In "Computer Algebra, Symbolic and Algebraic Computation" (B.Buchberger et al., eds.),
32  *          pp. 259-263, Springer-Verlag, New York, 1982.
33  */
34
35 /*
36  *  GiNaC Copyright (C) 1999-2015 Johannes Gutenberg University Mainz, Germany
37  *
38  *  This program is free software; you can redistribute it and/or modify
39  *  it under the terms of the GNU General Public License as published by
40  *  the Free Software Foundation; either version 2 of the License, or
41  *  (at your option) any later version.
42  *
43  *  This program is distributed in the hope that it will be useful,
44  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
45  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
46  *  GNU General Public License for more details.
47  *
48  *  You should have received a copy of the GNU General Public License
49  *  along with this program; if not, write to the Free Software
50  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
51  */
52
53 //#define DEBUGFACTOR
54
55 #include "factor.h"
56
57 #include "ex.h"
58 #include "numeric.h"
59 #include "operators.h"
60 #include "inifcns.h"
61 #include "symbol.h"
62 #include "relational.h"
63 #include "power.h"
64 #include "mul.h"
65 #include "normal.h"
66 #include "add.h"
67
68 #include <algorithm>
69 #include <cmath>
70 #include <limits>
71 #include <list>
72 #include <vector>
73 #ifdef DEBUGFACTOR
74 #include <ostream>
75 #endif
76 using namespace std;
77
78 #include <cln/cln.h>
79 using namespace cln;
80
81 namespace GiNaC {
82
83 #ifdef DEBUGFACTOR
84 #define DCOUT(str) cout << #str << endl
85 #define DCOUTVAR(var) cout << #var << ": " << var << endl
86 #define DCOUT2(str,var) cout << #str << ": " << var << endl
87 ostream& operator<<(ostream& o, const vector<int>& v)
88 {
89         auto i = v.begin(), end = v.end();
90         while ( i != end ) {
91                 o << *i << " ";
92                 ++i;
93         }
94         return o;
95 }
96 static ostream& operator<<(ostream& o, const vector<cl_I>& v)
97 {
98         auto i = v.begin(), end = v.end();
99         while ( i != end ) {
100                 o << *i << "[" << i-v.begin() << "]" << " ";
101                 ++i;
102         }
103         return o;
104 }
105 static ostream& operator<<(ostream& o, const vector<cl_MI>& v)
106 {
107         auto i = v.begin(), end = v.end();
108         while ( i != end ) {
109                 o << *i << "[" << i-v.begin() << "]" << " ";
110                 ++i;
111         }
112         return o;
113 }
114 ostream& operator<<(ostream& o, const vector<numeric>& v)
115 {
116         for ( size_t i=0; i<v.size(); ++i ) {
117                 o << v[i] << " ";
118         }
119         return o;
120 }
121 ostream& operator<<(ostream& o, const vector<vector<cl_MI>>& v)
122 {
123         auto i = v.begin(), end = v.end();
124         while ( i != end ) {
125                 o << i-v.begin() << ": " << *i << endl;
126                 ++i;
127         }
128         return o;
129 }
130 #else
131 #define DCOUT(str)
132 #define DCOUTVAR(var)
133 #define DCOUT2(str,var)
134 #endif // def DEBUGFACTOR
135
136 // anonymous namespace to hide all utility functions
137 namespace {
138
139 ////////////////////////////////////////////////////////////////////////////////
140 // modular univariate polynomial code
141
142 typedef std::vector<cln::cl_MI> umodpoly;
143 typedef std::vector<cln::cl_I> upoly;
144 typedef vector<umodpoly> upvec;
145
146 // COPY FROM UPOLY.HPP
147
148 // CHANGED size_t -> int !!!
149 template<typename T> static int degree(const T& p)
150 {
151         return p.size() - 1;
152 }
153
154 template<typename T> static typename T::value_type lcoeff(const T& p)
155 {
156         return p[p.size() - 1];
157 }
158
159 static bool normalize_in_field(umodpoly& a)
160 {
161         if (a.size() == 0)
162                 return true;
163         if ( lcoeff(a) == a[0].ring()->one() ) {
164                 return true;
165         }
166
167         const cln::cl_MI lc_1 = recip(lcoeff(a));
168         for (std::size_t k = a.size(); k-- != 0; )
169                 a[k] = a[k]*lc_1;
170         return false;
171 }
172
173 template<typename T> static void
174 canonicalize(T& p, const typename T::size_type hint = std::numeric_limits<typename T::size_type>::max())
175 {
176         if (p.empty())
177                 return;
178
179         std::size_t i = p.size() - 1;
180         // Be fast if the polynomial is already canonicalized
181         if (!zerop(p[i]))
182                 return;
183
184         if (hint < p.size())
185                 i = hint;
186
187         bool is_zero = false;
188         do {
189                 if (!zerop(p[i])) {
190                         ++i;
191                         break;
192                 }
193                 if (i == 0) {
194                         is_zero = true;
195                         break;
196                 }
197                 --i;
198         } while (true);
199
200         if (is_zero) {
201                 p.clear();
202                 return;
203         }
204
205         p.erase(p.begin() + i, p.end());
206 }
207
208 // END COPY FROM UPOLY.HPP
209
210 static void expt_pos(umodpoly& a, unsigned int q)
211 {
212         if ( a.empty() ) return;
213         cl_MI zero = a[0].ring()->zero(); 
214         int deg = degree(a);
215         a.resize(degree(a)*q+1, zero);
216         for ( int i=deg; i>0; --i ) {
217                 a[i*q] = a[i];
218                 a[i] = zero;
219         }
220 }
221
222 template<bool COND, typename T = void> struct enable_if
223 {
224         typedef T type;
225 };
226
227 template<typename T> struct enable_if<false, T> { /* empty */ };
228
229 template<typename T> struct uvar_poly_p
230 {
231         static const bool value = false;
232 };
233
234 template<> struct uvar_poly_p<upoly>
235 {
236         static const bool value = true;
237 };
238
239 template<> struct uvar_poly_p<umodpoly>
240 {
241         static const bool value = true;
242 };
243
244 template<typename T>
245 // Don't define this for anything but univariate polynomials.
246 static typename enable_if<uvar_poly_p<T>::value, T>::type
247 operator+(const T& a, const T& b)
248 {
249         int sa = a.size();
250         int sb = b.size();
251         if ( sa >= sb ) {
252                 T r(sa);
253                 int i = 0;
254                 for ( ; i<sb; ++i ) {
255                         r[i] = a[i] + b[i];
256                 }
257                 for ( ; i<sa; ++i ) {
258                         r[i] = a[i];
259                 }
260                 canonicalize(r);
261                 return r;
262         }
263         else {
264                 T r(sb);
265                 int i = 0;
266                 for ( ; i<sa; ++i ) {
267                         r[i] = a[i] + b[i];
268                 }
269                 for ( ; i<sb; ++i ) {
270                         r[i] = b[i];
271                 }
272                 canonicalize(r);
273                 return r;
274         }
275 }
276
277 template<typename T>
278 // Don't define this for anything but univariate polynomials. Otherwise
279 // overload resolution might fail (this actually happens when compiling
280 // GiNaC with g++ 3.4).
281 static typename enable_if<uvar_poly_p<T>::value, T>::type
282 operator-(const T& a, const T& b)
283 {
284         int sa = a.size();
285         int sb = b.size();
286         if ( sa >= sb ) {
287                 T r(sa);
288                 int i = 0;
289                 for ( ; i<sb; ++i ) {
290                         r[i] = a[i] - b[i];
291                 }
292                 for ( ; i<sa; ++i ) {
293                         r[i] = a[i];
294                 }
295                 canonicalize(r);
296                 return r;
297         }
298         else {
299                 T r(sb);
300                 int i = 0;
301                 for ( ; i<sa; ++i ) {
302                         r[i] = a[i] - b[i];
303                 }
304                 for ( ; i<sb; ++i ) {
305                         r[i] = -b[i];
306                 }
307                 canonicalize(r);
308                 return r;
309         }
310 }
311
312 static upoly operator*(const upoly& a, const upoly& b)
313 {
314         upoly c;
315         if ( a.empty() || b.empty() ) return c;
316
317         int n = degree(a) + degree(b);
318         c.resize(n+1, 0);
319         for ( int i=0 ; i<=n; ++i ) {
320                 for ( int j=0 ; j<=i; ++j ) {
321                         if ( j > degree(a) || (i-j) > degree(b) ) continue;
322                         c[i] = c[i] + a[j] * b[i-j];
323                 }
324         }
325         canonicalize(c);
326         return c;
327 }
328
329 static umodpoly operator*(const umodpoly& a, const umodpoly& b)
330 {
331         umodpoly c;
332         if ( a.empty() || b.empty() ) return c;
333
334         int n = degree(a) + degree(b);
335         c.resize(n+1, a[0].ring()->zero());
336         for ( int i=0 ; i<=n; ++i ) {
337                 for ( int j=0 ; j<=i; ++j ) {
338                         if ( j > degree(a) || (i-j) > degree(b) ) continue;
339                         c[i] = c[i] + a[j] * b[i-j];
340                 }
341         }
342         canonicalize(c);
343         return c;
344 }
345
346 static upoly operator*(const upoly& a, const cl_I& x)
347 {
348         if ( zerop(x) ) {
349                 upoly r;
350                 return r;
351         }
352         upoly r(a.size());
353         for ( size_t i=0; i<a.size(); ++i ) {
354                 r[i] = a[i] * x;
355         }
356         return r;
357 }
358
359 static upoly operator/(const upoly& a, const cl_I& x)
360 {
361         if ( zerop(x) ) {
362                 upoly r;
363                 return r;
364         }
365         upoly r(a.size());
366         for ( size_t i=0; i<a.size(); ++i ) {
367                 r[i] = exquo(a[i],x);
368         }
369         return r;
370 }
371
372 static umodpoly operator*(const umodpoly& a, const cl_MI& x)
373 {
374         umodpoly r(a.size());
375         for ( size_t i=0; i<a.size(); ++i ) {
376                 r[i] = a[i] * x;
377         }
378         canonicalize(r);
379         return r;
380 }
381
382 static void upoly_from_ex(upoly& up, const ex& e, const ex& x)
383 {
384         // assert: e is in Z[x]
385         int deg = e.degree(x);
386         up.resize(deg+1);
387         int ldeg = e.ldegree(x);
388         for ( ; deg>=ldeg; --deg ) {
389                 up[deg] = the<cl_I>(ex_to<numeric>(e.coeff(x, deg)).to_cl_N());
390         }
391         for ( ; deg>=0; --deg ) {
392                 up[deg] = 0;
393         }
394         canonicalize(up);
395 }
396
397 static void umodpoly_from_upoly(umodpoly& ump, const upoly& e, const cl_modint_ring& R)
398 {
399         int deg = degree(e);
400         ump.resize(deg+1);
401         for ( ; deg>=0; --deg ) {
402                 ump[deg] = R->canonhom(e[deg]);
403         }
404         canonicalize(ump);
405 }
406
407 static void umodpoly_from_ex(umodpoly& ump, const ex& e, const ex& x, const cl_modint_ring& R)
408 {
409         // assert: e is in Z[x]
410         int deg = e.degree(x);
411         ump.resize(deg+1);
412         int ldeg = e.ldegree(x);
413         for ( ; deg>=ldeg; --deg ) {
414                 cl_I coeff = the<cl_I>(ex_to<numeric>(e.coeff(x, deg)).to_cl_N());
415                 ump[deg] = R->canonhom(coeff);
416         }
417         for ( ; deg>=0; --deg ) {
418                 ump[deg] = R->zero();
419         }
420         canonicalize(ump);
421 }
422
423 #ifdef DEBUGFACTOR
424 static void umodpoly_from_ex(umodpoly& ump, const ex& e, const ex& x, const cl_I& modulus)
425 {
426         umodpoly_from_ex(ump, e, x, find_modint_ring(modulus));
427 }
428 #endif
429
430 static ex upoly_to_ex(const upoly& a, const ex& x)
431 {
432         if ( a.empty() ) return 0;
433         ex e;
434         for ( int i=degree(a); i>=0; --i ) {
435                 e += numeric(a[i]) * pow(x, i);
436         }
437         return e;
438 }
439
440 static ex umodpoly_to_ex(const umodpoly& a, const ex& x)
441 {
442         if ( a.empty() ) return 0;
443         cl_modint_ring R = a[0].ring();
444         cl_I mod = R->modulus;
445         cl_I halfmod = (mod-1) >> 1;
446         ex e;
447         for ( int i=degree(a); i>=0; --i ) {
448                 cl_I n = R->retract(a[i]);
449                 if ( n > halfmod ) {
450                         e += numeric(n-mod) * pow(x, i);
451                 } else {
452                         e += numeric(n) * pow(x, i);
453                 }
454         }
455         return e;
456 }
457
458 static upoly umodpoly_to_upoly(const umodpoly& a)
459 {
460         upoly e(a.size());
461         if ( a.empty() ) return e;
462         cl_modint_ring R = a[0].ring();
463         cl_I mod = R->modulus;
464         cl_I halfmod = (mod-1) >> 1;
465         for ( int i=degree(a); i>=0; --i ) {
466                 cl_I n = R->retract(a[i]);
467                 if ( n > halfmod ) {
468                         e[i] = n-mod;
469                 } else {
470                         e[i] = n;
471                 }
472         }
473         return e;
474 }
475
476 static umodpoly umodpoly_to_umodpoly(const umodpoly& a, const cl_modint_ring& R, unsigned int m)
477 {
478         umodpoly e;
479         if ( a.empty() ) return e;
480         cl_modint_ring oldR = a[0].ring();
481         size_t sa = a.size();
482         e.resize(sa+m, R->zero());
483         for ( size_t i=0; i<sa; ++i ) {
484                 e[i+m] = R->canonhom(oldR->retract(a[i]));
485         }
486         canonicalize(e);
487         return e;
488 }
489
490 /** Divides all coefficients of the polynomial a by the integer x.
491  *  All coefficients are supposed to be divisible by x. If they are not, the
492  *  the<cl_I> cast will raise an exception.
493  *
494  *  @param[in,out] a  polynomial of which the coefficients will be reduced by x
495  *  @param[in]     x  integer that divides the coefficients
496  */
497 static void reduce_coeff(umodpoly& a, const cl_I& x)
498 {
499         if ( a.empty() ) return;
500
501         cl_modint_ring R = a[0].ring();
502         for (auto & i : a) {
503                 // cln cannot perform this division in the modular field
504                 cl_I c = R->retract(i);
505                 i = cl_MI(R, the<cl_I>(c / x));
506         }
507 }
508
509 /** Calculates remainder of a/b.
510  *  Assertion: a and b not empty.
511  *
512  *  @param[in]  a  polynomial dividend
513  *  @param[in]  b  polynomial divisor
514  *  @param[out] r  polynomial remainder
515  */
516 static void rem(const umodpoly& a, const umodpoly& b, umodpoly& r)
517 {
518         int k, n;
519         n = degree(b);
520         k = degree(a) - n;
521         r = a;
522         if ( k < 0 ) return;
523
524         do {
525                 cl_MI qk = div(r[n+k], b[n]);
526                 if ( !zerop(qk) ) {
527                         for ( int i=0; i<n; ++i ) {
528                                 unsigned int j = n + k - 1 - i;
529                                 r[j] = r[j] - qk * b[j-k];
530                         }
531                 }
532         } while ( k-- );
533
534         fill(r.begin()+n, r.end(), a[0].ring()->zero());
535         canonicalize(r);
536 }
537
538 /** Calculates quotient of a/b.
539  *  Assertion: a and b not empty.
540  *
541  *  @param[in]  a  polynomial dividend
542  *  @param[in]  b  polynomial divisor
543  *  @param[out] q  polynomial quotient
544  */
545 static void div(const umodpoly& a, const umodpoly& b, umodpoly& q)
546 {
547         int k, n;
548         n = degree(b);
549         k = degree(a) - n;
550         q.clear();
551         if ( k < 0 ) return;
552
553         umodpoly r = a;
554         q.resize(k+1, a[0].ring()->zero());
555         do {
556                 cl_MI qk = div(r[n+k], b[n]);
557                 if ( !zerop(qk) ) {
558                         q[k] = qk;
559                         for ( int i=0; i<n; ++i ) {
560                                 unsigned int j = n + k - 1 - i;
561                                 r[j] = r[j] - qk * b[j-k];
562                         }
563                 }
564         } while ( k-- );
565
566         canonicalize(q);
567 }
568
569 /** Calculates quotient and remainder of a/b.
570  *  Assertion: a and b not empty.
571  *
572  *  @param[in]  a  polynomial dividend
573  *  @param[in]  b  polynomial divisor
574  *  @param[out] r  polynomial remainder
575  *  @param[out] q  polynomial quotient
576  */
577 static void remdiv(const umodpoly& a, const umodpoly& b, umodpoly& r, umodpoly& q)
578 {
579         int k, n;
580         n = degree(b);
581         k = degree(a) - n;
582         q.clear();
583         r = a;
584         if ( k < 0 ) return;
585
586         q.resize(k+1, a[0].ring()->zero());
587         do {
588                 cl_MI qk = div(r[n+k], b[n]);
589                 if ( !zerop(qk) ) {
590                         q[k] = qk;
591                         for ( int i=0; i<n; ++i ) {
592                                 unsigned int j = n + k - 1 - i;
593                                 r[j] = r[j] - qk * b[j-k];
594                         }
595                 }
596         } while ( k-- );
597
598         fill(r.begin()+n, r.end(), a[0].ring()->zero());
599         canonicalize(r);
600         canonicalize(q);
601 }
602
603 /** Calculates the GCD of polynomial a and b.
604  *
605  *  @param[in]  a  polynomial
606  *  @param[in]  b  polynomial
607  *  @param[out] c  GCD
608  */
609 static void gcd(const umodpoly& a, const umodpoly& b, umodpoly& c)
610 {
611         if ( degree(a) < degree(b) ) return gcd(b, a, c);
612
613         c = a;
614         normalize_in_field(c);
615         umodpoly d = b;
616         normalize_in_field(d);
617         umodpoly r;
618         while ( !d.empty() ) {
619                 rem(c, d, r);
620                 c = d;
621                 d = r;
622         }
623         normalize_in_field(c);
624 }
625
626 /** Calculates the derivative of the polynomial a.
627  *  
628  *  @param[in]  a  polynomial of which to take the derivative
629  *  @param[out] d  result/derivative
630  */
631 static void deriv(const umodpoly& a, umodpoly& d)
632 {
633         d.clear();
634         if ( a.size() <= 1 ) return;
635
636         d.insert(d.begin(), a.begin()+1, a.end());
637         int max = d.size();
638         for ( int i=1; i<max; ++i ) {
639                 d[i] = d[i] * (i+1);
640         }
641         canonicalize(d);
642 }
643
644 static bool unequal_one(const umodpoly& a)
645 {
646         if ( a.empty() ) return true;
647         return ( a.size() != 1 || a[0] != a[0].ring()->one() );
648 }
649
650 static bool equal_one(const umodpoly& a)
651 {
652         return ( a.size() == 1 && a[0] == a[0].ring()->one() );
653 }
654
655 /** Returns true if polynomial a is square free.
656  *
657  *  @param[in] a  polynomial to check
658  *  @return       true if polynomial is square free, false otherwise
659  */
660 static bool squarefree(const umodpoly& a)
661 {
662         umodpoly b;
663         deriv(a, b);
664         if ( b.empty() ) {
665                 return false;
666         }
667         umodpoly c;
668         gcd(a, b, c);
669         return equal_one(c);
670 }
671
672 // END modular univariate polynomial code
673 ////////////////////////////////////////////////////////////////////////////////
674
675 ////////////////////////////////////////////////////////////////////////////////
676 // modular matrix
677
678 typedef vector<cl_MI> mvec;
679
680 class modular_matrix
681 {
682 #ifdef DEBUGFACTOR
683         friend ostream& operator<<(ostream& o, const modular_matrix& m);
684 #endif
685 public:
686         modular_matrix(size_t r_, size_t c_, const cl_MI& init) : r(r_), c(c_)
687         {
688                 m.resize(c*r, init);
689         }
690         size_t rowsize() const { return r; }
691         size_t colsize() const { return c; }
692         cl_MI& operator()(size_t row, size_t col) { return m[row*c + col]; }
693         cl_MI operator()(size_t row, size_t col) const { return m[row*c + col]; }
694         void mul_col(size_t col, const cl_MI x)
695         {
696                 for ( size_t rc=0; rc<r; ++rc ) {
697                         std::size_t i = c*rc + col;
698                         m[i] = m[i] * x;
699                 }
700         }
701         void sub_col(size_t col1, size_t col2, const cl_MI fac)
702         {
703                 for ( size_t rc=0; rc<r; ++rc ) {
704                         std::size_t i1 = col1 + c*rc;
705                         std::size_t i2 = col2 + c*rc;
706                         m[i1] = m[i1] - m[i2]*fac;
707                 }
708         }
709         void switch_col(size_t col1, size_t col2)
710         {
711                 for ( size_t rc=0; rc<r; ++rc ) {
712                         std::size_t i1 = col1 + rc*c;
713                         std::size_t i2 = col2 + rc*c;
714                         std::swap(m[i1], m[i2]);
715                 }
716         }
717         void mul_row(size_t row, const cl_MI x)
718         {
719                 for ( size_t cc=0; cc<c; ++cc ) {
720                         std::size_t i = row*c + cc; 
721                         m[i] = m[i] * x;
722                 }
723         }
724         void sub_row(size_t row1, size_t row2, const cl_MI fac)
725         {
726                 for ( size_t cc=0; cc<c; ++cc ) {
727                         std::size_t i1 = row1*c + cc;
728                         std::size_t i2 = row2*c + cc;
729                         m[i1] = m[i1] - m[i2]*fac;
730                 }
731         }
732         void switch_row(size_t row1, size_t row2)
733         {
734                 for ( size_t cc=0; cc<c; ++cc ) {
735                         std::size_t i1 = row1*c + cc;
736                         std::size_t i2 = row2*c + cc;
737                         std::swap(m[i1], m[i2]);
738                 }
739         }
740         bool is_col_zero(size_t col) const
741         {
742                 for ( size_t rr=0; rr<r; ++rr ) {
743                         std::size_t i = col + rr*c;
744                         if ( !zerop(m[i]) ) {
745                                 return false;
746                         }
747                 }
748                 return true;
749         }
750         bool is_row_zero(size_t row) const
751         {
752                 for ( size_t cc=0; cc<c; ++cc ) {
753                         std::size_t i = row*c + cc;
754                         if ( !zerop(m[i]) ) {
755                                 return false;
756                         }
757                 }
758                 return true;
759         }
760         void set_row(size_t row, const vector<cl_MI>& newrow)
761         {
762                 for (std::size_t i2 = 0; i2 < newrow.size(); ++i2) {
763                         std::size_t i1 = row*c + i2;
764                         m[i1] = newrow[i2];
765                 }
766         }
767         mvec::const_iterator row_begin(size_t row) const { return m.begin()+row*c; }
768         mvec::const_iterator row_end(size_t row) const { return m.begin()+row*c+r; }
769 private:
770         size_t r, c;
771         mvec m;
772 };
773
774 #ifdef DEBUGFACTOR
775 modular_matrix operator*(const modular_matrix& m1, const modular_matrix& m2)
776 {
777         const unsigned int r = m1.rowsize();
778         const unsigned int c = m2.colsize();
779         modular_matrix o(r,c,m1(0,0));
780
781         for ( size_t i=0; i<r; ++i ) {
782                 for ( size_t j=0; j<c; ++j ) {
783                         cl_MI buf;
784                         buf = m1(i,0) * m2(0,j);
785                         for ( size_t k=1; k<c; ++k ) {
786                                 buf = buf + m1(i,k)*m2(k,j);
787                         }
788                         o(i,j) = buf;
789                 }
790         }
791         return o;
792 }
793
794 ostream& operator<<(ostream& o, const modular_matrix& m)
795 {
796         cl_modint_ring R = m(0,0).ring();
797         o << "{";
798         for ( size_t i=0; i<m.rowsize(); ++i ) {
799                 o << "{";
800                 for ( size_t j=0; j<m.colsize()-1; ++j ) {
801                         o << R->retract(m(i,j)) << ",";
802                 }
803                 o << R->retract(m(i,m.colsize()-1)) << "}";
804                 if ( i != m.rowsize()-1 ) {
805                         o << ",";
806                 }
807         }
808         o << "}";
809         return o;
810 }
811 #endif // def DEBUGFACTOR
812
813 // END modular matrix
814 ////////////////////////////////////////////////////////////////////////////////
815
816 /** Calculates the Q matrix for a polynomial. Used by Berlekamp's algorithm.
817  *
818  *  @param[in]  a_  modular polynomial
819  *  @param[out] Q   Q matrix
820  */
821 static void q_matrix(const umodpoly& a_, modular_matrix& Q)
822 {
823         umodpoly a = a_;
824         normalize_in_field(a);
825
826         int n = degree(a);
827         unsigned int q = cl_I_to_uint(a[0].ring()->modulus);
828         umodpoly r(n, a[0].ring()->zero());
829         r[0] = a[0].ring()->one();
830         Q.set_row(0, r);
831         unsigned int max = (n-1) * q;
832         for ( size_t m=1; m<=max; ++m ) {
833                 cl_MI rn_1 = r.back();
834                 for ( size_t i=n-1; i>0; --i ) {
835                         r[i] = r[i-1] - (rn_1 * a[i]);
836                 }
837                 r[0] = -rn_1 * a[0];
838                 if ( (m % q) == 0 ) {
839                         Q.set_row(m/q, r);
840                 }
841         }
842 }
843
844 /** Determine the nullspace of a matrix M-1.
845  *
846  *  @param[in,out] M      matrix, will be modified
847  *  @param[out]    basis  calculated nullspace of M-1
848  */
849 static void nullspace(modular_matrix& M, vector<mvec>& basis)
850 {
851         const size_t n = M.rowsize();
852         const cl_MI one = M(0,0).ring()->one();
853         for ( size_t i=0; i<n; ++i ) {
854                 M(i,i) = M(i,i) - one;
855         }
856         for ( size_t r=0; r<n; ++r ) {
857                 size_t cc = 0;
858                 for ( ; cc<n; ++cc ) {
859                         if ( !zerop(M(r,cc)) ) {
860                                 if ( cc < r ) {
861                                         if ( !zerop(M(cc,cc)) ) {
862                                                 continue;
863                                         }
864                                         M.switch_col(cc, r);
865                                 }
866                                 else if ( cc > r ) {
867                                         M.switch_col(cc, r);
868                                 }
869                                 break;
870                         }
871                 }
872                 if ( cc < n ) {
873                         M.mul_col(r, recip(M(r,r)));
874                         for ( cc=0; cc<n; ++cc ) {
875                                 if ( cc != r ) {
876                                         M.sub_col(cc, r, M(r,cc));
877                                 }
878                         }
879                 }
880         }
881
882         for ( size_t i=0; i<n; ++i ) {
883                 M(i,i) = M(i,i) - one;
884         }
885         for ( size_t i=0; i<n; ++i ) {
886                 if ( !M.is_row_zero(i) ) {
887                         mvec nu(M.row_begin(i), M.row_end(i));
888                         basis.push_back(nu);
889                 }
890         }
891 }
892
893 /** Berlekamp's modular factorization.
894  *  
895  *  The implementation follows the algorithm in chapter 8 of [GCL].
896  *
897  *  @param[in]  a    modular polynomial
898  *  @param[out] upv  vector containing modular factors. if upv was not empty the
899  *                   new elements are added at the end
900  */
901 static void berlekamp(const umodpoly& a, upvec& upv)
902 {
903         cl_modint_ring R = a[0].ring();
904         umodpoly one(1, R->one());
905
906         // find nullspace of Q matrix
907         modular_matrix Q(degree(a), degree(a), R->zero());
908         q_matrix(a, Q);
909         vector<mvec> nu;
910         nullspace(Q, nu);
911
912         const unsigned int k = nu.size();
913         if ( k == 1 ) {
914                 // irreducible
915                 return;
916         }
917
918         list<umodpoly> factors;
919         factors.push_back(a);
920         unsigned int size = 1;
921         unsigned int r = 1;
922         unsigned int q = cl_I_to_uint(R->modulus);
923
924         list<umodpoly>::iterator u = factors.begin();
925
926         // calculate all gcd's
927         while ( true ) {
928                 for ( unsigned int s=0; s<q; ++s ) {
929                         umodpoly nur = nu[r];
930                         nur[0] = nur[0] - cl_MI(R, s);
931                         canonicalize(nur);
932                         umodpoly g;
933                         gcd(nur, *u, g);
934                         if ( unequal_one(g) && g != *u ) {
935                                 umodpoly uo;
936                                 div(*u, g, uo);
937                                 if ( equal_one(uo) ) {
938                                         throw logic_error("berlekamp: unexpected divisor.");
939                                 }
940                                 else {
941                                         *u = uo;
942                                 }
943                                 factors.push_back(g);
944                                 size = 0;
945                                 for (auto & i : factors) {
946                                         if (degree(i))
947                                                 ++size;
948                                 }
949                                 if ( size == k ) {
950                                         for (auto & i : factors) {
951                                                 upv.push_back(i);
952                                         }
953                                         return;
954                                 }
955                         }
956                 }
957                 if ( ++r == k ) {
958                         r = 1;
959                         ++u;
960                 }
961         }
962 }
963
964 // modular square free factorization is not used at the moment so we deactivate
965 // the code
966 #if 0
967
968 /** Calculates a^(1/prime).
969  *  
970  *  @param[in] a      polynomial
971  *  @param[in] prime  prime number -> exponent 1/prime
972  *  @param[in] ap     resulting polynomial
973  */
974 static void expt_1_over_p(const umodpoly& a, unsigned int prime, umodpoly& ap)
975 {
976         size_t newdeg = degree(a)/prime;
977         ap.resize(newdeg+1);
978         ap[0] = a[0];
979         for ( size_t i=1; i<=newdeg; ++i ) {
980                 ap[i] = a[i*prime];
981         }
982 }
983
984 /** Modular square free factorization.
985  *
986  *  @param[in]  a        polynomial
987  *  @param[out] factors  modular factors
988  *  @param[out] mult     corresponding multiplicities (exponents)
989  */
990 static void modsqrfree(const umodpoly& a, upvec& factors, vector<int>& mult)
991 {
992         const unsigned int prime = cl_I_to_uint(a[0].ring()->modulus);
993         int i = 1;
994         umodpoly b;
995         deriv(a, b);
996         if ( b.size() ) {
997                 umodpoly c;
998                 gcd(a, b, c);
999                 umodpoly w;
1000                 div(a, c, w);
1001                 while ( unequal_one(w) ) {
1002                         umodpoly y;
1003                         gcd(w, c, y);
1004                         umodpoly z;
1005                         div(w, y, z);
1006                         factors.push_back(z);
1007                         mult.push_back(i);
1008                         ++i;
1009                         w = y;
1010                         umodpoly buf;
1011                         div(c, y, buf);
1012                         c = buf;
1013                 }
1014                 if ( unequal_one(c) ) {
1015                         umodpoly cp;
1016                         expt_1_over_p(c, prime, cp);
1017                         size_t previ = mult.size();
1018                         modsqrfree(cp, factors, mult);
1019                         for ( size_t i=previ; i<mult.size(); ++i ) {
1020                                 mult[i] *= prime;
1021                         }
1022                 }
1023         }
1024         else {
1025                 umodpoly ap;
1026                 expt_1_over_p(a, prime, ap);
1027                 size_t previ = mult.size();
1028                 modsqrfree(ap, factors, mult);
1029                 for ( size_t i=previ; i<mult.size(); ++i ) {
1030                         mult[i] *= prime;
1031                 }
1032         }
1033 }
1034
1035 #endif // deactivation of square free factorization
1036
1037 /** Distinct degree factorization (DDF).
1038  *  
1039  *  The implementation follows the algorithm in chapter 8 of [GCL].
1040  *
1041  *  @param[in]  a_         modular polynomial
1042  *  @param[out] degrees    vector containing the degrees of the factors of the
1043  *                         corresponding polynomials in ddfactors.
1044  *  @param[out] ddfactors  vector containing polynomials which factors have the
1045  *                         degree given in degrees.
1046  */
1047 static void distinct_degree_factor(const umodpoly& a_, vector<int>& degrees, upvec& ddfactors)
1048 {
1049         umodpoly a = a_;
1050
1051         cl_modint_ring R = a[0].ring();
1052         int q = cl_I_to_int(R->modulus);
1053         int nhalf = degree(a)/2;
1054
1055         int i = 1;
1056         umodpoly w(2);
1057         w[0] = R->zero();
1058         w[1] = R->one();
1059         umodpoly x = w;
1060
1061         while ( i <= nhalf ) {
1062                 expt_pos(w, q);
1063                 umodpoly buf;
1064                 rem(w, a, buf);
1065                 w = buf;
1066                 umodpoly wx = w - x;
1067                 gcd(a, wx, buf);
1068                 if ( unequal_one(buf) ) {
1069                         degrees.push_back(i);
1070                         ddfactors.push_back(buf);
1071                 }
1072                 if ( unequal_one(buf) ) {
1073                         umodpoly buf2;
1074                         div(a, buf, buf2);
1075                         a = buf2;
1076                         nhalf = degree(a)/2;
1077                         rem(w, a, buf);
1078                         w = buf;
1079                 }
1080                 ++i;
1081         }
1082         if ( unequal_one(a) ) {
1083                 degrees.push_back(degree(a));
1084                 ddfactors.push_back(a);
1085         }
1086 }
1087
1088 /** Modular same degree factorization.
1089  *  Same degree factorization is a kind of misnomer. It performs distinct degree
1090  *  factorization, but instead of using the Cantor-Zassenhaus algorithm it
1091  *  (sub-optimally) uses Berlekamp's algorithm for the factors of the same
1092  *  degree.
1093  *
1094  *  @param[in]  a    modular polynomial
1095  *  @param[out] upv  vector containing modular factors. if upv was not empty the
1096  *                   new elements are added at the end
1097  */
1098 static void same_degree_factor(const umodpoly& a, upvec& upv)
1099 {
1100         cl_modint_ring R = a[0].ring();
1101
1102         vector<int> degrees;
1103         upvec ddfactors;
1104         distinct_degree_factor(a, degrees, ddfactors);
1105
1106         for ( size_t i=0; i<degrees.size(); ++i ) {
1107                 if ( degrees[i] == degree(ddfactors[i]) ) {
1108                         upv.push_back(ddfactors[i]);
1109                 }
1110                 else {
1111                         berlekamp(ddfactors[i], upv);
1112                 }
1113         }
1114 }
1115
1116 // Yes, we can (choose).
1117 #define USE_SAME_DEGREE_FACTOR
1118
1119 /** Modular univariate factorization.
1120  *
1121  *  In principle, we have two algorithms at our disposal: Berlekamp's algorithm
1122  *  and same degree factorization (SDF). SDF seems to be slightly faster in
1123  *  almost all cases so it is activated as default.
1124  *
1125  *  @param[in]  p    modular polynomial
1126  *  @param[out] upv  vector containing modular factors. if upv was not empty the
1127  *                   new elements are added at the end
1128  */
1129 static void factor_modular(const umodpoly& p, upvec& upv)
1130 {
1131 #ifdef USE_SAME_DEGREE_FACTOR
1132         same_degree_factor(p, upv);
1133 #else
1134         berlekamp(p, upv);
1135 #endif
1136 }
1137
1138 /** Calculates modular polynomials s and t such that a*s+b*t==1.
1139  *  Assertion: a and b are relatively prime and not zero.
1140  *
1141  *  @param[in]  a  polynomial
1142  *  @param[in]  b  polynomial
1143  *  @param[out] s  polynomial
1144  *  @param[out] t  polynomial
1145  */
1146 static void exteuclid(const umodpoly& a, const umodpoly& b, umodpoly& s, umodpoly& t)
1147 {
1148         if ( degree(a) < degree(b) ) {
1149                 exteuclid(b, a, t, s);
1150                 return;
1151         }
1152
1153         umodpoly one(1, a[0].ring()->one());
1154         umodpoly c = a; normalize_in_field(c);
1155         umodpoly d = b; normalize_in_field(d);
1156         s = one;
1157         t.clear();
1158         umodpoly d1;
1159         umodpoly d2 = one;
1160         umodpoly q;
1161         while ( true ) {
1162                 div(c, d, q);
1163                 umodpoly r = c - q * d;
1164                 umodpoly r1 = s - q * d1;
1165                 umodpoly r2 = t - q * d2;
1166                 c = d;
1167                 s = d1;
1168                 t = d2;
1169                 if ( r.empty() ) break;
1170                 d = r;
1171                 d1 = r1;
1172                 d2 = r2;
1173         }
1174         cl_MI fac = recip(lcoeff(a) * lcoeff(c));
1175         for (auto & i : s) {
1176                 i = i * fac;
1177         }
1178         canonicalize(s);
1179         fac = recip(lcoeff(b) * lcoeff(c));
1180         for (auto & i : t) {
1181                 i = i * fac;
1182         }
1183         canonicalize(t);
1184 }
1185
1186 /** Replaces the leading coefficient in a polynomial by a given number.
1187  *
1188  *  @param[in] poly  polynomial to change
1189  *  @param[in] lc    new leading coefficient
1190  *  @return          changed polynomial
1191  */
1192 static upoly replace_lc(const upoly& poly, const cl_I& lc)
1193 {
1194         if ( poly.empty() ) return poly;
1195         upoly r = poly;
1196         r.back() = lc;
1197         return r;
1198 }
1199
1200 /** Calculates the bound for the modulus.
1201  *  See [Mig].
1202  */
1203 static inline cl_I calc_bound(const ex& a, const ex& x, int maxdeg)
1204 {
1205         cl_I maxcoeff = 0;
1206         cl_R coeff = 0;
1207         for ( int i=a.degree(x); i>=a.ldegree(x); --i ) {
1208                 cl_I aa = abs(the<cl_I>(ex_to<numeric>(a.coeff(x, i)).to_cl_N()));
1209                 if ( aa > maxcoeff ) maxcoeff = aa;
1210                 coeff = coeff + square(aa);
1211         }
1212         cl_I coeffnorm = ceiling1(the<cl_R>(cln::sqrt(coeff)));
1213         cl_I B = coeffnorm * expt_pos(cl_I(2), cl_I(maxdeg));
1214         return ( B > maxcoeff ) ? B : maxcoeff;
1215 }
1216
1217 /** Calculates the bound for the modulus.
1218  *  See [Mig].
1219  */
1220 static inline cl_I calc_bound(const upoly& a, int maxdeg)
1221 {
1222         cl_I maxcoeff = 0;
1223         cl_R coeff = 0;
1224         for ( int i=degree(a); i>=0; --i ) {
1225                 cl_I aa = abs(a[i]);
1226                 if ( aa > maxcoeff ) maxcoeff = aa;
1227                 coeff = coeff + square(aa);
1228         }
1229         cl_I coeffnorm = ceiling1(the<cl_R>(cln::sqrt(coeff)));
1230         cl_I B = coeffnorm * expt_pos(cl_I(2), cl_I(maxdeg));
1231         return ( B > maxcoeff ) ? B : maxcoeff;
1232 }
1233
1234 /** Hensel lifting as used by factor_univariate().
1235  *
1236  *  The implementation follows the algorithm in chapter 6 of [GCL].
1237  *
1238  *  @param[in]  a_   primitive univariate polynomials
1239  *  @param[in]  p    prime number that does not divide lcoeff(a)
1240  *  @param[in]  u1_  modular factor of a (mod p)
1241  *  @param[in]  w1_  modular factor of a (mod p), relatively prime to u1_,
1242  *                   fulfilling  u1_*w1_ == a mod p
1243  *  @param[out] u    lifted factor
1244  *  @param[out] w    lifted factor, u*w = a
1245  */
1246 static void hensel_univar(const upoly& a_, unsigned int p, const umodpoly& u1_, const umodpoly& w1_, upoly& u, upoly& w)
1247 {
1248         upoly a = a_;
1249         const cl_modint_ring& R = u1_[0].ring();
1250
1251         // calc bound B
1252         int maxdeg = (degree(u1_) > degree(w1_)) ? degree(u1_) : degree(w1_);
1253         cl_I maxmodulus = 2*calc_bound(a, maxdeg);
1254
1255         // step 1
1256         cl_I alpha = lcoeff(a);
1257         a = a * alpha;
1258         umodpoly nu1 = u1_;
1259         normalize_in_field(nu1);
1260         umodpoly nw1 = w1_;
1261         normalize_in_field(nw1);
1262         upoly phi;
1263         phi = umodpoly_to_upoly(nu1) * alpha;
1264         umodpoly u1;
1265         umodpoly_from_upoly(u1, phi, R);
1266         phi = umodpoly_to_upoly(nw1) * alpha;
1267         umodpoly w1;
1268         umodpoly_from_upoly(w1, phi, R);
1269
1270         // step 2
1271         umodpoly s;
1272         umodpoly t;
1273         exteuclid(u1, w1, s, t);
1274
1275         // step 3
1276         u = replace_lc(umodpoly_to_upoly(u1), alpha);
1277         w = replace_lc(umodpoly_to_upoly(w1), alpha);
1278         upoly e = a - u * w;
1279         cl_I modulus = p;
1280
1281         // step 4
1282         while ( !e.empty() && modulus < maxmodulus ) {
1283                 upoly c = e / modulus;
1284                 phi = umodpoly_to_upoly(s) * c;
1285                 umodpoly sigmatilde;
1286                 umodpoly_from_upoly(sigmatilde, phi, R);
1287                 phi = umodpoly_to_upoly(t) * c;
1288                 umodpoly tautilde;
1289                 umodpoly_from_upoly(tautilde, phi, R);
1290                 umodpoly r, q;
1291                 remdiv(sigmatilde, w1, r, q);
1292                 umodpoly sigma = r;
1293                 phi = umodpoly_to_upoly(tautilde) + umodpoly_to_upoly(q) * umodpoly_to_upoly(u1);
1294                 umodpoly tau;
1295                 umodpoly_from_upoly(tau, phi, R);
1296                 u = u + umodpoly_to_upoly(tau) * modulus;
1297                 w = w + umodpoly_to_upoly(sigma) * modulus;
1298                 e = a - u * w;
1299                 modulus = modulus * p;
1300         }
1301
1302         // step 5
1303         if ( e.empty() ) {
1304                 cl_I g = u[0];
1305                 for ( size_t i=1; i<u.size(); ++i ) {
1306                         g = gcd(g, u[i]);
1307                         if ( g == 1 ) break;
1308                 }
1309                 if ( g != 1 ) {
1310                         u = u / g;
1311                         w = w * g;
1312                 }
1313                 if ( alpha != 1 ) {
1314                         w = w / alpha;
1315                 }
1316         }
1317         else {
1318                 u.clear();
1319         }
1320 }
1321
1322 /** Returns a new prime number.
1323  *
1324  *  @param[in] p  prime number
1325  *  @return       next prime number after p
1326  */
1327 static unsigned int next_prime(unsigned int p)
1328 {
1329         static vector<unsigned int> primes;
1330         if ( primes.size() == 0 ) {
1331                 primes.push_back(3); primes.push_back(5); primes.push_back(7);
1332         }
1333         if ( p >= primes.back() ) {
1334                 unsigned int candidate = primes.back() + 2;
1335                 while ( true ) {
1336                         size_t n = primes.size()/2;
1337                         for ( size_t i=0; i<n; ++i ) {
1338                                 if ( candidate % primes[i] ) continue;
1339                                 candidate += 2;
1340                                 i=-1;
1341                         }
1342                         primes.push_back(candidate);
1343                         if ( candidate > p ) break;
1344                 }
1345                 return candidate;
1346         }
1347         for (auto & it : primes) {
1348                 if ( it > p ) {
1349                         return it;
1350                 }
1351         }
1352         throw logic_error("next_prime: should not reach this point!");
1353 }
1354
1355 /** Manages the splitting a vector of of modular factors into two partitions.
1356  */
1357 class factor_partition
1358 {
1359 public:
1360         /** Takes the vector of modular factors and initializes the first partition */
1361         factor_partition(const upvec& factors_) : factors(factors_)
1362         {
1363                 n = factors.size();
1364                 k.resize(n, 0);
1365                 k[0] = 1;
1366                 cache.resize(n-1);
1367                 one.resize(1, factors.front()[0].ring()->one());
1368                 len = 1;
1369                 last = 0;
1370                 split();
1371         }
1372         int operator[](size_t i) const { return k[i]; }
1373         size_t size() const { return n; }
1374         size_t size_left() const { return n-len; }
1375         size_t size_right() const { return len; }
1376         /** Initializes the next partition.
1377             Returns true, if there is one, false otherwise. */
1378         bool next()
1379         {
1380                 if ( last == n-1 ) {
1381                         int rem = len - 1;
1382                         int p = last - 1;
1383                         while ( rem ) {
1384                                 if ( k[p] ) {
1385                                         --rem;
1386                                         --p;
1387                                         continue;
1388                                 }
1389                                 last = p - 1;
1390                                 while ( k[last] == 0 ) { --last; }
1391                                 if ( last == 0 && n == 2*len ) return false;
1392                                 k[last++] = 0;
1393                                 for ( size_t i=0; i<=len-rem; ++i ) {
1394                                         k[last] = 1;
1395                                         ++last;
1396                                 }
1397                                 fill(k.begin()+last, k.end(), 0);
1398                                 --last;
1399                                 split();
1400                                 return true;
1401                         }
1402                         last = len;
1403                         ++len;
1404                         if ( len > n/2 ) return false;
1405                         fill(k.begin(), k.begin()+len, 1);
1406                         fill(k.begin()+len+1, k.end(), 0);
1407                 }
1408                 else {
1409                         k[last++] = 0;
1410                         k[last] = 1;
1411                 }
1412                 split();
1413                 return true;
1414         }
1415         /** Get first partition */
1416         umodpoly& left() { return lr[0]; }
1417         /** Get second partition */
1418         umodpoly& right() { return lr[1]; }
1419 private:
1420         void split_cached()
1421         {
1422                 size_t i = 0;
1423                 do {
1424                         size_t pos = i;
1425                         int group = k[i++];
1426                         size_t d = 0;
1427                         while ( i < n && k[i] == group ) { ++d; ++i; }
1428                         if ( d ) {
1429                                 if ( cache[pos].size() >= d ) {
1430                                         lr[group] = lr[group] * cache[pos][d-1];
1431                                 }
1432                                 else {
1433                                         if ( cache[pos].size() == 0 ) {
1434                                                 cache[pos].push_back(factors[pos] * factors[pos+1]);
1435                                         }
1436                                         size_t j = pos + cache[pos].size() + 1;
1437                                         d -= cache[pos].size();
1438                                         while ( d ) {
1439                                                 umodpoly buf = cache[pos].back() * factors[j];
1440                                                 cache[pos].push_back(buf);
1441                                                 --d;
1442                                                 ++j;
1443                                         }
1444                                         lr[group] = lr[group] * cache[pos].back();
1445                                 }
1446                         }
1447                         else {
1448                                 lr[group] = lr[group] * factors[pos];
1449                         }
1450                 } while ( i < n );
1451         }
1452         void split()
1453         {
1454                 lr[0] = one;
1455                 lr[1] = one;
1456                 if ( n > 6 ) {
1457                         split_cached();
1458                 }
1459                 else {
1460                         for ( size_t i=0; i<n; ++i ) {
1461                                 lr[k[i]] = lr[k[i]] * factors[i];
1462                         }
1463                 }
1464         }
1465 private:
1466         umodpoly lr[2];
1467         vector<vector<umodpoly>> cache;
1468         upvec factors;
1469         umodpoly one;
1470         size_t n;
1471         size_t len;
1472         size_t last;
1473         vector<int> k;
1474 };
1475
1476 /** Contains a pair of univariate polynomial and its modular factors.
1477  *  Used by factor_univariate().
1478  */
1479 struct ModFactors
1480 {
1481         upoly poly;
1482         upvec factors;
1483 };
1484
1485 /** Univariate polynomial factorization.
1486  *
1487  *  Modular factorization is tried for several primes to minimize the number of
1488  *  modular factors. Then, Hensel lifting is performed.
1489  *
1490  *  @param[in]     poly   expanded square free univariate polynomial
1491  *  @param[in]     x      symbol
1492  *  @param[in,out] prime  prime number to start trying modular factorization with,
1493  *                        output value is the prime number actually used
1494  */
1495 static ex factor_univariate(const ex& poly, const ex& x, unsigned int& prime)
1496 {
1497         ex unit, cont, prim_ex;
1498         poly.unitcontprim(x, unit, cont, prim_ex);
1499         upoly prim;
1500         upoly_from_ex(prim, prim_ex, x);
1501
1502         // determine proper prime and minimize number of modular factors
1503         prime = 3;
1504         unsigned int lastp = prime;
1505         cl_modint_ring R;
1506         unsigned int trials = 0;
1507         unsigned int minfactors = 0;
1508
1509         const numeric& cont_n = ex_to<numeric>(cont);
1510         cl_I i_cont;
1511         if (cont_n.is_integer()) {
1512                 i_cont = the<cl_I>(cont_n.to_cl_N());
1513         } else {
1514                 // poly \in Q[x] => poly = q ipoly, ipoly \in Z[x], q \in Q
1515                 // factor(poly) \equiv q factor(ipoly)
1516                 i_cont = cl_I(1);
1517         }
1518         cl_I lc = lcoeff(prim)*i_cont;
1519         upvec factors;
1520         while ( trials < 2 ) {
1521                 umodpoly modpoly;
1522                 while ( true ) {
1523                         prime = next_prime(prime);
1524                         if ( !zerop(rem(lc, prime)) ) {
1525                                 R = find_modint_ring(prime);
1526                                 umodpoly_from_upoly(modpoly, prim, R);
1527                                 if ( squarefree(modpoly) ) break;
1528                         }
1529                 }
1530
1531                 // do modular factorization
1532                 upvec trialfactors;
1533                 factor_modular(modpoly, trialfactors);
1534                 if ( trialfactors.size() <= 1 ) {
1535                         // irreducible for sure
1536                         return poly;
1537                 }
1538
1539                 if ( minfactors == 0 || trialfactors.size() < minfactors ) {
1540                         factors = trialfactors;
1541                         minfactors = trialfactors.size();
1542                         lastp = prime;
1543                         trials = 1;
1544                 }
1545                 else {
1546                         ++trials;
1547                 }
1548         }
1549         prime = lastp;
1550         R = find_modint_ring(prime);
1551
1552         // lift all factor combinations
1553         stack<ModFactors> tocheck;
1554         ModFactors mf;
1555         mf.poly = prim;
1556         mf.factors = factors;
1557         tocheck.push(mf);
1558         upoly f1, f2;
1559         ex result = 1;
1560         while ( tocheck.size() ) {
1561                 const size_t n = tocheck.top().factors.size();
1562                 factor_partition part(tocheck.top().factors);
1563                 while ( true ) {
1564                         // call Hensel lifting
1565                         hensel_univar(tocheck.top().poly, prime, part.left(), part.right(), f1, f2);
1566                         if ( !f1.empty() ) {
1567                                 // successful, update the stack and the result
1568                                 if ( part.size_left() == 1 ) {
1569                                         if ( part.size_right() == 1 ) {
1570                                                 result *= upoly_to_ex(f1, x) * upoly_to_ex(f2, x);
1571                                                 tocheck.pop();
1572                                                 break;
1573                                         }
1574                                         result *= upoly_to_ex(f1, x);
1575                                         tocheck.top().poly = f2;
1576                                         for ( size_t i=0; i<n; ++i ) {
1577                                                 if ( part[i] == 0 ) {
1578                                                         tocheck.top().factors.erase(tocheck.top().factors.begin()+i);
1579                                                         break;
1580                                                 }
1581                                         }
1582                                         break;
1583                                 }
1584                                 else if ( part.size_right() == 1 ) {
1585                                         if ( part.size_left() == 1 ) {
1586                                                 result *= upoly_to_ex(f1, x) * upoly_to_ex(f2, x);
1587                                                 tocheck.pop();
1588                                                 break;
1589                                         }
1590                                         result *= upoly_to_ex(f2, x);
1591                                         tocheck.top().poly = f1;
1592                                         for ( size_t i=0; i<n; ++i ) {
1593                                                 if ( part[i] == 1 ) {
1594                                                         tocheck.top().factors.erase(tocheck.top().factors.begin()+i);
1595                                                         break;
1596                                                 }
1597                                         }
1598                                         break;
1599                                 }
1600                                 else {
1601                                         upvec newfactors1(part.size_left()), newfactors2(part.size_right());
1602                                         auto i1 = newfactors1.begin(), i2 = newfactors2.begin();
1603                                         for ( size_t i=0; i<n; ++i ) {
1604                                                 if ( part[i] ) {
1605                                                         *i2++ = tocheck.top().factors[i];
1606                                                 }
1607                                                 else {
1608                                                         *i1++ = tocheck.top().factors[i];
1609                                                 }
1610                                         }
1611                                         tocheck.top().factors = newfactors1;
1612                                         tocheck.top().poly = f1;
1613                                         ModFactors mf;
1614                                         mf.factors = newfactors2;
1615                                         mf.poly = f2;
1616                                         tocheck.push(mf);
1617                                         break;
1618                                 }
1619                         }
1620                         else {
1621                                 // not successful
1622                                 if ( !part.next() ) {
1623                                         // if no more combinations left, return polynomial as
1624                                         // irreducible
1625                                         result *= upoly_to_ex(tocheck.top().poly, x);
1626                                         tocheck.pop();
1627                                         break;
1628                                 }
1629                         }
1630                 }
1631         }
1632
1633         return unit * cont * result;
1634 }
1635
1636 /** Second interface to factor_univariate() to be used if the information about
1637  *  the prime is not needed.
1638  */
1639 static inline ex factor_univariate(const ex& poly, const ex& x)
1640 {
1641         unsigned int prime;
1642         return factor_univariate(poly, x, prime);
1643 }
1644
1645 /** Represents an evaluation point (<symbol>==<integer>).
1646  */
1647 struct EvalPoint
1648 {
1649         ex x;
1650         int evalpoint;
1651 };
1652
1653 #ifdef DEBUGFACTOR
1654 ostream& operator<<(ostream& o, const vector<EvalPoint>& v)
1655 {
1656         for ( size_t i=0; i<v.size(); ++i ) {
1657                 o << "(" << v[i].x << "==" << v[i].evalpoint << ") ";
1658         }
1659         return o;
1660 }
1661 #endif // def DEBUGFACTOR
1662
1663 // forward declaration
1664 static vector<ex> multivar_diophant(const vector<ex>& a_, const ex& x, const ex& c, const vector<EvalPoint>& I, unsigned int d, unsigned int p, unsigned int k);
1665
1666 /** Utility function for multivariate Hensel lifting.
1667  *
1668  *  Solves the equation
1669  *    s_1*b_1 + ... + s_r*b_r == 1 mod p^k
1670  *  with deg(s_i) < deg(a_i)
1671  *  and with given b_1 = a_1 * ... * a_{i-1} * a_{i+1} * ... * a_r
1672  *
1673  *  The implementation follows the algorithm in chapter 6 of [GCL].
1674  *
1675  *  @param[in]  a   vector of modular univariate polynomials
1676  *  @param[in]  x   symbol
1677  *  @param[in]  p   prime number
1678  *  @param[in]  k   p^k is modulus
1679  *  @return         vector of polynomials (s_i)
1680  */
1681 static upvec multiterm_eea_lift(const upvec& a, const ex& x, unsigned int p, unsigned int k)
1682 {
1683         const size_t r = a.size();
1684         cl_modint_ring R = find_modint_ring(expt_pos(cl_I(p),k));
1685         upvec q(r-1);
1686         q[r-2] = a[r-1];
1687         for ( size_t j=r-2; j>=1; --j ) {
1688                 q[j-1] = a[j] * q[j];
1689         }
1690         umodpoly beta(1, R->one());
1691         upvec s;
1692         for ( size_t j=1; j<r; ++j ) {
1693                 vector<ex> mdarg(2);
1694                 mdarg[0] = umodpoly_to_ex(q[j-1], x);
1695                 mdarg[1] = umodpoly_to_ex(a[j-1], x);
1696                 vector<EvalPoint> empty;
1697                 vector<ex> exsigma = multivar_diophant(mdarg, x, umodpoly_to_ex(beta, x), empty, 0, p, k);
1698                 umodpoly sigma1;
1699                 umodpoly_from_ex(sigma1, exsigma[0], x, R);
1700                 umodpoly sigma2;
1701                 umodpoly_from_ex(sigma2, exsigma[1], x, R);
1702                 beta = sigma1;
1703                 s.push_back(sigma2);
1704         }
1705         s.push_back(beta);
1706         return s;
1707 }
1708
1709 /** Changes the modulus of a modular polynomial. Used by eea_lift().
1710  *
1711  *  @param[in]     R  new modular ring
1712  *  @param[in,out] a  polynomial to change (in situ)
1713  */
1714 static void change_modulus(const cl_modint_ring& R, umodpoly& a)
1715 {
1716         if ( a.empty() ) return;
1717         cl_modint_ring oldR = a[0].ring();
1718         for (auto & i : a) {
1719                 i = R->canonhom(oldR->retract(i));
1720         }
1721         canonicalize(a);
1722 }
1723
1724 /** Utility function for multivariate Hensel lifting.
1725  *
1726  *  Solves  s*a + t*b == 1 mod p^k  given a,b.
1727  *
1728  *  The implementation follows the algorithm in chapter 6 of [GCL].
1729  *
1730  *  @param[in]  a   polynomial
1731  *  @param[in]  b   polynomial
1732  *  @param[in]  x   symbol
1733  *  @param[in]  p   prime number
1734  *  @param[in]  k   p^k is modulus
1735  *  @param[out] s_  output polynomial
1736  *  @param[out] t_  output polynomial
1737  */
1738 static void eea_lift(const umodpoly& a, const umodpoly& b, const ex& x, unsigned int p, unsigned int k, umodpoly& s_, umodpoly& t_)
1739 {
1740         cl_modint_ring R = find_modint_ring(p);
1741         umodpoly amod = a;
1742         change_modulus(R, amod);
1743         umodpoly bmod = b;
1744         change_modulus(R, bmod);
1745
1746         umodpoly smod;
1747         umodpoly tmod;
1748         exteuclid(amod, bmod, smod, tmod);
1749
1750         cl_modint_ring Rpk = find_modint_ring(expt_pos(cl_I(p),k));
1751         umodpoly s = smod;
1752         change_modulus(Rpk, s);
1753         umodpoly t = tmod;
1754         change_modulus(Rpk, t);
1755
1756         cl_I modulus(p);
1757         umodpoly one(1, Rpk->one());
1758         for ( size_t j=1; j<k; ++j ) {
1759                 umodpoly e = one - a * s - b * t;
1760                 reduce_coeff(e, modulus);
1761                 umodpoly c = e;
1762                 change_modulus(R, c);
1763                 umodpoly sigmabar = smod * c;
1764                 umodpoly taubar = tmod * c;
1765                 umodpoly sigma, q;
1766                 remdiv(sigmabar, bmod, sigma, q);
1767                 umodpoly tau = taubar + q * amod;
1768                 umodpoly sadd = sigma;
1769                 change_modulus(Rpk, sadd);
1770                 cl_MI modmodulus(Rpk, modulus);
1771                 s = s + sadd * modmodulus;
1772                 umodpoly tadd = tau;
1773                 change_modulus(Rpk, tadd);
1774                 t = t + tadd * modmodulus;
1775                 modulus = modulus * p;
1776         }
1777
1778         s_ = s; t_ = t;
1779 }
1780
1781 /** Utility function for multivariate Hensel lifting.
1782  *
1783  *  Solves the equation
1784  *    s_1*b_1 + ... + s_r*b_r == x^m mod p^k
1785  *  with given b_1 = a_1 * ... * a_{i-1} * a_{i+1} * ... * a_r
1786  *
1787  *  The implementation follows the algorithm in chapter 6 of [GCL].
1788  *
1789  *  @param a  vector with univariate polynomials mod p^k
1790  *  @param x  symbol
1791  *  @param m  exponent of x^m in the equation to solve
1792  *  @param p  prime number
1793  *  @param k  p^k is modulus
1794  *  @return   vector of polynomials (s_i)
1795  */
1796 static upvec univar_diophant(const upvec& a, const ex& x, unsigned int m, unsigned int p, unsigned int k)
1797 {
1798         cl_modint_ring R = find_modint_ring(expt_pos(cl_I(p),k));
1799
1800         const size_t r = a.size();
1801         upvec result;
1802         if ( r > 2 ) {
1803                 upvec s = multiterm_eea_lift(a, x, p, k);
1804                 for ( size_t j=0; j<r; ++j ) {
1805                         umodpoly bmod = umodpoly_to_umodpoly(s[j], R, m);
1806                         umodpoly buf;
1807                         rem(bmod, a[j], buf);
1808                         result.push_back(buf);
1809                 }
1810         }
1811         else {
1812                 umodpoly s, t;
1813                 eea_lift(a[1], a[0], x, p, k, s, t);
1814                 umodpoly bmod = umodpoly_to_umodpoly(s, R, m);
1815                 umodpoly buf, q;
1816                 remdiv(bmod, a[0], buf, q);
1817                 result.push_back(buf);
1818                 umodpoly t1mod = umodpoly_to_umodpoly(t, R, m);
1819                 buf = t1mod + q * a[1];
1820                 result.push_back(buf);
1821         }
1822
1823         return result;
1824 }
1825
1826 /** Map used by function make_modular().
1827  *  Finds every coefficient in a polynomial and replaces it by is value in the
1828  *  given modular ring R (symmetric representation).
1829  */
1830 struct make_modular_map : public map_function {
1831         cl_modint_ring R;
1832         make_modular_map(const cl_modint_ring& R_) : R(R_) { }
1833         ex operator()(const ex& e)
1834         {
1835                 if ( is_a<add>(e) || is_a<mul>(e) ) {
1836                         return e.map(*this);
1837                 }
1838                 else if ( is_a<numeric>(e) ) {
1839                         numeric mod(R->modulus);
1840                         numeric halfmod = (mod-1)/2;
1841                         cl_MI emod = R->canonhom(the<cl_I>(ex_to<numeric>(e).to_cl_N()));
1842                         numeric n(R->retract(emod));
1843                         if ( n > halfmod ) {
1844                                 return n-mod;
1845                         }
1846                         else {
1847                                 return n;
1848                         }
1849                 }
1850                 return e;
1851         }
1852 };
1853
1854 /** Helps mimicking modular multivariate polynomial arithmetic.
1855  *
1856  *  @param e  expression of which to make the coefficients equal to their value
1857  *            in the modular ring R (symmetric representation)
1858  *  @param R  modular ring
1859  *  @return   resulting expression
1860  */
1861 static ex make_modular(const ex& e, const cl_modint_ring& R)
1862 {
1863         make_modular_map map(R);
1864         return map(e.expand());
1865 }
1866
1867 /** Utility function for multivariate Hensel lifting.
1868  *
1869  *  Returns the polynomials s_i that fulfill
1870  *    s_1*b_1 + ... + s_r*b_r == c mod <I^(d+1),p^k>
1871  *  with given b_1 = a_1 * ... * a_{i-1} * a_{i+1} * ... * a_r
1872  *
1873  *  The implementation follows the algorithm in chapter 6 of [GCL].
1874  *
1875  *  @param a_  vector of multivariate factors mod p^k
1876  *  @param x   symbol (equiv. x_1 in [GCL])
1877  *  @param c   polynomial mod p^k
1878  *  @param I   vector of evaluation points
1879  *  @param d   maximum total degree of result
1880  *  @param p   prime number
1881  *  @param k   p^k is modulus
1882  *  @return    vector of polynomials (s_i)
1883  */
1884 static vector<ex> multivar_diophant(const vector<ex>& a_, const ex& x, const ex& c, const vector<EvalPoint>& I,
1885                                     unsigned int d, unsigned int p, unsigned int k)
1886 {
1887         vector<ex> a = a_;
1888
1889         const cl_modint_ring R = find_modint_ring(expt_pos(cl_I(p),k));
1890         const size_t r = a.size();
1891         const size_t nu = I.size() + 1;
1892
1893         vector<ex> sigma;
1894         if ( nu > 1 ) {
1895                 ex xnu = I.back().x;
1896                 int alphanu = I.back().evalpoint;
1897
1898                 ex A = 1;
1899                 for ( size_t i=0; i<r; ++i ) {
1900                         A *= a[i];
1901                 }
1902                 vector<ex> b(r);
1903                 for ( size_t i=0; i<r; ++i ) {
1904                         b[i] = normal(A / a[i]);
1905                 }
1906
1907                 vector<ex> anew = a;
1908                 for ( size_t i=0; i<r; ++i ) {
1909                         anew[i] = anew[i].subs(xnu == alphanu);
1910                 }
1911                 ex cnew = c.subs(xnu == alphanu);
1912                 vector<EvalPoint> Inew = I;
1913                 Inew.pop_back();
1914                 sigma = multivar_diophant(anew, x, cnew, Inew, d, p, k);
1915
1916                 ex buf = c;
1917                 for ( size_t i=0; i<r; ++i ) {
1918                         buf -= sigma[i] * b[i];
1919                 }
1920                 ex e = make_modular(buf, R);
1921
1922                 ex monomial = 1;
1923                 for ( size_t m=1; !e.is_zero() && e.has(xnu) && m<=d; ++m ) {
1924                         monomial *= (xnu - alphanu);
1925                         monomial = expand(monomial);
1926                         ex cm = e.diff(ex_to<symbol>(xnu), m).subs(xnu==alphanu) / factorial(m);
1927                         cm = make_modular(cm, R);
1928                         if ( !cm.is_zero() ) {
1929                                 vector<ex> delta_s = multivar_diophant(anew, x, cm, Inew, d, p, k);
1930                                 ex buf = e;
1931                                 for ( size_t j=0; j<delta_s.size(); ++j ) {
1932                                         delta_s[j] *= monomial;
1933                                         sigma[j] += delta_s[j];
1934                                         buf -= delta_s[j] * b[j];
1935                                 }
1936                                 e = make_modular(buf, R);
1937                         }
1938                 }
1939         }
1940         else {
1941                 upvec amod;
1942                 for ( size_t i=0; i<a.size(); ++i ) {
1943                         umodpoly up;
1944                         umodpoly_from_ex(up, a[i], x, R);
1945                         amod.push_back(up);
1946                 }
1947
1948                 sigma.insert(sigma.begin(), r, 0);
1949                 size_t nterms;
1950                 ex z;
1951                 if ( is_a<add>(c) ) {
1952                         nterms = c.nops();
1953                         z = c.op(0);
1954                 }
1955                 else {
1956                         nterms = 1;
1957                         z = c;
1958                 }
1959                 for ( size_t i=0; i<nterms; ++i ) {
1960                         int m = z.degree(x);
1961                         cl_I cm = the<cl_I>(ex_to<numeric>(z.lcoeff(x)).to_cl_N());
1962                         upvec delta_s = univar_diophant(amod, x, m, p, k);
1963                         cl_MI modcm;
1964                         cl_I poscm = cm;
1965                         while ( poscm < 0 ) {
1966                                 poscm = poscm + expt_pos(cl_I(p),k);
1967                         }
1968                         modcm = cl_MI(R, poscm);
1969                         for ( size_t j=0; j<delta_s.size(); ++j ) {
1970                                 delta_s[j] = delta_s[j] * modcm;
1971                                 sigma[j] = sigma[j] + umodpoly_to_ex(delta_s[j], x);
1972                         }
1973                         if ( nterms > 1 ) {
1974                                 z = c.op(i+1);
1975                         }
1976                 }
1977         }
1978
1979         for ( size_t i=0; i<sigma.size(); ++i ) {
1980                 sigma[i] = make_modular(sigma[i], R);
1981         }
1982
1983         return sigma;
1984 }
1985
1986 /** Multivariate Hensel lifting.
1987  *  The implementation follows the algorithm in chapter 6 of [GCL].
1988  *  Since we don't have a data type for modular multivariate polynomials, the
1989  *  respective operations are done in a GiNaC::ex and the function
1990  *  make_modular() is then called to make the coefficient modular p^l.
1991  *
1992  *  @param a    multivariate polynomial primitive in x
1993  *  @param x    symbol (equiv. x_1 in [GCL])
1994  *  @param I    vector of evaluation points (x_2==a_2,x_3==a_3,...)
1995  *  @param p    prime number (should not divide lcoeff(a mod I))
1996  *  @param l    p^l is the modulus of the lifted univariate field
1997  *  @param u    vector of modular (mod p^l) factors of a mod I
1998  *  @param lcU  correct leading coefficient of the univariate factors of a mod I
1999  *  @return     list GiNaC::lst with lifted factors (multivariate factors of a),
2000  *              empty if Hensel lifting did not succeed
2001  */
2002 static ex hensel_multivar(const ex& a, const ex& x, const vector<EvalPoint>& I,
2003                           unsigned int p, const cl_I& l, const upvec& u, const vector<ex>& lcU)
2004 {
2005         const size_t nu = I.size() + 1;
2006         const cl_modint_ring R = find_modint_ring(expt_pos(cl_I(p),l));
2007
2008         vector<ex> A(nu);
2009         A[nu-1] = a;
2010
2011         for ( size_t j=nu; j>=2; --j ) {
2012                 ex x = I[j-2].x;
2013                 int alpha = I[j-2].evalpoint;
2014                 A[j-2] = A[j-1].subs(x==alpha);
2015                 A[j-2] = make_modular(A[j-2], R);
2016         }
2017
2018         int maxdeg = a.degree(I.front().x);
2019         for ( size_t i=1; i<I.size(); ++i ) {
2020                 int maxdeg2 = a.degree(I[i].x);
2021                 if ( maxdeg2 > maxdeg ) maxdeg = maxdeg2;
2022         }
2023
2024         const size_t n = u.size();
2025         vector<ex> U(n);
2026         for ( size_t i=0; i<n; ++i ) {
2027                 U[i] = umodpoly_to_ex(u[i], x);
2028         }
2029
2030         for ( size_t j=2; j<=nu; ++j ) {
2031                 vector<ex> U1 = U;
2032                 ex monomial = 1;
2033                 for ( size_t m=0; m<n; ++m) {
2034                         if ( lcU[m] != 1 ) {
2035                                 ex coef = lcU[m];
2036                                 for ( size_t i=j-1; i<nu-1; ++i ) {
2037                                         coef = coef.subs(I[i].x == I[i].evalpoint);
2038                                 }
2039                                 coef = make_modular(coef, R);
2040                                 int deg = U[m].degree(x);
2041                                 U[m] = U[m] - U[m].lcoeff(x) * pow(x,deg) + coef * pow(x,deg);
2042                         }
2043                 }
2044                 ex Uprod = 1;
2045                 for ( size_t i=0; i<n; ++i ) {
2046                         Uprod *= U[i];
2047                 }
2048                 ex e = expand(A[j-1] - Uprod);
2049
2050                 vector<EvalPoint> newI;
2051                 for ( size_t i=1; i<=j-2; ++i ) {
2052                         newI.push_back(I[i-1]);
2053                 }
2054
2055                 ex xj = I[j-2].x;
2056                 int alphaj = I[j-2].evalpoint;
2057                 size_t deg = A[j-1].degree(xj);
2058                 for ( size_t k=1; k<=deg; ++k ) {
2059                         if ( !e.is_zero() ) {
2060                                 monomial *= (xj - alphaj);
2061                                 monomial = expand(monomial);
2062                                 ex dif = e.diff(ex_to<symbol>(xj), k);
2063                                 ex c = dif.subs(xj==alphaj) / factorial(k);
2064                                 if ( !c.is_zero() ) {
2065                                         vector<ex> deltaU = multivar_diophant(U1, x, c, newI, maxdeg, p, cl_I_to_uint(l));
2066                                         for ( size_t i=0; i<n; ++i ) {
2067                                                 deltaU[i] *= monomial;
2068                                                 U[i] += deltaU[i];
2069                                                 U[i] = make_modular(U[i], R);
2070                                         }
2071                                         ex Uprod = 1;
2072                                         for ( size_t i=0; i<n; ++i ) {
2073                                                 Uprod *= U[i];
2074                                         }
2075                                         e = A[j-1] - Uprod;
2076                                         e = make_modular(e, R);
2077                                 }
2078                         }
2079                 }
2080         }
2081
2082         ex acand = 1;
2083         for ( size_t i=0; i<U.size(); ++i ) {
2084                 acand *= U[i];
2085         }
2086         if ( expand(a-acand).is_zero() ) {
2087                 lst res;
2088                 for ( size_t i=0; i<U.size(); ++i ) {
2089                         res.append(U[i]);
2090                 }
2091                 return res;
2092         }
2093         else {
2094                 lst res;
2095                 return lst();
2096         }
2097 }
2098
2099 /** Takes a factorized expression and puts the factors in a lst. The exponents
2100  *  of the factors are discarded, e.g. 7*x^2*(y+1)^4 --> {7,x,y+1}. The first
2101  *  element of the list is always the numeric coefficient.
2102  */
2103 static ex put_factors_into_lst(const ex& e)
2104 {
2105         lst result;
2106         if ( is_a<numeric>(e) ) {
2107                 result.append(e);
2108                 return result;
2109         }
2110         if ( is_a<power>(e) ) {
2111                 result.append(1);
2112                 result.append(e.op(0));
2113                 return result;
2114         }
2115         if ( is_a<symbol>(e) || is_a<add>(e) ) {
2116                 ex icont(e.integer_content());
2117                 result.append(icont);
2118                 result.append(e/icont);
2119                 return result;
2120         }
2121         if ( is_a<mul>(e) ) {
2122                 ex nfac = 1;
2123                 for ( size_t i=0; i<e.nops(); ++i ) {
2124                         ex op = e.op(i);
2125                         if ( is_a<numeric>(op) ) {
2126                                 nfac = op;
2127                         }
2128                         if ( is_a<power>(op) ) {
2129                                 result.append(op.op(0));
2130                         }
2131                         if ( is_a<symbol>(op) || is_a<add>(op) ) {
2132                                 result.append(op);
2133                         }
2134                 }
2135                 result.prepend(nfac);
2136                 return result;
2137         }
2138         throw runtime_error("put_factors_into_lst: bad term.");
2139 }
2140
2141 /** Checks a set of numbers for whether each number has a unique prime factor.
2142  *
2143  *  @param[in]  f  list of numbers to check
2144  *  @return        true: if number set is bad, false: if set is okay (has unique
2145  *                 prime factors)
2146  */
2147 static bool checkdivisors(const lst& f)
2148 {
2149         const int k = f.nops();
2150         numeric q, r;
2151         vector<numeric> d(k);
2152         d[0] = ex_to<numeric>(abs(f.op(0)));
2153         for ( int i=1; i<k; ++i ) {
2154                 q = ex_to<numeric>(abs(f.op(i)));
2155                 for ( int j=i-1; j>=0; --j ) {
2156                         r = d[j];
2157                         do {
2158                                 r = gcd(r, q);
2159                                 q = q/r;
2160                         } while ( r != 1 );
2161                         if ( q == 1 ) {
2162                                 return true;
2163                         }
2164                 }
2165                 d[i] = q;
2166         }
2167         return false;
2168 }
2169
2170 /** Generates a set of evaluation points for a multivariate polynomial.
2171  *  The set fulfills the following conditions:
2172  *  1. lcoeff(evaluated_polynomial) does not vanish
2173  *  2. factors of lcoeff(evaluated_polynomial) have each a unique prime factor
2174  *  3. evaluated_polynomial is square free
2175  *  See [Wan] for more details.
2176  *
2177  *  @param[in]     u        multivariate polynomial to be factored
2178  *  @param[in]     vn       leading coefficient of u in x (x==first symbol in syms)
2179  *  @param[in]     syms     set of symbols that appear in u
2180  *  @param[in]     f        lst containing the factors of the leading coefficient vn
2181  *  @param[in,out] modulus  integer modulus for random number generation (i.e. |a_i| < modulus)
2182  *  @param[out]    u0       returns the evaluated (univariate) polynomial
2183  *  @param[out]    a        returns the valid evaluation points. must have initial size equal
2184  *                          number of symbols-1 before calling generate_set
2185  */
2186 static void generate_set(const ex& u, const ex& vn, const exset& syms, const lst& f,
2187                          numeric& modulus, ex& u0, vector<numeric>& a)
2188 {
2189         const ex& x = *syms.begin();
2190         while ( true ) {
2191                 ++modulus;
2192                 // generate a set of integers ...
2193                 u0 = u;
2194                 ex vna = vn;
2195                 ex vnatry;
2196                 exset::const_iterator s = syms.begin();
2197                 ++s;
2198                 for ( size_t i=0; i<a.size(); ++i ) {
2199                         do {
2200                                 a[i] = mod(numeric(rand()), 2*modulus) - modulus;
2201                                 vnatry = vna.subs(*s == a[i]);
2202                                 // ... for which the leading coefficient doesn't vanish ...
2203                         } while ( vnatry == 0 );
2204                         vna = vnatry;
2205                         u0 = u0.subs(*s == a[i]);
2206                         ++s;
2207                 }
2208                 // ... for which u0 is square free ...
2209                 ex g = gcd(u0, u0.diff(ex_to<symbol>(x)));
2210                 if ( !is_a<numeric>(g) ) {
2211                         continue;
2212                 }
2213                 if ( !is_a<numeric>(vn) ) {
2214                         // ... and for which the evaluated factors have each an unique prime factor
2215                         lst fnum = f;
2216                         fnum.let_op(0) = fnum.op(0) * u0.content(x);
2217                         for ( size_t i=1; i<fnum.nops(); ++i ) {
2218                                 if ( !is_a<numeric>(fnum.op(i)) ) {
2219                                         s = syms.begin();
2220                                         ++s;
2221                                         for ( size_t j=0; j<a.size(); ++j, ++s ) {
2222                                                 fnum.let_op(i) = fnum.op(i).subs(*s == a[j]);
2223                                         }
2224                                 }
2225                         }
2226                         if ( checkdivisors(fnum) ) {
2227                                 continue;
2228                         }
2229                 }
2230                 // ok, we have a valid set now
2231                 return;
2232         }
2233 }
2234
2235 // forward declaration
2236 static ex factor_sqrfree(const ex& poly);
2237
2238 /** Multivariate factorization.
2239  *  
2240  *  The implementation is based on the algorithm described in [Wan].
2241  *  An evaluation homomorphism (a set of integers) is determined that fulfills
2242  *  certain criteria. The evaluated polynomial is univariate and is factorized
2243  *  by factor_univariate(). The main work then is to find the correct leading
2244  *  coefficients of the univariate factors. They have to correspond to the
2245  *  factors of the (multivariate) leading coefficient of the input polynomial
2246  *  (as defined for a specific variable x). After that the Hensel lifting can be
2247  *  performed.
2248  *
2249  *  @param[in] poly  expanded, square free polynomial
2250  *  @param[in] syms  contains the symbols in the polynomial
2251  *  @return          factorized polynomial
2252  */
2253 static ex factor_multivariate(const ex& poly, const exset& syms)
2254 {
2255         exset::const_iterator s;
2256         const ex& x = *syms.begin();
2257
2258         // make polynomial primitive
2259         ex unit, cont, pp;
2260         poly.unitcontprim(x, unit, cont, pp);
2261         if ( !is_a<numeric>(cont) ) {
2262                 return factor_sqrfree(cont) * factor_sqrfree(pp);
2263         }
2264
2265         // factor leading coefficient
2266         ex vn = pp.collect(x).lcoeff(x);
2267         ex vnlst;
2268         if ( is_a<numeric>(vn) ) {
2269                 vnlst = lst(vn);
2270         }
2271         else {
2272                 ex vnfactors = factor(vn);
2273                 vnlst = put_factors_into_lst(vnfactors);
2274         }
2275
2276         const unsigned int maxtrials = 3;
2277         numeric modulus = (vnlst.nops() > 3) ? vnlst.nops() : 3;
2278         vector<numeric> a(syms.size()-1, 0);
2279
2280         // try now to factorize until we are successful
2281         while ( true ) {
2282
2283                 unsigned int trialcount = 0;
2284                 unsigned int prime;
2285                 int factor_count = 0;
2286                 int min_factor_count = -1;
2287                 ex u, delta;
2288                 ex ufac, ufaclst;
2289
2290                 // try several evaluation points to reduce the number of factors
2291                 while ( trialcount < maxtrials ) {
2292
2293                         // generate a set of valid evaluation points
2294                         generate_set(pp, vn, syms, ex_to<lst>(vnlst), modulus, u, a);
2295
2296                         ufac = factor_univariate(u, x, prime);
2297                         ufaclst = put_factors_into_lst(ufac);
2298                         factor_count = ufaclst.nops()-1;
2299                         delta = ufaclst.op(0);
2300
2301                         if ( factor_count <= 1 ) {
2302                                 // irreducible
2303                                 return poly;
2304                         }
2305                         if ( min_factor_count < 0 ) {
2306                                 // first time here
2307                                 min_factor_count = factor_count;
2308                         }
2309                         else if ( min_factor_count == factor_count ) {
2310                                 // one less to try
2311                                 ++trialcount;
2312                         }
2313                         else if ( min_factor_count > factor_count ) {
2314                                 // new minimum, reset trial counter
2315                                 min_factor_count = factor_count;
2316                                 trialcount = 0;
2317                         }
2318                 }
2319
2320                 // determine true leading coefficients for the Hensel lifting
2321                 vector<ex> C(factor_count);
2322                 if ( is_a<numeric>(vn) ) {
2323                         // easy case
2324                         for ( size_t i=1; i<ufaclst.nops(); ++i ) {
2325                                 C[i-1] = ufaclst.op(i).lcoeff(x);
2326                         }
2327                 }
2328                 else {
2329                         // difficult case.
2330                         // we use the property of the ftilde having a unique prime factor.
2331                         // details can be found in [Wan].
2332                         // calculate ftilde
2333                         vector<numeric> ftilde(vnlst.nops()-1);
2334                         for ( size_t i=0; i<ftilde.size(); ++i ) {
2335                                 ex ft = vnlst.op(i+1);
2336                                 s = syms.begin();
2337                                 ++s;
2338                                 for ( size_t j=0; j<a.size(); ++j ) {
2339                                         ft = ft.subs(*s == a[j]);
2340                                         ++s;
2341                                 }
2342                                 ftilde[i] = ex_to<numeric>(ft);
2343                         }
2344                         // calculate D and C
2345                         vector<bool> used_flag(ftilde.size(), false);
2346                         vector<ex> D(factor_count, 1);
2347                         if ( delta == 1 ) {
2348                                 for ( int i=0; i<factor_count; ++i ) {
2349                                         numeric prefac = ex_to<numeric>(ufaclst.op(i+1).lcoeff(x));
2350                                         for ( int j=ftilde.size()-1; j>=0; --j ) {
2351                                                 int count = 0;
2352                                                 while ( irem(prefac, ftilde[j]) == 0 ) {
2353                                                         prefac = iquo(prefac, ftilde[j]);
2354                                                         ++count;
2355                                                 }
2356                                                 if ( count ) {
2357                                                         used_flag[j] = true;
2358                                                         D[i] = D[i] * pow(vnlst.op(j+1), count);
2359                                                 }
2360                                         }
2361                                         C[i] = D[i] * prefac;
2362                                 }
2363                         }
2364                         else {
2365                                 for ( int i=0; i<factor_count; ++i ) {
2366                                         numeric prefac = ex_to<numeric>(ufaclst.op(i+1).lcoeff(x));
2367                                         for ( int j=ftilde.size()-1; j>=0; --j ) {
2368                                                 int count = 0;
2369                                                 while ( irem(prefac, ftilde[j]) == 0 ) {
2370                                                         prefac = iquo(prefac, ftilde[j]);
2371                                                         ++count;
2372                                                 }
2373                                                 while ( irem(ex_to<numeric>(delta)*prefac, ftilde[j]) == 0 ) {
2374                                                         numeric g = gcd(prefac, ex_to<numeric>(ftilde[j]));
2375                                                         prefac = iquo(prefac, g);
2376                                                         delta = delta / (ftilde[j]/g);
2377                                                         ufaclst.let_op(i+1) = ufaclst.op(i+1) * (ftilde[j]/g);
2378                                                         ++count;
2379                                                 }
2380                                                 if ( count ) {
2381                                                         used_flag[j] = true;
2382                                                         D[i] = D[i] * pow(vnlst.op(j+1), count);
2383                                                 }
2384                                         }
2385                                         C[i] = D[i] * prefac;
2386                                 }
2387                         }
2388                         // check if something went wrong
2389                         bool some_factor_unused = false;
2390                         for ( size_t i=0; i<used_flag.size(); ++i ) {
2391                                 if ( !used_flag[i] ) {
2392                                         some_factor_unused = true;
2393                                         break;
2394                                 }
2395                         }
2396                         if ( some_factor_unused ) {
2397                                 continue;
2398                         }
2399                 }
2400                 
2401                 // multiply the remaining content of the univariate polynomial into the
2402                 // first factor
2403                 if ( delta != 1 ) {
2404                         C[0] = C[0] * delta;
2405                         ufaclst.let_op(1) = ufaclst.op(1) * delta;
2406                 }
2407
2408                 // set up evaluation points
2409                 EvalPoint ep;
2410                 vector<EvalPoint> epv;
2411                 s = syms.begin();
2412                 ++s;
2413                 for ( size_t i=0; i<a.size(); ++i ) {
2414                         ep.x = *s++;
2415                         ep.evalpoint = a[i].to_int();
2416                         epv.push_back(ep);
2417                 }
2418
2419                 // calc bound p^l
2420                 int maxdeg = 0;
2421                 for ( int i=1; i<=factor_count; ++i ) {
2422                         if ( ufaclst.op(i).degree(x) > maxdeg ) {
2423                                 maxdeg = ufaclst[i].degree(x);
2424                         }
2425                 }
2426                 cl_I B = 2*calc_bound(u, x, maxdeg);
2427                 cl_I l = 1;
2428                 cl_I pl = prime;
2429                 while ( pl < B ) {
2430                         l = l + 1;
2431                         pl = pl * prime;
2432                 }
2433                 
2434                 // set up modular factors (mod p^l)
2435                 cl_modint_ring R = find_modint_ring(expt_pos(cl_I(prime),l));
2436                 upvec modfactors(ufaclst.nops()-1);
2437                 for ( size_t i=1; i<ufaclst.nops(); ++i ) {
2438                         umodpoly_from_ex(modfactors[i-1], ufaclst.op(i), x, R);
2439                 }
2440
2441                 // try Hensel lifting
2442                 ex res = hensel_multivar(pp, x, epv, prime, l, modfactors, C);
2443                 if ( res != lst() ) {
2444                         ex result = cont * unit;
2445                         for ( size_t i=0; i<res.nops(); ++i ) {
2446                                 result *= res.op(i).content(x) * res.op(i).unit(x);
2447                                 result *= res.op(i).primpart(x);
2448                         }
2449                         return result;
2450                 }
2451         }
2452 }
2453
2454 /** Finds all symbols in an expression. Used by factor_sqrfree() and factor().
2455  */
2456 struct find_symbols_map : public map_function {
2457         exset syms;
2458         ex operator()(const ex& e)
2459         {
2460                 if ( is_a<symbol>(e) ) {
2461                         syms.insert(e);
2462                         return e;
2463                 }
2464                 return e.map(*this);
2465         }
2466 };
2467
2468 /** Factorizes a polynomial that is square free. It calls either the univariate
2469  *  or the multivariate factorization functions.
2470  */
2471 static ex factor_sqrfree(const ex& poly)
2472 {
2473         // determine all symbols in poly
2474         find_symbols_map findsymbols;
2475         findsymbols(poly);
2476         if ( findsymbols.syms.size() == 0 ) {
2477                 return poly;
2478         }
2479
2480         if ( findsymbols.syms.size() == 1 ) {
2481                 // univariate case
2482                 const ex& x = *(findsymbols.syms.begin());
2483                 if ( poly.ldegree(x) > 0 ) {
2484                         // pull out direct factors
2485                         int ld = poly.ldegree(x);
2486                         ex res = factor_univariate(expand(poly/pow(x, ld)), x);
2487                         return res * pow(x,ld);
2488                 }
2489                 else {
2490                         ex res = factor_univariate(poly, x);
2491                         return res;
2492                 }
2493         }
2494
2495         // multivariate case
2496         ex res = factor_multivariate(poly, findsymbols.syms);
2497         return res;
2498 }
2499
2500 /** Map used by factor() when factor_options::all is given to access all
2501  *  subexpressions and to call factor() on them.
2502  */
2503 struct apply_factor_map : public map_function {
2504         unsigned options;
2505         apply_factor_map(unsigned options_) : options(options_) { }
2506         ex operator()(const ex& e)
2507         {
2508                 if ( e.info(info_flags::polynomial) ) {
2509                         return factor(e, options);
2510                 }
2511                 if ( is_a<add>(e) ) {
2512                         ex s1, s2;
2513                         for ( size_t i=0; i<e.nops(); ++i ) {
2514                                 if ( e.op(i).info(info_flags::polynomial) ) {
2515                                         s1 += e.op(i);
2516                                 }
2517                                 else {
2518                                         s2 += e.op(i);
2519                                 }
2520                         }
2521                         s1 = s1.eval();
2522                         s2 = s2.eval();
2523                         return factor(s1, options) + s2.map(*this);
2524                 }
2525                 return e.map(*this);
2526         }
2527 };
2528
2529 } // anonymous namespace
2530
2531 /** Interface function to the outside world. It checks the arguments, tries a
2532  *  square free factorization, and then calls factor_sqrfree to do the hard
2533  *  work.
2534  */
2535 ex factor(const ex& poly, unsigned options)
2536 {
2537         // check arguments
2538         if ( !poly.info(info_flags::polynomial) ) {
2539                 if ( options & factor_options::all ) {
2540                         options &= ~factor_options::all;
2541                         apply_factor_map factor_map(options);
2542                         return factor_map(poly);
2543                 }
2544                 return poly;
2545         }
2546
2547         // determine all symbols in poly
2548         find_symbols_map findsymbols;
2549         findsymbols(poly);
2550         if ( findsymbols.syms.size() == 0 ) {
2551                 return poly;
2552         }
2553         lst syms;
2554         for (auto & i : findsymbols.syms ) {
2555                 syms.append(i);
2556         }
2557
2558         // make poly square free
2559         ex sfpoly = sqrfree(poly.expand(), syms);
2560
2561         // factorize the square free components
2562         if ( is_a<power>(sfpoly) ) {
2563                 // case: (polynomial)^exponent
2564                 const ex& base = sfpoly.op(0);
2565                 if ( !is_a<add>(base) ) {
2566                         // simple case: (monomial)^exponent
2567                         return sfpoly;
2568                 }
2569                 ex f = factor_sqrfree(base);
2570                 return pow(f, sfpoly.op(1));
2571         }
2572         if ( is_a<mul>(sfpoly) ) {
2573                 // case: multiple factors
2574                 ex res = 1;
2575                 for ( size_t i=0; i<sfpoly.nops(); ++i ) {
2576                         const ex& t = sfpoly.op(i);
2577                         if ( is_a<power>(t) ) {
2578                                 const ex& base = t.op(0);
2579                                 if ( !is_a<add>(base) ) {
2580                                         res *= t;
2581                                 }
2582                                 else {
2583                                         ex f = factor_sqrfree(base);
2584                                         res *= pow(f, t.op(1));
2585                                 }
2586                         }
2587                         else if ( is_a<add>(t) ) {
2588                                 ex f = factor_sqrfree(t);
2589                                 res *= f;
2590                         }
2591                         else {
2592                                 res *= t;
2593                         }
2594                 }
2595                 return res;
2596         }
2597         if ( is_a<symbol>(sfpoly) ) {
2598                 return poly;
2599         }
2600         // case: (polynomial)
2601         ex f = factor_sqrfree(sfpoly);
2602         return f;
2603 }
2604
2605 } // namespace GiNaC
2606
2607 #ifdef DEBUGFACTOR
2608 #include "test.h"
2609 #endif