Beispiel #1
0
 /**
  * Coefficient squarefree factorization.
  *
  * @param coeff coefficient.
  * @return [p_1 -> e_1, ..., p_k -> e_k] with P = prod_{i=1,...,k} p_i^{e_i} and p_i
  *     squarefree.
  */
 @Override
 public SortedMap<C, Long> squarefreeFactors(C coeff) {
   if (coeff == null) {
     return null;
   }
   SortedMap<C, Long> factors = new TreeMap<C, Long>();
   RingFactory<C> cfac = (RingFactory<C>) coeff.factory();
   if (aCoFac != null) {
     AlgebraicNumber<C> an = (AlgebraicNumber<C>) (Object) coeff;
     if (cfac.isFinite()) {
       SquarefreeFiniteFieldCharP<C> reng =
           (SquarefreeFiniteFieldCharP) SquarefreeFactory.getImplementation(cfac);
       SortedMap<C, Long> rfactors = reng.rootCharacteristic(coeff); // ??
       logger.info("rfactors,finite = " + rfactors);
       factors.putAll(rfactors);
       // return factors;
     } else {
       SquarefreeInfiniteAlgebraicFieldCharP<C> reng =
           (SquarefreeInfiniteAlgebraicFieldCharP) SquarefreeFactory.getImplementation(cfac);
       SortedMap<AlgebraicNumber<C>, Long> rfactors = reng.squarefreeFactors(an);
       logger.info("rfactors,infinite,algeb = " + rfactors);
       for (Map.Entry<AlgebraicNumber<C>, Long> me : rfactors.entrySet()) {
         AlgebraicNumber<C> c = me.getKey();
         if (!c.isONE()) {
           C cr = (C) (Object) c;
           Long rk = me.getValue(); // rfactors.get(c);
           factors.put(cr, rk);
         }
       }
     }
   } else if (qCoFac != null) {
     Quotient<C> q = (Quotient<C>) (Object) coeff;
     SquarefreeInfiniteFieldCharP<C> reng =
         (SquarefreeInfiniteFieldCharP) SquarefreeFactory.getImplementation(cfac);
     SortedMap<Quotient<C>, Long> rfactors = reng.squarefreeFactors(q);
     logger.info("rfactors,infinite = " + rfactors);
     for (Map.Entry<Quotient<C>, Long> me : rfactors.entrySet()) {
       Quotient<C> c = me.getKey();
       if (!c.isONE()) {
         C cr = (C) (Object) c;
         Long rk = me.getValue(); // rfactors.get(c);
         factors.put(cr, rk);
       }
     }
   } else if (cfac.isFinite()) {
     SquarefreeFiniteFieldCharP<C> reng =
         (SquarefreeFiniteFieldCharP) SquarefreeFactory.getImplementation(cfac);
     SortedMap<C, Long> rfactors = reng.rootCharacteristic(coeff); // ??
     logger.info("rfactors,finite = " + rfactors);
     factors.putAll(rfactors);
     // return factors;
   } else {
     logger.warn("case " + cfac + " not implemented");
   }
   return factors;
 }
Beispiel #2
0
  /**
   * GenPolynomial absolute factorization of a irreducible polynomial.
   *
   * @param P irreducible! GenPolynomial.
   * @return factors container: [p_1,...,p_k] with P = prod_{i=1, ..., k} p_i in K(alpha)[x] for
   *     suitable alpha and p_i irreducible over L[x], where K \subset K(alpha) \subset L is an
   *     algebraically closed field over K. <b>Note:</b> K(alpha) not yet minimal.
   */
  public Factors<C> factorsAbsoluteIrreducible(GenPolynomial<C> P) {
    if (P == null) {
      throw new RuntimeException(this.getClass().getName() + " P == null");
    }
    if (P.isZERO()) {
      return new Factors<C>(P);
    }
    GenPolynomialRing<C> pfac = P.ring; // K[x]
    if (pfac.nvar <= 1) {
      return baseFactorsAbsoluteIrreducible(P);
    }
    if (!pfac.coFac.isField()) {
      throw new RuntimeException("only for field coefficients");
    }
    List<GenPolynomial<C>> factors = new ArrayList<GenPolynomial<C>>();
    if (P.degree() <= 1) {
      return new Factors<C>(P);
    }
    // find field extension K(alpha)
    GenPolynomial<C> up = P;
    RingFactory<C> cf = pfac.coFac;
    long cr = cf.characteristic().longValue(); // char might be larger
    if (cr == 0L) {
      cr = Long.MAX_VALUE;
    }
    long rp = 0L;
    for (int i = 0; i < (pfac.nvar - 1); i++) {
      rp = 0L;
      GenPolynomialRing<C> nfac = pfac.contract(1);
      String[] vn = new String[] {pfac.getVars()[pfac.nvar - 1]};
      GenPolynomialRing<GenPolynomial<C>> rfac =
          new GenPolynomialRing<GenPolynomial<C>>(nfac, 1, pfac.tord, vn);
      GenPolynomial<GenPolynomial<C>> upr = PolyUtil.<C>recursive(rfac, up);
      // System.out.println("upr = " + upr);
      GenPolynomial<C> ep;
      do {
        if (rp >= cr) {
          throw new RuntimeException("elements of prime field exhausted: " + cr);
        }
        C r = cf.fromInteger(rp); // cf.random(rp);
        // System.out.println("r   = " + r);
        ep = PolyUtil.<C>evaluateMain(nfac, upr, r);
        // System.out.println("ep  = " + ep);
        rp++;
      } while (!isSquarefree(ep) /*todo: || ep.degree() <= 1*/); // max deg
      up = ep;
      pfac = nfac;
    }
    up = up.monic();
    if (debug) {
      logger.info("P(" + rp + ") = " + up);
      // System.out.println("up  = " + up);
    }
    if (debug && !isSquarefree(up)) {
      throw new RuntimeException("not irreducible up = " + up);
    }
    if (up.degree(0) <= 1) {
      return new Factors<C>(P);
    }
    // find irreducible factor of up
    List<GenPolynomial<C>> UF = baseFactorsSquarefree(up);
    // System.out.println("UF  = " + UF);
    FactorsList<C> aUF = baseFactorsAbsoluteSquarefree(up);
    // System.out.println("aUF  = " + aUF);
    AlgebraicNumberRing<C> arfac = aUF.findExtensionField();
    // System.out.println("arfac  = " + arfac);

    long e = up.degree(0);
    // search factor polynomial with smallest degree
    for (int i = 0; i < UF.size(); i++) {
      GenPolynomial<C> upi = UF.get(i);
      long d = upi.degree(0);
      if (1 <= d && d <= e) {
        up = upi;
        e = up.degree(0);
      }
    }
    if (up.degree(0) <= 1) {
      return new Factors<C>(P);
    }
    if (debug) {
      logger.info("field extension by " + up);
    }

    List<GenPolynomial<AlgebraicNumber<C>>> afactors =
        new ArrayList<GenPolynomial<AlgebraicNumber<C>>>();

    // setup field extension K(alpha)
    // String[] vars = new String[] { "z_" + Math.abs(up.hashCode() % 1000) };
    String[] vars = pfac.newVars("z_");
    pfac = pfac.clone();
    String[] ovars = pfac.setVars(vars); // side effects!
    GenPolynomial<C> aup = pfac.copy(up); // hack to exchange the variables

    // AlgebraicNumberRing<C> afac = new AlgebraicNumberRing<C>(aup,true); // since irreducible
    AlgebraicNumberRing<C> afac = arfac;
    int depth = afac.depth();
    // System.out.println("afac = " + afac);
    GenPolynomialRing<AlgebraicNumber<C>> pafac =
        new GenPolynomialRing<AlgebraicNumber<C>>(afac, P.ring.nvar, P.ring.tord, P.ring.getVars());
    // System.out.println("pafac = " + pafac);
    // convert to K(alpha)
    GenPolynomial<AlgebraicNumber<C>> Pa =
        PolyUtil.<C>convertToRecAlgebraicCoefficients(depth, pafac, P);
    // System.out.println("Pa = " + Pa);
    // factor over K(alpha)
    FactorAbstract<AlgebraicNumber<C>> engine = FactorFactory.<C>getImplementation(afac);
    afactors = engine.factorsSquarefree(Pa);
    if (debug) {
      logger.info("K(alpha) factors multi = " + afactors);
      // System.out.println("K(alpha) factors = " + afactors);
    }
    if (afactors.size() <= 1) {
      return new Factors<C>(P);
    }
    // normalize first factor to monic
    GenPolynomial<AlgebraicNumber<C>> p1 = afactors.get(0);
    AlgebraicNumber<C> p1c = p1.leadingBaseCoefficient();
    if (!p1c.isONE()) {
      GenPolynomial<AlgebraicNumber<C>> p2 = afactors.get(1);
      afactors.remove(p1);
      afactors.remove(p2);
      p1 = p1.divide(p1c);
      p2 = p2.multiply(p1c);
      afactors.add(p1);
      afactors.add(p2);
    }
    // recursion for splitting field
    // find minimal field extension K(beta) \subset K(alpha)
    return new Factors<C>(P, afac, Pa, afactors);
  }