My Project
Loading...
Searching...
No Matches
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
27class idrec; typedef idrec * idhdl;
28
29class 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
41poly leadmonom(const poly p, const ring r, const bool bSetZeroComp = true);
42
43/// inplace sorting of the module (ideal) id wrt <_(c,ds)
44void Sort_c_ds(const ideal id, const ring r);
45
46
47class sBucket; typedef sBucket* sBucket_pt;
48
49/** @class SBucketFactory syzextra.h
50 *
51 * sBucket Factory
52 *
53 * Cleate/store/reuse buckets
54 *
55 */
56class 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:
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 {
180 }
181
182 /// output lifting tree
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
200class CLCM: public SchreyerSyzygyComputationFlags, public std::vector<bool>
201{
202 public:
204
205 bool Check(const poly m) const;
206
207 private:
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:
241};
242
243
244// TODO: needs a specialized variant without a component (hash!)
246{
247#if NOPRODUCT
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:
293};
294
295bool my_p_LmCmp (poly, poly, const ring);
296
297typedef poly TCacheKey;
298typedef 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
314typedef std::map<TCacheKey, TCacheValue, CCacheCompare> TP2PCache; // deallocation??? !!!
315typedef 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?)
446
447 /// output (syzygy) tails
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
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
481static inline void ComputeSyzygy(const ideal L, const ideal T, ideal& LL, ideal& TT, const SchreyerSyzygyComputationFlags A)
482{
484 syz.ComputeSyzygy();
485 syz.ReadOffResult(LL, TT);
486}
487
488static 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
497static inline ideal Compute2LeadingSyzygyTerms(const ideal& L, const SchreyerSyzygyComputationFlags A)
498{
501 ideal LL, TT;
502 syz.ReadOffResult(LL, TT);
503 return LL; // assume TT is NULL!
504}
505
506static 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
513static 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
520static 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
528static 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:230
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
bool operator()(const TCacheKey &l, const TCacheKey &r) const
Definition: syzextra.h:311
CCacheCompare(const CCacheCompare &lhs)
Definition: syzextra.h:308
CCacheCompare & operator=(const CCacheCompare &lhs)
Definition: syzextra.h:309
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