k_basis()

Matrix * KBasis::k_basis ( const Matrix * bottom, M2_arrayint lo_degree, M2_arrayint hi_degree, std::vector< int > heftvec, std::vector< int > varlist, bool do_truncation, int limit )

static

Definition at line 491 of file matrix-kbasis.cpp.

{
  // There are essentially 3 situations:
  // (a) basis(M) -- lo_degree and hi_degree are not given
  //     in this case, only need that for each variable in 'varlist',
  //     some power is an initial term of 'bottom' (for each row of 'bottom').
  //     heft is not used here, or considered.
  // (b) basis(lo,hi,M) -- case when the ring is singly-graded
  //     one of lo and hi must be given. (otherwise we are in case (a) above)
  //     In this case, heft is a list with one element in it.
  //     Assume: heft * deg(x) > 0, for all x in 'varlist'.
  //     In this situation: we use kb_target_lo_heft, kb_target_hi_heft
  // (c) basis(d, d, M) -- ring is multi-graded
  //   ASSUME: deg_d(x) . heft > 0 for all vars 'x' in 'varlist'
  //     where deg_d(x) consists of the first #d components of deg(x)
  //   ASSUME: 1 <= #d <= degreeRank of the ring
  //   use kb_target_multidegree, kb_target_lo_heft
  //     and kb_exp_multidegree (of length #d).
  //   if do_truncation, then any generator with heft > kb_target_lo_heft is
  //   placed in the resulting matrix
  //
  // Further assumptions:
  //  1 <= #heft <= degreeRank P
  //  #heft = #lo_degree = #hi_degree, if these are not 0.
  //
  //
  // Do some checks first, return 0 if not good.
  const PolynomialRing *P = bottom->get_ring()->cast_to_PolynomialRing();
  if (P == nullptr) return Matrix::identity(bottom->rows());
 
  const PolynomialRing *D = P->get_degree_ring();
  const int *lo = lo_degree->len > 0 ? lo_degree->array : nullptr;
  const int *hi = hi_degree->len > 0 ? hi_degree->array : nullptr;
 
  if (heftvec.size() > D->n_vars())
    {
      ERROR("expected heft vector of length <= %d", D->n_vars());
      return nullptr;
    }
 
  if (lo && heftvec.size() != lo_degree->len)
    {
      ERROR("expected degrees of length %d", heftvec.size());
      return nullptr;
    }
 
  if (hi && heftvec.size() != hi_degree->len)
    {
      ERROR("expected degrees of length %d", heftvec.size());
      return nullptr;
    }
 
  // If heftvec.size() is > 1, and both lo and hi are non-null,
  // they need to be the same
  if (heftvec.size() > 1 && lo && hi)
    for (int i = 0; i < heftvec.size(); i++)
      if (lo_degree->array[i] != hi_degree->array[i])
        {
          ERROR("expected degree bounds to be equal");
          return nullptr;
        }
 
  KBasis KB(bottom, lo, hi, heftvec, varlist, do_truncation, limit);
 
  // If either a low degree, or high degree is given, then we require a
  // non-negative heft vector:
  if (lo || hi)
    for (int i = 0; i < varlist.size(); i++)
      if (KB.var_wts[i] < 0)
        {
          ERROR(
              "basis: computation requires a heft form non-negative on the "
              "degrees of the variables");
          return nullptr;
        }
  // This next line will happen if both lo,hi degrees are given, and they are
  // different.  This can only be the singly generated case, and in that case
  // the degrees are in the wrong order, so return with 0 basis.
  if (lo != nullptr && hi != nullptr && lo[0] > hi[0]) return KB.value();
 
  KB.compute();
  if (system_interrupted()) return nullptr;
  return KB.value();
}

References Ring::cast_to_PolynomialRing(), compute(), D, do_truncation, ERROR, Matrix::get_ring(), hi_degree, KBasis(), limit, lo_degree, Matrix, P, Matrix::rows(), system_interrupted(), value(), and var_wts.

Referenced by Matrix::basis().