find_pairs()

void GBinhom_comp::find_pairs ( gb_elem * p )

private

Definition at line 277 of file gb-sugarless.cpp.

{
  gc_vector<Bag*> elems;
  gc_vector<int> vplcm;
  s_pair *q;
  int nvars = M->n_vars();
  monomial f_m = M->make_one();
  monomial f_m2 = M->make_one();
  int *find_pairs_lcm = newarray_atomic(int, nvars);
  monomial find_pairs_mon = M->make_one();
  int *pi = newarray_atomic(int, nvars);
  int *pj = newarray_atomic(int, nvars);
  int *pij = newarray_atomic(int, nvars);
 
  GR->gbvector_get_lead_monomial(F, p->f, f_m);
  if (GR->is_skew_commutative())
    {
      exponents_t find_pairs_exp = newarray_atomic(int, nvars);
      M->to_expvector(f_m, find_pairs_exp);
 
      for (int v = 0; v < GR->n_skew_commutative_vars(); v++)
        {
          int w = GR->skew_variable(v);
          if (find_pairs_exp[w] == 0) continue;
 
          find_pairs_exp[w]++;
          M->from_expvector(find_pairs_exp, find_pairs_lcm);
          find_pairs_exp[w]--;
 
          vplcm.resize(0);
          M->to_varpower(find_pairs_lcm, vplcm);
          s_pair *q2 = new_var_pair(p, find_pairs_lcm);
          elems.push_back(new Bag(q2, vplcm));
        }
      freemem(find_pairs_exp);
    }
 
// Add in syzygies arising from a base ring
#ifdef DEVELOPMENT
#warning "quotient ring stuff"
#endif
  if (originalR->is_quotient_ring())
    {
      for (int i = 0; i < originalR->n_quotients(); i++)
        {
          const gbvector *f = originalR->quotient_gbvector(i);
          M->lcm(f->monom, f_m, find_pairs_lcm);
          vplcm.resize(0);
          M->to_varpower(find_pairs_lcm, vplcm);
          s_pair *q2 = new_ring_pair(p, find_pairs_lcm);
          elems.push_back(new Bag(q2, vplcm));
        }
    }
 
  // Add in syzygies arising as s-pairs
  for (gb_elem *s = gb->next_min; s != nullptr; s = s->next_min)
    {
      if (p->f->comp != s->f->comp) continue;
 
      GR->gbvector_get_lead_monomial(F, s->f, f_m2);
      M->lcm(f_m, f_m2, find_pairs_lcm);
 
      vplcm.resize(0);
      M->to_varpower(find_pairs_lcm, vplcm);
      q = new_s_pair(p, s, find_pairs_lcm);
      elems.push_back(new Bag(q, vplcm));
    }
 
  // Now minimalize these elements, and insert the minimal ones
 
  VECTOR(Bag *) rejects;
  MonomialIdeal mi(originalR, elems, rejects);
  for (auto& b : rejects)
    {
      s_pair *q2 = reinterpret_cast<s_pair *>(b->basis_ptr());
      remove_pair(q2);
      delete b;
    }
 
  s_pair head;
  s_pair *nextsame = &head;
  int len = 0;
 
  for (Bag& a : mi)
    {
      q = reinterpret_cast<s_pair *>(a.basis_ptr());
      nextsame->next = q;
      nextsame = q;
      len++;
      if (is_ideal && q->syz_type == SPAIR_PAIR)
        {
          M->gcd(q->first->f->monom, q->second->f->monom, find_pairs_mon);
          if (M->is_one(find_pairs_mon))
            {
              n_saved_gcd++;
              q->compare_num = -1;  // MES: change name of field!!
                                    // This means: don't compute spair.
              if (M2_gbTrace >= 8)
                {
                  buffer o;
                  o << "removed pair[" << q->first->me << " " << q->second->me
                    << "]";
                  emit_line(o.str());
                }
            }
        }
    }
  n_pairs += len;
  nextsame->next = nullptr;
  p->pair_list = head.next;
  spairs->sort_list(p->pair_list);
  if (M2_gbTrace >= 8)
    {
      buffer o;
      for (q = p->pair_list; q != nullptr; q = q->next)
        {
          o << "insert ";
          debug_out(o, q);
          o << newline;
        }
      emit(o.str());
    }
  for (q = p->pair_list; q != nullptr; q = q->next) q->next_same = q->next;
  spairs->insert(p->pair_list, len);
 
  // remove those pairs (i,j) for which gcd(p:i, p:j) = 1
  // and for which (p,i), (p,j) are both in the previous list of add-ons.
  // MES: this does not catch all of the un-necessary pairs...
  // Also much optimization might be able to be done, as far as removing
  // keeping the 'correct' minimal generator of the lcms.
 
  for (s_pair *s1 = p->pair_list; s1 != nullptr; s1 = s1->next_same)
    {
      if (s1->syz_type != SPAIR_PAIR) continue;
 
      GR->gbvector_get_lead_monomial(F, s1->second->f, f_m);
 
      M->divide(s1->lcm, f_m, pi);
 
      for (s_pair *t1 = s1->next_same; t1 != nullptr; t1 = t1->next_same)
        {
          if (t1->syz_type != SPAIR_PAIR) continue;
          GR->gbvector_get_lead_monomial(F, t1->second->f, f_m);
          M->divide(t1->lcm, f_m, pj);
          M->gcd(pi, pj, pij);
          if (M->is_one(pij))
            {
              if (mark_pair(s1->second, t1->second))
                {
                  n_saved_lcm++;
                }
            }
        }
    }
 
  // Remove the local variables
  freemem(find_pairs_lcm);
  freemem(pi);
  freemem(pj);
  freemem(pij);
  M->remove(find_pairs_mon);
  M->remove(f_m);
  M->remove(f_m2);
}

References s_pair::compare_num, debug_out(), emit(), emit_line(), F, gb_elem::f, s_pair::first, freemem(), gb, GR, is_ideal, M, M2_gbTrace, mark_pair(), gb_elem::me, gbvector::monom, monomial, n_pairs, n_saved_gcd, n_saved_lcm, new_ring_pair(), new_s_pair(), new_var_pair(), newarray_atomic, newline, s_pair::next, s_pair::next_same, originalR, p, remove_pair(), s, s_pair::second, SPAIR_PAIR, spairs, buffer::str(), s_pair::syz_type, and VECTOR.

Referenced by gb_insert().