My Project
syzextra.h
Go to the documentation of this file.
1 // -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
2 /*****************************************************************************\
3  * Computer Algebra System SINGULAR
4 \*****************************************************************************/
5 /** @file syzextra.h
6  *
7  * Computation of Syzygies
8  *
9  * ABSTRACT: Computation of Syzygies due to Schreyer
10  *
11  * @author Oleksandr Motsak
12  *
13  **/
14 /*****************************************************************************/
15 
16 #ifndef SYZEXTRA_H
17 #define SYZEXTRA_H
18 
19 #include <vector>
20 #include <map>
21 #include <string.h>
22 #include <stack>
23 
24 // include basic definitions
25 #include "kernel/ideals.h"
26 
27 class idrec; typedef idrec * idhdl;
28 
29 class kBucket; typedef kBucket* kBucket_pt;
30 
31 #ifndef NOPRODUCT
32 # define NOPRODUCT 1
33 #endif
34 
35 // set to 1 if all leading coeffs are assumed to be all =1...
36 // note the use of simplify on input in SSinit!
37 #ifndef NODIVISION
38 # define NODIVISION 1
39 #endif
40 
41 poly leadmonom(const poly p, const ring r, const bool bSetZeroComp = true);
42 
43 /// inplace sorting of the module (ideal) id wrt <_(c,ds)
44 void Sort_c_ds(const ideal id, const ring r);
45 
46 
47 class sBucket; typedef sBucket* sBucket_pt;
48 
49 /** @class SBucketFactory syzextra.h
50  *
51  * sBucket Factory
52  *
53  * Cleate/store/reuse buckets
54  *
55  */
56 class SBucketFactory: private std::stack <sBucket_pt>
57 {
58  private:
59  typedef std::stack <sBucket_pt> Base;
60 
61  public:
62  typedef Base::value_type Bucket;
63 
64  SBucketFactory(const ring r)
65  {
66  push ( _CreateBucket(r) ); // start with at least one sBucket...?
67  assume( top() != NULL );
68  };
69 
71  {
72  while( !empty() )
73  {
74  _DestroyBucket( top() );
75  pop();
76  }
77  }
78 
79  Bucket getBucket(const ring r, const bool remove = true)
80  {
81  Bucket bt = NULL;
82 
83  if( !empty() )
84  {
85  bt = top();
86 
87  if( remove )
88  pop();
89  }
90  else
91  {
92  bt = _CreateBucket(r);
93 
94  if( !remove )
95  {
96  push(bt);
97  assume( bt == top() );
98  }
99  }
100 
101  assume( bt != NULL );
102 
103  return bt;
104  }
105 
106  // TODO: this may be spared if we give-out a smart Bucket (which returns here upon its destructor!)
107  void putBucket(const Bucket & bt, const bool replace = false)
108  {
109  assume( bt != NULL );
110 
111  if( empty() )
112  push( bt );
113  else
114  {
115  if( replace )
116  top() = bt;
117  else
118  {
119  if( bt != top() )
120  push( bt );
121  }
122  }
123 
124  assume( bt == top() );
125  }
126 
127  private:
128  /// inital allocation for new buckets
129  static Bucket _CreateBucket(const ring r);
130 
131  /// we only expect empty buckets to be left at the end for destructor
132  /// bt will be set to NULL
133  static void _DestroyBucket(Bucket & bt);
134 
135  private:
138  void operator=(const SBucketFactory&);
139 
140 };
141 
142 /// Computation attribute storage
144 {
146 
155  {}
156 
157  /// output all the intermediate states
158  const int OPT__DEBUG; // DebugOutput;
159 
160  /// ?
161  const int OPT__LEAD2SYZ; // TwoLeadingSyzygyTerms;
162 
163  /// Reduce syzygy tails wrt the leading syzygy terms
164  const int OPT__TAILREDSYZ; // TailReducedSyzygies;
165 
166  /// Use the usual NF's S-poly reduction while dropping lower order terms
167  /// 2 means - smart selection!
168  const int OPT__HYBRIDNF; // UseHybridNF
169 
170 
171  /// ignore tails and compute the pure Schreyer frame
172  const int OPT__IGNORETAILS; // @IGNORETAILS
173 
174  /// Syzygy level (within a resolution)
175  mutable int OPT__SYZNUMBER;
176 
177  inline void nextSyzygyLayer() const
178  {
179  OPT__SYZNUMBER++;
180  }
181 
182  /// output lifting tree
183  const int OPT__TREEOUTPUT;
184 
185  /// CheckSyzygyProperty: TODO
186  const int OPT__SYZCHECK;
187 
188  /// TEST_OPT_PROT
189  const bool OPT__PROT;
190 
191  /// no caching/stores/lookups
192  const int OPT__NOCACHING;
193 
194  /// global base ring
195  const ring m_rBaseRing;
196 };
197 
199 
200 class CLCM: public SchreyerSyzygyComputationFlags, public std::vector<bool>
201 {
202  public:
203  CLCM(const ideal& L, const SchreyerSyzygyComputationFlags& flags);
204 
205  bool Check(const poly m) const;
206 
207  private:
208  bool m_compute;
209 
210  const unsigned int m_N; ///< number of ring variables
211 };
212 
213 
215 {
216  public:
217  CLeadingTerm(unsigned int label, const poly lt, const ring);
218 
219 #if NOPRODUCT
220  bool DivisibilityCheck(const poly multiplier, const poly t, const unsigned long not_sev, const ring r) const;
221 #endif
222  bool DivisibilityCheck(const poly product, const unsigned long not_sev, const ring r) const;
223 
224  bool CheckLT( const ideal & L ) const;
225 
226  inline poly lt() const { return m_lt; };
227  inline unsigned long sev() const { return m_sev; };
228  inline unsigned int label() const { return m_label; };
229  private:
230  const unsigned long m_sev; ///< not short exp. vector
231 
232  // NOTE/TODO: either of the following should be enough:
233  const unsigned int m_label; ///< index in the main L[] + 1
234 
235  const poly m_lt; ///< the leading term itself L[label-1]
236 
237  // disable the following:
240  void operator=(const CLeadingTerm&);
241 };
242 
243 
244 // TODO: needs a specialized variant without a component (hash!)
246 {
247 #if NOPRODUCT
248  friend class CDivisorEnumerator2;
249 #endif
250  friend class CDivisorEnumerator;
251 
252  public:
253  typedef long TComponentKey;
254  typedef std::vector<const CLeadingTerm*> TReducers;
255 
256  private:
257  typedef std::map< TComponentKey, TReducers> CReducersHash;
258 
259  public:
260  /// goes over all leading terms
262 
263  void Initialize(const ideal L);
264 
266 
267 
268 #if NOPRODUCT
269  poly
270  FindReducer(const poly multiplier, const poly monom, const poly syzterm, const CReducerFinder& checker) const;
271 
272 #endif
273  // TODO: save shortcut (syz: |-.->) LM(LM(m) * "t") -> syz?
274  poly // const_iterator // TODO: return const_iterator it, s.th: it->m_lt is the needed
275  FindReducer(const poly product, const poly syzterm, const CReducerFinder& checker) const;
276 
277  bool IsDivisible(const poly q) const;
278 
279 
280  inline bool IsNonempty() const { return !m_hash.empty(); }
281 
282  /// is the term to be "preprocessed" as lower order term or lead to only reducible syzygies...
283  int PreProcessTerm(const poly t, CReducerFinder& syzChecker) const;
284 
285  private:
286  ideal m_L; ///< only for debug
287 
288  CReducersHash m_hash; // can also be replaced with a vector indexed by components
289 
290  private:
292  void operator=(const CReducerFinder&);
293 };
294 
295 bool my_p_LmCmp (poly, poly, const ring);
296 
297 typedef poly TCacheKey;
298 typedef poly TCacheValue;
299 
301 {
302  const ring & m_ring;
303 
305 
306  CCacheCompare(const ring& r): m_ring(r) { assume(r != NULL); }
307 
309  CCacheCompare& operator=(const CCacheCompare& lhs) { assume(lhs.m_ring != NULL); return (const_cast<CCacheCompare&>(lhs)); }
310 
311  inline bool operator() (const TCacheKey& l, const TCacheKey& r) const { assume(m_ring != NULL); return my_p_LmCmp(l, r, m_ring); }
312 };
313 
314 typedef std::map<TCacheKey, TCacheValue, CCacheCompare> TP2PCache; // deallocation??? !!!
315 typedef std::map<int, TP2PCache> TCache;
316 
317 
318 /** @class SchreyerSyzygyComputation syzextra.h
319  *
320  * Computing syzygies after Schreyer
321  *
322  * Storing/accumulating data during the computation requires some global
323  * object, like this class. Ideally the above global functions should not
324  * be used in favour of this class.
325  *
326  * @sa Schreyer Syzygy Computation Paper & Talk & Python prototype
327  */
329 {
330  friend class CLCM;
331  friend class CReducerFinder;
332 
333  public:
334  /// Construct a global object for given input data (separated into leads & tails)
335  SchreyerSyzygyComputation(const ideal idLeads, const ideal idTails, const SchreyerSyzygyComputationFlags setting):
337  m_idLeads(idLeads), m_idTails(id_Copy(idTails, setting.m_rBaseRing)),
339  m_LS(NULL), m_lcm(m_idLeads, setting),
340  m_div(m_idLeads, setting), m_checker(NULL, setting), m_cache(),
343  {
344  if( UNLIKELY(OPT__PROT) ) memset( &m_stat, 0, sizeof(m_stat) );
345  }
346 
347  /// Construct a global object for given input data (separated into leads & tails)
348  SchreyerSyzygyComputation(const ideal idLeads, const ideal idTails, const ideal syzLeads, const SchreyerSyzygyComputationFlags setting):
350  m_idLeads(idLeads), m_idTails(id_Copy(idTails, setting.m_rBaseRing)),
351  m_syzLeads(syzLeads), m_syzTails(NULL),
352  m_LS(syzLeads), m_lcm(m_idLeads, setting),
353  m_div(m_idLeads, setting), m_checker(NULL, setting), m_cache(),
356  {
357  if( UNLIKELY(OPT__PROT) ) memset( &m_stat, 0, sizeof(m_stat) );
358 
360  {
361  if (syzLeads != NULL)
362  m_checker.Initialize(syzLeads);
363 // if( idTails != NULL )
364 // SetUpTailTerms();
365  }
366  }
367 
368  /// Destructor should not destruct the resulting m_syzLeads, m_syzTails.
370 
371  /// Convert the given ideal of tails into the internal representation (with reducers!)
372  /// Preprocess m_idTails as well...?
374 
375  /// print statistics about the used heuristics
376  void PrintStats() const;
377 
378  /// Read off the results while detaching them from this object
379  /// NOTE: no copy!
380  inline void ReadOffResult(ideal& syzL, ideal& syzT)
381  {
382  syzL = m_syzLeads; syzT = m_syzTails;
383 
384  m_syzLeads = m_syzTails = NULL; // m_LS ?
385 
386  if ( UNLIKELY(OPT__PROT) )
387  PrintStats();
388  }
389 
390 
391  /// The main driver function: computes
393 
394  /// Computes Syz(leads) or only LEAD of it.
395  /// The result is stored into m_syzLeads
396  void ComputeLeadingSyzygyTerms(bool bComputeSecondTerms = true);
397 
398 
399 
400  /// Main HybridNF == 1: poly reduce + LOT + LCM?
401  poly SchreyerSyzygyNF(const poly syz_lead, poly syz_2 = NULL) const;
402 
403 
404  // Main (HybridNF == 0) Tree Travers + LOT + LCM?
405  poly TraverseNF(const poly syz_lead, const poly syz_2 = NULL) const;
406 
407  /// High level caching function!!!
408  poly TraverseTail(poly multiplier, const int tail) const;
409 
410  // REMOVE?
411  /// called only from above and from outside (for testing)
412  poly TraverseTail(poly multiplier, poly tail) const;
413 
414  /// TODO: save shortcut (syz: |-.->) LM(m) * "t" -> ? ???
415  poly ReduceTerm(poly multiplier, poly term4reduction, poly syztermCheck) const;
416 
417  /// low level computation...
418  poly ComputeImage(poly multiplier, const int tail) const;
419 
420  public:
421  /// just for testing via the wrapper below
422  inline poly _FindReducer(const poly product, const poly syzterm) const
423  { return m_div.FindReducer(product, syzterm, m_checker); }
424  private:
425  void CleanUp();
426  protected:
427 
428 
429  /// just leading terms
431 
432  /// leading + second terms
434 
435 
436 
437  private:
438  /// input leading terms
439  const ideal m_idLeads;
440 
441  /// input tails
442  const ideal m_idTails;
443 
444  /// output (syzygy) leading terms (+2nd terms?)
445  ideal m_syzLeads;
446 
447  /// output (syzygy) tails
448  ideal m_syzTails;
449 
450  /*mutable?*/ ideal m_LS; ///< leading syzygy terms used for reducing syzygy tails
451 
452 
453  /// Bitmask for variables occuring in leading terms
454  const CLCM m_lcm;
455 
456  /// Divisor finder
458 
459  /// for checking tail-terms and makeing them irreducible (wrt m_LS!)
461 
462  mutable TCache m_cache; // cacher comp + poly -> poly! // mutable???
463 
464  /// used for simple summing up
465  mutable SBucketFactory m_sum_bucket_factory; // sBucket_pt
466 
467  /// for S-Polynomial reductions
468  mutable kBucket_pt m_spoly_bucket; // only used inside of SchreyerSyzygyNF! destruction by CleanUp()!
469 
470 
471  /// Statistics:
472  /// 0..3: as in SetUpTailTerms()::PreProcessTerm() // TODO!!??
473  /// 4: number of terms discarded due to LOT heuristics
474  /// 5: number of terms discarded due to LCM heuristics
475  /// 6, 7: lookups without & with rescale, 8: stores
476  mutable unsigned long m_stat[9];
477 };
478 
479 // The following wrappers are just for testing separate functions on highest level (within schreyer.lib)
480 
481 static inline void ComputeSyzygy(const ideal L, const ideal T, ideal& LL, ideal& TT, const SchreyerSyzygyComputationFlags A)
482 {
483  SchreyerSyzygyComputation syz(L, T, A);
484  syz.ComputeSyzygy();
485  syz.ReadOffResult(LL, TT);
486 }
487 
488 static inline ideal ComputeLeadingSyzygyTerms(const ideal& L, const SchreyerSyzygyComputationFlags A)
489 {
491  syz.ComputeLeadingSyzygyTerms(false);
492  ideal LL, TT;
493  syz.ReadOffResult(LL, TT);
494  return LL; // assume TT is NULL!
495 }
496 
497 static inline ideal Compute2LeadingSyzygyTerms(const ideal& L, const SchreyerSyzygyComputationFlags A)
498 {
500  syz.ComputeLeadingSyzygyTerms(true);
501  ideal LL, TT;
502  syz.ReadOffResult(LL, TT);
503  return LL; // assume TT is NULL!
504 }
505 
506 static inline poly FindReducer(poly product, poly syzterm,
507  ideal L, ideal LS, const SchreyerSyzygyComputationFlags A)
508 {
509  SchreyerSyzygyComputation syz(L, NULL, LS, A);
510  return syz._FindReducer(product, syzterm);
511 }
512 
513 static inline poly TraverseTail(poly multiplier, poly tail,
514  ideal L, ideal T, ideal LS, const SchreyerSyzygyComputationFlags A)
515 {
516  SchreyerSyzygyComputation syz(L, T, LS, A);
517  return syz.TraverseTail(multiplier, tail);
518 }
519 
520 static inline poly ReduceTerm(poly multiplier, poly term4reduction, poly syztermCheck,
521  ideal L, ideal T, ideal LS, const SchreyerSyzygyComputationFlags A)
522 {
523  SchreyerSyzygyComputation syz(L, T, LS, A);
524  return syz.ReduceTerm(multiplier, term4reduction, syztermCheck);
525 }
526 
527 
528 static inline poly SchreyerSyzygyNF(poly syz_lead, poly syz_2,
529  ideal L, ideal T, ideal LS, const SchreyerSyzygyComputationFlags A)
530 {
531  SchreyerSyzygyComputation syz(L, T, LS, A);
532  return syz.SchreyerSyzygyNF(syz_lead, syz_2);
533 }
534 
535 #endif
536 /* #ifndef SYZEXTRA_H */
537 
538 // Vi-modeline: vim: filetype=c:syntax:shiftwidth=2:tabstop=8:textwidth=0:expandtab
539 
#define UNLIKELY(X)
Definition: auxiliary.h:404
#define LIKELY(X)
Definition: auxiliary.h:403
int l
Definition: cfEzgcd.cc:100
int m
Definition: cfEzgcd.cc:128
int p
Definition: cfModGcd.cc:4078
Definition: syzextra.h:201
const unsigned int m_N
number of ring variables
Definition: syzextra.h:210
bool Check(const poly m) const
CLCM(const ideal &L, const SchreyerSyzygyComputationFlags &flags)
bool m_compute
Definition: syzextra.h:208
bool DivisibilityCheck(const poly multiplier, const poly t, const unsigned long not_sev, const ring r) const
CLeadingTerm(const CLeadingTerm &)
bool CheckLT(const ideal &L) const
const poly m_lt
the leading term itself L[label-1]
Definition: syzextra.h:235
const unsigned long m_sev
not short exp. vector
Definition: syzextra.h:228
unsigned int label() const
Definition: syzextra.h:228
const unsigned int m_label
index in the main L[] + 1
Definition: syzextra.h:233
poly lt() const
Definition: syzextra.h:226
bool DivisibilityCheck(const poly product, const unsigned long not_sev, const ring r) const
void operator=(const CLeadingTerm &)
unsigned long sev() const
Definition: syzextra.h:227
CLeadingTerm(unsigned int label, const poly lt, const ring)
poly FindReducer(const poly product, const poly syzterm, const CReducerFinder &checker) const
CReducerFinder(const CReducerFinder &)
CReducerFinder(const ideal L, const SchreyerSyzygyComputationFlags &flags)
goes over all leading terms
poly FindReducer(const poly multiplier, const poly monom, const poly syzterm, const CReducerFinder &checker) const
std::map< TComponentKey, TReducers > CReducersHash
Definition: syzextra.h:257
friend class CDivisorEnumerator
Definition: syzextra.h:250
bool IsNonempty() const
Definition: syzextra.h:280
long TComponentKey
Definition: syzextra.h:253
ideal m_L
only for debug
Definition: syzextra.h:286
friend class CDivisorEnumerator2
Definition: syzextra.h:248
std::vector< const CLeadingTerm * > TReducers
Definition: syzextra.h:254
void Initialize(const ideal L)
int PreProcessTerm(const poly t, CReducerFinder &syzChecker) const
is the term to be "preprocessed" as lower order term or lead to only reducible syzygies....
void operator=(const CReducerFinder &)
CReducersHash m_hash
Definition: syzextra.h:288
bool IsDivisible(const poly q) const
sBucket Factory
Definition: syzextra.h:57
Base::value_type Bucket
Definition: syzextra.h:62
SBucketFactory(const ring r)
Definition: syzextra.h:64
void operator=(const SBucketFactory &)
static Bucket _CreateBucket(const ring r)
inital allocation for new buckets
static void _DestroyBucket(Bucket &bt)
we only expect empty buckets to be left at the end for destructor bt will be set to NULL
std::stack< sBucket_pt > Base
Definition: syzextra.h:59
SBucketFactory(const SBucketFactory &)
void putBucket(const Bucket &bt, const bool replace=false)
Definition: syzextra.h:107
Bucket getBucket(const ring r, const bool remove=true)
Definition: syzextra.h:79
Computing syzygies after Schreyer.
Definition: syzextra.h:329
const CLCM m_lcm
Bitmask for variables occuring in leading terms.
Definition: syzextra.h:454
poly ComputeImage(poly multiplier, const int tail) const
low level computation...
const ideal m_idLeads
input leading terms
Definition: syzextra.h:439
kBucket_pt m_spoly_bucket
for S-Polynomial reductions
Definition: syzextra.h:468
void ReadOffResult(ideal &syzL, ideal &syzT)
Read off the results while detaching them from this object NOTE: no copy!
Definition: syzextra.h:380
poly _FindReducer(const poly product, const poly syzterm) const
just for testing via the wrapper below
Definition: syzextra.h:422
poly TraverseTail(poly multiplier, poly tail) const
called only from above and from outside (for testing)
void SetUpTailTerms()
Convert the given ideal of tails into the internal representation (with reducers!) Preprocess m_idTai...
ideal Compute1LeadingSyzygyTerms()
just leading terms
poly TraverseNF(const poly syz_lead, const poly syz_2=NULL) const
unsigned long m_stat[9]
Statistics: 0..3: as in SetUpTailTerms()::PreProcessTerm() // TODO!!?? 4: number of terms discarded d...
Definition: syzextra.h:476
ideal m_syzTails
output (syzygy) tails
Definition: syzextra.h:448
void ComputeSyzygy()
The main driver function: computes.
void PrintStats() const
print statistics about the used heuristics
SchreyerSyzygyComputation(const ideal idLeads, const ideal idTails, const ideal syzLeads, const SchreyerSyzygyComputationFlags setting)
Construct a global object for given input data (separated into leads & tails)
Definition: syzextra.h:348
poly TraverseTail(poly multiplier, const int tail) const
High level caching function!!!
const ideal m_idTails
input tails
Definition: syzextra.h:442
ideal Compute2LeadingSyzygyTerms()
leading + second terms
void ComputeLeadingSyzygyTerms(bool bComputeSecondTerms=true)
Computes Syz(leads) or only LEAD of it. The result is stored into m_syzLeads.
poly SchreyerSyzygyNF(const poly syz_lead, poly syz_2=NULL) const
Main HybridNF == 1: poly reduce + LOT + LCM?
const CReducerFinder m_div
Divisor finder.
Definition: syzextra.h:457
~SchreyerSyzygyComputation()
Destructor should not destruct the resulting m_syzLeads, m_syzTails.
Definition: syzextra.h:369
SchreyerSyzygyComputation(const ideal idLeads, const ideal idTails, const SchreyerSyzygyComputationFlags setting)
Construct a global object for given input data (separated into leads & tails)
Definition: syzextra.h:335
ideal m_syzLeads
output (syzygy) leading terms (+2nd terms?)
Definition: syzextra.h:445
SBucketFactory m_sum_bucket_factory
used for simple summing up
Definition: syzextra.h:465
poly ReduceTerm(poly multiplier, poly term4reduction, poly syztermCheck) const
TODO: save shortcut (syz: |-.->) LM(m) * "t" -> ? ???
ideal m_LS
leading syzygy terms used for reducing syzygy tails
Definition: syzextra.h:450
CReducerFinder m_checker
for checking tail-terms and makeing them irreducible (wrt m_LS!)
Definition: syzextra.h:460
Definition: idrec.h:35
Definition: attrib.h:21
ideal id_Copy(ideal h1, const ring r)
copy an ideal
STATIC_VAR jList * T
Definition: janet.cc:30
#define assume(x)
Definition: mod2.h:389
#define NULL
Definition: omList.c:12
int status int void size_t count int const void size_t count const char int flags
Definition: si_signals.h:73
#define A
Definition: sirandom.c:24
CCacheCompare & operator=(const CCacheCompare &lhs)
Definition: syzextra.h:309
bool operator()(const TCacheKey &l, const TCacheKey &r) const
Definition: syzextra.h:311
CCacheCompare(const CCacheCompare &lhs)
Definition: syzextra.h:308
CCacheCompare(const ring &r)
Definition: syzextra.h:306
const ring & m_ring
Definition: syzextra.h:302
Computation attribute storage.
Definition: syzextra.h:144
SchreyerSyzygyComputationFlags(const SchreyerSyzygyComputationFlags &attr)
Definition: syzextra.h:147
SchreyerSyzygyComputationFlags(idhdl rootRingHdl)
const int OPT__HYBRIDNF
Use the usual NF's S-poly reduction while dropping lower order terms 2 means - smart selection!
Definition: syzextra.h:168
const ring m_rBaseRing
global base ring
Definition: syzextra.h:195
const int OPT__TREEOUTPUT
output lifting tree
Definition: syzextra.h:183
const int OPT__SYZCHECK
CheckSyzygyProperty: TODO.
Definition: syzextra.h:186
const int OPT__NOCACHING
no caching/stores/lookups
Definition: syzextra.h:192
int OPT__SYZNUMBER
Syzygy level (within a resolution)
Definition: syzextra.h:175
const bool OPT__PROT
TEST_OPT_PROT.
Definition: syzextra.h:189
const int OPT__DEBUG
output all the intermediate states
Definition: syzextra.h:158
const int OPT__TAILREDSYZ
Reduce syzygy tails wrt the leading syzygy terms.
Definition: syzextra.h:164
const int OPT__IGNORETAILS
ignore tails and compute the pure Schreyer frame
Definition: syzextra.h:172
bool my_p_LmCmp(poly, poly, const ring)
static poly SchreyerSyzygyNF(poly syz_lead, poly syz_2, ideal L, ideal T, ideal LS, const SchreyerSyzygyComputationFlags A)
Definition: syzextra.h:528
poly TCacheKey
Definition: syzextra.h:297
poly leadmonom(const poly p, const ring r, const bool bSetZeroComp=true)
poly TCacheValue
Definition: syzextra.h:298
std::map< TCacheKey, TCacheValue, CCacheCompare > TP2PCache
Definition: syzextra.h:314
static poly ReduceTerm(poly multiplier, poly term4reduction, poly syztermCheck, ideal L, ideal T, ideal LS, const SchreyerSyzygyComputationFlags A)
Definition: syzextra.h:520
static ideal ComputeLeadingSyzygyTerms(const ideal &L, const SchreyerSyzygyComputationFlags A)
Definition: syzextra.h:488
void Sort_c_ds(const ideal id, const ring r)
inplace sorting of the module (ideal) id wrt <_(c,ds)
static ideal Compute2LeadingSyzygyTerms(const ideal &L, const SchreyerSyzygyComputationFlags A)
Definition: syzextra.h:497
std::map< int, TP2PCache > TCache
Definition: syzextra.h:315
kBucket * kBucket_pt
Definition: syzextra.h:29
static poly FindReducer(poly product, poly syzterm, ideal L, ideal LS, const SchreyerSyzygyComputationFlags A)
Definition: syzextra.h:506
sBucket * sBucket_pt
Definition: syzextra.h:47
static poly TraverseTail(poly multiplier, poly tail, ideal L, ideal T, ideal LS, const SchreyerSyzygyComputationFlags A)
Definition: syzextra.h:513
static void ComputeSyzygy(const ideal L, const ideal T, ideal &LL, ideal &TT, const SchreyerSyzygyComputationFlags A)
Definition: syzextra.h:481
idrec * idhdl
Definition: syzextra.h:27