Groebner.jl: Fast Gr\"obner Tracing in Julia

Alexander Demin

A public learn-and-apply interface for Traverso Gröbner tracing, plus product-ring batching, speeds repeated modular F4 runs by multi-fold factors in multi-modular computer-algebra workloads.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

T0 review · grok-4.5

2026-07-14 16:01 UTC pith:3RZDX5LQ

load-bearing objection Solid engineering paper: public Traverso learn/apply + product-ring batching in Julia F4, with real measured speed-ups on two multi-modular apps.

arxiv 2607.06372 v2 pith:3RZDX5LQ submitted 2026-07-07 cs.SC math.AC

Groebner.jl: Fast Gr\"obner Tracing in Julia

Alexander Demin This is my paper

classification cs.SC math.AC MSC 13P1068W30

keywords Gröbner basesF4 algorithmTraverso tracingmulti-modular methodsevaluation-interpolationJuliaSIMDstructural identifiability

verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

When multi-modular or evaluation–interpolation methods compute Gröbner bases, the same ideal is specialized many times and each specialization is reduced independently. This paper shows that Traverso’s tracing—record once which S-polynomials reduce to zero, then skip those reductions on later specializations—can be exposed as ordinary library calls rather than hidden inside a black-box solver. The Julia package implements F4 with public learn and apply routines, and further amortizes cost by performing several modular reductions at once over a product ring of machine integers that the compiler turns into SIMD code. Measured on structural-identifiability and rational-univariate-representation pipelines, the combination yields wall-clock speed-ups between roughly 1.5× and 6.6× once a modest number of bases have been computed. A sympathetic reader cares because many exact algebraic workflows already spend most of their time on exactly these repeated modular bases; a reusable tracing API turns that bottleneck into a shared, amortizable precomputation.

Core claim

Groebner.jl implements the F4 algorithm so that Traverso’s learn stage records a coefficient-independent trace of useful Macaulay-matrix rows, and the apply stage rebuilds only those rows for later specializations of the same ideal. The apply stage further accepts batches of specializations realized as arithmetic in a product ring of machine integers; Julia’s compiler produces SIMD code for the component-wise operations with little manual vectorization. On the paper’s multi-modular benchmarks the learn cost is amortized after a handful to roughly twenty bases, after which each apply (especially with batch size 4–16) is substantially faster than an independent F4 run, producing overall speed-

What carries the argument

Traverso’s learn/apply tracing of F4: a single modified F4 run records which Macaulay-matrix rows reduce to zero; subsequent apply runs construct only the rows marked useful, skipping monomial work and zero reductions. The same infrastructure is reused over product-ring coefficients (N-tuples of machine residues) so that critical-pair and monomial work is shared across N primes while linear algebra stays SIMD-friendly.

Load-bearing premise

A trace learned from one modular specialization correctly predicts which reductions vanish for later specializations of the same parametric ideal—that is, the specializations remain lucky with respect to the monomial structure.

What would settle it

Learn a trace on one prime (or evaluation point), apply it to a deliberately unlucky specialization known to change the leading-term ideal, and check whether the support-comparison success flag reports failure or whether an incorrect non-Gröbner basis is returned undetected; alternatively, recompute break-even counts on a family whose monomial structure is known to vary with the modulus.

Watch this falsifier — get emailed when new claim-graph text bears on it.

If this is right

Other Julia packages can call a single learned trace for hundreds of modular specializations without reimplementing F4 internals.
Multi-modular Gröbner bases over the rationals and evaluation–interpolation schemes amortize monomial arithmetic across batches of primes.
Structural-identifiability pipelines that already perform hundreds of specializations obtain measured multi-fold wall-clock reductions.
Rational-univariate-representation solvers gain 1.8–6.6× overall speed-ups on the reported zero-dimensional systems.
Batch sizes between 8 and 16 typically maximize throughput before memory and cache costs dominate.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

Any language whose compiler can auto-vectorize component-wise tuple arithmetic could reuse the same generic product-ring pattern for sparse F4 linear algebra without hand-written SIMD kernels.
A public tracing API invites hybrid exact/modular workflows in which intermediate ideals are reduced many times under different coefficient rings while sharing one monomial skeleton.
Memory growth linear in batch size (observed roughly ten-fold from N=1 to N=32) may constrain large systems more tightly than the reported throughput tables suggest.
Because the runtime success flag can still give false positives, end-to-end correctness remains classical lucky-prime theory; a certified apply stage is a natural next target.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Desk Editor's Note

Solid engineering paper: public Traverso learn/apply + product-ring batching in Julia F4, with real measured speed-ups on two multi-modular apps.

read the letter

This is a clean software paper. What is new is not the math—F4, Traverso tracing, and product-ring multi-modular arithmetic are classical—but a reusable public learn/apply interface in Groebner.jl, plus a generic product-ring layer (N-tuples of machine integers) that reuses the same F4 code path and lets Julia/LLVM emit SIMD with almost no hand-written kernels. The author then wires it into two real Julia packages (RUR solving and structural identifiability) and shows wall-clock gains of roughly 1.5–6.6× versus independent modular runs (Tables 3–4).

The paper does the engineering carefully. Table 1 gives honest break-even counts (often under 20 applications), Table 2 shows that N=4–16 is the sweet spot before memory and cache hurt, and the code is public at a fixed version. The baseline is the package’s own randomized F4, not a straw-man, and the author notes that the support-check success flag can give false positives. That is exactly the classical lucky-prime caveat; it does not invent a new correctness claim and does not undermine the reported timings on the concrete workloads.

Soft spots are minor and proportionate. Timings look single-run with no error bars, and there is no head-to-head against msolve’s or Giac’s internal tracers. The novelty claim stays modest, so those gaps do not sink the contribution. Self-citations are to prior algorithmic work that is independently checkable.

This is for people who ship multi-modular or evaluation-interpolation pipelines in Julia (or who care about how far generic programming + LLVM can push sparse linear algebra). It is not a theory paper. I would send it to a serious referee; the artifact and the numbers are checkable, the claims are not overstated, and the ecosystem value is real. Engage with it if you work in that stack.

Referee Report

0 major / 4 minor

Summary. The paper presents Groebner.jl, a Julia implementation of the F4 algorithm that exposes Traverso’s Gröbner tracing via a public learn/apply interface and supports product-ring batching over tuples of machine integers. After a learn stage that records which S-polynomials reduce to zero in a coefficient-independent way, subsequent apply stages on specializations of the same ideal omit those reductions and can process several primes (or evaluation points) simultaneously. The authors measure amortization break-even points (Table 1), batch-size speed-ups (Table 2), and end-to-end gains of 1.5–6.6× on multi-modular rational univariate representation and structural-identifiability workloads (Tables 3–4), using open-source code (v0.10.3).

Significance. The contribution is primarily engineering and software-systems: making classical Traverso tracing reusable outside the internal multi-modular pipelines of systems such as msolve or Giac, and showing that Julia’s generic arithmetic plus automatic SIMD on N-tuples yields practical wall-clock gains on concrete applications. Strengths include a public, documented API, open-source code with a pinned version, and concrete timings on named benchmarks that arise in structural identifiability and RUR-based solving. If the reported speed-ups hold under broader use, the package lowers the barrier for other Julia CAS workflows that repeatedly specialize the same ideal. The novelty is not algorithmic but in the reusable interface and the measured amortization of monomial work via product rings; that is still valuable for the computer-algebra software community.

minor comments (4)

Tables 1–4 report single-run wall-clock times with no statistical error bars or repeated-trial protocol. A short note on measurement methodology (number of runs, warm-up, variance) would strengthen reproducibility claims.
Section 3.2 correctly notes that the support-comparison success flag can produce false positives. A one-sentence pointer to the classical lucky-prime literature (or a brief remark that users should still verify the final basis when absolute correctness is required) would make the limitation more visible to non-specialists.
The product-ring reduce kernel in §4.2 is a useful illustration; a short remark on how Julia/LLVM chooses vector width for N=4 versus N=8/16 on the reported Intel platform would help readers who wish to port the technique.
Minor typography: “Gröbner.jl” appears both with and without the period after “Groebner”; consistent spelling of the package name would improve polish.

Circularity Check

0 steps flagged

No circularity: engineering measurements of a public learn/apply F4 interface against independent baselines

full rationale

The paper presents an implementation of Traverso's classical tracing (learn stage records zero-reductions of S-polynomials; apply stage reuses the monomial skeleton) together with product-ring batching of coefficient tuples. All claimed speed-ups are wall-clock timings of this implementation versus the package's own non-tracing F4 baseline (and versus classical deterministic F4) on concrete multi-modular workloads (Tables 1–4). The amortization arithmetic is ordinary: learn cost is paid once, apply cost is measured per specialization, and break-even counts are computed from those measured times. No parameter is fitted to data and then re-presented as a prediction; no uniqueness theorem is imported from overlapping authors to force a modelling choice; the success flag is explicitly acknowledged to be only a heuristic (Section 3.2). Self-citations point to independently published algorithmic or application papers and are not load-bearing for the measured gains. The derivation chain is therefore self-contained engineering evaluation, not a circular reduction of outputs to inputs.

Axiom & Free-Parameter Ledger

1 free parameters · 3 axioms · 0 invented entities

The paper rests almost entirely on standard algorithmic algebra (F4, Traverso tracing, multi-modular reconstruction) plus ordinary software-engineering assumptions about Julia’s compiler. No new mathematical entities are postulated; the only free choices are engineering parameters such as batch size.

free parameters (1)

batch size N = 4 (default)
Number of primes processed simultaneously in the product ring; chosen by hand (internally N=4 for rational arithmetic) after measuring throughput saturation around N=8–16 (Table 2).

axioms (3)

standard math Correctness of the F4 algorithm for computing Gröbner bases over fields
Invoked throughout Sections 2–4 as the underlying engine; no new proof is offered.
standard math Traverso’s tracing correctly identifies S-polynomials that reduce to zero for all specializations that share the same monomial structure (lucky primes)
Stated in Section 2 and used as the justification for the apply stage; classical reference [19].
domain assumption Julia’s LLVM backend will auto-vectorize component-wise arithmetic on NTuples of Int64 for the product-ring kernels
Section 4.2; the paper notes that the generated code is less effective on ARM, so the assumption is architecture-dependent.

pith-pipeline@v1.1.0-grok45 · 13028 in / 2379 out tokens · 31559 ms · 2026-07-14T16:01:51.154335+00:00 · methodology

0 comments

read the original abstract

A standard way to control expression swell in computer algebra is to use multi-modular or evaluation-interpolation methods. In computations involving Gr\"obner bases, these techniques typically require repeatedly computing Gr\"obner bases of specializations of the same ideal. These repeated computations can be accelerated through precomputation, notably using Traverso's tracing. We present Groebner$.$jl (https://github.com/sumiya11/Groebner.jl), a Julia implementation of the F4 algorithm that exposes Traverso's tracing through a reusable public interface. The implementation supports SIMD-friendly coefficient types, such as tuples of machine integers, which Julia compiles to efficient code with little manual intervention. This lets other Julia software leverage tracing to obtain speedups in applications such as structural identifiability of ordinary differential equation models and polynomial system solving.

Figures

Figures reproduced from arXiv: 2607.06372 by Alexander Demin.

**Figure 1.** Figure 1: A single iteration of the F4 algorithm as a row-reduction of a Macaulay matrix. Learn stage (on the left) and apply stage (on the right). LM denotes the leading monomial without coefficient. Learn stage. Input: a system of polynomials F1. Output: a trace. The algorithm performs a modified F4 computation on F1. At each iteration, it constructs and row-reduces a Macaulay matrix. In addition to the operation… view at source ↗

Review history (2 revisions) →

discussion (0)

Reference graph

Works this paper leans on

19 extracted references · 2 linked inside Pith

[1]

Ahmed, S., Crepeau, N., Dessauer, P.R., Edozie, A., Garcia-Lopez, O., Grimsley, T., Garcia, J.L., Neri, V., Shiu, A.: Identifiability of directed-cycle and catenary linearcompartmentalmodels.SIAMJournalonAppliedDynamicalSystems25(1), 304–350 (2026).https://doi.org/10.1137/25M1728636

doi:10.1137/25m1728636 2026
[2]

In: Proceedings of the 2021 International Symposium on Symbolic and Algebraic Computation

Berthomieu,J.,Eder,C.,SafeyElDin,M.:msolve:Alibraryforsolvingpolynomial systems. In: Proceedings of the 2021 International Symposium on Symbolic and Algebraic Computation. pp. 51–58 (2021).https://doi.org/10.1145/3452143. 3465545

doi:10.1145/3452143 2021
[3]

Bosma, W., Cannon, J., Playoust, C.: The Magma algebra system. I. The user language. J. Symbolic Comput.24(3-4), 235–265 (1997).https://doi.org/10. 1006/jsco.1996.0125,http://dx.doi.org/10.1006/jsco.1996.0125, Computa- tional algebra and number theory (London, 1993)

doi:10.1006/jsco.1996.0125 1997
[4]

Drug Design and Delivery1(4), 333–348 (May 1987), https://pubmed.ncbi.nlm.nih.gov/2855567/

Demignot, S., Domurado, D.: Effect of prosthetic sugar groups on the pharmacoki- netics of glucose-oxidase. Drug Design and Delivery1(4), 333–348 (May 1987), https://pubmed.ncbi.nlm.nih.gov/2855567/

arXiv 1987
[5]

arXiv preprint arXiv:2602.10878 (2026),https://arxiv.org/abs/2602.10878 10 Demin

Demin, A., Pogudin, G.: Simple generators of rational function fields. arXiv preprint arXiv:2602.10878 (2026),https://arxiv.org/abs/2602.10878 10 Demin

arXiv 2026
[6]

arXiv preprint arXiv:2402.07141 (2024),https:// arxiv.org/abs/2402.07141

Demin, A., Rouillier, F., Ruiz, J.: Reading rational univariate representations on lexicographic Gröbner bases. arXiv preprint arXiv:2402.07141 (2024),https:// arxiv.org/abs/2402.07141

Pith/arXiv arXiv 2024
[7]

SIAM Journal on Applied Algebra and Geometry7(1), 194–235 (2023).https: //doi.org/10.1137/22M1469067,https://doi.org/10.1137/22M1469067

Dong, R., Goodbrake, C., Harrington, H.A., Pogudin, G.: Differential elimination for dynamical models via projections with applications to structural identifiability. SIAM Journal on Applied Algebra and Geometry7(1), 194–235 (2023).https: //doi.org/10.1137/22M1469067,https://doi.org/10.1137/22M1469067

doi:10.1137/22m1469067 2023
[8]

Journal of Pure and Applied Algebra139(1–3), 61–88 (1999).https://doi.org/10.1016/S0022-4049(99)00005-5

Faugère, J.C.: A new efficient algorithm for computing Gröbner bases without reduction to zero (F4). Journal of Pure and Applied Algebra139(1–3), 61–88 (1999).https://doi.org/10.1016/S0022-4049(99)00005-5

doi:10.1016/s0022-4049(99)00005-5 1999
[9]

Chaos, Solitons & Fractals 140, 110244 (2020),http://dx.doi.org/10.1016/j.chaos.2020.110244

Fokas, A., Cuevas-Maraver, J., Kevrekidis, P.: A quantitative framework for ex- ploring exit strategies from the COVID-19 lockdown. Chaos, Solitons & Fractals 140, 110244 (2020),http://dx.doi.org/10.1016/j.chaos.2020.110244

doi:10.1016/j.chaos.2020.110244 2020
[10]

arXiv preprint arXiv:2304.06935 (2023),https://arxiv.org/abs/2304

Gowda, S., Demin, A.: Groebner.jl: A package for Gröbner bases computations in Julia. arXiv preprint arXiv:2304.06935 (2023),https://arxiv.org/abs/2304. 06935

Pith/arXiv arXiv 2023
[11]

Journal of Symbolic Computation15(2), 199–209 (1993),https://www.informatik.uni-leipzig.de/~graebe/ComputerAlgebra/ Publications/olp.pdf

Gräbe, H.G.: On lucky primes. Journal of Symbolic Computation15(2), 199–209 (1993),https://www.informatik.uni-leipzig.de/~graebe/ComputerAlgebra/ Publications/olp.pdf

1993
[12]

ACM Trans

van der Hoeven, J., Lecerf, G., Quintin, G.: Modular simd arithmetic in math- emagix. ACM Trans. Math. Softw.43(1) (Aug 2016).https://doi.org/10.1145/ 2876503,https://doi.org/10.1145/2876503

doi:10.1145/2876503 2016
[13]

Cryptology ePrint Archive, Paper 2010/158 (2010),https://eprint.iacr.org/2010/158

Joux, A., Vitse, V.: A variant of the F4 algorithm. Cryptology ePrint Archive, Paper 2010/158 (2010),https://eprint.iacr.org/2010/158

2010
[14]

MS project report, Simon Fraser Univ

de Kleine, J., Monagan, M.: A modular design and implementation of Buchberger’s algorithm. MS project report, Simon Fraser Univ. (2001)

2001
[15]

Kouba, R., Neiger, V., Din, M.S.E.: A complexity analysis of the f4 gröbner basis algorithm with tracer data (2026),https://arxiv.org/abs/2603.16378

arXiv 2026
[16]

In: Pro- ceedings of the 2015 International Workshop on Parallel Symbolic Computation

Monagan, M., Pearce, R.: A compact parallel implementation of F4. In: Pro- ceedings of the 2015 International Workshop on Parallel Symbolic Computation. pp. 95–100. PASCO ’15, Association for Computing Machinery, New York, NY, USA(2015).https://doi.org/10.1145/2790282.2790293,https://doi.org/10. 1145/2790282.2790293

doi:10.1145/2790282.2790293 2015
[17]

univ-grenoble-alpes.fr/~parisse/giac.html(2026), version 2.0.0

Parisse, B., De Graeve, R.: Giac/xcas.http://www-fourier. univ-grenoble-alpes.fr/~parisse/giac.html(2026), version 2.0.0

2026
[18]

Applicable Algebra in Engineering, Communication and Computing 9(5), 433–461 (1999).https://doi.org/10.1007/s002000050114

Rouillier, F.: Solving zero-dimensional systems through the rational univariate rep- resentation. Applicable Algebra in Engineering, Communication and Computing 9(5), 433–461 (1999).https://doi.org/10.1007/s002000050114

doi:10.1007/s002000050114 1999
[19]

In: Gianni, P

Traverso, C.: Gröbner trace algorithms. In: Gianni, P. (ed.) Symbolic and Algebraic Computation. pp. 125–138. Springer, Berlin, Heidelberg (1989).https://doi.org/ 10.1007/3-540-51084-2_12

doi:10.1007/3-540-51084-2_12 1989

[1] [1]

Ahmed, S., Crepeau, N., Dessauer, P.R., Edozie, A., Garcia-Lopez, O., Grimsley, T., Garcia, J.L., Neri, V., Shiu, A.: Identifiability of directed-cycle and catenary linearcompartmentalmodels.SIAMJournalonAppliedDynamicalSystems25(1), 304–350 (2026).https://doi.org/10.1137/25M1728636

doi:10.1137/25m1728636 2026

[2] [2]

In: Proceedings of the 2021 International Symposium on Symbolic and Algebraic Computation

Berthomieu,J.,Eder,C.,SafeyElDin,M.:msolve:Alibraryforsolvingpolynomial systems. In: Proceedings of the 2021 International Symposium on Symbolic and Algebraic Computation. pp. 51–58 (2021).https://doi.org/10.1145/3452143. 3465545

doi:10.1145/3452143 2021

[3] [3]

Bosma, W., Cannon, J., Playoust, C.: The Magma algebra system. I. The user language. J. Symbolic Comput.24(3-4), 235–265 (1997).https://doi.org/10. 1006/jsco.1996.0125,http://dx.doi.org/10.1006/jsco.1996.0125, Computa- tional algebra and number theory (London, 1993)

doi:10.1006/jsco.1996.0125 1997

[4] [4]

Drug Design and Delivery1(4), 333–348 (May 1987), https://pubmed.ncbi.nlm.nih.gov/2855567/

Demignot, S., Domurado, D.: Effect of prosthetic sugar groups on the pharmacoki- netics of glucose-oxidase. Drug Design and Delivery1(4), 333–348 (May 1987), https://pubmed.ncbi.nlm.nih.gov/2855567/

arXiv 1987

[5] [5]

arXiv preprint arXiv:2602.10878 (2026),https://arxiv.org/abs/2602.10878 10 Demin

Demin, A., Pogudin, G.: Simple generators of rational function fields. arXiv preprint arXiv:2602.10878 (2026),https://arxiv.org/abs/2602.10878 10 Demin

arXiv 2026

[6] [6]

arXiv preprint arXiv:2402.07141 (2024),https:// arxiv.org/abs/2402.07141

Demin, A., Rouillier, F., Ruiz, J.: Reading rational univariate representations on lexicographic Gröbner bases. arXiv preprint arXiv:2402.07141 (2024),https:// arxiv.org/abs/2402.07141

Pith/arXiv arXiv 2024

[7] [7]

SIAM Journal on Applied Algebra and Geometry7(1), 194–235 (2023).https: //doi.org/10.1137/22M1469067,https://doi.org/10.1137/22M1469067

Dong, R., Goodbrake, C., Harrington, H.A., Pogudin, G.: Differential elimination for dynamical models via projections with applications to structural identifiability. SIAM Journal on Applied Algebra and Geometry7(1), 194–235 (2023).https: //doi.org/10.1137/22M1469067,https://doi.org/10.1137/22M1469067

doi:10.1137/22m1469067 2023

[8] [8]

Journal of Pure and Applied Algebra139(1–3), 61–88 (1999).https://doi.org/10.1016/S0022-4049(99)00005-5

Faugère, J.C.: A new efficient algorithm for computing Gröbner bases without reduction to zero (F4). Journal of Pure and Applied Algebra139(1–3), 61–88 (1999).https://doi.org/10.1016/S0022-4049(99)00005-5

doi:10.1016/s0022-4049(99)00005-5 1999

[9] [9]

Chaos, Solitons & Fractals 140, 110244 (2020),http://dx.doi.org/10.1016/j.chaos.2020.110244

Fokas, A., Cuevas-Maraver, J., Kevrekidis, P.: A quantitative framework for ex- ploring exit strategies from the COVID-19 lockdown. Chaos, Solitons & Fractals 140, 110244 (2020),http://dx.doi.org/10.1016/j.chaos.2020.110244

doi:10.1016/j.chaos.2020.110244 2020

[10] [10]

arXiv preprint arXiv:2304.06935 (2023),https://arxiv.org/abs/2304

Gowda, S., Demin, A.: Groebner.jl: A package for Gröbner bases computations in Julia. arXiv preprint arXiv:2304.06935 (2023),https://arxiv.org/abs/2304. 06935

Pith/arXiv arXiv 2023

[11] [11]

Journal of Symbolic Computation15(2), 199–209 (1993),https://www.informatik.uni-leipzig.de/~graebe/ComputerAlgebra/ Publications/olp.pdf

Gräbe, H.G.: On lucky primes. Journal of Symbolic Computation15(2), 199–209 (1993),https://www.informatik.uni-leipzig.de/~graebe/ComputerAlgebra/ Publications/olp.pdf

1993

[12] [12]

ACM Trans

van der Hoeven, J., Lecerf, G., Quintin, G.: Modular simd arithmetic in math- emagix. ACM Trans. Math. Softw.43(1) (Aug 2016).https://doi.org/10.1145/ 2876503,https://doi.org/10.1145/2876503

doi:10.1145/2876503 2016

[13] [13]

Cryptology ePrint Archive, Paper 2010/158 (2010),https://eprint.iacr.org/2010/158

Joux, A., Vitse, V.: A variant of the F4 algorithm. Cryptology ePrint Archive, Paper 2010/158 (2010),https://eprint.iacr.org/2010/158

2010

[14] [14]

MS project report, Simon Fraser Univ

de Kleine, J., Monagan, M.: A modular design and implementation of Buchberger’s algorithm. MS project report, Simon Fraser Univ. (2001)

2001

[15] [15]

Kouba, R., Neiger, V., Din, M.S.E.: A complexity analysis of the f4 gröbner basis algorithm with tracer data (2026),https://arxiv.org/abs/2603.16378

arXiv 2026

[16] [16]

In: Pro- ceedings of the 2015 International Workshop on Parallel Symbolic Computation

Monagan, M., Pearce, R.: A compact parallel implementation of F4. In: Pro- ceedings of the 2015 International Workshop on Parallel Symbolic Computation. pp. 95–100. PASCO ’15, Association for Computing Machinery, New York, NY, USA(2015).https://doi.org/10.1145/2790282.2790293,https://doi.org/10. 1145/2790282.2790293

doi:10.1145/2790282.2790293 2015

[17] [17]

univ-grenoble-alpes.fr/~parisse/giac.html(2026), version 2.0.0

Parisse, B., De Graeve, R.: Giac/xcas.http://www-fourier. univ-grenoble-alpes.fr/~parisse/giac.html(2026), version 2.0.0

2026

[18] [18]

Applicable Algebra in Engineering, Communication and Computing 9(5), 433–461 (1999).https://doi.org/10.1007/s002000050114

Rouillier, F.: Solving zero-dimensional systems through the rational univariate rep- resentation. Applicable Algebra in Engineering, Communication and Computing 9(5), 433–461 (1999).https://doi.org/10.1007/s002000050114

doi:10.1007/s002000050114 1999

[19] [19]

In: Gianni, P

Traverso, C.: Gröbner trace algorithms. In: Gianni, P. (ed.) Symbolic and Algebraic Computation. pp. 125–138. Springer, Berlin, Heidelberg (1989).https://doi.org/ 10.1007/3-540-51084-2_12

doi:10.1007/3-540-51084-2_12 1989