createF4Res

ResolutionComputation * createF4Res ( const Matrix * groebnerBasisMatrix, int max_level, int strategy, int numThreads, bool parallelizeByDegree )

friend

createF4Res The only function to create an (F4) resolution computation The constructor for this class is private. This function provides all of the logic, and throws an exception if there is a problem.

Definition at line 27 of file res-f4-computation.cpp.

{
  // We expect the following to hold:
  // the ring of groebnerBasisMatrix is a PolynomialRing, but not:
  //   quotient ring
  //   Weyl algebra
  // We assume also that the matrix is homogeneous.
  // If any of these are incorrect, an error message is provided, and
  // null is returned.
  (void) strategy;
  const PolynomialRing* origR =
      groebnerBasisMatrix->get_ring()->cast_to_PolynomialRing();
  if (origR == nullptr)
    {
      ERROR("expected polynomial ring");
      return nullptr;
    }
  if (origR->is_quotient_ring())
    {
      ERROR("cannot use res(...,FastNonminimal=>true) for quotient rings");
      return nullptr;
    }
  if (origR->is_weyl_algebra())
    {
      ERROR("cannot use res(...,FastNonminimal=>true) over Weyl algebras");
      return nullptr;
    }
  if (origR->is_solvable_algebra())
    {
      ERROR(
          "cannot use res(...,FastNonminimal=>true) over non-commutative "
          "algebras");
      return nullptr;
    }
  //  if (!groebnerBasisMatrix->is_homogeneous())
  //    {
  //      ERROR(
  //          "cannot use res(...,FastNonminimal=>true) with inhomogeneous input");
  //      return nullptr;
  //    }
  //  if (origR->getMonoid()->get_degree_ring()->n_vars() != 1)
  //    {
  //      ERROR("expected singly graded with positive degrees for the variables");
  //      return nullptr;
  //    }
  if (!origR->getMonoid()->primary_degrees_of_vars_positive())
    {
      ERROR("expected the degree of each variable to be positive");
      return nullptr;
    }
  // Still to check:
  //   (a) coefficients are ZZ/p, for p in range.
 
  const Ring* K = origR->getCoefficients();
  auto mo = origR->getMonoid()->getMonomialOrdering();  // mon ordering
  auto motype = MonomialOrderingType::Weights;
  if (moIsLex(mo))
    motype = MonomialOrderingType::Lex;
  else if (moIsGRevLex(mo))
    motype = MonomialOrderingType::GRevLex;
 
  auto MI = new ResMonoid(origR->n_vars(),
                          origR->getMonoid()->getPrimaryDegreeVector(),
                          origR->getMonoid()->getFirstWeightVector(),
                          motype);
  ResPolyRing* R;
  if (origR->is_skew_commutative())
    {
      R = new ResPolyRing(K, MI, origR->getMonoid(), &(origR->getSkewInfo()));
    }
  else
    {
      R = new ResPolyRing(K, MI, origR->getMonoid());
    }
  auto result = new F4ResComputation(origR, R, groebnerBasisMatrix, max_level, numThreads, parallelizeByDegree);
 
  // Set level 0
  // take the columns of the matrix, and insert them into mComp
  const FreeModule* F = groebnerBasisMatrix->rows();
  int maxdeg = 0;
  if (F->rank() > 0)
    {
      maxdeg = F->primary_degree(0);
      for (int j = 1; j < F->rank(); j++)
        if (maxdeg < F->primary_degree(j)) maxdeg = F->primary_degree(j);
    }
 
  // Set level 0
  // take the info from F, place it into mComp
  SchreyerFrame& frame = result->frame();
  for (int i = 0; i < F->rank(); i++)
    {
      res_packed_monomial elem =
          frame.monomialBlock().allocate(MI->max_monomial_size());
      MI->one(i, elem);
      frame.insertLevelZero(elem, F->primary_degree(i), maxdeg);
    }
  frame.endLevel();
 
  // At this point, we want to sort the columns of groebnerBasisMatrix.
  Matrix* leadterms = groebnerBasisMatrix->lead_term();
  M2_arrayint pos = leadterms->sort(1 /* ascending degree */,
                                    -1 /* descending monomial order */);
 
  std::vector<ResPolynomial> input_polys;
  for (int i = 0; i < groebnerBasisMatrix->n_cols(); i++)
    {
      ResPolynomial f;
      ResF4toM2Interface::from_M2_vec(*R, F, groebnerBasisMatrix->elem(i), f);
      input_polys.emplace_back(std::move(f));
    }
 
  // Set level 1.
  for (int j = 0; j < F->rank(); j++)
    {
      // Only insert the ones whose lead monomials are in component j:
      for (int i = 0; i < pos->len; i++)
        {
          int loc = pos->array[i];
          ResPolynomial& f = input_polys[loc];
          if (f.len == 0) continue;
          if (MI->get_component(f.monoms.data()) != j) continue;
          res_packed_monomial elem =
              frame.monomialBlock().allocate(MI->max_monomial_size());
          MI->copy(f.monoms.data(), elem);
          // the following line grabs f.
          if (!frame.insertLevelOne(
                  elem, groebnerBasisMatrix->cols()->primary_degree(loc), f))
            {
              ERROR(
                  "input polynomials/vectors were computed in a non-compatible "
                  "monomial order");
              // TODO: clean up.
              return nullptr;
            }
        }
    }
  frame.endLevel();
  // frame.show(0);
  // Remove matrix:
  delete leadterms;
 
  return result;
}

References Ring::cast_to_PolynomialRing(), ERROR, Matrix::get_ring(), PolynomialRing::getMonoid(), PolynomialRing::is_quotient_ring(), PolynomialRing::is_solvable_algebra(), PolynomialRing::is_weyl_algebra(), Matrix, Monoid::primary_degrees_of_vars_positive(), and ResolutionComputation::ResolutionComputation().