source: git/factory/facFqBivar.h @ a52291

spielwiese
Last change on this file since a52291 was 615ca8, checked in by Martin Lee <martinlee84@…>, 12 years ago
added #ifdef HAVE_NTL for linking against libfactory.so
  • Property mode set to 100644
File size: 23.1 KB
Line 
1/*****************************************************************************\
2 * Computer Algebra System SINGULAR
3\*****************************************************************************/
4/** @file facFqBivar.h
5 *
6 * This file provides functions for factorizing a bivariate polynomial over
7 * \f$ F_{p} \f$ , \f$ F_{p}(\alpha ) \f$ or GF.
8 *
9 * @author Martin Lee
10 *
11 * @internal @version \$Id$
12 *
13 **/
14/*****************************************************************************/
15
16#ifndef FAC_FQ_BIVAR_H
17#define FAC_FQ_BIVAR_H
18
19// #include "config.h"
20
21#include "cf_assert.h"
22
23#include "facFqBivarUtil.h"
24#include "DegreePattern.h"
25#include "ExtensionInfo.h"
26#include "cf_util.h"
27#include "facFqSquarefree.h"
28#include "cf_map.h"
29#include "cfNewtonPolygon.h"
30
31static const double log2exp= 1.442695041;
32
33#ifdef HAVE_NTL
34/// Factorization of a squarefree bivariate polynomials over an arbitrary finite
35/// field, information on the current field we work over is in @a info. @a info
36/// may also contain information about the initial field if initial and current
37/// field do not coincide. In this case the current field is an extension of the
38/// initial field and the factors returned are factors of F over the initial
39/// field.
40///
41/// @return @a biFactorize returns a list of factors of F. If F is not monic
42///         its leading coefficient is not outputted.
43/// @sa extBifactorize()
44CFList
45biFactorize (const CanonicalForm& F,       ///< [in] a bivariate poly
46             const ExtensionInfo& info     ///< [in] information about extension
47            );
48
49/// factorize a squarefree bivariate polynomial over \f$ F_{p} \f$.
50///
51/// @return @a FpBiSqrfFactorize returns a list of monic factors, the first
52///         element is the leading coefficient.
53/// @sa FqBiSqrfFactorize(), GFBiSqrfFactorize()
54inline
55CFList FpBiSqrfFactorize (const CanonicalForm & G ///< [in] a bivariate poly
56                         )
57{
58  ExtensionInfo info= ExtensionInfo (false);
59  CFMap N;
60  CanonicalForm F= compress (G, N);
61  CanonicalForm contentX= content (F, 1);
62  CanonicalForm contentY= content (F, 2);
63  F /= (contentX*contentY);
64  CFFList contentXFactors, contentYFactors;
65  contentXFactors= factorize (contentX);
66  contentYFactors= factorize (contentY);
67  if (contentXFactors.getFirst().factor().inCoeffDomain())
68    contentXFactors.removeFirst();
69  if (contentYFactors.getFirst().factor().inCoeffDomain())
70    contentYFactors.removeFirst();
71  if (F.inCoeffDomain())
72  {
73    CFList result;
74    for (CFFListIterator i= contentXFactors; i.hasItem(); i++)
75      result.append (N (i.getItem().factor()));
76    for (CFFListIterator i= contentYFactors; i.hasItem(); i++)
77      result.append (N (i.getItem().factor()));
78    normalize (result);
79    result.insert (Lc (G));
80    return result;
81  }
82  mat_ZZ M;
83  vec_ZZ S;
84  F= compress (F, M, S);
85  CFList result= biFactorize (F, info);
86  for (CFListIterator i= result; i.hasItem(); i++)
87    i.getItem()= N (decompress (i.getItem(), M, S));
88  for (CFFListIterator i= contentXFactors; i.hasItem(); i++)
89    result.append (N(i.getItem().factor()));
90  for (CFFListIterator i= contentYFactors; i.hasItem(); i++)
91    result.append (N (i.getItem().factor()));
92  normalize (result);
93  result.insert (Lc(G));
94  return result;
95}
96
97/// factorize a squarefree bivariate polynomial over \f$ F_{p}(\alpha ) \f$.
98///
99/// @return @a FqBiSqrfFactorize returns a list of monic factors, the first
100///         element is the leading coefficient.
101/// @sa FpBiSqrfFactorize(), GFBiSqrfFactorize()
102inline
103CFList FqBiSqrfFactorize (const CanonicalForm & G, ///< [in] a bivariate poly
104                          const Variable& alpha    ///< [in] algebraic variable
105                         )
106{
107  ExtensionInfo info= ExtensionInfo (alpha, false);
108  CFMap N;
109  CanonicalForm F= compress (G, N);
110  CanonicalForm contentX= content (F, 1);
111  CanonicalForm contentY= content (F, 2);
112  F /= (contentX*contentY);
113  CFFList contentXFactors, contentYFactors;
114  contentXFactors= factorize (contentX, alpha);
115  contentYFactors= factorize (contentY, alpha);
116  if (contentXFactors.getFirst().factor().inCoeffDomain())
117    contentXFactors.removeFirst();
118  if (contentYFactors.getFirst().factor().inCoeffDomain())
119    contentYFactors.removeFirst();
120  if (F.inCoeffDomain())
121  {
122    CFList result;
123    for (CFFListIterator i= contentXFactors; i.hasItem(); i++)
124      result.append (N (i.getItem().factor()));
125    for (CFFListIterator i= contentYFactors; i.hasItem(); i++)
126      result.append (N (i.getItem().factor()));
127    normalize (result);
128    result.insert (Lc (G));
129    return result;
130  }
131  mat_ZZ M;
132  vec_ZZ S;
133  F= compress (F, M, S);
134  CFList result= biFactorize (F, info);
135  for (CFListIterator i= result; i.hasItem(); i++)
136    i.getItem()= N (decompress (i.getItem(), M, S));
137  for (CFFListIterator i= contentXFactors; i.hasItem(); i++)
138    result.append (N(i.getItem().factor()));
139  for (CFFListIterator i= contentYFactors; i.hasItem(); i++)
140    result.append (N (i.getItem().factor()));
141  normalize (result);
142  result.insert (Lc(G));
143  return result;
144}
145
146/// factorize a squarefree bivariate polynomial over GF
147///
148/// @return @a GFBiSqrfFactorize returns a list of monic factors, the first
149///         element is the leading coefficient.
150/// @sa FpBiSqrfFactorize(), FqBiSqrfFactorize()
151inline
152CFList GFBiSqrfFactorize (const CanonicalForm & G ///< [in] a bivariate poly
153                         )
154{
155  ASSERT (CFFactory::gettype() == GaloisFieldDomain,
156          "GF as base field expected");
157  ExtensionInfo info= ExtensionInfo (getGFDegree(), gf_name, false);
158  CFMap N;
159  CanonicalForm F= compress (G, N);
160  CanonicalForm contentX= content (F, 1);
161  CanonicalForm contentY= content (F, 2);
162  F /= (contentX*contentY);
163  CFList contentXFactors, contentYFactors;
164  contentXFactors= biFactorize (contentX, info);
165  contentYFactors= biFactorize (contentY, info);
166  if (contentXFactors.getFirst().inCoeffDomain())
167    contentXFactors.removeFirst();
168  if (contentYFactors.getFirst().inCoeffDomain())
169    contentYFactors.removeFirst();
170  if (F.inCoeffDomain())
171  {
172    CFList result;
173    for (CFListIterator i= contentXFactors; i.hasItem(); i++)
174      result.append (N (i.getItem()));
175    for (CFListIterator i= contentYFactors; i.hasItem(); i++)
176      result.append (N (i.getItem()));
177    normalize (result);
178    result.insert (Lc (G));
179    return result;
180  }
181  mat_ZZ M;
182  vec_ZZ S;
183  F= compress (F, M, S);
184  CFList result= biFactorize (F, info);
185  for (CFListIterator i= result; i.hasItem(); i++)
186    i.getItem()= N (decompress (i.getItem(), M, S));
187  for (CFListIterator i= contentXFactors; i.hasItem(); i++)
188    result.append (N(i.getItem()));
189  for (CFListIterator i= contentYFactors; i.hasItem(); i++)
190    result.append (N (i.getItem()));
191  normalize (result);
192  result.insert (Lc(G));
193  return result;
194}
195
196/// factorize a bivariate polynomial over \f$ F_{p} \f$
197///
198/// @return @a FpBiFactorize returns a list of monic factors with
199///         multiplicity, the first element is the leading coefficient.
200/// @sa FqBiFactorize(), GFBiFactorize()
201inline
202CFFList FpBiFactorize (const CanonicalForm & G ///< [in] a bivariate poly
203                      )
204{
205  ExtensionInfo info= ExtensionInfo (false);
206  CFMap N;
207  CanonicalForm F= compress (G, N);
208  CanonicalForm LcF= Lc (F);
209  CanonicalForm contentX= content (F, 1);
210  CanonicalForm contentY= content (F, 2);
211  F /= (contentX*contentY);
212  CFFList contentXFactors, contentYFactors;
213  contentXFactors= factorize (contentX);
214  contentYFactors= factorize (contentY);
215  if (contentXFactors.getFirst().factor().inCoeffDomain())
216    contentXFactors.removeFirst();
217  if (contentYFactors.getFirst().factor().inCoeffDomain())
218    contentYFactors.removeFirst();
219  decompress (contentXFactors, N);
220  decompress (contentYFactors, N);
221  CFFList result, resultRoot;
222  if (F.inCoeffDomain())
223  {
224    result= Union (contentXFactors, contentYFactors);
225    normalize (result);
226    result.insert (CFFactor (LcF, 1));
227    return result;
228  }
229  mat_ZZ M;
230  vec_ZZ S;
231  F= compress (F, M, S);
232  CanonicalForm pthRoot, A;
233  CanonicalForm sqrfP= sqrfPart (F/Lc(F), pthRoot, info.getAlpha());
234  CFList buf, bufRoot;
235  int p= getCharacteristic();
236  int l;
237  if (degree (pthRoot) > 0)
238  {
239    pthRoot= maxpthRoot (pthRoot, p, l);
240    result= FpBiFactorize (pthRoot);
241    result.removeFirst();
242    for (CFFListIterator i= result; i.hasItem(); i++)
243      i.getItem()= CFFactor (N (decompress (i.getItem().factor(), M, S)),
244                             i.getItem().exp()*ipower (p,l));
245    result= Union (result, contentXFactors);
246    result= Union (result, contentYFactors);
247    normalize (result);
248    result.insert (CFFactor (LcF, 1));
249    return result;
250  }
251  else
252  {
253    buf= biFactorize (sqrfP, info);
254    A= F/LcF;
255    result= multiplicity (A, buf);
256    for (CFFListIterator i= result; i.hasItem(); i++)
257      i.getItem()= CFFactor (N (decompress (i.getItem().factor(), M, S)),
258                             i.getItem().exp());
259  }
260  if (degree (A) > 0)
261  {
262    resultRoot= FpBiFactorize (A);
263    resultRoot.removeFirst();
264    for (CFFListIterator i= resultRoot; i.hasItem(); i++)
265      i.getItem()= CFFactor (N (decompress (i.getItem().factor(), M, S)),
266                             i.getItem().exp());
267    result= Union (result, resultRoot);
268  }
269  result= Union (result, contentXFactors);
270  result= Union (result, contentYFactors);
271  normalize (result);
272  result.insert (CFFactor (LcF, 1));
273  return result;
274}
275
276/// factorize a bivariate polynomial over \f$ F_{p}(\alpha ) \f$
277///
278/// @return @a FqBiFactorize returns a list of monic factors with
279///         multiplicity, the first element is the leading coefficient.
280/// @sa FpBiFactorize(), FqBiFactorize()
281inline
282CFFList FqBiFactorize (const CanonicalForm & G, ///< [in] a bivariate poly
283                       const Variable & alpha   ///< [in] algebraic variable
284                      )
285{
286  ExtensionInfo info= ExtensionInfo (alpha, false);
287  CFMap N;
288  CanonicalForm F= compress (G, N);
289  CanonicalForm LcF= Lc (F);
290  CanonicalForm contentX= content (F, 1);
291  CanonicalForm contentY= content (F, 2);
292  F /= (contentX*contentY);
293  CFFList contentXFactors, contentYFactors;
294  contentXFactors= factorize (contentX, alpha);
295  contentYFactors= factorize (contentY, alpha);
296  if (contentXFactors.getFirst().factor().inCoeffDomain())
297    contentXFactors.removeFirst();
298  if (contentYFactors.getFirst().factor().inCoeffDomain())
299    contentYFactors.removeFirst();
300  decompress (contentXFactors, N);
301  decompress (contentYFactors, N);
302  CFFList result, resultRoot;
303  if (F.inCoeffDomain())
304  {
305    result= Union (contentXFactors, contentYFactors);
306    normalize (result);
307    result.insert (CFFactor (LcF, 1));
308    return result;
309  }
310  mat_ZZ M;
311  vec_ZZ S;
312  CanonicalForm oldF= F;
313  F= compress (F, M, S);
314  CanonicalForm pthRoot, A, tmp;
315  CanonicalForm sqrfP= sqrfPart (F/Lc(F), pthRoot, alpha);
316  CFList buf, bufRoot;
317  int p= getCharacteristic();
318  int q= ipower (p, degree (getMipo (alpha)));
319  int l;
320  if (degree (pthRoot) > 0)
321  {
322    pthRoot= maxpthRoot (pthRoot, q, l);
323    result= FqBiFactorize (pthRoot, alpha);
324    result.removeFirst();
325    for (CFFListIterator i= result; i.hasItem(); i++)
326      i.getItem()= CFFactor (N (decompress (i.getItem().factor(), M, S)),
327                             i.getItem().exp()*ipower (p,l));
328    result= Union (result, contentXFactors);
329    result= Union (result, contentYFactors);
330    normalize (result);
331    result.insert (CFFactor (LcF, 1));
332    return result;
333  }
334  else
335  {
336    buf= biFactorize (sqrfP, info);
337    A= F/LcF;
338    result= multiplicity (A, buf);
339    for (CFFListIterator i= result; i.hasItem(); i++)
340      i.getItem()= CFFactor (N (decompress (i.getItem().factor(), M, S)),
341                             i.getItem().exp());
342  }
343  if (degree (A) > 0)
344  {
345    resultRoot= FqBiFactorize (A, alpha);
346    resultRoot.removeFirst();
347    for (CFFListIterator i= resultRoot; i.hasItem(); i++)
348      i.getItem()= CFFactor (N (decompress (i.getItem().factor(), M, S)),
349                             i.getItem().exp());
350    result= Union (result, resultRoot);
351  }
352  result= Union (result, contentXFactors);
353  result= Union (result, contentYFactors);
354  normalize (result);
355  result.insert (CFFactor (LcF, 1));
356  return result;
357}
358
359/// factorize a bivariate polynomial over GF
360///
361/// @return @a GFBiFactorize returns a list of monic factors with
362///         multiplicity, the first element is the leading coefficient.
363/// @sa FpBiFactorize(), FqBiFactorize()
364inline
365CFFList GFBiFactorize (const CanonicalForm & G ///< [in] a bivariate poly
366                      )
367{
368  ASSERT (CFFactory::gettype() == GaloisFieldDomain,
369          "GF as base field expected");
370  ExtensionInfo info= ExtensionInfo (getGFDegree(), gf_name, false);
371  CFMap N;
372  CanonicalForm F= compress (G, N);
373  CanonicalForm LcF= Lc (F);
374  CanonicalForm contentX= content (F, 1);
375  CanonicalForm contentY= content (F, 2);
376  F /= (contentX*contentY);
377  CFFList contentXFactors, contentYFactors;
378  contentXFactors= factorize (contentX);
379  contentYFactors= factorize (contentY);
380  if (contentXFactors.getFirst().factor().inCoeffDomain())
381    contentXFactors.removeFirst();
382  if (contentYFactors.getFirst().factor().inCoeffDomain())
383    contentYFactors.removeFirst();
384  decompress (contentXFactors, N);
385  decompress (contentYFactors, N);
386  CFFList result, resultRoot;
387  if (F.inCoeffDomain())
388  {
389    result= Union (contentXFactors, contentYFactors);
390    normalize (result);
391    result.insert (CFFactor (LcF, 1));
392    return result;
393  }
394  mat_ZZ M;
395  vec_ZZ S;
396  F= compress (F, M, S);
397  CanonicalForm pthRoot, A;
398  CanonicalForm sqrfP= sqrfPart (F/LcF, pthRoot, info.getAlpha());
399  CFList buf;
400  int p= getCharacteristic();
401  int q= ipower (p, getGFDegree());
402  int l;
403  if (degree (pthRoot) > 0)
404  {
405    pthRoot= maxpthRoot (pthRoot, q, l);
406    result= GFBiFactorize (pthRoot);
407    result.removeFirst();
408    for (CFFListIterator i= result; i.hasItem(); i++)
409      i.getItem()= CFFactor (N (decompress (i.getItem().factor(), M, S)),
410                             i.getItem().exp()*ipower (p,l));
411    result= Union (result, contentXFactors);
412    result= Union (result, contentYFactors);
413    normalize (result);
414    result.insert (CFFactor (LcF, 1));
415    return result;
416  }
417  else
418  {
419    buf= biFactorize (sqrfP, info);
420    A= F/LcF;
421    result= multiplicity (A, buf);
422    for (CFFListIterator i= result; i.hasItem(); i++)
423      i.getItem()= CFFactor (N (decompress (i.getItem().factor(), M, S)),
424                             i.getItem().exp());
425  }
426  if (degree (A) > 0)
427  {
428    resultRoot= GFBiFactorize (A);
429    resultRoot.removeFirst();
430    for (CFFListIterator i= resultRoot; i.hasItem(); i++)
431      i.getItem()= CFFactor (N (decompress (i.getItem().factor(), M, S)),
432                             i.getItem().exp());
433    result= Union (result, resultRoot);
434  }
435  result= Union (result, contentXFactors);
436  result= Union (result, contentYFactors);
437  normalize (result);
438  result.insert (CFFactor (LcF, 1));
439  return result;
440}
441
442/// \f$ \prod_{f\in L} {f (0, x)} \ mod\ M \f$ via divide-and-conquer
443///
444/// @return @a prodMod0 computes the above defined product
445/// @sa prodMod()
446CanonicalForm prodMod0 (const CFList& L,       ///< [in] a list of compressed,
447                                               ///< bivariate polynomials
448                        const CanonicalForm& M ///< [in] a power of Variable (2)
449                       );
450
451/// find an evaluation point p, s.t. F(p,y) is squarefree and
452/// \f$ deg_{y} (F(p,y))= deg_{y} (F(x,y)) \f$.
453///
454/// @return @a evalPoint returns an evaluation point, which is valid if and only
455///         if fail == false.
456CanonicalForm
457evalPoint (const CanonicalForm& F, ///< [in] compressed, bivariate poly
458           CanonicalForm & eval,   ///< [in,out] F (p, y)
459           const Variable& alpha,  ///< [in] algebraic variable
460           CFList& list,           ///< [in] list of points already considered
461           const bool& GF,         ///< [in] GaloisFieldDomain?
462           bool& fail              ///< [in,out] equals true, if there is no
463                                   ///< valid evaluation point
464          );
465
466/// Univariate factorization of squarefree monic polys over finite fields via
467/// NTL. If the characteristic is even special GF2 routines of NTL are used.
468///
469/// @return @a uniFactorizer returns a list of monic factors
470CFList
471uniFactorizer (const CanonicalForm& A, ///< [in] squarefree univariate poly
472               const Variable& alpha,  ///< [in] algebraic variable
473               const bool& GF          ///< [in] GaloisFieldDomain?
474              );
475
476/// naive factor recombination over an extension of the initial field.
477/// Uses precomputed data to exclude combinations that are not possible.
478///
479/// @return @a extFactorRecombination returns a list of factors over the initial
480///         field, whose shift to zero is reversed.
481/// @sa factorRecombination(), extEarlyFactorDetection()
482CFList
483extFactorRecombination (
484         CFList& factors,          ///< [in,out] list of lifted factors that are
485                                   ///< monic wrt Variable (1),
486                                   ///< original factors-factors found
487         CanonicalForm& F,         ///< [in,out] poly to be factored,
488                                   ///< F/factors found
489         const CanonicalForm& M,   ///< [in] Variable (2)^liftBound
490         const ExtensionInfo& info,///< [in] contains information about
491                                   ///< extension
492         DegreePattern& degs,
493         const CanonicalForm& eval,///< [in] evaluation point
494         int s,                    ///< [in] algorithm starts checking subsets
495                                   ///< of size s
496         int thres                 ///< [in] threshold for the size of subsets
497                                   ///< which are checked, for a full factor
498                                   ///< recombination choose
499                                   ///< thres= factors.length()/2
500                       );
501
502/// naive factor recombination.
503/// Uses precomputed data to exclude combinations that are not possible.
504///
505/// @return @a factorRecombination returns a list of factors of F.
506/// @sa extFactorRecombination(), earlyFactorDetectection()
507CFList
508factorRecombination (
509                CFList& factors,       ///< [in,out] list of lifted factors
510                                       ///< that are monic wrt Variable (1)
511                CanonicalForm& F,      ///< [in,out] poly to be factored
512                const CanonicalForm& M,///< [in] Variable (2)^liftBound
513                DegreePattern& degs,   ///< [in] degree pattern
514                int s,                 ///< [in] algorithm starts checking
515                                       ///< subsets of size s
516                int thres              ///< [in] threshold for the size of
517                                       ///< subsets which are checked, for a
518                                       ///< full factor recombination choose
519                                       ///< thres= factors.length()/2
520                    );
521
522/// chooses a field extension.
523///
524/// @return @a chooseExtension returns an extension specified by @a beta of
525///         appropiate size
526Variable chooseExtension (
527                      const Variable & alpha, ///< [in] some algebraic variable
528                      const Variable & beta,  ///< [in] some algebraic variable
529                      int k                   ///< [in] some int
530                         );
531
532/// detects factors of @a F at stage @a deg of Hensel lifting.
533/// No combinations of more than one factor are tested. Lift bound and possible
534/// degree pattern are updated.
535///
536/// @return @a earlyFactorDetection returns a list of factors of F (possibly in-
537///         complete), in case of success. Otherwise an empty list.
538/// @sa factorRecombination(), extEarlyFactorDetection()
539CFList
540earlyFactorDetection (
541           CanonicalForm& F,       ///< [in,out] poly to be factored, returns
542                                   ///< poly divided by detected factors in case
543                                   ///< of success
544           CFList& factors,        ///< [in,out] list of factors lifted up to
545                                   ///< @a deg, returns a list of factors
546                                   ///< without detected factors
547           int& adaptedLiftBound,  ///< [in,out] adapted lift bound
548           DegreePattern& degs,    ///< [in,out] degree pattern, is updated
549                                   ///< whenever we find a factor
550           bool& success,          ///< [in,out] indicating success
551           int deg                 ///< [in] stage of Hensel lifting
552                     );
553
554/// detects factors of @a F at stage @a deg of Hensel lifting.
555/// No combinations of more than one factor are tested. Lift bound and possible
556/// degree pattern are updated.
557///
558/// @return @a extEarlyFactorDetection returns a list of factors of F (possibly
559///         incomplete), whose shift to zero is reversed, in case of success.
560///         Otherwise an empty list.
561/// @sa factorRecombination(), earlyFactorDetection()
562CFList
563extEarlyFactorDetection (
564        CanonicalForm& F,          ///< [in,out] poly to be factored, returns
565                                   ///< poly divided by detected factors in case
566                                   ///< of success
567        CFList& factors,           ///< [in,out] list of factors lifted up to
568                                   ///< @a deg, returns a list of factors
569                                   ///< without detected factors
570        int& adaptedLiftBound,     ///< [in,out] adapted lift bound
571        DegreePattern& degs,       ///< [in,out] degree pattern, is updated
572                                   ///< whenever we find a factor
573        bool& success,             ///< [in,out] indicating success
574        const ExtensionInfo& info,  ///< [in] information about extension
575        const CanonicalForm& eval, ///< [in] evaluation point
576        int deg                    ///< [in] stage of Hensel lifting
577                      );
578
579/// hensel Lifting and early factor detection
580///
581/// @return @a henselLiftAndEarly returns monic (wrt Variable (1)) lifted
582///         factors without factors which have been detected at an early stage
583///         of Hensel lifting
584/// @sa earlyFactorDetection(), extEarlyFactorDetection()
585
586CFList
587henselLiftAndEarly (
588        CanonicalForm& A,          ///< [in,out] poly to be factored,
589                                   ///< returns poly divided by detected factors
590                                   ///< in case of success
591        bool& earlySuccess,        ///< [in,out] indicating success
592        CFList& earlyFactors,      ///< [in,out] list of factors detected
593                                   ///< at early stage of Hensel lifting
594        DegreePattern& degs,       ///< [in,out] degree pattern
595        int& liftBound,            ///< [in,out] (adapted) lift bound
596        const CFList& uniFactors,  ///< [in] univariate factors
597        const ExtensionInfo& info, ///< [in] information about extension
598        const CanonicalForm& eval  ///< [in] evaluation point
599                  );
600
601/// Factorization over an extension of initial field
602///
603/// @return @a extBiFactorize returns factorization of F over initial field
604/// @sa biFactorize()
605CFList
606extBiFactorize (const CanonicalForm& F,    ///< [in] poly to be factored
607                const ExtensionInfo& info  ///< [in] info about extension
608               );
609
610#endif
611#endif
612/* FAC_FQ_BIVAR_H */
613
Note: See TracBrowser for help on using the repository browser.