tla-ts 0.0.10-dev.f16792fed → 0.0.10-dev.fdc173479
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +2 -1
- package/dist/compile.cjs +6 -6
- package/dist/compile.js +10 -10
- package/dist/deciders.cjs +41 -37
- package/dist/deciders.js +41 -37
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +21 -4
- package/dist/index.d.ts +21 -4
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +1 -1
- package/dist/prove-worker.cjs +1 -1
- package/dist/prove-worker.js +1 -1
- package/dist/prove.cjs +2681 -425
- package/dist/prove.js +2681 -425
- package/dist/run.cjs +41 -42
- package/dist/run.js +41 -42
- package/dist/tlapm.cjs +2 -2
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +97 -89
- package/dist/transfer.js +97 -89
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +1 -1
- package/src/ast.ts +72 -39
- package/src/bags.ts +50 -29
- package/src/builtins.ts +8 -16
- package/src/check-failure.ts +118 -0
- package/src/check-trace.ts +321 -0
- package/src/check.ts +828 -770
- package/src/cli/options.ts +6 -31
- package/src/cli/runtime-invariants.ts +20 -56
- package/src/cli/shared.ts +1 -1
- package/src/cli/tlapm.ts +433 -70
- package/src/cli/tlc-arguments.ts +224 -212
- package/src/cli/tlc-output.ts +701 -0
- package/src/cli/tlc-usage.ts +1 -2
- package/src/cli/tlc.ts +65 -712
- package/src/cli/xml-exporter.ts +23 -33
- package/src/codegen.ts +28 -20
- package/src/coverage.ts +255 -20
- package/src/dependencies.ts +96 -27
- package/src/dfid.ts +115 -50
- package/src/environment-config.ts +315 -0
- package/src/environment.ts +175 -373
- package/src/errors.ts +40 -5
- package/src/evaluate.ts +429 -139
- package/src/exit-codes.ts +28 -12
- package/src/fingerprints.ts +65 -1
- package/src/instances.ts +178 -17
- package/src/java-hash.ts +14 -0
- package/src/java-overrides.ts +2 -2
- package/src/json.ts +4 -7
- package/src/levels.ts +708 -272
- package/src/lexer.ts +17 -5
- package/src/liveness-checker.ts +707 -249
- package/src/liveness.ts +148 -95
- package/src/obligations/action.ts +14 -17
- package/src/obligations/anonymize.ts +37 -16
- package/src/obligations/enabled-axioms.ts +218 -0
- package/src/obligations/equality.ts +1 -3
- package/src/obligations/expression.ts +36 -8
- package/src/obligations/format.ts +0 -2
- package/src/obligations/generate.ts +66 -54
- package/src/obligations/index.ts +39 -9
- package/src/obligations/levels.ts +24 -11
- package/src/obligations/module.ts +28 -41
- package/src/obligations/normalize.ts +27 -18
- package/src/obligations/operators.ts +0 -2
- package/src/obligations/pragma.ts +53 -16
- package/src/obligations/printer.ts +48 -18
- package/src/obligations/proof.ts +3 -2
- package/src/obligations/regroup.ts +0 -2
- package/src/obligations/simplify.ts +55 -50
- package/src/obligations/source.ts +120 -74
- package/src/obligations/subexpression.ts +45 -18
- package/src/obligations/substitution.ts +1 -3
- package/src/obligations/temporal.ts +5 -7
- package/src/obligations/tuples.ts +0 -2
- package/src/parallel-worker.ts +17 -31
- package/src/parallel.ts +29 -47
- package/src/parser.ts +757 -326
- package/src/pretty-print.ts +1 -1
- package/src/prover/decide-pool.ts +3 -3
- package/src/prover/deciders.ts +12 -9
- package/src/prover/isabelle/decide.ts +3 -25
- package/src/prover/isabelle/encode.ts +72 -42
- package/src/prover/isabelle/isar/attrib.ts +250 -0
- package/src/prover/isabelle/isar/context.ts +335 -0
- package/src/prover/isabelle/isar/induct.ts +382 -0
- package/src/prover/isabelle/isar/inner-syntax.ts +158 -7
- package/src/prover/isabelle/isar/method.ts +509 -212
- package/src/prover/isabelle/isar/proof.ts +570 -14
- package/src/prover/isabelle/isar/rule-cases.ts +226 -0
- package/src/prover/isabelle/isar/theory.ts +487 -76
- package/src/prover/isabelle/isar/toplevel.ts +331 -0
- package/src/prover/isabelle/isar/type-check.ts +89 -14
- package/src/prover/isabelle/provers/blast/blast.ts +7 -65
- package/src/prover/isabelle/provers/blast/branch.ts +0 -2
- package/src/prover/isabelle/provers/blast/prove.ts +0 -2
- package/src/prover/isabelle/provers/blast/rules.ts +0 -2
- package/src/prover/isabelle/provers/blast/state.ts +0 -2
- package/src/prover/isabelle/provers/blast/term.ts +0 -2
- package/src/prover/isabelle/provers/clasimp.ts +1 -3
- package/src/prover/isabelle/provers/classical.ts +45 -20
- package/src/prover/isabelle/provers/hypsubst.ts +19 -30
- package/src/prover/isabelle/pure/bicompose.ts +9 -27
- package/src/prover/isabelle/pure/consts.ts +0 -2
- package/src/prover/isabelle/pure/conv.ts +2 -10
- package/src/prover/isabelle/pure/drule.ts +72 -6
- package/src/prover/isabelle/pure/envir.ts +0 -2
- package/src/prover/isabelle/pure/goal.ts +1 -3
- package/src/prover/isabelle/pure/logic.ts +1 -3
- package/src/prover/isabelle/pure/name.ts +0 -2
- package/src/prover/isabelle/pure/net.ts +0 -2
- package/src/prover/isabelle/pure/object-logic.ts +13 -7
- package/src/prover/isabelle/pure/pattern.ts +0 -2
- package/src/prover/isabelle/pure/raw-simplifier.ts +4 -15
- package/src/prover/isabelle/pure/rewriter.ts +9 -20
- package/src/prover/isabelle/pure/search.ts +0 -2
- package/src/prover/isabelle/pure/seq.ts +0 -2
- package/src/prover/isabelle/pure/simplifier.ts +26 -7
- package/src/prover/isabelle/pure/table.ts +2 -3
- package/src/prover/isabelle/pure/tactic.ts +0 -2
- package/src/prover/isabelle/pure/tactical.ts +42 -37
- package/src/prover/isabelle/pure/term-ord.ts +0 -2
- package/src/prover/isabelle/pure/term.ts +3 -5
- package/src/prover/isabelle/pure/thm.ts +14 -13
- package/src/prover/isabelle/pure/type.ts +0 -2
- package/src/prover/isabelle/pure/unify.ts +0 -2
- package/src/prover/isabelle/pure/variable.ts +0 -2
- package/src/prover/isabelle/tla/classical-setup.ts +18 -16
- package/src/prover/isabelle/tla/context.ts +58 -11
- package/src/prover/isabelle/tla/logic-data.ts +1 -1
- package/src/prover/isabelle/tla/logic.ts +49 -21
- package/src/prover/isabelle/tla/simpdata.ts +1 -12
- package/src/prover/isabelle/tools/intuitionistic.ts +28 -12
- package/src/prover/ocaml.ts +4 -1
- package/src/prover/prep/action.ts +30 -31
- package/src/prover/prep/enabled-axioms.ts +11 -2
- package/src/prover/prep/fingerprint.ts +2 -5
- package/src/prover/prep/md5.ts +26 -29
- package/src/prover/prep/methods.ts +181 -51
- package/src/prover/prep/normalize.ts +38 -9
- package/src/prover/prove.ts +395 -94
- package/src/prover/ptl/decide.ts +95 -50
- package/src/prover/ptl/encode.ts +2 -3
- package/src/prover/ptl/tableau.ts +28 -2
- package/src/prover/smt/arithmetic.ts +310 -0
- package/src/prover/smt/axioms.ts +12 -8
- package/src/prover/smt/context.ts +43 -8
- package/src/prover/smt/data.ts +498 -379
- package/src/prover/smt/encode.ts +148 -57
- package/src/prover/smt/extensionality.ts +5 -3
- package/src/prover/smt/flatten.ts +4 -6
- package/src/prover/smt/format.ts +28 -4
- package/src/prover/smt/instances.ts +7 -1
- package/src/prover/smt/layout.ts +91 -0
- package/src/prover/smt/rewrite.ts +1016 -618
- package/src/prover/smt/simplify.ts +441 -0
- package/src/prover/smt/solver/ackermannize-bv-tactic.ts +62 -0
- package/src/prover/smt/solver/ackr-helper.ts +179 -0
- package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
- package/src/prover/smt/solver/act-cache.ts +0 -1
- package/src/prover/smt/solver/add-bounds-tactic.ts +59 -0
- package/src/prover/smt/solver/aig-tactic.ts +52 -0
- package/src/prover/smt/solver/aig.ts +889 -0
- package/src/prover/smt/solver/arith-rewriter.ts +624 -9
- package/src/prover/smt/solver/arith-terms.ts +121 -0
- package/src/prover/smt/solver/array-decl-plugin.ts +175 -0
- package/src/prover/smt/solver/array-rewriter.ts +319 -0
- package/src/prover/smt/solver/asserted-formulas.ts +240 -56
- package/src/prover/smt/solver/ast-lt.ts +165 -11
- package/src/prover/smt/solver/ast-util.ts +160 -2
- package/src/prover/smt/solver/ast.ts +1483 -45
- package/src/prover/smt/solver/auf-solver.ts +25 -18
- package/src/prover/smt/solver/bit-blast-tactic.ts +608 -0
- package/src/prover/smt/solver/bit-blaster.ts +871 -0
- package/src/prover/smt/solver/blast-term-ite.ts +47 -0
- package/src/prover/smt/solver/bound-manager.ts +196 -0
- package/src/prover/smt/solver/bound-simplifier.ts +598 -0
- package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
- package/src/prover/smt/solver/bv-decl-plugin.ts +341 -0
- package/src/prover/smt/solver/bv-divrem-bounds.ts +95 -0
- package/src/prover/smt/solver/bv-rewriter.ts +1901 -0
- package/src/prover/smt/solver/bv1-blast.ts +214 -0
- package/src/prover/smt/solver/bv2fpa-converter.ts +174 -0
- package/src/prover/smt/solver/bv2int-rewriter.ts +544 -0
- package/src/prover/smt/solver/bv2real-rewriter.ts +533 -0
- package/src/prover/smt/solver/card2bv.ts +127 -0
- package/src/prover/smt/solver/case-split-queue.ts +0 -2
- package/src/prover/smt/solver/cg-table.ts +39 -25
- package/src/prover/smt/solver/check-logic.ts +330 -0
- package/src/prover/smt/solver/clause.ts +0 -1
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +293 -0
- package/src/prover/smt/solver/conflict-resolution.ts +78 -2
- package/src/prover/smt/solver/context.ts +598 -128
- package/src/prover/smt/solver/ctx-simplify.ts +29 -14
- package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
- package/src/prover/smt/solver/datatype-decl-plugin.ts +580 -0
- package/src/prover/smt/solver/datatype-rewriter.ts +82 -0
- package/src/prover/smt/solver/demodulator.ts +786 -0
- package/src/prover/smt/solver/dependent-expr-state.ts +93 -0
- package/src/prover/smt/solver/der.ts +38 -10
- package/src/prover/smt/solver/diff-neq.ts +207 -0
- package/src/prover/smt/solver/distribute-forall.ts +57 -0
- package/src/prover/smt/solver/dom-simplify.ts +511 -0
- package/src/prover/smt/solver/dt2bv-tactic.ts +298 -0
- package/src/prover/smt/solver/dyn-ack.ts +0 -1
- package/src/prover/smt/solver/e-matching.ts +7 -8
- package/src/prover/smt/solver/elim-bounds.ts +89 -0
- package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
- package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
- package/src/prover/smt/solver/elim-uncnstr.ts +548 -0
- package/src/prover/smt/solver/enode.ts +100 -3
- package/src/prover/smt/solver/eq2bv-tactic.ts +227 -0
- package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
- package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
- package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
- package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
- package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
- package/src/prover/smt/solver/euf/array-solver.ts +306 -0
- package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
- package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
- package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
- package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
- package/src/prover/smt/solver/euf/egraph.ts +901 -0
- package/src/prover/smt/solver/euf/euf-solver.ts +1204 -0
- package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
- package/src/prover/smt/solver/euf/mam.ts +1046 -0
- package/src/prover/smt/solver/euf/q-ematch.ts +829 -0
- package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
- package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
- package/src/prover/smt/solver/euf/q-solver.ts +361 -0
- package/src/prover/smt/solver/euf/th-solver.ts +328 -0
- package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
- package/src/prover/smt/solver/expr-ref.ts +0 -1
- package/src/prover/smt/solver/expr-safe-replace.ts +26 -2
- package/src/prover/smt/solver/expr2polynomial.ts +271 -0
- package/src/prover/smt/solver/factor.ts +163 -0
- package/src/prover/smt/solver/fd-solver.ts +734 -0
- package/src/prover/smt/solver/fingerprints.ts +15 -15
- package/src/prover/smt/solver/fix-dl-var.ts +147 -0
- package/src/prover/smt/solver/flat-literals.ts +0 -1
- package/src/prover/smt/solver/fm-tactic.ts +886 -0
- package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
- package/src/prover/smt/solver/fpa-rewriter.ts +639 -0
- package/src/prover/smt/solver/fpa2bv-converter.ts +2251 -0
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +349 -0
- package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
- package/src/prover/smt/solver/goal.ts +178 -15
- package/src/prover/smt/solver/goal2nlsat.ts +216 -0
- package/src/prover/smt/solver/guard-set.ts +219 -0
- package/src/prover/smt/solver/hash.ts +0 -1
- package/src/prover/smt/solver/hashtable.ts +34 -16
- package/src/prover/smt/solver/inf-eps.ts +63 -0
- package/src/prover/smt/solver/inj-axiom.ts +101 -0
- package/src/prover/smt/solver/internalizer.ts +111 -39
- package/src/prover/smt/solver/lackr.ts +381 -0
- package/src/prover/smt/solver/lbool.ts +0 -1
- package/src/prover/smt/solver/lia2card.ts +268 -0
- package/src/prover/smt/solver/lia2pb.ts +154 -0
- package/src/prover/smt/solver/literal.ts +0 -1
- package/src/prover/smt/solver/logic-tactics.ts +355 -0
- package/src/prover/smt/solver/lp/bound-propagator.ts +0 -1
- package/src/prover/smt/solver/lp/constraints.ts +0 -1
- package/src/prover/smt/solver/lp/containers.ts +7 -2
- package/src/prover/smt/solver/lp/core-solver.ts +30 -11
- package/src/prover/smt/solver/lp/cross-nested.ts +1 -4
- package/src/prover/smt/solver/lp/dep-intervals.ts +0 -3
- package/src/prover/smt/solver/lp/dependency.ts +0 -2
- package/src/prover/smt/solver/lp/dioph-eq.ts +1 -10
- package/src/prover/smt/solver/lp/explanation.ts +0 -1
- package/src/prover/smt/solver/lp/gomory.ts +0 -1
- package/src/prover/smt/solver/lp/hnf-cutter.ts +1 -2
- package/src/prover/smt/solver/lp/hnf.ts +0 -3
- package/src/prover/smt/solver/lp/int-cube.ts +3 -4
- package/src/prover/smt/solver/lp/int-solver.ts +0 -2
- package/src/prover/smt/solver/lp/lar-solver.ts +41 -5
- package/src/prover/smt/solver/lp/lar-term.ts +0 -1
- package/src/prover/smt/solver/lp/lp-settings.ts +6 -3
- package/src/prover/smt/solver/lp/maximize-term.ts +59 -10
- package/src/prover/smt/solver/lp/nex-creator.ts +3 -3
- package/src/prover/smt/solver/lp/nex.ts +2 -2
- package/src/prover/smt/solver/lp/nla-backoff.ts +0 -2
- package/src/prover/smt/solver/lp/nla-basics.ts +46 -3
- package/src/prover/smt/solver/lp/nla-core.ts +68 -17
- package/src/prover/smt/solver/lp/nla-divisions.ts +0 -2
- package/src/prover/smt/solver/lp/nla-emonics.ts +0 -1
- package/src/prover/smt/solver/lp/nla-factorization.ts +0 -1
- package/src/prover/smt/solver/lp/nla-grobner.ts +167 -85
- package/src/prover/smt/solver/lp/nla-horner.ts +0 -2
- package/src/prover/smt/solver/lp/nla-intervals.ts +0 -1
- package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +0 -2
- package/src/prover/smt/solver/lp/nla-monotone.ts +0 -1
- package/src/prover/smt/solver/lp/nla-order.ts +0 -2
- package/src/prover/smt/solver/lp/nla-patcher.ts +0 -1
- package/src/prover/smt/solver/lp/nla-powers.ts +220 -0
- package/src/prover/smt/solver/lp/nla-tangents.ts +0 -2
- package/src/prover/smt/solver/lp/nla-throttle.ts +0 -1
- package/src/prover/smt/solver/lp/nla-transcendentals.ts +324 -0
- package/src/prover/smt/solver/lp/nla-types.ts +0 -2
- package/src/prover/smt/solver/lp/nla-var-eqs.ts +0 -1
- package/src/prover/smt/solver/lp/nra-solver.ts +163 -99
- package/src/prover/smt/solver/lp/numeric-pair.ts +0 -1
- package/src/prover/smt/solver/lp/pdd-interval.ts +6 -3
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -21
- package/src/prover/smt/solver/lp/pdd-solver.ts +72 -41
- package/src/prover/smt/solver/lp/pdd.ts +725 -290
- package/src/prover/smt/solver/lp/random-updater.ts +0 -2
- package/src/prover/smt/solver/lp/static-matrix.ts +0 -1
- package/src/prover/smt/solver/lp/union-find.ts +7 -2
- package/src/prover/smt/solver/macro-finder.ts +530 -0
- package/src/prover/smt/solver/mam-compiler.ts +122 -90
- package/src/prover/smt/solver/mam-interpreter.ts +0 -1
- package/src/prover/smt/solver/max-bv-sharing-tactic.ts +17 -0
- package/src/prover/smt/solver/max-cliques.ts +105 -0
- package/src/prover/smt/solver/maxcore.ts +310 -0
- package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -6
- package/src/prover/smt/solver/maxlex.ts +115 -0
- package/src/prover/smt/solver/maxsmt-base.ts +106 -0
- package/src/prover/smt/solver/maxsmt.ts +92 -0
- package/src/prover/smt/solver/mbp/mbp-arith.ts +467 -0
- package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +101 -0
- package/src/prover/smt/solver/mbp/mbp-plugin.ts +287 -0
- package/src/prover/smt/solver/mbp/mbp-qel.ts +48 -0
- package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +271 -0
- package/src/prover/smt/solver/mbp/mbp-term-graph.ts +606 -0
- package/src/prover/smt/solver/model-based-opt.ts +844 -0
- package/src/prover/smt/solver/model-checker.ts +19 -28
- package/src/prover/smt/solver/model-evaluator.ts +190 -12
- package/src/prover/smt/solver/model-finder.ts +12 -18
- package/src/prover/smt/solver/model-generator.ts +104 -35
- package/src/prover/smt/solver/model-macro-solver.ts +49 -46
- package/src/prover/smt/solver/model-printer.ts +214 -0
- package/src/prover/smt/solver/mpf.ts +709 -0
- package/src/prover/smt/solver/mus.ts +50 -0
- package/src/prover/smt/solver/muz/dl-context.ts +382 -0
- package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +97 -0
- package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +167 -0
- package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +125 -0
- package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +299 -0
- package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +455 -0
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +340 -0
- package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +163 -0
- package/src/prover/smt/solver/muz/dl-rule-set.ts +273 -0
- package/src/prover/smt/solver/muz/dl-rule-transformer.ts +123 -0
- package/src/prover/smt/solver/muz/dl-rule.ts +495 -0
- package/src/prover/smt/solver/muz/hnf.ts +201 -0
- package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
- package/src/prover/smt/solver/muz/horn-tactic.ts +214 -0
- package/src/prover/smt/solver/muz/rule-properties.ts +359 -0
- package/src/prover/smt/solver/muz/spacer-context.ts +1404 -0
- package/src/prover/smt/solver/muz/spacer-dl-interface.ts +52 -0
- package/src/prover/smt/solver/muz/spacer-generalizers.ts +241 -0
- package/src/prover/smt/solver/muz/spacer-manager.ts +127 -0
- package/src/prover/smt/solver/muz/spacer-pdr.ts +219 -0
- package/src/prover/smt/solver/muz/spacer-prop-solver.ts +333 -0
- package/src/prover/smt/solver/muz/spacer-util.ts +282 -0
- package/src/prover/smt/solver/muz/substitution.ts +203 -0
- package/src/prover/smt/solver/nla2bv-tactic.ts +285 -0
- package/src/prover/smt/solver/nlqsat.ts +485 -0
- package/src/prover/smt/solver/nlsat/algebraic.ts +315 -98
- package/src/prover/smt/solver/nlsat/atoms.ts +71 -38
- package/src/prover/smt/solver/nlsat/evaluator.ts +0 -1
- package/src/prover/smt/solver/nlsat/explain.ts +427 -229
- package/src/prover/smt/solver/nlsat/interval-set.ts +1 -2
- package/src/prover/smt/solver/nlsat/levelwise.ts +460 -246
- package/src/prover/smt/solver/nlsat/mpbq.ts +45 -1
- package/src/prover/smt/solver/nlsat/polynomial.ts +2376 -684
- package/src/prover/smt/solver/nlsat/solver.ts +293 -92
- package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
- package/src/prover/smt/solver/nlsat/transcendentals.ts +391 -0
- package/src/prover/smt/solver/nlsat/types.ts +0 -2
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +9 -8
- package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -20
- package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
- package/src/prover/smt/solver/nnf.ts +110 -24
- package/src/prover/smt/solver/normalize-bounds.ts +53 -0
- package/src/prover/smt/solver/occf.ts +97 -0
- package/src/prover/smt/solver/opt-context.ts +801 -0
- package/src/prover/smt/solver/opt-nlsat.ts +386 -0
- package/src/prover/smt/solver/opt-pareto.ts +301 -0
- package/src/prover/smt/solver/opt-preprocess.ts +101 -0
- package/src/prover/smt/solver/opt-solver.ts +312 -0
- package/src/prover/smt/solver/opt-value.ts +55 -0
- package/src/prover/smt/solver/optsmt.ts +692 -0
- package/src/prover/smt/solver/parallel-tactic.ts +299 -0
- package/src/prover/smt/solver/pattern-inference.ts +19 -11
- package/src/prover/smt/solver/pb-rewriter.ts +281 -0
- package/src/prover/smt/solver/pb2bv-tactic.ts +546 -0
- package/src/prover/smt/solver/poly-rewriter.ts +259 -57
- package/src/prover/smt/solver/probes.ts +577 -0
- package/src/prover/smt/solver/propagate-values.ts +37 -21
- package/src/prover/smt/solver/proto-model.ts +648 -19
- package/src/prover/smt/solver/pull-quant.ts +28 -12
- package/src/prover/smt/solver/purify-arith.ts +634 -0
- package/src/prover/smt/solver/push-app-ite.ts +37 -0
- package/src/prover/smt/solver/qe-arith-plugin.ts +1096 -0
- package/src/prover/smt/solver/qe-lite-der.ts +2 -3
- package/src/prover/smt/solver/qe-lite-fm.ts +3 -4
- package/src/prover/smt/solver/qe-lite.ts +39 -19
- package/src/prover/smt/solver/qe-mbp.ts +270 -0
- package/src/prover/smt/solver/qe.ts +1499 -0
- package/src/prover/smt/solver/qel.ts +25 -0
- package/src/prover/smt/solver/qi-queue.ts +0 -1
- package/src/prover/smt/solver/qsat.ts +829 -0
- package/src/prover/smt/solver/quant-hoist.ts +196 -0
- package/src/prover/smt/solver/quant-tactics.ts +16 -56
- package/src/prover/smt/solver/quantifier-analyzer.ts +19 -20
- package/src/prover/smt/solver/quantifier-manager.ts +22 -25
- package/src/prover/smt/solver/quasi-macros.ts +243 -0
- package/src/prover/smt/solver/random-gen.ts +0 -1
- package/src/prover/smt/solver/rational.ts +45 -1
- package/src/prover/smt/solver/recfun-decl-plugin.ts +262 -0
- package/src/prover/smt/solver/recfun-rewriter.ts +107 -0
- package/src/prover/smt/solver/reduce-args.ts +225 -0
- package/src/prover/smt/solver/reduce-bv-size.ts +119 -0
- package/src/prover/smt/solver/ref-vector.ts +0 -1
- package/src/prover/smt/solver/relevancy.ts +1 -2
- package/src/prover/smt/solver/rewriter-tpl.ts +82 -14
- package/src/prover/smt/solver/rewriter.ts +505 -60
- package/src/prover/smt/solver/rlimit.ts +45 -5
- package/src/prover/smt/solver/sat/asymm-branch.ts +325 -0
- package/src/prover/smt/solver/sat/big.ts +177 -0
- package/src/prover/smt/solver/sat/clause-use-list.ts +71 -0
- package/src/prover/smt/solver/sat/clause.ts +203 -0
- package/src/prover/smt/solver/sat/cleaner.ts +94 -0
- package/src/prover/smt/solver/sat/config.ts +122 -0
- package/src/prover/smt/solver/sat/consequences.ts +203 -0
- package/src/prover/smt/solver/sat/elim-eqs.ts +142 -0
- package/src/prover/smt/solver/sat/goal2sat.ts +589 -0
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +480 -0
- package/src/prover/smt/solver/sat/model-converter.ts +136 -0
- package/src/prover/smt/solver/sat/pb-constraint.ts +268 -0
- package/src/prover/smt/solver/sat/pb-solver.ts +1596 -0
- package/src/prover/smt/solver/sat/probing.ts +170 -0
- package/src/prover/smt/solver/sat/sat-tactic.ts +72 -0
- package/src/prover/smt/solver/sat/sat2goal.ts +190 -0
- package/src/prover/smt/solver/sat/scc.ts +142 -0
- package/src/prover/smt/solver/sat/simplifier.ts +1618 -0
- package/src/prover/smt/solver/sat/solver.ts +2107 -0
- package/src/prover/smt/solver/sat/var-queue.ts +117 -0
- package/src/prover/smt/solver/sat/watch-list.ts +140 -0
- package/src/prover/smt/solver/search-tree.ts +284 -0
- package/src/prover/smt/solver/seq-axioms.ts +995 -0
- package/src/prover/smt/solver/seq-decl-plugin.ts +819 -0
- package/src/prover/smt/solver/seq-derive.ts +1298 -0
- package/src/prover/smt/solver/seq-eq-approx.ts +236 -0
- package/src/prover/smt/solver/seq-eq-solver.ts +439 -0
- package/src/prover/smt/solver/seq-factory.ts +89 -0
- package/src/prover/smt/solver/seq-monadic.ts +730 -0
- package/src/prover/smt/solver/seq-range-predicate.ts +235 -0
- package/src/prover/smt/solver/seq-re-rewriter.ts +1171 -0
- package/src/prover/smt/solver/seq-re-util.ts +758 -0
- package/src/prover/smt/solver/seq-regex-bisim.ts +144 -0
- package/src/prover/smt/solver/seq-regex-live.ts +200 -0
- package/src/prover/smt/solver/seq-rewriter.ts +2404 -0
- package/src/prover/smt/solver/seq-skolem.ts +294 -0
- package/src/prover/smt/solver/seq-subset.ts +165 -0
- package/src/prover/smt/solver/seq-view-witness.ts +353 -0
- package/src/prover/smt/solver/smt-consequences.ts +297 -0
- package/src/prover/smt/solver/smt-kernel.ts +124 -0
- package/src/prover/smt/solver/smt-logics.ts +66 -0
- package/src/prover/smt/solver/smt-setup.ts +589 -0
- package/src/prover/smt/solver/smt2-printer.ts +765 -0
- package/src/prover/smt/solver/smtlib-parser.ts +3535 -360
- package/src/prover/smt/solver/smtlib-script.ts +2136 -0
- package/src/prover/smt/solver/solve-eqs.ts +928 -0
- package/src/prover/smt/solver/solver.ts +128 -23
- package/src/prover/smt/solver/static-features.ts +314 -0
- package/src/prover/smt/solver/sticky-generations.ts +0 -1
- package/src/prover/smt/solver/tactic.ts +2176 -0
- package/src/prover/smt/solver/term-enumeration.ts +205 -0
- package/src/prover/smt/solver/theory-array.ts +1240 -0
- package/src/prover/smt/solver/theory-bv.ts +1210 -0
- package/src/prover/smt/solver/theory-char.ts +355 -0
- package/src/prover/smt/solver/theory-datatype.ts +598 -0
- package/src/prover/smt/solver/theory-finite-set.ts +30 -0
- package/src/prover/smt/solver/theory-fpa.ts +389 -0
- package/src/prover/smt/solver/theory-lra-axioms.ts +53 -2
- package/src/prover/smt/solver/theory-lra-bounds.ts +31 -6
- package/src/prover/smt/solver/theory-lra-final-check.ts +57 -70
- package/src/prover/smt/solver/theory-lra-internalize.ts +96 -27
- package/src/prover/smt/solver/theory-lra-model.ts +20 -35
- package/src/prover/smt/solver/theory-lra-propagate.ts +35 -28
- package/src/prover/smt/solver/theory-lra-state.ts +7 -23
- package/src/prover/smt/solver/theory-lra.ts +189 -2
- package/src/prover/smt/solver/theory-pb.ts +951 -0
- package/src/prover/smt/solver/theory-polymorphism.ts +58 -0
- package/src/prover/smt/solver/theory-recfun.ts +307 -0
- package/src/prover/smt/solver/theory-seq-regex.ts +867 -0
- package/src/prover/smt/solver/theory-seq-solve.ts +1373 -0
- package/src/prover/smt/solver/theory-seq-state.ts +852 -0
- package/src/prover/smt/solver/theory-seq.ts +961 -0
- package/src/prover/smt/solver/theory-without-terms.ts +24 -0
- package/src/prover/smt/solver/theory.ts +189 -0
- package/src/prover/smt/solver/tseitin-cnf.ts +495 -0
- package/src/prover/smt/solver/var-subst.ts +36 -14
- package/src/prover/smt/table.ts +3 -2
- package/src/prover/smt/types.ts +146 -0
- package/src/prover/tlapm/cache.ts +57 -26
- package/src/prover/tlapm/tlapm.ts +15 -9
- package/src/prover/tlapm-library.ts +3208 -0
- package/src/prover/verdict.ts +9 -0
- package/src/prover/zenon/check/check.ts +1 -2
- package/src/prover/zenon/check/records.ts +1 -1
- package/src/prover/zenon/check/relations.ts +2 -1
- package/src/prover/zenon/check/rewrites.ts +2 -15
- package/src/prover/zenon/check/sets.ts +40 -58
- package/src/prover/zenon/check/terms.ts +1 -2
- package/src/prover/zenon/decide.ts +10 -7
- package/src/prover/zenon/encode.ts +0 -2
- package/src/prover/zenon/eqrel.ts +2 -2
- package/src/prover/zenon/equality-rules.ts +24 -2
- package/src/prover/zenon/expr.ts +28 -2
- package/src/prover/zenon/index-table.ts +16 -23
- package/src/prover/zenon/isar-case.ts +1 -3
- package/src/prover/zenon/isar.ts +37 -39
- package/src/prover/zenon/llproof.ts +2 -13
- package/src/prover/zenon/mltoll.ts +12 -30
- package/src/prover/zenon/node.ts +20 -5
- package/src/prover/zenon/parse.ts +9 -8
- package/src/prover/zenon/phrase.ts +1 -3
- package/src/prover/zenon/proof.ts +0 -2
- package/src/prover/zenon/propositional-rules.ts +0 -2
- package/src/prover/zenon/rules.ts +2 -3
- package/src/prover/zenon/search.ts +11 -19
- package/src/prover/zenon/tla/functions.ts +2 -4
- package/src/prover/zenon/tla/llproof.ts +9 -13
- package/src/prover/zenon/tla/records.ts +1 -8
- package/src/prover/zenon/tla/rewrites.ts +0 -2
- package/src/prover/zenon/tla/sets.ts +22 -22
- package/src/prover/zenon/tla/terms.ts +0 -2
- package/src/prover/zenon/tla/tla.ts +7 -8
- package/src/resolve.ts +1327 -328
- package/src/runtime.ts +25 -2
- package/src/sany/builtins.ts +10 -10
- package/src/sany/generation.ts +384 -0
- package/src/sany/generator-def-entries.ts +297 -0
- package/src/sany/generator-definitions.ts +688 -0
- package/src/sany/generator-expressions.ts +1123 -0
- package/src/sany/generator-proofs.ts +668 -0
- package/src/sany/generator.ts +161 -2625
- package/src/sany/levels.ts +0 -2
- package/src/sany/lexer.ts +32 -23
- package/src/sany/linter.ts +0 -2
- package/src/sany/modules.ts +4 -2
- package/src/sany/nodes.ts +3 -4
- package/src/sany/report.ts +3 -6
- package/src/sany/selectors.ts +46 -44
- package/src/sany/xml.ts +25 -58
- package/src/search.ts +513 -165
- package/src/simulate.ts +340 -251
- package/src/spec-description.ts +48 -55
- package/src/standard-definitions.ts +5 -0
- package/src/standard-modules.ts +72 -54
- package/src/state-graph.ts +0 -2
- package/src/subexpressions.ts +564 -138
- package/src/substitution-levels.ts +5 -4
- package/src/successors.ts +56 -28
- package/src/symmetry.ts +4 -3
- package/src/tableau.ts +2 -2
- package/src/tlc/fingerprint.ts +81 -9
- package/src/tlc/jar-data.ts +10 -0
- package/src/tlc/messages.ts +23 -18
- package/src/tlc/order.ts +14 -3
- package/src/tlc/random.ts +6 -5
- package/src/tlc/replay.ts +152 -58
- package/src/tlc/summary.ts +29 -14
- package/src/tlc/tlc-operators.ts +12 -11
- package/src/tlc/tlcext-operators.ts +87 -26
- package/src/tlc/trace-spec.ts +27 -60
- package/src/trace-liveness.ts +529 -0
- package/src/typed-tier.ts +6556 -0
- package/src/typescript/actions.ts +2 -4
- package/src/typescript/collections.ts +34 -20
- package/src/typescript/compile.ts +1 -3
- package/src/typescript/formula.ts +5 -3
- package/src/typescript/model.ts +4 -5
- package/src/typescript/steps.ts +20 -18
- package/src/typescript/types.ts +2 -2
- package/src/values.ts +208 -227
- package/src/prover/isabelle/isar/statement.ts +0 -52
- package/src/prover/smt/solver/z3-license.txt +0 -10
- package/src/prover/tlaps-module.ts +0 -510
- package/src/prover/zenon/LICENSE +0 -32
|
@@ -1,13 +1,13 @@
|
|
|
1
|
-
// Ported from Z3 (src/math/polynomial/polynomial.{h,cpp}, src/math/polynomial/polynomial_cache.cpp),
|
|
2
|
-
// MIT license, see z3-license.txt.
|
|
3
1
|
import { SmtInvariantError } from "../../../../errors";
|
|
2
|
+
import { RandomGen } from "../random-gen";
|
|
4
3
|
import { getGcd, Rational } from "../rational";
|
|
5
|
-
import {
|
|
4
|
+
import type { ResourceLimit } from "../rlimit";
|
|
5
|
+
import { BIG_PRIMES, getExtendedGcd, UpolynomialManager } from "./upolynomial";
|
|
6
6
|
import {
|
|
7
7
|
DEFAULT_FACTOR_PARAMS,
|
|
8
8
|
factorSquareFree,
|
|
9
9
|
getExactSquareRoot,
|
|
10
|
-
|
|
10
|
+
mkFactors,
|
|
11
11
|
} from "./upolynomial-factorization";
|
|
12
12
|
|
|
13
13
|
export const NULL_VAR = -1;
|
|
@@ -32,6 +32,24 @@ const RATIONAL_OPS: ValueOps<Rational> = {
|
|
|
32
32
|
const getMonomialKey = (vars: readonly number[], degrees: readonly number[]) =>
|
|
33
33
|
vars.map((variable, index) => `${variable}^${degrees[index]}`).join(",");
|
|
34
34
|
|
|
35
|
+
const normalizeZp = (value: bigint, modulus: bigint) => {
|
|
36
|
+
const upper = modulus / 2n;
|
|
37
|
+
const lower = modulus % 2n === 0n ? -upper + 1n : -upper;
|
|
38
|
+
const rest = value % modulus;
|
|
39
|
+
return rest > upper ? rest - modulus : rest < lower ? rest + modulus : rest;
|
|
40
|
+
};
|
|
41
|
+
|
|
42
|
+
const divMpz = (dividend: bigint, divisor: bigint) => {
|
|
43
|
+
const quotient = dividend / divisor;
|
|
44
|
+
if (dividend >= 0n || dividend % divisor === 0n) return quotient;
|
|
45
|
+
return divisor < 0n ? quotient + 1n : quotient - 1n;
|
|
46
|
+
};
|
|
47
|
+
|
|
48
|
+
const modMpz = (value: bigint, modulus: bigint) => {
|
|
49
|
+
const rest = value % modulus;
|
|
50
|
+
return rest < 0n ? rest + (modulus < 0n ? -modulus : modulus) : rest;
|
|
51
|
+
};
|
|
52
|
+
|
|
35
53
|
class Monomial {
|
|
36
54
|
readonly totalDegree: number;
|
|
37
55
|
|
|
@@ -67,6 +85,11 @@ class Monomial {
|
|
|
67
85
|
for (const current of this.vars) if (current < variable) result = current;
|
|
68
86
|
return result;
|
|
69
87
|
}
|
|
88
|
+
|
|
89
|
+
isSquare() {
|
|
90
|
+
for (const degree of this.degrees) if (degree % 2 === 1) return false;
|
|
91
|
+
return true;
|
|
92
|
+
}
|
|
70
93
|
}
|
|
71
94
|
|
|
72
95
|
const lexCompare = (first: Monomial, second: Monomial) => {
|
|
@@ -91,6 +114,45 @@ const lexCompare = (first: Monomial, second: Monomial) => {
|
|
|
91
114
|
return firstIndex < 0 ? -1 : 1;
|
|
92
115
|
};
|
|
93
116
|
|
|
117
|
+
const lexCompare2 = (first: Monomial, second: Monomial, minVar: number) => {
|
|
118
|
+
if (first === second) return 0;
|
|
119
|
+
let firstIndex = first.size - 1;
|
|
120
|
+
let secondIndex = second.size - 1;
|
|
121
|
+
let firstMinVarDegree = 0;
|
|
122
|
+
let secondMinVarDegree = 0;
|
|
123
|
+
while (firstIndex >= 0 && secondIndex >= 0) {
|
|
124
|
+
const firstVar = first.vars[firstIndex];
|
|
125
|
+
const secondVar = second.vars[secondIndex];
|
|
126
|
+
if (firstVar === minVar) {
|
|
127
|
+
firstMinVarDegree = first.degrees[firstIndex];
|
|
128
|
+
firstIndex--;
|
|
129
|
+
if (secondVar === minVar) {
|
|
130
|
+
secondMinVarDegree = second.degrees[secondIndex];
|
|
131
|
+
secondIndex--;
|
|
132
|
+
}
|
|
133
|
+
continue;
|
|
134
|
+
}
|
|
135
|
+
if (secondVar === minVar) {
|
|
136
|
+
secondMinVarDegree = second.degrees[secondIndex];
|
|
137
|
+
secondIndex--;
|
|
138
|
+
continue;
|
|
139
|
+
}
|
|
140
|
+
if (firstVar === secondVar) {
|
|
141
|
+
const firstDegree = first.degrees[firstIndex];
|
|
142
|
+
const secondDegree = second.degrees[secondIndex];
|
|
143
|
+
if (firstDegree === secondDegree) {
|
|
144
|
+
firstIndex--;
|
|
145
|
+
secondIndex--;
|
|
146
|
+
continue;
|
|
147
|
+
}
|
|
148
|
+
return firstDegree < secondDegree ? -1 : 1;
|
|
149
|
+
}
|
|
150
|
+
return firstVar > secondVar ? 1 : -1;
|
|
151
|
+
}
|
|
152
|
+
if (firstIndex === secondIndex) return firstMinVarDegree < secondMinVarDegree ? -1 : 1;
|
|
153
|
+
return firstIndex < 0 ? -1 : 1;
|
|
154
|
+
};
|
|
155
|
+
|
|
94
156
|
const gradedLexCompare = (first: Monomial, second: Monomial) =>
|
|
95
157
|
first.totalDegree === second.totalDegree
|
|
96
158
|
? lexCompare(first, second)
|
|
@@ -107,6 +169,7 @@ const isPoGreater = (first: Monomial, second: Monomial) => {
|
|
|
107
169
|
|
|
108
170
|
export class Polynomial {
|
|
109
171
|
isLexSorted = false;
|
|
172
|
+
refCount = 0;
|
|
110
173
|
|
|
111
174
|
constructor(
|
|
112
175
|
readonly id: number,
|
|
@@ -162,6 +225,13 @@ export class Polynomial {
|
|
|
162
225
|
return maxPos;
|
|
163
226
|
}
|
|
164
227
|
|
|
228
|
+
getGradedLexMinPos() {
|
|
229
|
+
let minPos = 0;
|
|
230
|
+
for (let index = 1; index < this.ms.length; index++)
|
|
231
|
+
if (gradedLexCompare(this.ms[index], this.ms[minPos]) < 0) minPos = index;
|
|
232
|
+
return minPos;
|
|
233
|
+
}
|
|
234
|
+
|
|
165
235
|
toString() {
|
|
166
236
|
if (this.ms.length === 0) return "0";
|
|
167
237
|
return this.ms
|
|
@@ -177,6 +247,112 @@ export class Polynomial {
|
|
|
177
247
|
}
|
|
178
248
|
}
|
|
179
249
|
|
|
250
|
+
export class PolynomialRef {
|
|
251
|
+
private value: Polynomial | null = null;
|
|
252
|
+
|
|
253
|
+
constructor(private readonly pm: PolynomialManager) {}
|
|
254
|
+
|
|
255
|
+
get() {
|
|
256
|
+
const value = this.value;
|
|
257
|
+
if (value === null) throw new SmtInvariantError("polynomial reference is null");
|
|
258
|
+
return value;
|
|
259
|
+
}
|
|
260
|
+
|
|
261
|
+
getOrNull() {
|
|
262
|
+
return this.value;
|
|
263
|
+
}
|
|
264
|
+
|
|
265
|
+
set(polynomial: Polynomial) {
|
|
266
|
+
this.pm.incRef(polynomial);
|
|
267
|
+
if (this.value !== null) this.pm.decRef(this.value);
|
|
268
|
+
this.value = polynomial;
|
|
269
|
+
}
|
|
270
|
+
|
|
271
|
+
copy(other: PolynomialRef) {
|
|
272
|
+
if (this.value === other.value) return;
|
|
273
|
+
if (this.value !== null) this.pm.decRef(this.value);
|
|
274
|
+
this.value = other.value;
|
|
275
|
+
if (this.value !== null) this.pm.incRef(this.value);
|
|
276
|
+
}
|
|
277
|
+
|
|
278
|
+
move(other: PolynomialRef) {
|
|
279
|
+
if (this === other) return;
|
|
280
|
+
if (this.value !== null) this.pm.decRef(this.value);
|
|
281
|
+
this.value = other.value;
|
|
282
|
+
other.value = null;
|
|
283
|
+
}
|
|
284
|
+
|
|
285
|
+
swap(other: PolynomialRef) {
|
|
286
|
+
const value = this.value;
|
|
287
|
+
this.value = other.value;
|
|
288
|
+
other.value = value;
|
|
289
|
+
}
|
|
290
|
+
|
|
291
|
+
reset() {
|
|
292
|
+
if (this.value !== null) this.pm.decRef(this.value);
|
|
293
|
+
this.value = null;
|
|
294
|
+
}
|
|
295
|
+
}
|
|
296
|
+
|
|
297
|
+
export class PolynomialRefVector {
|
|
298
|
+
readonly items: Polynomial[] = [];
|
|
299
|
+
|
|
300
|
+
constructor(private readonly pm: PolynomialManager) {}
|
|
301
|
+
|
|
302
|
+
get size() {
|
|
303
|
+
return this.items.length;
|
|
304
|
+
}
|
|
305
|
+
|
|
306
|
+
get(index: number) {
|
|
307
|
+
return this.items[index];
|
|
308
|
+
}
|
|
309
|
+
|
|
310
|
+
push(polynomial: Polynomial) {
|
|
311
|
+
this.pm.incRef(polynomial);
|
|
312
|
+
this.items.push(polynomial);
|
|
313
|
+
}
|
|
314
|
+
|
|
315
|
+
set(index: number, polynomial: Polynomial) {
|
|
316
|
+
this.pm.incRef(polynomial);
|
|
317
|
+
this.pm.decRef(this.items[index]);
|
|
318
|
+
this.items[index] = polynomial;
|
|
319
|
+
}
|
|
320
|
+
|
|
321
|
+
append(other: PolynomialRefVector) {
|
|
322
|
+
for (const polynomial of other.items) this.push(polynomial);
|
|
323
|
+
}
|
|
324
|
+
|
|
325
|
+
shrink(size: number) {
|
|
326
|
+
for (let index = size; index < this.items.length; index++) this.pm.decRef(this.items[index]);
|
|
327
|
+
this.items.length = size;
|
|
328
|
+
}
|
|
329
|
+
|
|
330
|
+
reset() {
|
|
331
|
+
this.shrink(0);
|
|
332
|
+
}
|
|
333
|
+
}
|
|
334
|
+
|
|
335
|
+
export class Factors {
|
|
336
|
+
constant = 1n;
|
|
337
|
+
readonly factors: Polynomial[] = [];
|
|
338
|
+
readonly degrees: number[] = [];
|
|
339
|
+
|
|
340
|
+
constructor(private readonly pm: PolynomialManager) {}
|
|
341
|
+
|
|
342
|
+
push(polynomial: Polynomial, degree: number) {
|
|
343
|
+
this.factors.push(polynomial);
|
|
344
|
+
this.degrees.push(degree);
|
|
345
|
+
this.pm.incRef(polynomial);
|
|
346
|
+
}
|
|
347
|
+
|
|
348
|
+
reset() {
|
|
349
|
+
for (const factor of this.factors) this.pm.decRef(factor);
|
|
350
|
+
this.factors.length = 0;
|
|
351
|
+
this.degrees.length = 0;
|
|
352
|
+
this.constant = 1n;
|
|
353
|
+
}
|
|
354
|
+
}
|
|
355
|
+
|
|
180
356
|
class SomBuffer {
|
|
181
357
|
as: bigint[] = [];
|
|
182
358
|
ms: Monomial[] = [];
|
|
@@ -192,52 +368,69 @@ class SomBuffer {
|
|
|
192
368
|
|
|
193
369
|
addTerm(coeff: bigint, monomial: Monomial) {
|
|
194
370
|
if (coeff === 0n) return;
|
|
371
|
+
const modulus = this.manager.modulus;
|
|
195
372
|
const position = this.positions.get(monomial.id);
|
|
196
373
|
if (position === undefined) {
|
|
197
374
|
this.positions.set(monomial.id, this.ms.length);
|
|
198
375
|
this.ms.push(monomial);
|
|
199
|
-
this.as.push(coeff);
|
|
376
|
+
this.as.push(modulus === null ? coeff : normalizeZp(coeff, modulus));
|
|
200
377
|
return;
|
|
201
378
|
}
|
|
202
|
-
this.as[position]
|
|
379
|
+
const sum = this.as[position] + coeff;
|
|
380
|
+
this.as[position] = modulus === null ? sum : normalizeZp(sum, modulus);
|
|
203
381
|
}
|
|
204
382
|
|
|
205
383
|
add(polynomial: Polynomial) {
|
|
384
|
+
const modulus = this.manager.modulus;
|
|
206
385
|
for (let index = 0; index < polynomial.size; index++) {
|
|
207
386
|
const monomial = polynomial.ms[index];
|
|
208
387
|
const position = this.positions.get(monomial.id);
|
|
209
388
|
if (position === undefined) {
|
|
210
389
|
this.positions.set(monomial.id, this.ms.length);
|
|
211
390
|
this.ms.push(monomial);
|
|
212
|
-
|
|
213
|
-
|
|
391
|
+
const coeff = polynomial.as[index];
|
|
392
|
+
this.as.push(modulus === null ? coeff : normalizeZp(coeff, modulus));
|
|
393
|
+
continue;
|
|
394
|
+
}
|
|
395
|
+
const sum = this.as[position] + polynomial.as[index];
|
|
396
|
+
this.as[position] = modulus === null ? sum : normalizeZp(sum, modulus);
|
|
214
397
|
}
|
|
215
398
|
}
|
|
216
399
|
|
|
217
400
|
addmul(coeff: bigint, monomial: Monomial, polynomial: Polynomial) {
|
|
218
401
|
if (coeff === 0n) return;
|
|
402
|
+
const modulus = this.manager.modulus;
|
|
219
403
|
for (let index = 0; index < polynomial.size; index++) {
|
|
220
404
|
const product = this.manager.mulMonomials(monomial, polynomial.ms[index]);
|
|
221
405
|
const position = this.positions.get(product.id);
|
|
222
406
|
if (position === undefined) {
|
|
223
407
|
this.positions.set(product.id, this.ms.length);
|
|
224
408
|
this.ms.push(product);
|
|
225
|
-
|
|
226
|
-
|
|
409
|
+
const value = coeff * polynomial.as[index];
|
|
410
|
+
this.as.push(modulus === null ? value : normalizeZp(value, modulus));
|
|
411
|
+
continue;
|
|
412
|
+
}
|
|
413
|
+
const sum = this.as[position] + coeff * polynomial.as[index];
|
|
414
|
+
this.as[position] = modulus === null ? sum : normalizeZp(sum, modulus);
|
|
227
415
|
}
|
|
228
416
|
}
|
|
229
417
|
|
|
230
418
|
// Like Z3, zero entries of the other buffer are added too, which keeps their monomials' positions.
|
|
231
419
|
addmulBuffer(coeff: bigint, monomial: Monomial, buffer: SomBuffer) {
|
|
232
420
|
if (coeff === 0n) return;
|
|
421
|
+
const modulus = this.manager.modulus;
|
|
233
422
|
for (let index = 0; index < buffer.ms.length; index++) {
|
|
234
423
|
const product = this.manager.mulMonomials(monomial, buffer.ms[index]);
|
|
235
424
|
const position = this.positions.get(product.id);
|
|
236
425
|
if (position === undefined) {
|
|
237
426
|
this.positions.set(product.id, this.ms.length);
|
|
238
427
|
this.ms.push(product);
|
|
239
|
-
|
|
240
|
-
|
|
428
|
+
const value = coeff * buffer.as[index];
|
|
429
|
+
this.as.push(modulus === null ? value : normalizeZp(value, modulus));
|
|
430
|
+
continue;
|
|
431
|
+
}
|
|
432
|
+
const sum = this.as[position] + coeff * buffer.as[index];
|
|
433
|
+
this.as[position] = modulus === null ? sum : normalizeZp(sum, modulus);
|
|
241
434
|
}
|
|
242
435
|
}
|
|
243
436
|
|
|
@@ -259,8 +452,8 @@ class SomBuffer {
|
|
|
259
452
|
ms.push(this.ms[index]);
|
|
260
453
|
}
|
|
261
454
|
this.reset();
|
|
262
|
-
|
|
263
|
-
return this.manager.mkPolynomialCore(
|
|
455
|
+
if (isNormalized) this.manager.normalizeNumerals(as);
|
|
456
|
+
return this.manager.mkPolynomialCore(as, ms);
|
|
264
457
|
}
|
|
265
458
|
}
|
|
266
459
|
|
|
@@ -270,20 +463,38 @@ class CheapSomBuffer {
|
|
|
270
463
|
|
|
271
464
|
constructor(private manager: PolynomialManager) {}
|
|
272
465
|
|
|
273
|
-
|
|
466
|
+
addReset(coeff: bigint, monomial: Monomial) {
|
|
274
467
|
if (coeff === 0n) return;
|
|
275
468
|
this.as.push(coeff);
|
|
276
469
|
this.ms.push(monomial);
|
|
277
470
|
}
|
|
278
471
|
|
|
472
|
+
add(coeff: bigint, monomial: Monomial) {
|
|
473
|
+
if (coeff === 0n) return;
|
|
474
|
+
const modulus = this.manager.modulus;
|
|
475
|
+
this.as.push(modulus === null ? coeff : normalizeZp(coeff, modulus));
|
|
476
|
+
this.ms.push(monomial);
|
|
477
|
+
}
|
|
478
|
+
|
|
279
479
|
addmul(coeff: bigint, monomial: Monomial, polynomial: Polynomial) {
|
|
280
480
|
if (coeff === 0n) return;
|
|
481
|
+
const modulus = this.manager.modulus;
|
|
281
482
|
for (let index = 0; index < polynomial.size; index++) {
|
|
282
|
-
|
|
483
|
+
const value = coeff * polynomial.as[index];
|
|
484
|
+
this.as.push(modulus === null ? value : normalizeZp(value, modulus));
|
|
283
485
|
this.ms.push(this.manager.mulMonomials(monomial, polynomial.ms[index]));
|
|
284
486
|
}
|
|
285
487
|
}
|
|
286
488
|
|
|
489
|
+
normalize() {
|
|
490
|
+
this.manager.normalizeNumerals(this.as);
|
|
491
|
+
}
|
|
492
|
+
|
|
493
|
+
reset() {
|
|
494
|
+
this.as = [];
|
|
495
|
+
this.ms = [];
|
|
496
|
+
}
|
|
497
|
+
|
|
287
498
|
mk() {
|
|
288
499
|
const result = this.manager.mkPolynomialCore(this.as, this.ms);
|
|
289
500
|
this.as = [];
|
|
@@ -292,27 +503,238 @@ class CheapSomBuffer {
|
|
|
292
503
|
}
|
|
293
504
|
}
|
|
294
505
|
|
|
295
|
-
|
|
296
|
-
|
|
297
|
-
|
|
298
|
-
|
|
506
|
+
class NewtonInterpolator {
|
|
507
|
+
readonly inputs: bigint[] = [];
|
|
508
|
+
private invs: bigint[] = [0n];
|
|
509
|
+
private vs: PolynomialRefVector;
|
|
510
|
+
|
|
511
|
+
constructor(private readonly pm: PolynomialManager) {
|
|
512
|
+
this.vs = new PolynomialRefVector(pm);
|
|
513
|
+
}
|
|
514
|
+
|
|
515
|
+
reset() {
|
|
516
|
+
this.inputs.length = 0;
|
|
517
|
+
this.invs.length = 1;
|
|
518
|
+
this.vs.reset();
|
|
519
|
+
}
|
|
520
|
+
|
|
521
|
+
add(input: bigint, output: Polynomial) {
|
|
522
|
+
const pm = this.pm;
|
|
523
|
+
const size = this.inputs.length;
|
|
524
|
+
if (size === 0) {
|
|
525
|
+
this.inputs.push(input);
|
|
526
|
+
this.vs.push(output);
|
|
527
|
+
return;
|
|
528
|
+
}
|
|
529
|
+
const k = size;
|
|
530
|
+
let product = pm.subNumeral(input, this.inputs[0]);
|
|
531
|
+
for (let index = 1; index <= k - 1; index++)
|
|
532
|
+
product = pm.mulNumeral(product, pm.subNumeral(input, this.inputs[index]));
|
|
533
|
+
product = pm.invNumeral(product);
|
|
534
|
+
this.inputs.push(input);
|
|
535
|
+
this.invs.push(product);
|
|
536
|
+
const temp = new PolynomialRef(pm);
|
|
537
|
+
const auxPoly = new PolynomialRef(pm);
|
|
538
|
+
temp.set(this.vs.get(k - 1));
|
|
539
|
+
for (let j = k - 2; j >= 0; j--) {
|
|
540
|
+
const aux = pm.subNumeral(input, this.inputs[j]);
|
|
541
|
+
auxPoly.set(pm.mulConst(aux, temp.get()));
|
|
542
|
+
temp.set(pm.add(auxPoly.get(), this.vs.get(j)));
|
|
543
|
+
}
|
|
544
|
+
auxPoly.set(pm.sub(output, temp.get()));
|
|
545
|
+
auxPoly.set(pm.mulConst(this.invs[size], auxPoly.get()));
|
|
546
|
+
this.vs.push(auxPoly.get());
|
|
547
|
+
auxPoly.reset();
|
|
548
|
+
temp.reset();
|
|
549
|
+
}
|
|
550
|
+
|
|
551
|
+
mk(x: number, r: PolynomialRef) {
|
|
552
|
+
const pm = this.pm;
|
|
553
|
+
const u = new PolynomialRef(pm);
|
|
554
|
+
const auxPoly = new PolynomialRef(pm);
|
|
555
|
+
const d = this.inputs.length - 1;
|
|
556
|
+
u.set(this.vs.get(d));
|
|
557
|
+
for (let k = d - 1; k >= 0; k--) {
|
|
558
|
+
const c = pm.negNumeral(this.inputs[k]);
|
|
559
|
+
auxPoly.set(pm.mkLinear([1n], [x], c));
|
|
560
|
+
auxPoly.set(pm.mul(u.get(), auxPoly.get()));
|
|
561
|
+
u.set(pm.add(auxPoly.get(), this.vs.get(k)));
|
|
562
|
+
}
|
|
563
|
+
r.copy(u);
|
|
564
|
+
auxPoly.reset();
|
|
565
|
+
u.reset();
|
|
566
|
+
}
|
|
567
|
+
}
|
|
568
|
+
|
|
569
|
+
interface SkeletonEntry {
|
|
570
|
+
monomial: Monomial;
|
|
571
|
+
firstPowerIndex: number;
|
|
572
|
+
numPowers: number;
|
|
573
|
+
}
|
|
574
|
+
|
|
575
|
+
class Skeleton {
|
|
576
|
+
readonly entries: SkeletonEntry[] = [];
|
|
577
|
+
readonly powers: number[] = [];
|
|
578
|
+
readonly origMonomials: Monomial[] = [];
|
|
579
|
+
maxPowers = 0;
|
|
580
|
+
|
|
581
|
+
constructor(pm: PolynomialManager, polynomial: Polynomial, x: number) {
|
|
582
|
+
const ms = [...polynomial.ms].sort((first, second) => lexCompare2(first, second, x));
|
|
583
|
+
let previous: Monomial | null = null;
|
|
584
|
+
for (const origMonomial of ms) {
|
|
585
|
+
const k = origMonomial.degreeOf(x);
|
|
586
|
+
const monomial = k > 0 ? pm.divX(origMonomial, x) : origMonomial;
|
|
587
|
+
if (monomial === previous) {
|
|
588
|
+
const entry = this.entries[this.entries.length - 1];
|
|
589
|
+
entry.numPowers++;
|
|
590
|
+
if (entry.numPowers > this.maxPowers) this.maxPowers = entry.numPowers;
|
|
591
|
+
} else {
|
|
592
|
+
previous = monomial;
|
|
593
|
+
this.entries.push({ monomial, firstPowerIndex: this.powers.length, numPowers: 1 });
|
|
594
|
+
if (this.maxPowers === 0) this.maxPowers = 1;
|
|
595
|
+
}
|
|
596
|
+
this.origMonomials.push(origMonomial);
|
|
597
|
+
this.powers.push(k);
|
|
598
|
+
}
|
|
599
|
+
}
|
|
600
|
+
|
|
601
|
+
getEntryIndex(monomial: Monomial) {
|
|
602
|
+
for (let index = 0; index < this.entries.length; index++)
|
|
603
|
+
if (this.entries[index].monomial === monomial) return index;
|
|
604
|
+
return -1;
|
|
605
|
+
}
|
|
606
|
+
}
|
|
607
|
+
|
|
608
|
+
const solveLinearEquations = (
|
|
609
|
+
pm: PolynomialManager,
|
|
610
|
+
rows: bigint[][],
|
|
611
|
+
b: bigint[],
|
|
612
|
+
xs: bigint[],
|
|
613
|
+
) => {
|
|
614
|
+
const n = rows.length;
|
|
615
|
+
for (let k = 0; k < n; k++) {
|
|
616
|
+
let i = k;
|
|
617
|
+
for (; i < n; i++) if (rows[i][k] !== 0n) break;
|
|
618
|
+
if (i === n) return false;
|
|
619
|
+
const row = rows[k];
|
|
620
|
+
rows[k] = rows[i];
|
|
621
|
+
rows[i] = row;
|
|
622
|
+
const rowK = rows[k];
|
|
623
|
+
const pivot = rowK[k];
|
|
624
|
+
for (let column = k + 1; column < n; column++)
|
|
625
|
+
rowK[column] = pm.divNumeral(rowK[column], pivot);
|
|
626
|
+
b[k] = pm.divNumeral(b[k], pivot);
|
|
627
|
+
rowK[k] = pm.normalizeNumeral(1n);
|
|
628
|
+
for (let other = k + 1; other < n; other++) {
|
|
629
|
+
const rowI = rows[other];
|
|
630
|
+
const factor = rowI[k];
|
|
631
|
+
for (let column = k + 1; column < n; column++)
|
|
632
|
+
rowI[column] = pm.normalizeNumeral(rowI[column] - factor * rowK[column]);
|
|
633
|
+
b[other] = pm.normalizeNumeral(b[other] - factor * b[k]);
|
|
634
|
+
rowI[k] = 0n;
|
|
635
|
+
}
|
|
636
|
+
}
|
|
637
|
+
for (let k = n; k-- > 0;) {
|
|
638
|
+
xs[k] = b[k];
|
|
639
|
+
for (let other = k; other-- > 0;) {
|
|
640
|
+
b[other] = pm.normalizeNumeral(b[other] - rows[other][k] * b[k]);
|
|
641
|
+
rows[other][k] = 0n;
|
|
642
|
+
}
|
|
643
|
+
}
|
|
644
|
+
return true;
|
|
645
|
+
};
|
|
646
|
+
|
|
647
|
+
class SparseInterpolator {
|
|
648
|
+
private inputs: bigint[] = [];
|
|
649
|
+
private outputs: bigint[] = [];
|
|
650
|
+
|
|
651
|
+
constructor(
|
|
652
|
+
private readonly pm: PolynomialManager,
|
|
653
|
+
skeleton: Skeleton | null,
|
|
654
|
+
) {
|
|
655
|
+
if (skeleton !== null)
|
|
656
|
+
for (const entry of skeleton.entries)
|
|
657
|
+
for (let index = 0; index < entry.numPowers; index++) this.outputs.push(0n);
|
|
658
|
+
}
|
|
659
|
+
|
|
660
|
+
reset() {
|
|
661
|
+
this.inputs.length = 0;
|
|
662
|
+
}
|
|
663
|
+
|
|
664
|
+
isReady(skeleton: Skeleton) {
|
|
665
|
+
return this.inputs.length === skeleton.maxPowers;
|
|
666
|
+
}
|
|
667
|
+
|
|
668
|
+
add(skeleton: Skeleton, input: bigint, q: Polynomial) {
|
|
669
|
+
const inputIndex = this.inputs.length;
|
|
670
|
+
this.inputs.push(this.pm.normalizeNumeral(input));
|
|
671
|
+
for (let index = 0; index < q.size; index++) {
|
|
672
|
+
const entryIndex = skeleton.getEntryIndex(q.ms[index]);
|
|
673
|
+
if (entryIndex === -1) return false;
|
|
674
|
+
const entry = skeleton.entries[entryIndex];
|
|
675
|
+
if (inputIndex >= entry.numPowers) continue;
|
|
676
|
+
this.outputs[entry.firstPowerIndex + inputIndex] = this.pm.normalizeNumeral(q.as[index]);
|
|
677
|
+
}
|
|
678
|
+
return true;
|
|
679
|
+
}
|
|
680
|
+
|
|
681
|
+
mk(skeleton: Skeleton, r: PolynomialRef) {
|
|
682
|
+
const pm = this.pm;
|
|
683
|
+
const as: bigint[] = [];
|
|
684
|
+
const ms: Monomial[] = [];
|
|
685
|
+
let rows: bigint[][] = [];
|
|
686
|
+
let b: bigint[] = [];
|
|
687
|
+
for (const entry of skeleton.entries) {
|
|
688
|
+
const numPowers = entry.numPowers;
|
|
689
|
+
if (rows.length !== numPowers) {
|
|
690
|
+
rows = Array.from({ length: numPowers }, () => Array.from({ length: numPowers }, () => 0n));
|
|
691
|
+
b = Array.from({ length: numPowers }, () => 0n);
|
|
692
|
+
}
|
|
693
|
+
const newAs = Array.from({ length: numPowers }, () => 0n);
|
|
694
|
+
for (let index = 0; index < numPowers; index++) {
|
|
695
|
+
const input = this.inputs[index];
|
|
696
|
+
for (let j = 0; j < numPowers; j++)
|
|
697
|
+
rows[index][j] = pm.powerNumeral(input, skeleton.powers[entry.firstPowerIndex + j]);
|
|
698
|
+
b[index] = this.outputs[entry.firstPowerIndex + index];
|
|
699
|
+
}
|
|
700
|
+
if (!solveLinearEquations(pm, rows, b, newAs)) return false;
|
|
701
|
+
for (let index = 0; index < numPowers; index++) {
|
|
702
|
+
if (newAs[index] === 0n) continue;
|
|
703
|
+
as.push(newAs[index]);
|
|
704
|
+
ms.push(skeleton.origMonomials[entry.firstPowerIndex + index]);
|
|
705
|
+
}
|
|
706
|
+
}
|
|
707
|
+
r.set(pm.mkPolynomial(as, ms));
|
|
708
|
+
return true;
|
|
709
|
+
}
|
|
299
710
|
}
|
|
300
711
|
|
|
301
712
|
export class PolynomialManager {
|
|
302
713
|
private monomials = new Map<string, Monomial>();
|
|
303
714
|
private nextPolynomialId = 0;
|
|
715
|
+
private freePolynomialIds: number[] = [];
|
|
716
|
+
private polynomials: (Polynomial | null)[] = [];
|
|
717
|
+
modulus: bigint | null = null;
|
|
304
718
|
readonly unit: Monomial;
|
|
305
719
|
readonly zero: Polynomial;
|
|
306
720
|
readonly one: Polynomial;
|
|
307
|
-
private um
|
|
721
|
+
private um: UpolynomialManager;
|
|
308
722
|
private som = new SomBuffer(this);
|
|
309
723
|
private som2 = new SomBuffer(this);
|
|
310
724
|
private cheap = new CheapSomBuffer(this);
|
|
311
|
-
|
|
312
|
-
|
|
725
|
+
private cheap2 = new CheapSomBuffer(this);
|
|
726
|
+
private random = new RandomGen(0);
|
|
727
|
+
private mgcdInterpolators: NewtonInterpolator[] = [];
|
|
728
|
+
private mgcdSkeletons: (Skeleton | null)[] = [];
|
|
729
|
+
private iccpZpXBuffers: SomBuffer[] = [];
|
|
730
|
+
|
|
731
|
+
constructor(readonly limit: ResourceLimit) {
|
|
732
|
+
this.um = new UpolynomialManager(limit);
|
|
313
733
|
this.unit = this.mkMonomial([], []);
|
|
314
734
|
this.zero = this.mkPolynomialCore([], []);
|
|
315
|
-
this.
|
|
735
|
+
this.incRef(this.zero);
|
|
736
|
+
this.one = this.mkConstCore(1n);
|
|
737
|
+
this.incRef(this.one);
|
|
316
738
|
}
|
|
317
739
|
|
|
318
740
|
mkMonomial(vars: readonly number[], degrees: readonly number[]) {
|
|
@@ -324,7 +746,7 @@ export class PolynomialManager {
|
|
|
324
746
|
return monomial;
|
|
325
747
|
}
|
|
326
748
|
|
|
327
|
-
rename(permutation: readonly number[]
|
|
749
|
+
rename(permutation: readonly number[]) {
|
|
328
750
|
const monomials = new Map<string, Monomial>();
|
|
329
751
|
for (const monomial of this.monomials.values()) {
|
|
330
752
|
const order = monomial.vars
|
|
@@ -338,7 +760,8 @@ export class PolynomialManager {
|
|
|
338
760
|
monomials.set(getMonomialKey(monomial.vars, monomial.degrees), monomial);
|
|
339
761
|
}
|
|
340
762
|
this.monomials = monomials;
|
|
341
|
-
for (const polynomial of polynomials)
|
|
763
|
+
for (const polynomial of this.polynomials)
|
|
764
|
+
if (polynomial !== null) polynomial.makeFirstMaximal();
|
|
342
765
|
}
|
|
343
766
|
|
|
344
767
|
mkPower(variable: number, power: number) {
|
|
@@ -403,22 +826,114 @@ export class PolynomialManager {
|
|
|
403
826
|
return this.mkMonomial(vars, degrees);
|
|
404
827
|
}
|
|
405
828
|
|
|
406
|
-
|
|
829
|
+
divX(monomial: Monomial, variable: number) {
|
|
407
830
|
return this.divXk(monomial, variable, monomial.degreeOf(variable));
|
|
408
831
|
}
|
|
409
832
|
|
|
833
|
+
private sqrtMonomial(monomial: Monomial) {
|
|
834
|
+
return this.mkMonomial(
|
|
835
|
+
monomial.vars,
|
|
836
|
+
monomial.degrees.map((degree) => degree / 2),
|
|
837
|
+
);
|
|
838
|
+
}
|
|
839
|
+
|
|
840
|
+
normalizeNumeral(value: bigint) {
|
|
841
|
+
const modulus = this.modulus;
|
|
842
|
+
return modulus === null ? value : normalizeZp(value, modulus);
|
|
843
|
+
}
|
|
844
|
+
|
|
845
|
+
subNumeral(first: bigint, second: bigint) {
|
|
846
|
+
return this.normalizeNumeral(first - second);
|
|
847
|
+
}
|
|
848
|
+
|
|
849
|
+
mulNumeral(first: bigint, second: bigint) {
|
|
850
|
+
return this.normalizeNumeral(first * second);
|
|
851
|
+
}
|
|
852
|
+
|
|
853
|
+
negNumeral(value: bigint) {
|
|
854
|
+
return this.normalizeNumeral(-value);
|
|
855
|
+
}
|
|
856
|
+
|
|
857
|
+
invNumeral(value: bigint) {
|
|
858
|
+
const modulus = this.modulus;
|
|
859
|
+
if (modulus === null) throw new SmtInvariantError("inverse over Z");
|
|
860
|
+
return normalizeZp(getExtendedGcd(normalizeZp(value, modulus), modulus).x, modulus);
|
|
861
|
+
}
|
|
862
|
+
|
|
863
|
+
divNumeral(dividend: bigint, divisor: bigint) {
|
|
864
|
+
return this.modulus === null
|
|
865
|
+
? divMpz(dividend, divisor)
|
|
866
|
+
: this.mulNumeral(dividend, this.invNumeral(divisor));
|
|
867
|
+
}
|
|
868
|
+
|
|
869
|
+
powerNumeral(base: bigint, exponent: number) {
|
|
870
|
+
if (exponent === 1) return this.normalizeNumeral(base);
|
|
871
|
+
if (exponent === 0) return this.normalizeNumeral(1n);
|
|
872
|
+
let mask = 1;
|
|
873
|
+
let power = this.normalizeNumeral(base);
|
|
874
|
+
let result = this.normalizeNumeral(1n);
|
|
875
|
+
while (mask <= exponent) {
|
|
876
|
+
if ((mask & exponent) !== 0) result = this.mulNumeral(result, power);
|
|
877
|
+
power = this.mulNumeral(power, power);
|
|
878
|
+
mask <<= 1;
|
|
879
|
+
}
|
|
880
|
+
return result;
|
|
881
|
+
}
|
|
882
|
+
|
|
883
|
+
private dividesNumeral(divisor: bigint, dividend: bigint) {
|
|
884
|
+
if (this.modulus !== null && divisor !== 0n) return true;
|
|
885
|
+
return divisor === 0n ? dividend === 0n : dividend % divisor === 0n;
|
|
886
|
+
}
|
|
887
|
+
|
|
888
|
+
private gcdNumerals(as: readonly bigint[]) {
|
|
889
|
+
let result = 0n;
|
|
890
|
+
for (const coeff of as) result = getGcd(result, coeff);
|
|
891
|
+
return result;
|
|
892
|
+
}
|
|
893
|
+
|
|
894
|
+
normalizeNumerals(as: bigint[]) {
|
|
895
|
+
if (as.length === 0) return;
|
|
896
|
+
const g = this.gcdNumerals(as);
|
|
897
|
+
if (g === 1n) return;
|
|
898
|
+
for (let index = 0; index < as.length; index++) as[index] = this.divNumeral(as[index], g);
|
|
899
|
+
}
|
|
900
|
+
|
|
901
|
+
setZp(prime: bigint) {
|
|
902
|
+
this.modulus = prime;
|
|
903
|
+
}
|
|
904
|
+
|
|
410
905
|
mkPolynomialCore(as: bigint[], ms: Monomial[]) {
|
|
411
|
-
|
|
906
|
+
const id = this.freePolynomialIds.pop() ?? this.nextPolynomialId++;
|
|
907
|
+
const polynomial = new Polynomial(id, as, ms);
|
|
908
|
+
this.polynomials[id] = polynomial;
|
|
909
|
+
return polynomial;
|
|
910
|
+
}
|
|
911
|
+
|
|
912
|
+
incRef(polynomial: Polynomial) {
|
|
913
|
+
polynomial.refCount++;
|
|
914
|
+
}
|
|
915
|
+
|
|
916
|
+
decRef(polynomial: Polynomial) {
|
|
917
|
+
if (--polynomial.refCount === 0) this.del(polynomial);
|
|
918
|
+
}
|
|
919
|
+
|
|
920
|
+
private del(polynomial: Polynomial) {
|
|
921
|
+
this.polynomials[polynomial.id] = null;
|
|
922
|
+
this.freePolynomialIds.push(polynomial.id);
|
|
923
|
+
}
|
|
924
|
+
|
|
925
|
+
private mkConstCore(value: bigint) {
|
|
926
|
+
return this.mkPolynomialCore([value], [this.unit]);
|
|
412
927
|
}
|
|
413
928
|
|
|
414
929
|
mkConst(value: bigint) {
|
|
415
930
|
if (value === 0n) return this.zero;
|
|
416
931
|
if (value === 1n) return this.one;
|
|
417
|
-
return this.
|
|
932
|
+
return this.mkConstCore(value);
|
|
418
933
|
}
|
|
419
934
|
|
|
420
935
|
mkVar(variable: number, degree = 1) {
|
|
421
|
-
return this.mkPolynomialCore([1n], [this.
|
|
936
|
+
return this.mkPolynomialCore([1n], [this.mkPower(variable, degree)]);
|
|
422
937
|
}
|
|
423
938
|
|
|
424
939
|
mkPolynomial(as: readonly bigint[], ms: readonly Monomial[]) {
|
|
@@ -427,6 +942,17 @@ export class PolynomialManager {
|
|
|
427
942
|
return this.som.mk();
|
|
428
943
|
}
|
|
429
944
|
|
|
945
|
+
private mkUnivariate(variable: number, coeffs: readonly bigint[]) {
|
|
946
|
+
for (let power = coeffs.length - 1; power >= 0; power--)
|
|
947
|
+
this.cheap.addReset(coeffs[power], this.mkPower(variable, power));
|
|
948
|
+
return this.cheap.mk();
|
|
949
|
+
}
|
|
950
|
+
|
|
951
|
+
toPolynomial(coeffs: readonly bigint[], variable: number) {
|
|
952
|
+
if (coeffs.length === 0) return this.zero;
|
|
953
|
+
return this.mkUnivariate(variable, coeffs);
|
|
954
|
+
}
|
|
955
|
+
|
|
430
956
|
mkLinear(as: readonly bigint[], vars: readonly number[], constant: bigint) {
|
|
431
957
|
const coeffs: bigint[] = [];
|
|
432
958
|
const ms: Monomial[] = [];
|
|
@@ -462,6 +988,15 @@ export class PolynomialManager {
|
|
|
462
988
|
return polynomial.size === 0 ? NULL_VAR : polynomial.ms[0].maxVar;
|
|
463
989
|
}
|
|
464
990
|
|
|
991
|
+
getMaxVarOfPolys(polynomials: readonly Polynomial[]) {
|
|
992
|
+
let result = NULL_VAR;
|
|
993
|
+
for (const polynomial of polynomials) {
|
|
994
|
+
const variable = this.maxVar(polynomial);
|
|
995
|
+
if (result === NULL_VAR || variable > result) result = variable;
|
|
996
|
+
}
|
|
997
|
+
return result;
|
|
998
|
+
}
|
|
999
|
+
|
|
465
1000
|
degree(polynomial: Polynomial, variable: number) {
|
|
466
1001
|
let result = 0;
|
|
467
1002
|
for (const monomial of polynomial.ms) result = Math.max(result, monomial.degreeOf(variable));
|
|
@@ -495,29 +1030,47 @@ export class PolynomialManager {
|
|
|
495
1030
|
return key;
|
|
496
1031
|
}
|
|
497
1032
|
|
|
498
|
-
|
|
1033
|
+
addmulTerms(
|
|
1034
|
+
firstCoeff: bigint,
|
|
1035
|
+
firstMonomial: Monomial,
|
|
1036
|
+
first: Polynomial,
|
|
1037
|
+
secondCoeff: bigint,
|
|
1038
|
+
secondMonomial: Monomial,
|
|
1039
|
+
second: Polynomial,
|
|
1040
|
+
) {
|
|
499
1041
|
this.som.reset();
|
|
500
|
-
this.som.addmul(firstCoeff,
|
|
501
|
-
this.som.addmul(secondCoeff,
|
|
1042
|
+
this.som.addmul(firstCoeff, firstMonomial, first);
|
|
1043
|
+
this.som.addmul(secondCoeff, secondMonomial, second);
|
|
502
1044
|
return this.som.mk();
|
|
503
1045
|
}
|
|
504
1046
|
|
|
1047
|
+
addmul(first: Polynomial, secondCoeff: bigint, second: Polynomial) {
|
|
1048
|
+
return this.addmulTerms(1n, this.unit, first, secondCoeff, this.unit, second);
|
|
1049
|
+
}
|
|
1050
|
+
|
|
505
1051
|
add(first: Polynomial, second: Polynomial) {
|
|
506
|
-
return this.
|
|
1052
|
+
return this.addmulTerms(1n, this.unit, first, 1n, this.unit, second);
|
|
507
1053
|
}
|
|
508
1054
|
|
|
509
1055
|
sub(first: Polynomial, second: Polynomial) {
|
|
510
|
-
return this.
|
|
1056
|
+
return this.addmulTerms(1n, this.unit, first, this.normalizeNumeral(-1n), this.unit, second);
|
|
511
1057
|
}
|
|
512
1058
|
|
|
513
|
-
|
|
514
|
-
if (first.size === 0 || second.size === 0) return this.
|
|
1059
|
+
muladd(first: Polynomial, second: Polynomial, constant: bigint) {
|
|
1060
|
+
if (first.size === 0 || second.size === 0) return this.mkConst(constant);
|
|
515
1061
|
this.som.reset();
|
|
516
|
-
for (let index = 0; index < first.size; index++)
|
|
1062
|
+
for (let index = 0; index < first.size; index++) {
|
|
1063
|
+
this.limit.checkpoint();
|
|
517
1064
|
this.som.addmul(first.as[index], first.ms[index], second);
|
|
1065
|
+
}
|
|
1066
|
+
this.som.addTerm(constant, this.unit);
|
|
518
1067
|
return this.som.mk();
|
|
519
1068
|
}
|
|
520
1069
|
|
|
1070
|
+
mul(first: Polynomial, second: Polynomial) {
|
|
1071
|
+
return this.muladd(first, second, 0n);
|
|
1072
|
+
}
|
|
1073
|
+
|
|
521
1074
|
mulTerm(coeff: bigint, monomial: Monomial, polynomial: Polynomial) {
|
|
522
1075
|
if (coeff === 0n) return this.zero;
|
|
523
1076
|
if (coeff === 1n && monomial === this.unit) return polynomial;
|
|
@@ -529,25 +1082,39 @@ export class PolynomialManager {
|
|
|
529
1082
|
return this.mulTerm(coeff, this.unit, polynomial);
|
|
530
1083
|
}
|
|
531
1084
|
|
|
1085
|
+
private mulScaled(coeff: bigint, first: Polynomial, second: Polynomial) {
|
|
1086
|
+
if (coeff === 0n || first.size === 0 || second.size === 0) return this.zero;
|
|
1087
|
+
this.som.reset();
|
|
1088
|
+
for (let index = 0; index < first.size; index++) {
|
|
1089
|
+
this.limit.checkpoint();
|
|
1090
|
+
this.som.addmul(this.mulNumeral(coeff, first.as[index]), first.ms[index], second);
|
|
1091
|
+
}
|
|
1092
|
+
return this.som.mk();
|
|
1093
|
+
}
|
|
1094
|
+
|
|
532
1095
|
neg(polynomial: Polynomial) {
|
|
533
1096
|
for (let index = 0; index < polynomial.size; index++)
|
|
534
|
-
this.cheap.add(
|
|
1097
|
+
this.cheap.add(this.negNumeral(polynomial.as[index]), polynomial.ms[index]);
|
|
535
1098
|
return this.cheap.mk();
|
|
536
1099
|
}
|
|
537
1100
|
|
|
538
|
-
|
|
539
|
-
|
|
540
|
-
|
|
541
|
-
|
|
542
|
-
|
|
1101
|
+
coeff(polynomial: Polynomial, variable: number, power: number) {
|
|
1102
|
+
for (let index = 0; index < polynomial.size; index++) {
|
|
1103
|
+
const monomial = polynomial.ms[index];
|
|
1104
|
+
if (monomial.degreeOf(variable) === power)
|
|
1105
|
+
this.cheap.add(polynomial.as[index], this.divX(monomial, variable));
|
|
1106
|
+
}
|
|
1107
|
+
return this.cheap.mk();
|
|
543
1108
|
}
|
|
544
1109
|
|
|
545
|
-
|
|
1110
|
+
coeffWithReduct(polynomial: Polynomial, variable: number, power: number, reduct: PolynomialRef) {
|
|
546
1111
|
for (let index = 0; index < polynomial.size; index++) {
|
|
547
1112
|
const monomial = polynomial.ms[index];
|
|
548
1113
|
if (monomial.degreeOf(variable) === power)
|
|
549
1114
|
this.cheap.add(polynomial.as[index], this.divX(monomial, variable));
|
|
1115
|
+
else this.cheap2.add(polynomial.as[index], monomial);
|
|
550
1116
|
}
|
|
1117
|
+
reduct.set(this.cheap2.mk());
|
|
551
1118
|
return this.cheap.mk();
|
|
552
1119
|
}
|
|
553
1120
|
|
|
@@ -562,6 +1129,17 @@ export class PolynomialManager {
|
|
|
562
1129
|
return result;
|
|
563
1130
|
}
|
|
564
1131
|
|
|
1132
|
+
isNonzeroConstCoeff(polynomial: Polynomial, variable: number, power: number) {
|
|
1133
|
+
const coeff = this.getConstCoeff(polynomial, variable, power);
|
|
1134
|
+
return coeff !== null && coeff !== 0n;
|
|
1135
|
+
}
|
|
1136
|
+
|
|
1137
|
+
private getUnivCoeff(polynomial: Polynomial, power: number) {
|
|
1138
|
+
for (let index = 0; index < polynomial.size; index++)
|
|
1139
|
+
if (polynomial.ms[index].totalDegree === power) return polynomial.as[index];
|
|
1140
|
+
return 0n;
|
|
1141
|
+
}
|
|
1142
|
+
|
|
565
1143
|
lc(polynomial: Polynomial, variable: number) {
|
|
566
1144
|
return this.coeff(polynomial, variable, this.degree(polynomial, variable));
|
|
567
1145
|
}
|
|
@@ -571,7 +1149,10 @@ export class PolynomialManager {
|
|
|
571
1149
|
const monomial = polynomial.ms[index];
|
|
572
1150
|
const degree = monomial.degreeOf(variable);
|
|
573
1151
|
if (degree > 0)
|
|
574
|
-
this.cheap.
|
|
1152
|
+
this.cheap.addReset(
|
|
1153
|
+
this.mulNumeral(polynomial.as[index], BigInt(degree)),
|
|
1154
|
+
this.divXk(monomial, variable, 1),
|
|
1155
|
+
);
|
|
575
1156
|
}
|
|
576
1157
|
return this.cheap.mk();
|
|
577
1158
|
}
|
|
@@ -592,24 +1173,43 @@ export class PolynomialManager {
|
|
|
592
1173
|
return result;
|
|
593
1174
|
}
|
|
594
1175
|
|
|
595
|
-
private icWithContent(polynomial: Polynomial
|
|
596
|
-
if (polynomial.size === 0)
|
|
597
|
-
|
|
598
|
-
|
|
599
|
-
|
|
600
|
-
if (
|
|
1176
|
+
private icWithContent(polynomial: Polynomial, c: PolynomialRef) {
|
|
1177
|
+
if (polynomial.size === 0) {
|
|
1178
|
+
c.set(polynomial);
|
|
1179
|
+
return 0n;
|
|
1180
|
+
}
|
|
1181
|
+
if (this.isConst(polynomial)) {
|
|
1182
|
+
c.set(this.one);
|
|
1183
|
+
return polynomial.as[0];
|
|
1184
|
+
}
|
|
1185
|
+
const content = this.gcdNumerals(polynomial.as);
|
|
1186
|
+
if (content === 1n) {
|
|
1187
|
+
c.set(polynomial);
|
|
1188
|
+
return content;
|
|
1189
|
+
}
|
|
1190
|
+
this.cheap.reset();
|
|
601
1191
|
for (let index = 0; index < polynomial.size; index++)
|
|
602
|
-
this.cheap.
|
|
603
|
-
|
|
1192
|
+
this.cheap.addReset(this.divNumeral(polynomial.as[index], content), polynomial.ms[index]);
|
|
1193
|
+
c.set(this.cheap.mk());
|
|
1194
|
+
return content;
|
|
604
1195
|
}
|
|
605
1196
|
|
|
606
|
-
iccp(polynomial: Polynomial, variable: number
|
|
607
|
-
if (polynomial.size === 0)
|
|
608
|
-
|
|
1197
|
+
iccp(polynomial: Polynomial, variable: number, c: PolynomialRef, pp: PolynomialRef) {
|
|
1198
|
+
if (polynomial.size === 0) {
|
|
1199
|
+
c.set(this.one);
|
|
1200
|
+
pp.set(polynomial);
|
|
1201
|
+
return 0n;
|
|
1202
|
+
}
|
|
1203
|
+
if (this.isConst(polynomial)) {
|
|
1204
|
+
c.set(this.one);
|
|
1205
|
+
pp.set(this.one);
|
|
1206
|
+
return polynomial.as[0];
|
|
1207
|
+
}
|
|
609
1208
|
const degree = this.degree(polynomial, variable);
|
|
610
1209
|
if (degree === 0) {
|
|
611
|
-
const
|
|
612
|
-
|
|
1210
|
+
const integer = this.icWithContent(polynomial, c);
|
|
1211
|
+
pp.set(this.one);
|
|
1212
|
+
return integer;
|
|
613
1213
|
}
|
|
614
1214
|
const filter = Array.from({ length: degree + 1 }, () => 0);
|
|
615
1215
|
const powers: number[] = [];
|
|
@@ -618,160 +1218,597 @@ export class PolynomialManager {
|
|
|
618
1218
|
if (filter[power] === 0) powers.push(power);
|
|
619
1219
|
filter[power] += monomial.size === (power > 0 ? 1 : 0) ? 1 : 2;
|
|
620
1220
|
}
|
|
621
|
-
const
|
|
622
|
-
|
|
623
|
-
|
|
1221
|
+
for (const power of powers)
|
|
1222
|
+
if (filter[power] === 1) {
|
|
1223
|
+
const integer = this.icWithContent(polynomial, pp);
|
|
1224
|
+
c.set(this.one);
|
|
1225
|
+
return integer;
|
|
1226
|
+
}
|
|
1227
|
+
const integer = this.icWithContent(polynomial, pp);
|
|
1228
|
+
const ci = new PolynomialRef(this);
|
|
1229
|
+
c.set(this.coeff(pp.get(), variable, powers[0]));
|
|
624
1230
|
for (let index = 1; index < powers.length; index++) {
|
|
625
|
-
|
|
626
|
-
|
|
1231
|
+
ci.set(this.coeff(pp.get(), variable, powers[index]));
|
|
1232
|
+
this.gcd(c.get(), ci.get(), c);
|
|
1233
|
+
if (this.isConst(c.get())) {
|
|
1234
|
+
c.set(this.one);
|
|
1235
|
+
ci.reset();
|
|
1236
|
+
return integer;
|
|
1237
|
+
}
|
|
627
1238
|
}
|
|
628
|
-
|
|
629
|
-
|
|
1239
|
+
c.set(this.flipSignIfLmNeg(c.get()));
|
|
1240
|
+
pp.set(this.exactDiv(pp.get(), c.get()));
|
|
1241
|
+
ci.reset();
|
|
1242
|
+
return integer;
|
|
630
1243
|
}
|
|
631
1244
|
|
|
632
1245
|
pp(polynomial: Polynomial, variable: number) {
|
|
633
|
-
|
|
1246
|
+
const c = new PolynomialRef(this);
|
|
1247
|
+
const result = new PolynomialRef(this);
|
|
1248
|
+
this.iccp(polynomial, variable, c, result);
|
|
1249
|
+
c.reset();
|
|
1250
|
+
return result;
|
|
634
1251
|
}
|
|
635
1252
|
|
|
636
|
-
|
|
637
|
-
|
|
638
|
-
const
|
|
639
|
-
|
|
640
|
-
const
|
|
641
|
-
|
|
642
|
-
|
|
643
|
-
|
|
644
|
-
return this.mul(this.mulConst(integer, squareFreeContent), squareFreePrimitive);
|
|
1253
|
+
isPrimitive(polynomial: Polynomial, variable: number) {
|
|
1254
|
+
const c = new PolynomialRef(this);
|
|
1255
|
+
const pp = new PolynomialRef(this);
|
|
1256
|
+
this.iccp(polynomial, variable, c, pp);
|
|
1257
|
+
const result = this.eq(polynomial, pp.get());
|
|
1258
|
+
pp.reset();
|
|
1259
|
+
c.reset();
|
|
1260
|
+
return result;
|
|
645
1261
|
}
|
|
646
1262
|
|
|
647
|
-
|
|
648
|
-
|
|
649
|
-
|
|
650
|
-
|
|
651
|
-
|
|
652
|
-
|
|
653
|
-
|
|
654
|
-
|
|
655
|
-
|
|
656
|
-
|
|
657
|
-
|
|
658
|
-
const
|
|
659
|
-
|
|
660
|
-
|
|
661
|
-
|
|
662
|
-
|
|
663
|
-
|
|
664
|
-
|
|
665
|
-
|
|
666
|
-
|
|
667
|
-
|
|
668
|
-
|
|
669
|
-
|
|
670
|
-
|
|
671
|
-
const
|
|
1263
|
+
private gcdPrs(first: Polynomial, second: Polynomial, variable: number, r: PolynomialRef) {
|
|
1264
|
+
const isSwapped = this.degree(first, variable) < this.degree(second, variable);
|
|
1265
|
+
const u = isSwapped ? second : first;
|
|
1266
|
+
const v = isSwapped ? first : second;
|
|
1267
|
+
const cU = new PolynomialRef(this);
|
|
1268
|
+
const cV = new PolynomialRef(this);
|
|
1269
|
+
const ppU = new PolynomialRef(this);
|
|
1270
|
+
const ppV = new PolynomialRef(this);
|
|
1271
|
+
const dR = new PolynomialRef(this);
|
|
1272
|
+
const g = new PolynomialRef(this);
|
|
1273
|
+
const h = new PolynomialRef(this);
|
|
1274
|
+
const rem = new PolynomialRef(this);
|
|
1275
|
+
const newH = new PolynomialRef(this);
|
|
1276
|
+
const release = () => {
|
|
1277
|
+
newH.reset();
|
|
1278
|
+
rem.reset();
|
|
1279
|
+
h.reset();
|
|
1280
|
+
g.reset();
|
|
1281
|
+
dR.reset();
|
|
1282
|
+
ppV.reset();
|
|
1283
|
+
ppU.reset();
|
|
1284
|
+
cV.reset();
|
|
1285
|
+
cU.reset();
|
|
1286
|
+
};
|
|
1287
|
+
const iU = this.iccp(u, variable, cU, ppU);
|
|
1288
|
+
const iV = this.iccp(v, variable, cV, ppV);
|
|
1289
|
+
this.gcd(cU.get(), cV.get(), dR);
|
|
1290
|
+
const dA = getGcd(iU, iV);
|
|
1291
|
+
g.set(this.one);
|
|
1292
|
+
h.set(this.one);
|
|
672
1293
|
while (true) {
|
|
673
|
-
|
|
674
|
-
|
|
675
|
-
|
|
676
|
-
|
|
1294
|
+
this.limit.checkpoint();
|
|
1295
|
+
const delta = this.degree(ppU.get(), variable) - this.degree(ppV.get(), variable);
|
|
1296
|
+
this.exactPseudoRemainder(ppU.get(), ppV.get(), variable, rem);
|
|
1297
|
+
if (this.isZero(rem.get())) {
|
|
1298
|
+
ppV.set(this.flipSignIfLmNeg(ppV.get()));
|
|
1299
|
+
r.move(this.pp(ppV.get(), variable));
|
|
1300
|
+
r.set(this.mulScaled(dA, dR.get(), r.get()));
|
|
1301
|
+
release();
|
|
1302
|
+
return;
|
|
677
1303
|
}
|
|
678
|
-
|
|
679
|
-
|
|
680
|
-
|
|
681
|
-
|
|
682
|
-
|
|
1304
|
+
if (this.isConst(rem.get())) {
|
|
1305
|
+
r.set(this.mulConst(dA, dR.get()));
|
|
1306
|
+
release();
|
|
1307
|
+
return;
|
|
1308
|
+
}
|
|
1309
|
+
ppU.copy(ppV);
|
|
1310
|
+
ppV.set(this.exactDiv(rem.get(), g.get()));
|
|
1311
|
+
for (let index = 0; index < delta; index++) ppV.set(this.exactDiv(ppV.get(), h.get()));
|
|
1312
|
+
g.set(this.lc(ppU.get(), variable));
|
|
1313
|
+
newH.set(this.one);
|
|
1314
|
+
for (let index = 0; index < delta; index++) newH.set(this.mul(newH.get(), g.get()));
|
|
1315
|
+
if (delta > 1)
|
|
1316
|
+
for (let index = 0; index < delta - 1; index++)
|
|
1317
|
+
newH.set(this.exactDiv(newH.get(), h.get()));
|
|
1318
|
+
h.copy(newH);
|
|
683
1319
|
}
|
|
684
1320
|
}
|
|
685
1321
|
|
|
686
|
-
|
|
687
|
-
|
|
688
|
-
|
|
689
|
-
variable
|
|
690
|
-
|
|
691
|
-
|
|
692
|
-
|
|
1322
|
+
private gcdContent(u: Polynomial, variable: number, v: Polynomial, r: PolynomialRef) {
|
|
1323
|
+
const cU = new PolynomialRef(this);
|
|
1324
|
+
const ppU = new PolynomialRef(this);
|
|
1325
|
+
const iU = this.iccp(u, variable, cU, ppU);
|
|
1326
|
+
cU.set(this.mulConst(iU, cU.get()));
|
|
1327
|
+
this.gcd(cU.get(), v, r);
|
|
1328
|
+
ppU.reset();
|
|
1329
|
+
cU.reset();
|
|
693
1330
|
}
|
|
694
1331
|
|
|
695
|
-
|
|
696
|
-
|
|
1332
|
+
private euclidGcd(u: Polynomial, v: Polynomial, r: PolynomialRef) {
|
|
1333
|
+
if (this.isZero(u)) {
|
|
1334
|
+
r.set(v);
|
|
1335
|
+
r.set(this.flipSignIfLmNeg(r.get()));
|
|
1336
|
+
return;
|
|
1337
|
+
}
|
|
1338
|
+
if (this.isZero(v)) {
|
|
1339
|
+
r.set(u);
|
|
1340
|
+
r.set(this.flipSignIfLmNeg(r.get()));
|
|
1341
|
+
return;
|
|
1342
|
+
}
|
|
1343
|
+
if (u === v) {
|
|
1344
|
+
r.set(u);
|
|
1345
|
+
r.set(this.flipSignIfLmNeg(r.get()));
|
|
1346
|
+
return;
|
|
1347
|
+
}
|
|
1348
|
+
if (this.isConst(u) || this.isConst(v)) {
|
|
1349
|
+
const iV = this.getIc(v);
|
|
1350
|
+
const iU = this.getIc(u);
|
|
1351
|
+
r.set(this.mkConst(getGcd(iV, iU)));
|
|
1352
|
+
return;
|
|
1353
|
+
}
|
|
1354
|
+
this.gcdPrs(u, v, this.maxVar(u), r);
|
|
697
1355
|
}
|
|
698
1356
|
|
|
699
|
-
private
|
|
700
|
-
|
|
701
|
-
|
|
702
|
-
|
|
703
|
-
|
|
704
|
-
|
|
1357
|
+
private craCombineImages(
|
|
1358
|
+
c1: Polynomial,
|
|
1359
|
+
b1: bigint,
|
|
1360
|
+
c2: Polynomial,
|
|
1361
|
+
b2: bigint,
|
|
1362
|
+
r: PolynomialRef,
|
|
705
1363
|
) {
|
|
706
|
-
|
|
707
|
-
|
|
708
|
-
|
|
709
|
-
|
|
710
|
-
|
|
711
|
-
|
|
712
|
-
|
|
713
|
-
|
|
714
|
-
|
|
715
|
-
|
|
716
|
-
|
|
717
|
-
|
|
718
|
-
|
|
719
|
-
|
|
720
|
-
let
|
|
721
|
-
let
|
|
722
|
-
let steps = 0;
|
|
1364
|
+
c1.lexSort();
|
|
1365
|
+
c2.lexSort();
|
|
1366
|
+
const inverses = getExtendedGcd(b1, b2);
|
|
1367
|
+
const inv1 = modMpz(inverses.x, b2);
|
|
1368
|
+
const inv2 = modMpz(inverses.y, b1);
|
|
1369
|
+
const a1 = this.mulNumeral(b2, inv2);
|
|
1370
|
+
const a2 = this.mulNumeral(b1, inv1);
|
|
1371
|
+
const newBound = this.mulNumeral(b1, b2);
|
|
1372
|
+
const upper = divMpz(newBound, 2n);
|
|
1373
|
+
const add = (first: bigint, second: bigint, monomial: Monomial) => {
|
|
1374
|
+
const tmp3 = this.normalizeNumeral(this.mulNumeral(first, a1) + this.mulNumeral(second, a2));
|
|
1375
|
+
const value = modMpz(tmp3, newBound);
|
|
1376
|
+
this.cheap.add(value > upper ? this.subNumeral(value, newBound) : value, monomial);
|
|
1377
|
+
};
|
|
1378
|
+
let i1 = 0;
|
|
1379
|
+
let i2 = 0;
|
|
723
1380
|
while (true) {
|
|
724
|
-
|
|
725
|
-
|
|
726
|
-
|
|
727
|
-
if (isExact && steps < exactSteps) {
|
|
728
|
-
const power = this.pw(lcB, exactSteps - steps);
|
|
729
|
-
if (isQuotient) quotient = this.mul(power, quotient);
|
|
730
|
-
remainder = this.mul(power, remainder);
|
|
731
|
-
}
|
|
732
|
-
return { quotient, remainder, steps };
|
|
1381
|
+
if (i1 === c1.size) {
|
|
1382
|
+
for (; i2 < c2.size; i2++) add(0n, c2.as[i2], c2.ms[i2]);
|
|
1383
|
+
break;
|
|
733
1384
|
}
|
|
734
|
-
|
|
735
|
-
|
|
736
|
-
|
|
737
|
-
const monomial = remainder.ms[index];
|
|
738
|
-
const coeff = remainder.as[index];
|
|
739
|
-
if (monomial.degreeOf(variable) === degR) {
|
|
740
|
-
const shifted = this.divXk(monomial, variable, degB);
|
|
741
|
-
if (isQuotient) this.som2.addTerm(coeff, shifted);
|
|
742
|
-
this.som.addmul(-coeff, shifted, reductB);
|
|
743
|
-
} else this.som.addmul(coeff, monomial, lcB);
|
|
1385
|
+
if (i2 === c2.size) {
|
|
1386
|
+
for (; i1 < c1.size; i1++) add(c1.as[i1], 0n, c1.ms[i1]);
|
|
1387
|
+
break;
|
|
744
1388
|
}
|
|
745
|
-
|
|
746
|
-
|
|
747
|
-
|
|
748
|
-
|
|
749
|
-
|
|
1389
|
+
const m1 = c1.ms[i1];
|
|
1390
|
+
const m2 = c2.ms[i2];
|
|
1391
|
+
const s = lexCompare(m1, m2);
|
|
1392
|
+
if (s === 0) {
|
|
1393
|
+
add(c1.as[i1], c2.as[i2], m1);
|
|
1394
|
+
i1++;
|
|
1395
|
+
i2++;
|
|
1396
|
+
} else if (s > 0) {
|
|
1397
|
+
add(c1.as[i1], 0n, m1);
|
|
1398
|
+
i1++;
|
|
1399
|
+
} else {
|
|
1400
|
+
add(0n, c2.as[i2], m2);
|
|
1401
|
+
i2++;
|
|
750
1402
|
}
|
|
751
|
-
steps++;
|
|
752
1403
|
}
|
|
1404
|
+
r.set(this.cheap.mk());
|
|
1405
|
+
return newBound;
|
|
1406
|
+
}
|
|
1407
|
+
|
|
1408
|
+
private uniModGcd(u: Polynomial, v: Polynomial, r: PolynomialRef) {
|
|
1409
|
+
const x = this.maxVar(u);
|
|
1410
|
+
const ppU = new PolynomialRef(this);
|
|
1411
|
+
const ppV = new PolynomialRef(this);
|
|
1412
|
+
const cU = this.icWithContent(u, ppU);
|
|
1413
|
+
const cV = this.icWithContent(v, ppV);
|
|
1414
|
+
const dA = getGcd(cU, cV);
|
|
1415
|
+
const dU = this.degree(ppU.get(), x);
|
|
1416
|
+
const dV = this.degree(ppV.get(), x);
|
|
1417
|
+
const lcU = this.getUnivCoeff(ppU.get(), dU);
|
|
1418
|
+
const lcV = this.getUnivCoeff(ppV.get(), dV);
|
|
1419
|
+
const lcG = getGcd(lcU, lcV);
|
|
1420
|
+
const uZp = new PolynomialRef(this);
|
|
1421
|
+
const vZp = new PolynomialRef(this);
|
|
1422
|
+
const cStar = new PolynomialRef(this);
|
|
1423
|
+
let bound = 0n;
|
|
1424
|
+
const q = new PolynomialRef(this);
|
|
1425
|
+
const candidate = new PolynomialRef(this);
|
|
1426
|
+
const release = () => {
|
|
1427
|
+
candidate.reset();
|
|
1428
|
+
q.reset();
|
|
1429
|
+
cStar.reset();
|
|
1430
|
+
vZp.reset();
|
|
1431
|
+
uZp.reset();
|
|
1432
|
+
ppV.reset();
|
|
1433
|
+
ppU.reset();
|
|
1434
|
+
};
|
|
1435
|
+
for (const prime of BIG_PRIMES) {
|
|
1436
|
+
const savedModulus = this.modulus;
|
|
1437
|
+
this.setZp(prime);
|
|
1438
|
+
uZp.set(this.normalize(ppU.get()));
|
|
1439
|
+
vZp.set(this.normalize(ppV.get()));
|
|
1440
|
+
const isBadPrime = this.degree(uZp.get(), x) < dU || this.degree(vZp.get(), x) < dV;
|
|
1441
|
+
if (!isBadPrime) {
|
|
1442
|
+
this.euclidGcd(uZp.get(), vZp.get(), q);
|
|
1443
|
+
q.set(this.mkGlexMonic(q.get()));
|
|
1444
|
+
q.set(this.mulConst(this.normalizeNumeral(lcG), q.get()));
|
|
1445
|
+
}
|
|
1446
|
+
this.modulus = savedModulus;
|
|
1447
|
+
if (isBadPrime) continue;
|
|
1448
|
+
if (this.isConst(q.get())) {
|
|
1449
|
+
// Deviation from Z3: when d_a is 1, uni_mod_gcd returns a constant q other than 1, so gcd(2x - 3, 2x - 1) is 2 there.
|
|
1450
|
+
r.set(dA === 1n && q.get().as[0] === 1n ? q.get() : this.mkConst(dA));
|
|
1451
|
+
release();
|
|
1452
|
+
return;
|
|
1453
|
+
}
|
|
1454
|
+
if (cStar.getOrNull() === null) {
|
|
1455
|
+
cStar.copy(q);
|
|
1456
|
+
bound = prime;
|
|
1457
|
+
} else if (this.degree(q.get(), x) < this.degree(cStar.get(), x)) {
|
|
1458
|
+
cStar.copy(q);
|
|
1459
|
+
bound = prime;
|
|
1460
|
+
} else bound = this.craCombineImages(q.get(), prime, cStar.get(), bound, cStar);
|
|
1461
|
+
candidate.move(this.pp(cStar.get(), x));
|
|
1462
|
+
const lcCandidate = this.getUnivCoeff(candidate.get(), this.degree(candidate.get(), x));
|
|
1463
|
+
if (
|
|
1464
|
+
this.dividesNumeral(lcCandidate, lcG) &&
|
|
1465
|
+
this.divides(candidate.get(), ppU.get()) &&
|
|
1466
|
+
this.divides(candidate.get(), ppV.get())
|
|
1467
|
+
) {
|
|
1468
|
+
r.set(this.mulConst(dA, candidate.get()));
|
|
1469
|
+
r.set(this.flipSignIfLmNeg(r.get()));
|
|
1470
|
+
release();
|
|
1471
|
+
return;
|
|
1472
|
+
}
|
|
1473
|
+
}
|
|
1474
|
+
this.gcdPrs(u, v, x, r);
|
|
1475
|
+
release();
|
|
753
1476
|
}
|
|
754
1477
|
|
|
755
|
-
|
|
756
|
-
|
|
1478
|
+
private iccpZpX(polynomial: Polynomial, x: number, c: PolynomialRef, pp: PolynomialRef): bigint {
|
|
1479
|
+
if (polynomial.size === 0) {
|
|
1480
|
+
c.set(this.one);
|
|
1481
|
+
pp.set(polynomial);
|
|
1482
|
+
return 0n;
|
|
1483
|
+
}
|
|
1484
|
+
if (this.isConst(polynomial)) {
|
|
1485
|
+
c.set(this.one);
|
|
1486
|
+
pp.set(this.one);
|
|
1487
|
+
return polynomial.as[0];
|
|
1488
|
+
}
|
|
1489
|
+
const degree = this.degree(polynomial, x);
|
|
1490
|
+
if (degree === 0) {
|
|
1491
|
+
const ci = this.icWithContent(polynomial, pp);
|
|
1492
|
+
c.set(this.one);
|
|
1493
|
+
return ci;
|
|
1494
|
+
}
|
|
1495
|
+
const marks = new Map<number, number>();
|
|
1496
|
+
const noXMonomials: Monomial[] = [];
|
|
1497
|
+
let minDegree = Infinity;
|
|
1498
|
+
for (const monomial of polynomial.ms) {
|
|
1499
|
+
const k = monomial.degreeOf(x);
|
|
1500
|
+
if (k === 0 && !marks.has(monomial.id)) {
|
|
1501
|
+
noXMonomials.push(monomial);
|
|
1502
|
+
marks.set(monomial.id, 1);
|
|
1503
|
+
}
|
|
1504
|
+
if (k < minDegree) minDegree = k;
|
|
1505
|
+
}
|
|
1506
|
+
if (minDegree > 0) {
|
|
1507
|
+
const xmin = new PolynomialRef(this);
|
|
1508
|
+
const newP = new PolynomialRef(this);
|
|
1509
|
+
xmin.set(this.mkVar(x, minDegree));
|
|
1510
|
+
newP.set(this.exactDiv(polynomial, xmin.get()));
|
|
1511
|
+
const ci = this.iccpZpX(newP.get(), x, c, pp);
|
|
1512
|
+
c.set(this.mul(xmin.get(), c.get()));
|
|
1513
|
+
newP.reset();
|
|
1514
|
+
xmin.reset();
|
|
1515
|
+
return ci;
|
|
1516
|
+
}
|
|
1517
|
+
const numMarked = noXMonomials.length;
|
|
1518
|
+
let numUnmarked = 0;
|
|
1519
|
+
for (const monomial of polynomial.ms) {
|
|
1520
|
+
if (monomial.degreeOf(x) === 0) continue;
|
|
1521
|
+
const reduced = this.divX(monomial, x);
|
|
1522
|
+
if (marks.get(reduced.id) === 1) {
|
|
1523
|
+
numUnmarked++;
|
|
1524
|
+
marks.delete(reduced.id);
|
|
1525
|
+
}
|
|
1526
|
+
}
|
|
1527
|
+
if (numUnmarked < numMarked) {
|
|
1528
|
+
const ci = this.icWithContent(polynomial, pp);
|
|
1529
|
+
c.set(this.one);
|
|
1530
|
+
return ci;
|
|
1531
|
+
}
|
|
1532
|
+
const ci = this.icWithContent(polynomial, pp);
|
|
1533
|
+
marks.clear();
|
|
1534
|
+
noXMonomials.length = 0;
|
|
1535
|
+
const buffers = this.iccpZpXBuffers;
|
|
1536
|
+
const ppValue = pp.get();
|
|
1537
|
+
for (let index = 0; index < polynomial.size; index++) {
|
|
1538
|
+
let monomial = ppValue.ms[index];
|
|
1539
|
+
const k = monomial.degreeOf(x);
|
|
1540
|
+
if (k !== 0) monomial = this.divX(monomial, x);
|
|
1541
|
+
let position = marks.get(monomial.id);
|
|
1542
|
+
if (position === undefined) {
|
|
1543
|
+
position = noXMonomials.length;
|
|
1544
|
+
noXMonomials.push(monomial);
|
|
1545
|
+
marks.set(monomial.id, position);
|
|
1546
|
+
}
|
|
1547
|
+
while (buffers.length <= position) buffers.push(new SomBuffer(this));
|
|
1548
|
+
buffers[position].addTerm(ppValue.as[index], this.mkPower(x, k));
|
|
1549
|
+
}
|
|
1550
|
+
const numMonomials = noXMonomials.length;
|
|
1551
|
+
const g = new PolynomialRef(this);
|
|
1552
|
+
const newG = new PolynomialRef(this);
|
|
1553
|
+
g.set(buffers[0].mk());
|
|
1554
|
+
for (let index = 1; index < numMonomials; index++) {
|
|
1555
|
+
const a = new PolynomialRef(this);
|
|
1556
|
+
a.set(buffers[index].mk());
|
|
1557
|
+
this.euclidGcd(g.get(), a.get(), newG);
|
|
1558
|
+
g.copy(newG);
|
|
1559
|
+
const isDone = this.isConst(g.get());
|
|
1560
|
+
a.reset();
|
|
1561
|
+
if (isDone) break;
|
|
1562
|
+
}
|
|
1563
|
+
if (!this.isConst(g.get())) {
|
|
1564
|
+
c.copy(g);
|
|
1565
|
+
pp.set(this.exactDiv(pp.get(), c.get()));
|
|
1566
|
+
} else c.set(this.one);
|
|
1567
|
+
for (let index = 0; index < numMonomials; index++) buffers[index].reset();
|
|
1568
|
+
newG.reset();
|
|
1569
|
+
g.reset();
|
|
1570
|
+
return ci;
|
|
757
1571
|
}
|
|
758
1572
|
|
|
759
|
-
|
|
1573
|
+
private lcGlexZpX(polynomial: Polynomial, x: number) {
|
|
1574
|
+
this.som.reset();
|
|
1575
|
+
let maxMonomial: Monomial | null = null;
|
|
1576
|
+
for (let index = 0; index < polynomial.size; index++) {
|
|
1577
|
+
let monomial = polynomial.ms[index];
|
|
1578
|
+
const k = monomial.degreeOf(x);
|
|
1579
|
+
if (k !== 0) monomial = this.divX(monomial, x);
|
|
1580
|
+
if (maxMonomial === null || gradedLexCompare(monomial, maxMonomial) > 0) {
|
|
1581
|
+
this.som.reset();
|
|
1582
|
+
maxMonomial = monomial;
|
|
1583
|
+
this.som.addTerm(polynomial.as[index], this.mkPower(x, k));
|
|
1584
|
+
} else if (maxMonomial === monomial)
|
|
1585
|
+
this.som.addTerm(polynomial.as[index], this.mkPower(x, k));
|
|
1586
|
+
}
|
|
1587
|
+
return this.som.mk();
|
|
1588
|
+
}
|
|
1589
|
+
|
|
1590
|
+
private primitiveZpX(polynomial: Polynomial, x: number, pp: PolynomialRef) {
|
|
1591
|
+
const c = new PolynomialRef(this);
|
|
1592
|
+
this.iccpZpX(polynomial, x, c, pp);
|
|
1593
|
+
c.reset();
|
|
1594
|
+
}
|
|
1595
|
+
|
|
1596
|
+
private peekFresh(values: readonly bigint[], prime: number) {
|
|
1597
|
+
while (true) {
|
|
1598
|
+
const hi = this.random.next();
|
|
1599
|
+
const lo = this.random.next();
|
|
1600
|
+
const value = this.normalizeNumeral(BigInt(((hi << 15) | lo) % prime));
|
|
1601
|
+
if (!values.includes(value)) return value;
|
|
1602
|
+
}
|
|
1603
|
+
}
|
|
1604
|
+
|
|
1605
|
+
private univEval(polynomial: Polynomial, value: bigint) {
|
|
1606
|
+
if (polynomial.size === 0) return 0n;
|
|
1607
|
+
if (this.isConst(polynomial)) return this.normalizeNumeral(polynomial.as[0]);
|
|
1608
|
+
polynomial.lexSort();
|
|
1609
|
+
let result = 0n;
|
|
760
1610
|
for (let index = 0; index < polynomial.size; index++)
|
|
761
|
-
|
|
762
|
-
|
|
763
|
-
|
|
1611
|
+
result = this.normalizeNumeral(
|
|
1612
|
+
result +
|
|
1613
|
+
this.mulNumeral(
|
|
1614
|
+
polynomial.as[index],
|
|
1615
|
+
this.powerNumeral(value, polynomial.ms[index].totalDegree),
|
|
1616
|
+
),
|
|
1617
|
+
);
|
|
1618
|
+
return result;
|
|
764
1619
|
}
|
|
765
1620
|
|
|
766
|
-
private
|
|
767
|
-
|
|
768
|
-
|
|
769
|
-
|
|
770
|
-
|
|
771
|
-
|
|
772
|
-
|
|
1621
|
+
private modGcdRec(
|
|
1622
|
+
u: Polynomial,
|
|
1623
|
+
v: Polynomial,
|
|
1624
|
+
prime: number,
|
|
1625
|
+
idx: number,
|
|
1626
|
+
vars: readonly number[],
|
|
1627
|
+
r: PolynomialRef,
|
|
1628
|
+
): boolean {
|
|
1629
|
+
if (idx === vars.length - 1) {
|
|
1630
|
+
this.euclidGcd(u, v, r);
|
|
1631
|
+
return true;
|
|
1632
|
+
}
|
|
1633
|
+
const x = vars[idx];
|
|
1634
|
+
const cU = new PolynomialRef(this);
|
|
1635
|
+
const ppU = new PolynomialRef(this);
|
|
1636
|
+
const lcU = new PolynomialRef(this);
|
|
1637
|
+
const cV = new PolynomialRef(this);
|
|
1638
|
+
const ppV = new PolynomialRef(this);
|
|
1639
|
+
const lcV = new PolynomialRef(this);
|
|
1640
|
+
const cG = new PolynomialRef(this);
|
|
1641
|
+
const lcG = new PolynomialRef(this);
|
|
1642
|
+
const u1 = new PolynomialRef(this);
|
|
1643
|
+
const v1 = new PolynomialRef(this);
|
|
1644
|
+
const q = new PolynomialRef(this);
|
|
1645
|
+
const h = new PolynomialRef(this);
|
|
1646
|
+
const c = new PolynomialRef(this);
|
|
1647
|
+
const lcH = new PolynomialRef(this);
|
|
1648
|
+
try {
|
|
1649
|
+
const ciU = this.iccpZpX(u, x, cU, ppU);
|
|
1650
|
+
const ciV = this.iccpZpX(v, x, cV, ppV);
|
|
1651
|
+
lcU.set(this.lcGlexZpX(ppU.get(), x));
|
|
1652
|
+
lcV.set(this.lcGlexZpX(ppV.get(), x));
|
|
1653
|
+
const ciG = getGcd(ciU, ciV);
|
|
1654
|
+
this.euclidGcd(cU.get(), cV.get(), cG);
|
|
1655
|
+
this.euclidGcd(lcU.get(), lcV.get(), lcG);
|
|
1656
|
+
const skeleton = this.mgcdSkeletons[idx];
|
|
1657
|
+
while (this.mgcdInterpolators.length <= idx)
|
|
1658
|
+
this.mgcdInterpolators.push(new NewtonInterpolator(this));
|
|
1659
|
+
const interpolator = this.mgcdInterpolators[idx];
|
|
1660
|
+
const sparseInterpolator = new SparseInterpolator(this, skeleton);
|
|
1661
|
+
let minDegQ = Infinity;
|
|
1662
|
+
while (true) {
|
|
1663
|
+
let value = 0n;
|
|
1664
|
+
let lcGValue = 0n;
|
|
1665
|
+
while (true) {
|
|
1666
|
+
value = this.peekFresh(interpolator.inputs, prime);
|
|
1667
|
+
lcGValue = this.univEval(lcG.get(), value);
|
|
1668
|
+
if (lcGValue !== 0n) break;
|
|
1669
|
+
}
|
|
1670
|
+
u1.set(this.substitute(ppU.get(), [x], [value]));
|
|
1671
|
+
v1.set(this.substitute(ppV.get(), [x], [value]));
|
|
1672
|
+
if (!this.modGcdRec(u1.get(), v1.get(), prime, idx + 1, vars, q)) return false;
|
|
1673
|
+
q.set(this.mkGlexMonic(q.get()));
|
|
1674
|
+
q.set(this.mulConst(lcGValue, q.get()));
|
|
1675
|
+
const qVar = this.maxVar(q.get());
|
|
1676
|
+
const degQ = qVar === NULL_VAR ? 0 : this.degree(q.get(), qVar);
|
|
1677
|
+
if (degQ < minDegQ) {
|
|
1678
|
+
minDegQ = degQ;
|
|
1679
|
+
if (skeleton === null) {
|
|
1680
|
+
interpolator.reset();
|
|
1681
|
+
interpolator.add(value, q.get());
|
|
1682
|
+
} else {
|
|
1683
|
+
sparseInterpolator.reset();
|
|
1684
|
+
if (!sparseInterpolator.add(skeleton, value, q.get())) return false;
|
|
1685
|
+
}
|
|
1686
|
+
} else if (degQ === minDegQ) {
|
|
1687
|
+
if (skeleton === null) interpolator.add(value, q.get());
|
|
1688
|
+
else if (!sparseInterpolator.add(skeleton, value, q.get())) return false;
|
|
1689
|
+
} else continue;
|
|
1690
|
+
let isCandidate = false;
|
|
1691
|
+
if (skeleton === null) {
|
|
1692
|
+
interpolator.mk(x, h);
|
|
1693
|
+
lcH.set(this.lcGlexZpX(h.get(), x));
|
|
1694
|
+
if (this.eq(lcH.get(), lcG.get())) isCandidate = true;
|
|
1695
|
+
} else if (sparseInterpolator.isReady(skeleton)) {
|
|
1696
|
+
if (!sparseInterpolator.mk(skeleton, h)) return false;
|
|
1697
|
+
isCandidate = true;
|
|
1698
|
+
}
|
|
1699
|
+
if (!isCandidate) continue;
|
|
1700
|
+
if (this.degree(h.get(), x) > 0) this.primitiveZpX(h.get(), x, c);
|
|
1701
|
+
else c.set(this.normalize(h.get()));
|
|
1702
|
+
if (this.divides(c.get(), ppU.get()) && this.divides(c.get(), ppV.get())) {
|
|
1703
|
+
r.set(this.mul(cG.get(), c.get()));
|
|
1704
|
+
r.set(this.mulConst(ciG, r.get()));
|
|
1705
|
+
} else if (minDegQ === 0) {
|
|
1706
|
+
r.copy(cG);
|
|
1707
|
+
r.set(this.mulConst(ciG, r.get()));
|
|
1708
|
+
} else if (skeleton !== null) return false;
|
|
1709
|
+
else continue;
|
|
1710
|
+
if (skeleton === null) this.mgcdSkeletons[idx] = new Skeleton(this, h.get(), x);
|
|
1711
|
+
return true;
|
|
773
1712
|
}
|
|
774
|
-
|
|
1713
|
+
} finally {
|
|
1714
|
+
lcH.reset();
|
|
1715
|
+
c.reset();
|
|
1716
|
+
h.reset();
|
|
1717
|
+
q.reset();
|
|
1718
|
+
v1.reset();
|
|
1719
|
+
u1.reset();
|
|
1720
|
+
lcG.reset();
|
|
1721
|
+
cG.reset();
|
|
1722
|
+
lcV.reset();
|
|
1723
|
+
ppV.reset();
|
|
1724
|
+
cV.reset();
|
|
1725
|
+
lcU.reset();
|
|
1726
|
+
ppU.reset();
|
|
1727
|
+
cU.reset();
|
|
1728
|
+
}
|
|
1729
|
+
}
|
|
1730
|
+
|
|
1731
|
+
private modGcd(
|
|
1732
|
+
u: Polynomial,
|
|
1733
|
+
v: Polynomial,
|
|
1734
|
+
uDegrees: readonly [number, number][],
|
|
1735
|
+
vDegrees: readonly [number, number][],
|
|
1736
|
+
r: PolynomialRef,
|
|
1737
|
+
): boolean {
|
|
1738
|
+
const minDegrees = uDegrees.map((entry, index): [number, number] => [
|
|
1739
|
+
entry[0],
|
|
1740
|
+
Math.min(entry[1], vDegrees[index][1]),
|
|
1741
|
+
]);
|
|
1742
|
+
minDegrees.sort((first, second) => first[1] - second[1] || first[0] - second[0]);
|
|
1743
|
+
this.mgcdSkeletons = minDegrees.map(() => null);
|
|
1744
|
+
const vars = minDegrees.map((entry) => entry[0]);
|
|
1745
|
+
const ppU = new PolynomialRef(this);
|
|
1746
|
+
const ppV = new PolynomialRef(this);
|
|
1747
|
+
const uZp = new PolynomialRef(this);
|
|
1748
|
+
const vZp = new PolynomialRef(this);
|
|
1749
|
+
const cStar = new PolynomialRef(this);
|
|
1750
|
+
const q = new PolynomialRef(this);
|
|
1751
|
+
const candidate = new PolynomialRef(this);
|
|
1752
|
+
try {
|
|
1753
|
+
const cU = this.icWithContent(u, ppU);
|
|
1754
|
+
const cV = this.icWithContent(v, ppV);
|
|
1755
|
+
const dA = getGcd(cU, cV);
|
|
1756
|
+
const lcU = ppU.get().as[ppU.get().getGradedLexMaxPos()];
|
|
1757
|
+
const lcV = ppV.get().as[ppV.get().getGradedLexMaxPos()];
|
|
1758
|
+
const lcG = getGcd(lcU, lcV);
|
|
1759
|
+
let bound = 0n;
|
|
1760
|
+
for (const prime of BIG_PRIMES) {
|
|
1761
|
+
const savedModulus = this.modulus;
|
|
1762
|
+
this.setZp(prime);
|
|
1763
|
+
try {
|
|
1764
|
+
uZp.set(this.normalize(ppU.get()));
|
|
1765
|
+
if (uZp.get().size !== ppU.get().size) continue;
|
|
1766
|
+
vZp.set(this.normalize(ppV.get()));
|
|
1767
|
+
if (vZp.get().size !== ppV.get().size) continue;
|
|
1768
|
+
if (!this.modGcdRec(uZp.get(), vZp.get(), Number(prime), 0, vars, q)) return false;
|
|
1769
|
+
q.set(this.mkGlexMonic(q.get()));
|
|
1770
|
+
q.set(this.mulConst(this.normalizeNumeral(lcG), q.get()));
|
|
1771
|
+
} finally {
|
|
1772
|
+
this.modulus = savedModulus;
|
|
1773
|
+
}
|
|
1774
|
+
if (this.isConst(q.get())) {
|
|
1775
|
+
r.set(this.mkConst(dA));
|
|
1776
|
+
return true;
|
|
1777
|
+
}
|
|
1778
|
+
if (cStar.getOrNull() === null) {
|
|
1779
|
+
cStar.copy(q);
|
|
1780
|
+
bound = prime;
|
|
1781
|
+
} else {
|
|
1782
|
+
const maxCStar = cStar.get().ms[cStar.get().getGradedLexMaxPos()];
|
|
1783
|
+
const maxQ = q.get().ms[q.get().getGradedLexMaxPos()];
|
|
1784
|
+
if (gradedLexCompare(maxQ, maxCStar) < 0) {
|
|
1785
|
+
cStar.copy(q);
|
|
1786
|
+
bound = prime;
|
|
1787
|
+
} else bound = this.craCombineImages(q.get(), prime, cStar.get(), bound, cStar);
|
|
1788
|
+
}
|
|
1789
|
+
candidate.set(this.normalize(cStar.get()));
|
|
1790
|
+
const lcCandidate = candidate.get().as[candidate.get().getGradedLexMaxPos()];
|
|
1791
|
+
if (
|
|
1792
|
+
this.dividesNumeral(lcCandidate, lcG) &&
|
|
1793
|
+
this.divides(candidate.get(), ppU.get()) &&
|
|
1794
|
+
this.divides(candidate.get(), ppV.get())
|
|
1795
|
+
) {
|
|
1796
|
+
r.set(this.mulConst(dA, candidate.get()));
|
|
1797
|
+
r.set(this.flipSignIfLmNeg(r.get()));
|
|
1798
|
+
return true;
|
|
1799
|
+
}
|
|
1800
|
+
}
|
|
1801
|
+
this.gcdPrs(u, v, this.maxVar(u), r);
|
|
1802
|
+
return true;
|
|
1803
|
+
} finally {
|
|
1804
|
+
candidate.reset();
|
|
1805
|
+
q.reset();
|
|
1806
|
+
cStar.reset();
|
|
1807
|
+
vZp.reset();
|
|
1808
|
+
uZp.reset();
|
|
1809
|
+
ppV.reset();
|
|
1810
|
+
ppU.reset();
|
|
1811
|
+
}
|
|
775
1812
|
}
|
|
776
1813
|
|
|
777
1814
|
private getVarMaxDegrees(polynomial: Polynomial) {
|
|
@@ -780,207 +1817,666 @@ export class PolynomialManager {
|
|
|
780
1817
|
);
|
|
781
1818
|
}
|
|
782
1819
|
|
|
783
|
-
|
|
784
|
-
|
|
785
|
-
|
|
786
|
-
|
|
787
|
-
|
|
788
|
-
|
|
789
|
-
|
|
790
|
-
|
|
791
|
-
|
|
792
|
-
|
|
1820
|
+
gcd(u: Polynomial, v: Polynomial, r: PolynomialRef) {
|
|
1821
|
+
if (this.isZero(u)) {
|
|
1822
|
+
r.set(v);
|
|
1823
|
+
r.set(this.flipSignIfLmNeg(r.get()));
|
|
1824
|
+
return;
|
|
1825
|
+
}
|
|
1826
|
+
if (this.isZero(v)) {
|
|
1827
|
+
r.set(u);
|
|
1828
|
+
r.set(this.flipSignIfLmNeg(r.get()));
|
|
1829
|
+
return;
|
|
1830
|
+
}
|
|
1831
|
+
if (u === v) {
|
|
1832
|
+
r.set(u);
|
|
1833
|
+
r.set(this.flipSignIfLmNeg(r.get()));
|
|
1834
|
+
return;
|
|
1835
|
+
}
|
|
1836
|
+
if (this.isConst(u) || this.isConst(v)) {
|
|
1837
|
+
const iV = this.getIc(v);
|
|
1838
|
+
const iU = this.getIc(u);
|
|
1839
|
+
r.set(this.mkConst(getGcd(iV, iU)));
|
|
1840
|
+
return;
|
|
1841
|
+
}
|
|
1842
|
+
const uDegrees = this.getVarMaxDegrees(u);
|
|
1843
|
+
const vDegrees = this.getVarMaxDegrees(v);
|
|
1844
|
+
const size = Math.min(uDegrees.length, vDegrees.length);
|
|
793
1845
|
for (let index = 0; index < size; index++) {
|
|
794
|
-
const
|
|
795
|
-
const
|
|
796
|
-
if (
|
|
797
|
-
|
|
798
|
-
|
|
799
|
-
if (size < firstDegrees.length) return this.gcdContent(first, firstDegrees[size][0], second);
|
|
800
|
-
if (size < secondDegrees.length) return this.gcdContent(second, secondDegrees[size][0], first);
|
|
801
|
-
return this.gcdPrs(first, second, firstDegrees[size - 1][0]);
|
|
802
|
-
}
|
|
803
|
-
|
|
804
|
-
private gcdContent(polynomial: Polynomial, variable: number, other: Polynomial) {
|
|
805
|
-
const [integer, content] = this.iccp(polynomial, variable);
|
|
806
|
-
return this.gcd(this.mulConst(integer, content), other);
|
|
807
|
-
}
|
|
808
|
-
|
|
809
|
-
private gcdPrs(first: Polynomial, second: Polynomial, variable: number) {
|
|
810
|
-
const [u, v] =
|
|
811
|
-
this.degree(first, variable) < this.degree(second, variable)
|
|
812
|
-
? [second, first]
|
|
813
|
-
: [first, second];
|
|
814
|
-
const [integerU, contentU, primitiveU] = this.iccp(u, variable);
|
|
815
|
-
const [integerV, contentV, primitiveV] = this.iccp(v, variable);
|
|
816
|
-
const contentGcd = this.gcd(contentU, contentV);
|
|
817
|
-
const integerGcd = getGcd(integerU, integerV);
|
|
818
|
-
let ppU = primitiveU;
|
|
819
|
-
let ppV = primitiveV;
|
|
820
|
-
let g = this.one;
|
|
821
|
-
let h = this.one;
|
|
822
|
-
while (true) {
|
|
823
|
-
const delta = this.degree(ppU, variable) - this.degree(ppV, variable);
|
|
824
|
-
const remainder = this.exactPseudoRemainder(ppU, ppV, variable);
|
|
825
|
-
if (remainder.size === 0) {
|
|
826
|
-
const result = this.pp(this.flipSignIfLmNeg(ppV), variable);
|
|
827
|
-
return this.mulConst(integerGcd, this.mul(contentGcd, result));
|
|
1846
|
+
const xu = uDegrees[index][0];
|
|
1847
|
+
const xv = vDegrees[index][0];
|
|
1848
|
+
if (xu < xv) {
|
|
1849
|
+
this.gcdContent(u, xu, v, r);
|
|
1850
|
+
return;
|
|
828
1851
|
}
|
|
829
|
-
if (
|
|
830
|
-
|
|
831
|
-
|
|
832
|
-
|
|
833
|
-
|
|
834
|
-
|
|
835
|
-
|
|
836
|
-
|
|
837
|
-
|
|
1852
|
+
if (xu > xv) {
|
|
1853
|
+
this.gcdContent(v, xv, u, r);
|
|
1854
|
+
return;
|
|
1855
|
+
}
|
|
1856
|
+
}
|
|
1857
|
+
if (size < uDegrees.length) {
|
|
1858
|
+
this.gcdContent(u, uDegrees[size][0], v, r);
|
|
1859
|
+
return;
|
|
1860
|
+
}
|
|
1861
|
+
if (size < vDegrees.length) {
|
|
1862
|
+
this.gcdContent(v, vDegrees[size][0], u, r);
|
|
1863
|
+
return;
|
|
1864
|
+
}
|
|
1865
|
+
const x = uDegrees[size - 1][0];
|
|
1866
|
+
if (this.modulus !== null) {
|
|
1867
|
+
this.gcdPrs(u, v, x, r);
|
|
1868
|
+
return;
|
|
838
1869
|
}
|
|
1870
|
+
if (this.isUnivariate(u)) {
|
|
1871
|
+
this.uniModGcd(u, v, r);
|
|
1872
|
+
return;
|
|
1873
|
+
}
|
|
1874
|
+
if (!this.modGcd(u, v, uDegrees, vDegrees, r)) this.gcdPrs(u, v, x, r);
|
|
839
1875
|
}
|
|
840
1876
|
|
|
841
|
-
|
|
842
|
-
|
|
843
|
-
|
|
844
|
-
|
|
845
|
-
|
|
846
|
-
|
|
847
|
-
|
|
1877
|
+
squareFree(polynomial: Polynomial, r: PolynomialRef) {
|
|
1878
|
+
if (this.isZero(polynomial)) {
|
|
1879
|
+
r.set(this.zero);
|
|
1880
|
+
return;
|
|
1881
|
+
}
|
|
1882
|
+
if (this.isConst(polynomial)) {
|
|
1883
|
+
r.set(polynomial);
|
|
1884
|
+
return;
|
|
1885
|
+
}
|
|
1886
|
+
const x = this.maxVar(polynomial);
|
|
1887
|
+
const c = new PolynomialRef(this);
|
|
1888
|
+
const pp = new PolynomialRef(this);
|
|
1889
|
+
const integer = this.iccp(polynomial, x, c, pp);
|
|
1890
|
+
const sqfC = new PolynomialRef(this);
|
|
1891
|
+
this.squareFree(c.get(), sqfC);
|
|
1892
|
+
const ppPrime = new PolynomialRef(this);
|
|
1893
|
+
ppPrime.set(this.derivative(pp.get(), x));
|
|
1894
|
+
const g = new PolynomialRef(this);
|
|
1895
|
+
this.gcd(pp.get(), ppPrime.get(), g);
|
|
1896
|
+
const release = () => {
|
|
1897
|
+
g.reset();
|
|
1898
|
+
ppPrime.reset();
|
|
1899
|
+
sqfC.reset();
|
|
1900
|
+
pp.reset();
|
|
1901
|
+
c.reset();
|
|
1902
|
+
};
|
|
1903
|
+
if (this.isConst(g.get())) {
|
|
1904
|
+
if (this.eq(sqfC.get(), c.get())) {
|
|
1905
|
+
r.set(polynomial);
|
|
1906
|
+
release();
|
|
1907
|
+
return;
|
|
848
1908
|
}
|
|
849
|
-
|
|
1909
|
+
} else pp.set(this.exactDiv(pp.get(), g.get()));
|
|
1910
|
+
r.set(this.mulConst(integer, sqfC.get()));
|
|
1911
|
+
r.set(this.mul(r.get(), pp.get()));
|
|
1912
|
+
release();
|
|
850
1913
|
}
|
|
851
1914
|
|
|
852
|
-
|
|
853
|
-
|
|
854
|
-
|
|
855
|
-
|
|
1915
|
+
private squareFreeIn(polynomial: Polynomial, x: number, r: PolynomialRef) {
|
|
1916
|
+
if (this.isZero(polynomial)) {
|
|
1917
|
+
r.set(this.zero);
|
|
1918
|
+
return;
|
|
1919
|
+
}
|
|
1920
|
+
if (this.isConst(polynomial)) {
|
|
1921
|
+
r.set(polynomial);
|
|
1922
|
+
return;
|
|
1923
|
+
}
|
|
1924
|
+
const pPrime = new PolynomialRef(this);
|
|
1925
|
+
pPrime.set(this.derivative(polynomial, x));
|
|
1926
|
+
const g = new PolynomialRef(this);
|
|
1927
|
+
this.gcd(polynomial, pPrime.get(), g);
|
|
1928
|
+
if (this.isConst(g.get())) r.set(polynomial);
|
|
1929
|
+
else r.set(this.exactDiv(polynomial, g.get()));
|
|
1930
|
+
g.reset();
|
|
1931
|
+
pPrime.reset();
|
|
1932
|
+
}
|
|
1933
|
+
|
|
1934
|
+
private isSquareFreeIn(polynomial: Polynomial, x: number) {
|
|
1935
|
+
const r = new PolynomialRef(this);
|
|
1936
|
+
this.squareFreeIn(polynomial, x, r);
|
|
1937
|
+
const result = polynomial === r.get();
|
|
1938
|
+
r.reset();
|
|
856
1939
|
return result;
|
|
857
1940
|
}
|
|
858
1941
|
|
|
859
|
-
|
|
1942
|
+
pw(polynomial: Polynomial, k: number, r: PolynomialRef) {
|
|
1943
|
+
if (k === 0) {
|
|
1944
|
+
r.set(this.one);
|
|
1945
|
+
return;
|
|
1946
|
+
}
|
|
1947
|
+
if (k === 1) {
|
|
1948
|
+
r.set(polynomial);
|
|
1949
|
+
return;
|
|
1950
|
+
}
|
|
1951
|
+
const result = new PolynomialRef(this);
|
|
1952
|
+
result.set(polynomial);
|
|
1953
|
+
for (let index = 1; index < k; index++) result.set(this.mul(result.get(), polynomial));
|
|
1954
|
+
r.copy(result);
|
|
1955
|
+
result.reset();
|
|
1956
|
+
}
|
|
1957
|
+
|
|
1958
|
+
composeXDivY(polynomial: Polynomial, y: number) {
|
|
1959
|
+
if (this.isConst(polynomial)) return polynomial;
|
|
1960
|
+
const x = this.maxVar(polynomial);
|
|
1961
|
+
const n = this.degree(polynomial, x);
|
|
1962
|
+
for (let index = 0; index < polynomial.size; index++) {
|
|
1963
|
+
const k = polynomial.ms[index].degreeOf(x);
|
|
1964
|
+
const vars: number[] = [];
|
|
1965
|
+
const degrees: number[] = [];
|
|
1966
|
+
const push = (variable: number, degree: number) => {
|
|
1967
|
+
if (degree === 0) return;
|
|
1968
|
+
vars.push(variable);
|
|
1969
|
+
degrees.push(degree);
|
|
1970
|
+
};
|
|
1971
|
+
if (x < y) {
|
|
1972
|
+
push(x, k);
|
|
1973
|
+
push(y, n - k);
|
|
1974
|
+
} else {
|
|
1975
|
+
push(y, n - k);
|
|
1976
|
+
push(x, k);
|
|
1977
|
+
}
|
|
1978
|
+
this.cheap.add(polynomial.as[index], this.mkMonomial(vars, degrees));
|
|
1979
|
+
}
|
|
1980
|
+
return this.cheap.mk();
|
|
1981
|
+
}
|
|
1982
|
+
|
|
1983
|
+
private compose(polynomial: Polynomial, q: Polynomial, r: PolynomialRef) {
|
|
860
1984
|
if (this.isConst(polynomial)) {
|
|
861
|
-
|
|
1985
|
+
r.set(polynomial);
|
|
862
1986
|
return;
|
|
863
1987
|
}
|
|
864
|
-
const
|
|
865
|
-
const
|
|
866
|
-
|
|
867
|
-
|
|
868
|
-
|
|
869
|
-
|
|
870
|
-
|
|
1988
|
+
const x = this.maxVar(polynomial);
|
|
1989
|
+
const d = this.degree(polynomial, x);
|
|
1990
|
+
const degree2pos = Array.from({ length: d + 1 }, () => -1);
|
|
1991
|
+
for (let index = 0; index < polynomial.size; index++)
|
|
1992
|
+
degree2pos[polynomial.ms[index].totalDegree] = index;
|
|
1993
|
+
r.set(this.mkConst(polynomial.as[degree2pos[d]]));
|
|
1994
|
+
for (let index = 1; index <= d; index++) {
|
|
1995
|
+
const position = degree2pos[d - index];
|
|
1996
|
+
r.set(this.muladd(q, r.get(), position === -1 ? 0n : polynomial.as[position]));
|
|
1997
|
+
}
|
|
1998
|
+
}
|
|
1999
|
+
|
|
2000
|
+
private mkXMinusY(x: number, y: number) {
|
|
2001
|
+
return this.mkLinear([1n, this.normalizeNumeral(-1n)], [x, y], 0n);
|
|
2002
|
+
}
|
|
2003
|
+
|
|
2004
|
+
composeXMinusY(polynomial: Polynomial, y: number, r: PolynomialRef) {
|
|
2005
|
+
const x = this.maxVar(polynomial);
|
|
2006
|
+
if (y === x) {
|
|
2007
|
+
r.set(this.coeff(polynomial, x, 0));
|
|
871
2008
|
return;
|
|
872
2009
|
}
|
|
873
|
-
|
|
874
|
-
|
|
875
|
-
|
|
876
|
-
|
|
877
|
-
|
|
878
|
-
|
|
879
|
-
|
|
880
|
-
|
|
2010
|
+
const xMinusY = new PolynomialRef(this);
|
|
2011
|
+
xMinusY.set(this.mkXMinusY(x, y));
|
|
2012
|
+
this.compose(polynomial, xMinusY.get(), r);
|
|
2013
|
+
xMinusY.reset();
|
|
2014
|
+
}
|
|
2015
|
+
|
|
2016
|
+
private pseudoDivisionCore(
|
|
2017
|
+
p: Polynomial,
|
|
2018
|
+
q: Polynomial,
|
|
2019
|
+
x: number,
|
|
2020
|
+
isExact: boolean,
|
|
2021
|
+
isQuotient: boolean,
|
|
2022
|
+
quotient: PolynomialRef,
|
|
2023
|
+
remainder: PolynomialRef,
|
|
2024
|
+
) {
|
|
2025
|
+
const a = p;
|
|
2026
|
+
const b = q;
|
|
2027
|
+
const degA = this.degree(a, x);
|
|
2028
|
+
const degB = this.degree(b, x);
|
|
2029
|
+
if (degB === 0) {
|
|
2030
|
+
remainder.set(this.zero);
|
|
2031
|
+
if (!isQuotient) return 0;
|
|
2032
|
+
if (!isExact) {
|
|
2033
|
+
quotient.set(a);
|
|
2034
|
+
return 1;
|
|
2035
|
+
}
|
|
2036
|
+
const d = degA + 1;
|
|
2037
|
+
if (d === 1) {
|
|
2038
|
+
quotient.set(a);
|
|
2039
|
+
return d;
|
|
2040
|
+
}
|
|
2041
|
+
const bdm1 = new PolynomialRef(this);
|
|
2042
|
+
this.pw(b, d - 1, bdm1);
|
|
2043
|
+
quotient.set(this.mul(a, bdm1.get()));
|
|
2044
|
+
bdm1.reset();
|
|
2045
|
+
return d;
|
|
2046
|
+
}
|
|
2047
|
+
if (degB > degA) {
|
|
2048
|
+
quotient.set(this.zero);
|
|
2049
|
+
remainder.set(a);
|
|
2050
|
+
}
|
|
2051
|
+
const lB = new PolynomialRef(this);
|
|
2052
|
+
const rB = new PolynomialRef(this);
|
|
2053
|
+
lB.set(this.coeffWithReduct(b, x, degB, rB));
|
|
2054
|
+
let d = 0;
|
|
2055
|
+
remainder.set(a);
|
|
2056
|
+
quotient.set(this.zero);
|
|
2057
|
+
while (true) {
|
|
2058
|
+
this.limit.checkpoint();
|
|
2059
|
+
const r = remainder.get();
|
|
2060
|
+
const degR = this.degree(r, x);
|
|
2061
|
+
if (degB > degR) {
|
|
2062
|
+
if (isExact) {
|
|
2063
|
+
const exactD = degA - degB + 1;
|
|
2064
|
+
if (d < exactD) {
|
|
2065
|
+
const lBE = new PolynomialRef(this);
|
|
2066
|
+
this.pw(lB.get(), exactD - d, lBE);
|
|
2067
|
+
if (isQuotient) quotient.set(this.mul(lBE.get(), quotient.get()));
|
|
2068
|
+
remainder.set(this.mul(lBE.get(), remainder.get()));
|
|
2069
|
+
lBE.reset();
|
|
2070
|
+
}
|
|
2071
|
+
}
|
|
2072
|
+
rB.reset();
|
|
2073
|
+
lB.reset();
|
|
2074
|
+
return d;
|
|
2075
|
+
}
|
|
2076
|
+
this.som.reset();
|
|
2077
|
+
this.som2.reset();
|
|
2078
|
+
for (let index = 0; index < r.size; index++) {
|
|
2079
|
+
if (r.size > 100 && index % 100 === 0) this.limit.checkpoint();
|
|
2080
|
+
const monomial = r.ms[index];
|
|
2081
|
+
const coeff = r.as[index];
|
|
2082
|
+
if (monomial.degreeOf(x) === degR) {
|
|
2083
|
+
const shifted = this.divXk(monomial, x, degB);
|
|
2084
|
+
if (isQuotient) this.som2.addTerm(coeff, shifted);
|
|
2085
|
+
this.som.addmul(this.negNumeral(coeff), shifted, rB.get());
|
|
2086
|
+
} else this.som.addmul(coeff, monomial, lB.get());
|
|
2087
|
+
}
|
|
2088
|
+
remainder.set(this.som.mk());
|
|
2089
|
+
if (isQuotient) {
|
|
2090
|
+
const current = quotient.get();
|
|
2091
|
+
for (let index = 0; index < current.size; index++)
|
|
2092
|
+
this.som2.addmul(current.as[index], current.ms[index], lB.get());
|
|
2093
|
+
quotient.set(this.som2.mk());
|
|
2094
|
+
}
|
|
2095
|
+
d++;
|
|
881
2096
|
}
|
|
882
2097
|
}
|
|
883
2098
|
|
|
884
|
-
|
|
885
|
-
const
|
|
886
|
-
|
|
887
|
-
|
|
888
|
-
else if (degree === 2) this.factorQuadratic(polynomial, variable, k, result);
|
|
889
|
-
else if (!this.factorMultivariate(polynomial, variable, k, result))
|
|
890
|
-
this.pushFactor(result, polynomial, k);
|
|
2099
|
+
exactPseudoRemainder(p: Polynomial, q: Polynomial, x: number, remainder: PolynomialRef) {
|
|
2100
|
+
const quotient = new PolynomialRef(this);
|
|
2101
|
+
this.pseudoDivisionCore(p, q, x, true, false, quotient, remainder);
|
|
2102
|
+
quotient.reset();
|
|
891
2103
|
}
|
|
892
2104
|
|
|
893
|
-
|
|
894
|
-
|
|
895
|
-
|
|
2105
|
+
pseudoRemainder(p: Polynomial, q: Polynomial, x: number, remainder: PolynomialRef) {
|
|
2106
|
+
const quotient = new PolynomialRef(this);
|
|
2107
|
+
const d = this.pseudoDivisionCore(p, q, x, false, false, quotient, remainder);
|
|
2108
|
+
quotient.reset();
|
|
2109
|
+
return d;
|
|
896
2110
|
}
|
|
897
2111
|
|
|
898
|
-
|
|
899
|
-
|
|
900
|
-
|
|
901
|
-
|
|
902
|
-
|
|
2112
|
+
exactPseudoDivision(
|
|
2113
|
+
p: Polynomial,
|
|
2114
|
+
q: Polynomial,
|
|
2115
|
+
x: number,
|
|
2116
|
+
quotient: PolynomialRef,
|
|
2117
|
+
remainder: PolynomialRef,
|
|
2118
|
+
) {
|
|
2119
|
+
this.pseudoDivisionCore(p, q, x, true, true, quotient, remainder);
|
|
903
2120
|
}
|
|
904
2121
|
|
|
905
|
-
|
|
906
|
-
|
|
907
|
-
|
|
908
|
-
|
|
2122
|
+
exactDiv(polynomial: Polynomial, divisor: Polynomial) {
|
|
2123
|
+
if (polynomial.size === 0) return polynomial;
|
|
2124
|
+
const remainder = this.som;
|
|
2125
|
+
const quotient = this.som2;
|
|
2126
|
+
remainder.reset();
|
|
2127
|
+
quotient.reset();
|
|
2128
|
+
remainder.add(polynomial);
|
|
2129
|
+
const maxPos = divisor.getGradedLexMaxPos();
|
|
2130
|
+
const divisorMonomial = divisor.ms[maxPos];
|
|
2131
|
+
const divisorCoeff = divisor.as[maxPos];
|
|
2132
|
+
while (true) {
|
|
2133
|
+
this.limit.checkpoint();
|
|
2134
|
+
const remainderPos = remainder.getGradedLexMaxPos();
|
|
2135
|
+
if (remainderPos === -1) {
|
|
2136
|
+
remainder.reset();
|
|
2137
|
+
return quotient.mk();
|
|
2138
|
+
}
|
|
2139
|
+
const monomial = this.divMonomials(remainder.ms[remainderPos], divisorMonomial);
|
|
2140
|
+
if (monomial === null) throw new SmtInvariantError("exact_div: the divisor does not divide");
|
|
2141
|
+
const coeff = this.divNumeral(remainder.as[remainderPos], divisorCoeff);
|
|
2142
|
+
quotient.addTerm(coeff, monomial);
|
|
2143
|
+
remainder.addmul(this.negNumeral(coeff), monomial, divisor);
|
|
2144
|
+
}
|
|
909
2145
|
}
|
|
910
2146
|
|
|
911
|
-
private
|
|
912
|
-
|
|
913
|
-
const
|
|
914
|
-
|
|
915
|
-
|
|
916
|
-
|
|
917
|
-
|
|
2147
|
+
private divides(divisor: Polynomial, polynomial: Polynomial) {
|
|
2148
|
+
if (polynomial.size === 0) return true;
|
|
2149
|
+
const remainder = this.som;
|
|
2150
|
+
this.som.reset();
|
|
2151
|
+
this.som2.reset();
|
|
2152
|
+
remainder.add(polynomial);
|
|
2153
|
+
const maxPos = divisor.getGradedLexMaxPos();
|
|
2154
|
+
const divisorMonomial = divisor.ms[maxPos];
|
|
2155
|
+
const divisorCoeff = divisor.as[maxPos];
|
|
2156
|
+
while (true) {
|
|
2157
|
+
this.limit.checkpoint();
|
|
2158
|
+
const remainderPos = remainder.getGradedLexMaxPos();
|
|
2159
|
+
if (remainderPos === -1) return true;
|
|
2160
|
+
const monomial = this.divMonomials(remainder.ms[remainderPos], divisorMonomial);
|
|
2161
|
+
if (monomial === null) return false;
|
|
2162
|
+
if (!this.dividesNumeral(divisorCoeff, remainder.as[remainderPos])) return false;
|
|
2163
|
+
const coeff = this.divNumeral(remainder.as[remainderPos], divisorCoeff);
|
|
2164
|
+
remainder.addmul(this.negNumeral(coeff), monomial, divisor);
|
|
918
2165
|
}
|
|
919
|
-
for (let index = 0; index < fs.factors.length; index++)
|
|
920
|
-
this.pushFactor(result, this.fromCoeffs(fs.factors[index], variable), k * fs.degrees[index]);
|
|
921
|
-
if (fs.constant === -1n && k % 2 === 1) result.constant = -result.constant;
|
|
922
2166
|
}
|
|
923
2167
|
|
|
924
|
-
|
|
925
|
-
|
|
926
|
-
|
|
927
|
-
|
|
928
|
-
|
|
929
|
-
if (
|
|
930
|
-
|
|
931
|
-
b
|
|
932
|
-
|
|
2168
|
+
resultant(p: Polynomial, q: Polynomial, x: number, result: PolynomialRef) {
|
|
2169
|
+
const a = new PolynomialRef(this);
|
|
2170
|
+
const b = new PolynomialRef(this);
|
|
2171
|
+
a.set(p);
|
|
2172
|
+
b.set(q);
|
|
2173
|
+
if (this.isZero(a.get()) || this.isZero(b.get())) {
|
|
2174
|
+
result.set(this.zero);
|
|
2175
|
+
b.reset();
|
|
2176
|
+
a.reset();
|
|
2177
|
+
return;
|
|
2178
|
+
}
|
|
2179
|
+
if (this.isConst(a.get())) {
|
|
2180
|
+
if (this.isConst(b.get())) result.set(this.one);
|
|
2181
|
+
else this.pw(a.get(), this.degree(b.get(), x), result);
|
|
2182
|
+
b.reset();
|
|
2183
|
+
a.reset();
|
|
2184
|
+
return;
|
|
2185
|
+
}
|
|
2186
|
+
if (this.isConst(b.get())) {
|
|
2187
|
+
this.pw(b.get(), this.degree(a.get(), x), result);
|
|
2188
|
+
b.reset();
|
|
2189
|
+
a.reset();
|
|
2190
|
+
return;
|
|
933
2191
|
}
|
|
934
|
-
const
|
|
935
|
-
|
|
936
|
-
|
|
2192
|
+
const cA = new PolynomialRef(this);
|
|
2193
|
+
const cB = new PolynomialRef(this);
|
|
2194
|
+
const ppA = new PolynomialRef(this);
|
|
2195
|
+
const ppB = new PolynomialRef(this);
|
|
2196
|
+
const iA = this.iccp(a.get(), x, cA, ppA);
|
|
2197
|
+
const iB = this.iccp(b.get(), x, cB, ppB);
|
|
2198
|
+
cA.set(this.mulConst(iA, cA.get()));
|
|
2199
|
+
cB.set(this.mulConst(iB, cB.get()));
|
|
2200
|
+
const t = new PolynomialRef(this);
|
|
2201
|
+
this.pw(cA.get(), this.degree(b.get(), x), cA);
|
|
2202
|
+
this.pw(cB.get(), this.degree(a.get(), x), cB);
|
|
2203
|
+
t.set(this.mul(cA.get(), cB.get()));
|
|
2204
|
+
a.copy(ppA);
|
|
2205
|
+
b.copy(ppB);
|
|
2206
|
+
let s = 1;
|
|
2207
|
+
let degA = this.degree(a.get(), x);
|
|
2208
|
+
let degB = this.degree(b.get(), x);
|
|
2209
|
+
if (degA < degB) {
|
|
2210
|
+
a.swap(b);
|
|
2211
|
+
if (degA % 2 === 1 && degB % 2 === 1) s = -1;
|
|
2212
|
+
}
|
|
2213
|
+
const remainder = new PolynomialRef(this);
|
|
2214
|
+
const g = new PolynomialRef(this);
|
|
2215
|
+
const h = new PolynomialRef(this);
|
|
2216
|
+
const newH = new PolynomialRef(this);
|
|
2217
|
+
g.set(this.one);
|
|
2218
|
+
h.set(this.one);
|
|
2219
|
+
while (true) {
|
|
2220
|
+
this.limit.checkpoint();
|
|
2221
|
+
degA = this.degree(a.get(), x);
|
|
2222
|
+
degB = this.degree(b.get(), x);
|
|
2223
|
+
const delta = degA - degB;
|
|
2224
|
+
if (degA % 2 === 1 && degB % 2 === 1) s = -s;
|
|
2225
|
+
this.exactPseudoRemainder(a.get(), b.get(), x, remainder);
|
|
2226
|
+
a.copy(b);
|
|
2227
|
+
b.set(this.exactDiv(remainder.get(), g.get()));
|
|
2228
|
+
for (let index = 0; index < delta; index++) b.set(this.exactDiv(b.get(), h.get()));
|
|
2229
|
+
g.set(this.lc(a.get(), x));
|
|
2230
|
+
newH.set(this.one);
|
|
2231
|
+
this.pw(g.get(), delta, newH);
|
|
2232
|
+
if (delta > 1)
|
|
2233
|
+
for (let index = 0; index < delta - 1; index++)
|
|
2234
|
+
newH.set(this.exactDiv(newH.get(), h.get()));
|
|
2235
|
+
h.copy(newH);
|
|
2236
|
+
if (this.degree(b.get(), x) === 0) {
|
|
2237
|
+
const lastDegA = this.degree(a.get(), x);
|
|
2238
|
+
newH.set(this.lc(b.get(), x));
|
|
2239
|
+
this.pw(newH.get(), lastDegA, newH);
|
|
2240
|
+
if (lastDegA > 1)
|
|
2241
|
+
for (let index = 0; index < lastDegA - 1; index++)
|
|
2242
|
+
newH.set(this.exactDiv(newH.get(), h.get()));
|
|
2243
|
+
h.copy(newH);
|
|
2244
|
+
result.set(this.mul(t.get(), h.get()));
|
|
2245
|
+
if (s < 0) result.set(this.neg(result.get()));
|
|
2246
|
+
newH.reset();
|
|
2247
|
+
h.reset();
|
|
2248
|
+
g.reset();
|
|
2249
|
+
remainder.reset();
|
|
2250
|
+
t.reset();
|
|
2251
|
+
ppB.reset();
|
|
2252
|
+
ppA.reset();
|
|
2253
|
+
cB.reset();
|
|
2254
|
+
cA.reset();
|
|
2255
|
+
b.reset();
|
|
2256
|
+
a.reset();
|
|
2257
|
+
return;
|
|
2258
|
+
}
|
|
2259
|
+
}
|
|
2260
|
+
}
|
|
2261
|
+
|
|
2262
|
+
private seLazard(d: number, lcSd: Polynomial, sd1: Polynomial, x: number, se: PolynomialRef) {
|
|
2263
|
+
let n = d - this.degree(sd1, x) - 1;
|
|
2264
|
+
if (n === 0) {
|
|
2265
|
+
se.set(sd1);
|
|
937
2266
|
return;
|
|
938
2267
|
}
|
|
939
|
-
|
|
940
|
-
|
|
941
|
-
|
|
942
|
-
|
|
2268
|
+
const xLc = new PolynomialRef(this);
|
|
2269
|
+
xLc.set(this.lc(sd1, x));
|
|
2270
|
+
const y = lcSd;
|
|
2271
|
+
let a = 1 << (31 - Math.clz32(n));
|
|
2272
|
+
const c = new PolynomialRef(this);
|
|
2273
|
+
c.copy(xLc);
|
|
2274
|
+
n -= a;
|
|
2275
|
+
while (a !== 1) {
|
|
2276
|
+
a /= 2;
|
|
2277
|
+
c.set(this.mul(c.get(), c.get()));
|
|
2278
|
+
c.set(this.exactDiv(c.get(), y));
|
|
2279
|
+
if (n >= a) {
|
|
2280
|
+
c.set(this.mul(c.get(), xLc.get()));
|
|
2281
|
+
c.set(this.exactDiv(c.get(), y));
|
|
2282
|
+
n -= a;
|
|
2283
|
+
}
|
|
2284
|
+
}
|
|
2285
|
+
se.set(this.mul(c.get(), sd1));
|
|
2286
|
+
se.set(this.exactDiv(se.get(), y));
|
|
2287
|
+
c.reset();
|
|
2288
|
+
xLc.reset();
|
|
2289
|
+
}
|
|
2290
|
+
|
|
2291
|
+
private optimizedSe1(
|
|
2292
|
+
d: number,
|
|
2293
|
+
e: number,
|
|
2294
|
+
a: Polynomial,
|
|
2295
|
+
sd1: Polynomial,
|
|
2296
|
+
se: Polynomial,
|
|
2297
|
+
s: Polynomial,
|
|
2298
|
+
x: number,
|
|
2299
|
+
se1: PolynomialRef,
|
|
2300
|
+
) {
|
|
2301
|
+
const cD1 = new PolynomialRef(this);
|
|
2302
|
+
const sE = new PolynomialRef(this);
|
|
2303
|
+
const xJ = new PolynomialRef(this);
|
|
2304
|
+
const tmp = new PolynomialRef(this);
|
|
2305
|
+
cD1.set(this.lc(sd1, x));
|
|
2306
|
+
sE.set(this.lc(se, x));
|
|
2307
|
+
const h = new PolynomialRefVector(this);
|
|
2308
|
+
xJ.set(this.one);
|
|
2309
|
+
for (let j = 0; j <= e - 1; j++) {
|
|
2310
|
+
xJ.set(this.mkVar(x, j));
|
|
2311
|
+
h.push(this.mul(sE.get(), xJ.get()));
|
|
2312
|
+
}
|
|
2313
|
+
xJ.set(this.mkVar(x, e));
|
|
2314
|
+
xJ.set(this.mul(sE.get(), xJ.get()));
|
|
2315
|
+
h.push(this.sub(xJ.get(), se));
|
|
2316
|
+
const xPol = new PolynomialRef(this);
|
|
2317
|
+
const xH = new PolynomialRef(this);
|
|
2318
|
+
const xHe = new PolynomialRef(this);
|
|
2319
|
+
xPol.set(this.mkVar(x, 1));
|
|
2320
|
+
for (let j = e + 1; j <= d - 1; j++) {
|
|
2321
|
+
xH.set(this.mul(xPol.get(), h.get(j - 1)));
|
|
2322
|
+
xHe.set(this.coeff(xH.get(), x, e));
|
|
2323
|
+
tmp.set(this.mul(xHe.get(), sd1));
|
|
2324
|
+
tmp.set(this.exactDiv(tmp.get(), cD1.get()));
|
|
2325
|
+
h.push(this.sub(xH.get(), tmp.get()));
|
|
2326
|
+
}
|
|
2327
|
+
const dPolynomial = new PolynomialRef(this);
|
|
2328
|
+
dPolynomial.set(this.zero);
|
|
2329
|
+
for (let j = 0; j < d; j++) {
|
|
2330
|
+
tmp.set(this.coeff(a, x, j));
|
|
2331
|
+
tmp.set(this.mul(tmp.get(), h.get(j)));
|
|
2332
|
+
dPolynomial.set(this.add(dPolynomial.get(), tmp.get()));
|
|
2333
|
+
}
|
|
2334
|
+
const lcA = new PolynomialRef(this);
|
|
2335
|
+
lcA.set(this.lc(a, x));
|
|
2336
|
+
dPolynomial.set(this.exactDiv(dPolynomial.get(), lcA.get()));
|
|
2337
|
+
xH.set(this.mul(xPol.get(), h.get(d - 1)));
|
|
2338
|
+
xHe.set(this.coeff(xH.get(), x, e));
|
|
2339
|
+
xHe.set(this.mul(xHe.get(), sd1));
|
|
2340
|
+
se1.set(this.add(xH.get(), dPolynomial.get()));
|
|
2341
|
+
se1.set(this.mul(cD1.get(), se1.get()));
|
|
2342
|
+
se1.set(this.sub(se1.get(), xHe.get()));
|
|
2343
|
+
se1.set(this.exactDiv(se1.get(), s));
|
|
2344
|
+
if ((d - e + 1) % 2 === 1) se1.set(this.neg(se1.get()));
|
|
2345
|
+
lcA.reset();
|
|
2346
|
+
dPolynomial.reset();
|
|
2347
|
+
xHe.reset();
|
|
2348
|
+
xH.reset();
|
|
2349
|
+
xPol.reset();
|
|
2350
|
+
h.reset();
|
|
2351
|
+
tmp.reset();
|
|
2352
|
+
xJ.reset();
|
|
2353
|
+
sE.reset();
|
|
2354
|
+
cD1.reset();
|
|
2355
|
+
}
|
|
2356
|
+
|
|
2357
|
+
private pscChainOptimizedCore(
|
|
2358
|
+
p: Polynomial,
|
|
2359
|
+
q: Polynomial,
|
|
2360
|
+
x: number,
|
|
2361
|
+
chain: PolynomialRefVector,
|
|
2362
|
+
) {
|
|
2363
|
+
const degP = this.degree(p, x);
|
|
2364
|
+
const degQ = this.degree(q, x);
|
|
2365
|
+
const a = new PolynomialRef(this);
|
|
2366
|
+
const b = new PolynomialRef(this);
|
|
2367
|
+
const c = new PolynomialRef(this);
|
|
2368
|
+
const minusQ = new PolynomialRef(this);
|
|
2369
|
+
const lcQ = new PolynomialRef(this);
|
|
2370
|
+
const ps = new PolynomialRef(this);
|
|
2371
|
+
lcQ.set(this.lc(q, x));
|
|
2372
|
+
const s = new PolynomialRef(this);
|
|
2373
|
+
const release = () => {
|
|
2374
|
+
s.reset();
|
|
2375
|
+
ps.reset();
|
|
2376
|
+
lcQ.reset();
|
|
2377
|
+
minusQ.reset();
|
|
2378
|
+
c.reset();
|
|
2379
|
+
b.reset();
|
|
2380
|
+
a.reset();
|
|
2381
|
+
};
|
|
2382
|
+
this.pw(lcQ.get(), degP - degQ, s);
|
|
2383
|
+
minusQ.set(this.neg(q));
|
|
2384
|
+
a.set(q);
|
|
2385
|
+
this.exactPseudoRemainder(p, minusQ.get(), x, b);
|
|
2386
|
+
while (true) {
|
|
2387
|
+
const d = this.degree(a.get(), x);
|
|
2388
|
+
const e = this.degree(b.get(), x);
|
|
2389
|
+
if (this.isZero(b.get())) {
|
|
2390
|
+
release();
|
|
2391
|
+
return;
|
|
2392
|
+
}
|
|
2393
|
+
ps.set(this.coeff(b.get(), x, d - 1));
|
|
2394
|
+
if (!this.isZero(ps.get())) chain.push(ps.get());
|
|
2395
|
+
const delta = d - e;
|
|
2396
|
+
if (delta > 1) {
|
|
2397
|
+
this.seLazard(d, s.get(), b.get(), x, c);
|
|
2398
|
+
ps.set(this.coeff(c.get(), x, e));
|
|
2399
|
+
if (!this.isZero(ps.get())) chain.push(ps.get());
|
|
2400
|
+
} else c.copy(b);
|
|
2401
|
+
if (e === 0) {
|
|
2402
|
+
release();
|
|
2403
|
+
return;
|
|
2404
|
+
}
|
|
2405
|
+
this.optimizedSe1(d, e, a.get(), b.get(), c.get(), s.get(), x, b);
|
|
2406
|
+
a.copy(c);
|
|
2407
|
+
s.set(this.lc(a.get(), x));
|
|
2408
|
+
}
|
|
2409
|
+
}
|
|
2410
|
+
|
|
2411
|
+
pscChain(p: Polynomial, q: Polynomial, x: number, chain: PolynomialRefVector) {
|
|
2412
|
+
chain.reset();
|
|
2413
|
+
if (this.degree(p, x) >= this.degree(q, x)) this.pscChainOptimizedCore(p, q, x, chain);
|
|
2414
|
+
else this.pscChainOptimizedCore(q, p, x, chain);
|
|
2415
|
+
if (chain.size === 0) chain.push(this.zero);
|
|
2416
|
+
chain.items.reverse();
|
|
2417
|
+
}
|
|
2418
|
+
|
|
2419
|
+
normalize(polynomial: Polynomial) {
|
|
2420
|
+
if (polynomial.size === 0) return polynomial;
|
|
2421
|
+
const modulus = this.modulus;
|
|
2422
|
+
if (modulus !== null) {
|
|
2423
|
+
let index = 0;
|
|
2424
|
+
for (; index < polynomial.size; index++)
|
|
2425
|
+
if (normalizeZp(polynomial.as[index], modulus) !== polynomial.as[index]) break;
|
|
2426
|
+
if (index < polynomial.size) {
|
|
2427
|
+
this.cheap.reset();
|
|
2428
|
+
for (let other = 0; other < polynomial.size; other++)
|
|
2429
|
+
this.cheap.addReset(normalizeZp(polynomial.as[other], modulus), polynomial.ms[other]);
|
|
2430
|
+
this.cheap.normalize();
|
|
2431
|
+
return this.cheap.mk();
|
|
2432
|
+
}
|
|
2433
|
+
}
|
|
2434
|
+
const g = this.gcdNumerals(polynomial.as);
|
|
2435
|
+
if (g === 1n) return polynomial;
|
|
2436
|
+
this.cheap.reset();
|
|
2437
|
+
for (let index = 0; index < polynomial.size; index++)
|
|
2438
|
+
this.cheap.addReset(this.divNumeral(polynomial.as[index], g), polynomial.ms[index]);
|
|
2439
|
+
return this.cheap.mk();
|
|
943
2440
|
}
|
|
944
2441
|
|
|
945
2442
|
private getTermSquareRoot(polynomial: Polynomial, position: number) {
|
|
946
|
-
|
|
947
|
-
if (monomial.degrees.some((degree) => degree % 2 === 1)) return null;
|
|
2443
|
+
if (!polynomial.ms[position].isSquare()) return null;
|
|
948
2444
|
return getExactSquareRoot(polynomial.as[position]);
|
|
949
2445
|
}
|
|
950
2446
|
|
|
951
|
-
sqrt(polynomial: Polynomial) {
|
|
952
|
-
if (polynomial.size === 0)
|
|
953
|
-
|
|
954
|
-
return
|
|
2447
|
+
sqrt(polynomial: Polynomial, r: PolynomialRef) {
|
|
2448
|
+
if (polynomial.size === 0) {
|
|
2449
|
+
r.set(polynomial);
|
|
2450
|
+
return true;
|
|
2451
|
+
}
|
|
2452
|
+
if (this.getTermSquareRoot(polynomial, polynomial.getGradedLexMinPos()) === null) return false;
|
|
955
2453
|
const maxPos = polynomial.getGradedLexMaxPos();
|
|
956
2454
|
const a = this.getTermSquareRoot(polynomial, maxPos);
|
|
957
|
-
if (a === null) return
|
|
958
|
-
const
|
|
959
|
-
const m1 = this.mkMonomial(
|
|
960
|
-
maxMonomial.vars,
|
|
961
|
-
maxMonomial.degrees.map((degree) => degree / 2),
|
|
962
|
-
);
|
|
2455
|
+
if (a === null) return false;
|
|
2456
|
+
const m1 = this.sqrtMonomial(polynomial.ms[maxPos]);
|
|
963
2457
|
const root = this.som;
|
|
964
2458
|
const rest = this.som2;
|
|
965
2459
|
root.reset();
|
|
966
2460
|
rest.reset();
|
|
967
|
-
const twoA =
|
|
2461
|
+
const twoA = a * 2n;
|
|
968
2462
|
root.addTerm(a, m1);
|
|
969
2463
|
for (let index = 0; index < polynomial.size; index++)
|
|
970
2464
|
if (index !== maxPos) rest.addTerm(polynomial.as[index], polynomial.ms[index]);
|
|
971
2465
|
while (true) {
|
|
2466
|
+
this.limit.checkpoint();
|
|
972
2467
|
const restMax = rest.getGradedLexMaxPos();
|
|
973
2468
|
if (restMax === -1) {
|
|
2469
|
+
r.set(root.mk());
|
|
974
2470
|
rest.reset();
|
|
975
|
-
return
|
|
2471
|
+
return true;
|
|
976
2472
|
}
|
|
977
2473
|
const monomial = this.divMonomials(rest.ms[restMax], m1);
|
|
978
|
-
if (monomial === null || rest.as[restMax]
|
|
979
|
-
root.reset();
|
|
2474
|
+
if (monomial === null || !this.dividesNumeral(twoA, rest.as[restMax])) {
|
|
980
2475
|
rest.reset();
|
|
981
|
-
|
|
2476
|
+
root.reset();
|
|
2477
|
+
return false;
|
|
982
2478
|
}
|
|
983
|
-
const coeff =
|
|
2479
|
+
const coeff = this.divNumeral(rest.as[restMax], twoA);
|
|
984
2480
|
const rootSize = root.as.length;
|
|
985
2481
|
for (let index = 0; index < rootSize; index++) {
|
|
986
2482
|
if (root.as[index] === 0n) continue;
|
|
@@ -991,13 +2487,6 @@ export class PolynomialManager {
|
|
|
991
2487
|
}
|
|
992
2488
|
}
|
|
993
2489
|
|
|
994
|
-
private getGradedLexMinPos(polynomial: Polynomial) {
|
|
995
|
-
let minPos = 0;
|
|
996
|
-
for (let index = 1; index < polynomial.size; index++)
|
|
997
|
-
if (gradedLexCompare(polynomial.ms[index], polynomial.ms[minPos]) < 0) minPos = index;
|
|
998
|
-
return minPos;
|
|
999
|
-
}
|
|
1000
|
-
|
|
1001
2490
|
getVars(polynomial: Polynomial) {
|
|
1002
2491
|
const vars: number[] = [];
|
|
1003
2492
|
for (const monomial of polynomial.ms)
|
|
@@ -1005,11 +2494,22 @@ export class PolynomialManager {
|
|
|
1005
2494
|
return vars;
|
|
1006
2495
|
}
|
|
1007
2496
|
|
|
2497
|
+
private getMaxDegrees(polynomial: Polynomial) {
|
|
2498
|
+
const degrees = new Map<number, number>();
|
|
2499
|
+
for (const monomial of polynomial.ms)
|
|
2500
|
+
for (let index = 0; index < monomial.size; index++) {
|
|
2501
|
+
const variable = monomial.vars[index];
|
|
2502
|
+
if (monomial.degrees[index] > (degrees.get(variable) ?? 0))
|
|
2503
|
+
degrees.set(variable, monomial.degrees[index]);
|
|
2504
|
+
}
|
|
2505
|
+
return degrees;
|
|
2506
|
+
}
|
|
2507
|
+
|
|
1008
2508
|
substitute(polynomial: Polynomial, vars: readonly number[], values: readonly bigint[]) {
|
|
1009
2509
|
this.som.reset();
|
|
1010
2510
|
for (let index = 0; index < polynomial.size; index++) {
|
|
1011
2511
|
const monomial = polynomial.ms[index];
|
|
1012
|
-
let coeff = polynomial.as[index];
|
|
2512
|
+
let coeff = this.normalizeNumeral(polynomial.as[index]);
|
|
1013
2513
|
const keptVars: number[] = [];
|
|
1014
2514
|
const keptDegrees: number[] = [];
|
|
1015
2515
|
for (let power = 0; power < monomial.size; power++) {
|
|
@@ -1017,7 +2517,11 @@ export class PolynomialManager {
|
|
|
1017
2517
|
if (position === -1) {
|
|
1018
2518
|
keptVars.push(monomial.vars[power]);
|
|
1019
2519
|
keptDegrees.push(monomial.degrees[power]);
|
|
1020
|
-
} else
|
|
2520
|
+
} else
|
|
2521
|
+
coeff = this.mulNumeral(
|
|
2522
|
+
this.powerNumeral(values[position], monomial.degrees[power]),
|
|
2523
|
+
coeff,
|
|
2524
|
+
);
|
|
1021
2525
|
}
|
|
1022
2526
|
this.som.addTerm(coeff, this.mkMonomial(keptVars, keptDegrees));
|
|
1023
2527
|
}
|
|
@@ -1035,9 +2539,11 @@ export class PolynomialManager {
|
|
|
1035
2539
|
this.divX(monomial, variable),
|
|
1036
2540
|
);
|
|
1037
2541
|
}
|
|
1038
|
-
for (let step = 1; step <= degree; step++)
|
|
2542
|
+
for (let step = 1; step <= degree; step++) {
|
|
2543
|
+
this.limit.checkpoint();
|
|
1039
2544
|
for (let power = degree - step; power <= degree - 1; power++)
|
|
1040
2545
|
coeffs[power].addmulBuffer(value, this.unit, coeffs[power + 1]);
|
|
2546
|
+
}
|
|
1041
2547
|
this.som.reset();
|
|
1042
2548
|
for (let power = 0; power <= degree; power++)
|
|
1043
2549
|
this.som.addmulBuffer(1n, this.mkPower(variable, power), coeffs[power]);
|
|
@@ -1072,377 +2578,538 @@ export class PolynomialManager {
|
|
|
1072
2578
|
if (value !== undefined && monomial.degreeOf(variable) === 0)
|
|
1073
2579
|
coeff *= value.den ** BigInt(maxDegree);
|
|
1074
2580
|
}
|
|
1075
|
-
this.som.addTerm(coeff, this.mkMonomial(keptVars, keptDegrees));
|
|
2581
|
+
if (coeff !== 0n) this.som.addTerm(coeff, this.mkMonomial(keptVars, keptDegrees));
|
|
1076
2582
|
}
|
|
1077
2583
|
return this.som.mk(true);
|
|
1078
2584
|
}
|
|
1079
2585
|
|
|
1080
|
-
private
|
|
1081
|
-
if (
|
|
1082
|
-
|
|
1083
|
-
|
|
1084
|
-
|
|
1085
|
-
this.
|
|
1086
|
-
|
|
2586
|
+
private mkGlexMonic(polynomial: Polynomial) {
|
|
2587
|
+
if (polynomial.size === 0) return polynomial;
|
|
2588
|
+
const position = polynomial.getGradedLexMaxPos();
|
|
2589
|
+
if (polynomial.as[position] === 1n) return polynomial;
|
|
2590
|
+
const inverse = this.invNumeral(polynomial.as[position]);
|
|
2591
|
+
this.cheap.reset();
|
|
2592
|
+
for (let index = 0; index < polynomial.size; index++)
|
|
2593
|
+
this.cheap.add(this.mulNumeral(polynomial.as[index], inverse), polynomial.ms[index]);
|
|
2594
|
+
return this.cheap.mk();
|
|
1087
2595
|
}
|
|
1088
2596
|
|
|
1089
|
-
private
|
|
1090
|
-
|
|
1091
|
-
|
|
1092
|
-
const degree
|
|
1093
|
-
|
|
1094
|
-
|
|
1095
|
-
|
|
1096
|
-
|
|
1097
|
-
for (let power = degree - 1; power >= 0; power--)
|
|
1098
|
-
result = this.muladd(inner, result, coeffs[power]);
|
|
2597
|
+
private getMinDegreeVar(polynomial: Polynomial) {
|
|
2598
|
+
let result = NULL_VAR;
|
|
2599
|
+
let minDegree = Infinity;
|
|
2600
|
+
for (const [variable, degree] of this.getMaxDegrees(polynomial))
|
|
2601
|
+
if (degree < minDegree) {
|
|
2602
|
+
result = variable;
|
|
2603
|
+
minDegree = degree;
|
|
2604
|
+
}
|
|
1099
2605
|
return result;
|
|
1100
2606
|
}
|
|
1101
2607
|
|
|
1102
|
-
|
|
1103
|
-
|
|
1104
|
-
|
|
1105
|
-
|
|
2608
|
+
toCoeffs(polynomial: Polynomial) {
|
|
2609
|
+
// Z3's to_numeral_vector builds normalize(p) and drops it, which takes and frees an id.
|
|
2610
|
+
const normalized = this.normalize(polynomial);
|
|
2611
|
+
if (normalized !== polynomial) {
|
|
2612
|
+
this.incRef(normalized);
|
|
2613
|
+
this.decRef(normalized);
|
|
2614
|
+
}
|
|
2615
|
+
const coeffs = Array.from({ length: this.totalDegree(polynomial) + 1 }, () => 0n);
|
|
2616
|
+
for (let index = 0; index < polynomial.size; index++)
|
|
2617
|
+
coeffs[polynomial.ms[index].totalDegree] = polynomial.as[index];
|
|
2618
|
+
return this.um.set(coeffs);
|
|
1106
2619
|
}
|
|
1107
2620
|
|
|
1108
|
-
|
|
1109
|
-
if (
|
|
1110
|
-
|
|
1111
|
-
|
|
1112
|
-
for (let index = 0; index < polynomial.size; index++) {
|
|
1113
|
-
const power = polynomial.ms[index].degreeOf(x);
|
|
1114
|
-
const powers: [number, number][] =
|
|
1115
|
-
x < variable
|
|
1116
|
-
? [
|
|
1117
|
-
[x, power],
|
|
1118
|
-
[variable, degree - power],
|
|
1119
|
-
]
|
|
1120
|
-
: [
|
|
1121
|
-
[variable, degree - power],
|
|
1122
|
-
[x, power],
|
|
1123
|
-
];
|
|
1124
|
-
const kept = powers.filter((entry) => entry[1] > 0);
|
|
1125
|
-
this.cheap.add(
|
|
1126
|
-
polynomial.as[index],
|
|
1127
|
-
this.mkMonomial(
|
|
1128
|
-
kept.map((entry) => entry[0]),
|
|
1129
|
-
kept.map((entry) => entry[1]),
|
|
1130
|
-
),
|
|
1131
|
-
);
|
|
2621
|
+
factor(polynomial: Polynomial, r: Factors) {
|
|
2622
|
+
if (polynomial.size === 0) {
|
|
2623
|
+
r.constant = 0n;
|
|
2624
|
+
return;
|
|
1132
2625
|
}
|
|
1133
|
-
|
|
2626
|
+
this.factorCore(polynomial, r);
|
|
1134
2627
|
}
|
|
1135
2628
|
|
|
1136
|
-
|
|
1137
|
-
if (
|
|
1138
|
-
|
|
1139
|
-
return
|
|
1140
|
-
|
|
1141
|
-
const
|
|
1142
|
-
const
|
|
1143
|
-
const
|
|
1144
|
-
|
|
1145
|
-
|
|
1146
|
-
);
|
|
1147
|
-
|
|
1148
|
-
|
|
1149
|
-
|
|
1150
|
-
|
|
1151
|
-
|
|
1152
|
-
|
|
1153
|
-
|
|
1154
|
-
|
|
1155
|
-
|
|
1156
|
-
|
|
1157
|
-
|
|
1158
|
-
|
|
1159
|
-
|
|
1160
|
-
|
|
1161
|
-
|
|
1162
|
-
|
|
1163
|
-
|
|
1164
|
-
|
|
1165
|
-
|
|
1166
|
-
let nextH = this.pw(g, delta);
|
|
1167
|
-
for (let index = 1; index < delta; index++) nextH = this.exactDiv(nextH, h);
|
|
1168
|
-
h = nextH;
|
|
1169
|
-
if (this.degree(b, variable) === 0) {
|
|
1170
|
-
const degree = this.degree(a, variable);
|
|
1171
|
-
let lastH = this.pw(this.lc(b, variable), degree);
|
|
1172
|
-
for (let index = 1; index < degree; index++) lastH = this.exactDiv(lastH, h);
|
|
1173
|
-
const result = this.mul(scale, lastH);
|
|
1174
|
-
return sign < 0 ? this.neg(result) : result;
|
|
2629
|
+
private factorCore(polynomial: Polynomial, r: Factors) {
|
|
2630
|
+
if (this.isConst(polynomial)) {
|
|
2631
|
+
r.constant *= polynomial.as[0];
|
|
2632
|
+
return;
|
|
2633
|
+
}
|
|
2634
|
+
const x = this.getMinDegreeVar(polynomial);
|
|
2635
|
+
const c = new PolynomialRef(this);
|
|
2636
|
+
const pp = new PolynomialRef(this);
|
|
2637
|
+
const integer = this.iccp(polynomial, x, c, pp);
|
|
2638
|
+
r.constant *= integer;
|
|
2639
|
+
this.factorCore(c.get(), r);
|
|
2640
|
+
const cPart = new PolynomialRef(this);
|
|
2641
|
+
cPart.copy(pp);
|
|
2642
|
+
const cPrime = new PolynomialRef(this);
|
|
2643
|
+
cPrime.set(this.derivative(cPart.get(), x));
|
|
2644
|
+
const b = new PolynomialRef(this);
|
|
2645
|
+
const a = new PolynomialRef(this);
|
|
2646
|
+
const d = new PolynomialRef(this);
|
|
2647
|
+
this.gcd(cPart.get(), cPrime.get(), b);
|
|
2648
|
+
if (this.isConst(b.get())) this.factorSqfPp(cPart.get(), r, x, 1);
|
|
2649
|
+
else {
|
|
2650
|
+
a.set(this.exactDiv(cPart.get(), b.get()));
|
|
2651
|
+
for (let j = 1; !this.isConst(a.get()); j++) {
|
|
2652
|
+
this.limit.checkpoint();
|
|
2653
|
+
this.gcd(a.get(), b.get(), d);
|
|
2654
|
+
cPart.set(this.exactDiv(a.get(), d.get()));
|
|
2655
|
+
if (!this.isConst(cPart.get())) this.factorSqfPp(cPart.get(), r, x, j);
|
|
2656
|
+
else if (cPart.get().as[0] === -1n && j % 2 === 1) r.constant = -r.constant;
|
|
2657
|
+
b.set(this.exactDiv(b.get(), d.get()));
|
|
2658
|
+
a.copy(d);
|
|
1175
2659
|
}
|
|
1176
2660
|
}
|
|
2661
|
+
d.reset();
|
|
2662
|
+
a.reset();
|
|
2663
|
+
b.reset();
|
|
2664
|
+
cPrime.reset();
|
|
2665
|
+
cPart.reset();
|
|
2666
|
+
pp.reset();
|
|
2667
|
+
c.reset();
|
|
1177
2668
|
}
|
|
1178
2669
|
|
|
1179
|
-
private
|
|
1180
|
-
|
|
1181
|
-
|
|
2670
|
+
private factorSqfPp(polynomial: Polynomial, r: Factors, x: number, k: number) {
|
|
2671
|
+
const degree = this.degree(polynomial, x);
|
|
2672
|
+
if (degree === 1) r.push(polynomial, k);
|
|
2673
|
+
else if (this.isUnivariate(polynomial)) this.factorSqfPpUniv(polynomial, r, k);
|
|
2674
|
+
else if (degree === 2) this.factor2SqfPp(polynomial, r, x, k);
|
|
2675
|
+
else this.factorNSqfPp(polynomial, r, x, k);
|
|
2676
|
+
}
|
|
2677
|
+
|
|
2678
|
+
private factor2SqfPp(polynomial: Polynomial, r: Factors, x: number, k: number) {
|
|
2679
|
+
const a = new PolynomialRef(this);
|
|
2680
|
+
const b = new PolynomialRef(this);
|
|
2681
|
+
const c = new PolynomialRef(this);
|
|
2682
|
+
a.set(this.coeff(polynomial, x, 2));
|
|
2683
|
+
b.set(this.coeff(polynomial, x, 1));
|
|
2684
|
+
c.set(this.coeff(polynomial, x, 0));
|
|
2685
|
+
let isFlipped = false;
|
|
2686
|
+
if (a.get().as[a.get().getGradedLexMaxPos()] < 0n) {
|
|
2687
|
+
a.set(this.neg(a.get()));
|
|
2688
|
+
b.set(this.neg(b.get()));
|
|
2689
|
+
c.set(this.neg(c.get()));
|
|
2690
|
+
isFlipped = true;
|
|
2691
|
+
}
|
|
2692
|
+
const b2 = new PolynomialRef(this);
|
|
2693
|
+
b2.set(this.mul(b.get(), b.get()));
|
|
2694
|
+
const ac = new PolynomialRef(this);
|
|
2695
|
+
ac.set(this.mul(a.get(), c.get()));
|
|
2696
|
+
const disc = new PolynomialRef(this);
|
|
2697
|
+
disc.set(this.addmul(b2.get(), -4n, ac.get()));
|
|
2698
|
+
const discSqrt = new PolynomialRef(this);
|
|
2699
|
+
const f1 = new PolynomialRef(this);
|
|
2700
|
+
const f2 = new PolynomialRef(this);
|
|
2701
|
+
const twoAx = new PolynomialRef(this);
|
|
2702
|
+
if (!this.sqrt(disc.get(), discSqrt)) r.push(polynomial, k);
|
|
2703
|
+
else {
|
|
2704
|
+
if (isFlipped && k % 2 === 1) r.constant = -r.constant;
|
|
2705
|
+
twoAx.set(this.mulTerm(2n, this.mkPower(x, 1), a.get()));
|
|
2706
|
+
f1.set(this.add(twoAx.get(), b.get()));
|
|
2707
|
+
f2.copy(f1);
|
|
2708
|
+
f1.set(this.sub(f1.get(), discSqrt.get()));
|
|
2709
|
+
f2.set(this.add(f2.get(), discSqrt.get()));
|
|
2710
|
+
f1.move(this.pp(f1.get(), x));
|
|
2711
|
+
f2.move(this.pp(f2.get(), x));
|
|
2712
|
+
r.push(f1.get(), k);
|
|
2713
|
+
r.push(f2.get(), k);
|
|
2714
|
+
}
|
|
2715
|
+
twoAx.reset();
|
|
2716
|
+
f2.reset();
|
|
2717
|
+
f1.reset();
|
|
2718
|
+
discSqrt.reset();
|
|
2719
|
+
disc.reset();
|
|
2720
|
+
ac.reset();
|
|
2721
|
+
b2.reset();
|
|
2722
|
+
c.reset();
|
|
2723
|
+
b.reset();
|
|
2724
|
+
a.reset();
|
|
2725
|
+
}
|
|
2726
|
+
|
|
2727
|
+
private factorSqfPpUniv(polynomial: Polynomial, r: Factors, k: number) {
|
|
2728
|
+
const x = this.maxVar(polynomial);
|
|
2729
|
+
const pRef = new PolynomialRef(this);
|
|
2730
|
+
pRef.set(polynomial);
|
|
2731
|
+
const fs = mkFactors();
|
|
2732
|
+
factorSquareFree(this.um, this.toCoeffs(polynomial), fs, 1, DEFAULT_FACTOR_PARAMS);
|
|
2733
|
+
if (fs.factors.length === 1 && fs.degrees[0] === 1) r.push(polynomial, k);
|
|
2734
|
+
else {
|
|
2735
|
+
const f = new PolynomialRef(this);
|
|
2736
|
+
for (let index = 0; index < fs.factors.length; index++) {
|
|
2737
|
+
f.set(this.toPolynomial(fs.factors[index], x));
|
|
2738
|
+
r.push(f.get(), k * fs.degrees[index]);
|
|
2739
|
+
}
|
|
2740
|
+
if (fs.constant === -1n && k % 2 === 1) r.constant = -r.constant;
|
|
2741
|
+
f.reset();
|
|
2742
|
+
}
|
|
2743
|
+
pRef.reset();
|
|
2744
|
+
}
|
|
2745
|
+
|
|
2746
|
+
private factorNSqfPp(polynomial: Polynomial, r: Factors, x: number, k: number) {
|
|
2747
|
+
if (this.isUnivariate(polynomial)) {
|
|
2748
|
+
this.factorSqfPpUniv(polynomial, r, k);
|
|
2749
|
+
return;
|
|
2750
|
+
}
|
|
2751
|
+
if (this.tryMultivarFactor(polynomial, r, x, k)) return;
|
|
2752
|
+
r.push(polynomial, k);
|
|
1182
2753
|
}
|
|
1183
2754
|
|
|
1184
|
-
private
|
|
1185
|
-
|
|
2755
|
+
private pushSmallFactor(part: PolynomialRef, r: Factors, x: number, k: number) {
|
|
2756
|
+
const d = this.degree(part.get(), x);
|
|
2757
|
+
if (d === 1) r.push(part.get(), k);
|
|
2758
|
+
else if (d === 2 && this.isPrimitive(part.get(), x) && this.isSquareFreeIn(part.get(), x))
|
|
2759
|
+
this.factor2SqfPp(part.get(), r, x, k);
|
|
2760
|
+
else r.push(part.get(), k);
|
|
1186
2761
|
}
|
|
1187
2762
|
|
|
1188
|
-
private
|
|
2763
|
+
private tryMultivarFactor(polynomial: Polynomial, r: Factors, x: number, k: number) {
|
|
1189
2764
|
const allVars = this.getVars(polynomial);
|
|
1190
|
-
const mainVars = [
|
|
1191
|
-
|
|
1192
|
-
|
|
1193
|
-
|
|
1194
|
-
|
|
1195
|
-
|
|
1196
|
-
.filter((entry) => entry[0] > 1)
|
|
1197
|
-
.map((entry) => entry[1]),
|
|
1198
|
-
];
|
|
2765
|
+
const mainVars = [x];
|
|
2766
|
+
const varsByDegree: [number, number][] = [];
|
|
2767
|
+
for (const variable of allVars)
|
|
2768
|
+
if (variable !== x) varsByDegree.push([this.degree(polynomial, variable), variable]);
|
|
2769
|
+
varsByDegree.sort((first, second) => second[0] - first[0] || second[1] - first[1]);
|
|
2770
|
+
for (const [degree, variable] of varsByDegree) if (degree > 1) mainVars.push(variable);
|
|
1199
2771
|
for (const mainVar of mainVars) {
|
|
1200
2772
|
const degMain = this.degree(polynomial, mainVar);
|
|
1201
2773
|
if (degMain <= 1) continue;
|
|
1202
2774
|
for (const liftVar of allVars) {
|
|
1203
2775
|
if (liftVar === mainVar) continue;
|
|
1204
|
-
|
|
1205
|
-
const
|
|
2776
|
+
this.limit.checkpoint();
|
|
2777
|
+
const evalVars: number[] = [];
|
|
2778
|
+
for (const variable of allVars)
|
|
2779
|
+
if (variable !== mainVar && variable !== liftVar) evalVars.push(variable);
|
|
2780
|
+
const nEval = evalVars.length;
|
|
2781
|
+
const maxCombos = nEval === 0 ? 1 : Math.min(FACTOR_EVAL_VALUES.length, 5);
|
|
1206
2782
|
for (let combo = 0; combo < maxCombos; combo++) {
|
|
1207
|
-
|
|
1208
|
-
|
|
1209
|
-
|
|
1210
|
-
|
|
1211
|
-
|
|
1212
|
-
|
|
1213
|
-
|
|
1214
|
-
|
|
1215
|
-
|
|
1216
|
-
|
|
1217
|
-
|
|
1218
|
-
|
|
1219
|
-
|
|
1220
|
-
|
|
1221
|
-
|
|
1222
|
-
|
|
1223
|
-
if (degLift === 0) continue;
|
|
1224
|
-
for (const point of FACTOR_EVAL_VALUES) {
|
|
1225
|
-
const univariate = this.substitute(bivariate, [liftVar], [point]);
|
|
1226
|
-
if (!this.isUnivariate(univariate)) continue;
|
|
1227
|
-
if (this.degree(univariate, mainVar) !== degMain) continue;
|
|
1228
|
-
if (!this.isSquareFreeIn(univariate, mainVar)) continue;
|
|
1229
|
-
const univariateFs: UpolynomialFactors = { constant: 1n, factors: [], degrees: [] };
|
|
1230
|
-
factorSquareFree(
|
|
1231
|
-
this.um,
|
|
1232
|
-
this.um.getPrimitive(this.toCoeffs(univariate)),
|
|
1233
|
-
univariateFs,
|
|
1234
|
-
1,
|
|
1235
|
-
DEFAULT_FACTOR_PARAMS,
|
|
1236
|
-
);
|
|
1237
|
-
const factorCount = univariateFs.factors.length;
|
|
1238
|
-
if (factorCount <= 1) continue;
|
|
1239
|
-
const translated = this.translate(bivariate, liftVar, point);
|
|
1240
|
-
const lcPolynomial = this.coeff(translated, mainVar, degMain);
|
|
1241
|
-
const lcAtZero = this.isConst(lcPolynomial)
|
|
1242
|
-
? (lcPolynomial.as[0] ?? 0n)
|
|
1243
|
-
: this.getConstValue(this.substitute(lcPolynomial, [liftVar], [0n]));
|
|
1244
|
-
if (lcAtZero === null) continue;
|
|
1245
|
-
for (const prime of FACTOR_PRIMES) {
|
|
1246
|
-
if (getGcd(prime, lcAtZero) !== 1n) continue;
|
|
1247
|
-
for (let split = 1; split <= Math.floor(factorCount / 2); split++) {
|
|
1248
|
-
let h1 = univariateFs.factors[0];
|
|
1249
|
-
for (let index = 1; index < split; index++)
|
|
1250
|
-
h1 = this.um.mul(h1, univariateFs.factors[index]);
|
|
1251
|
-
let h2 = univariateFs.factors[split];
|
|
1252
|
-
for (let index = split + 1; index < factorCount; index++)
|
|
1253
|
-
h2 = this.um.mul(h2, univariateFs.factors[index]);
|
|
1254
|
-
const lifted = this.liftBivariate(
|
|
1255
|
-
translated,
|
|
1256
|
-
mainVar,
|
|
1257
|
-
liftVar,
|
|
1258
|
-
degLift,
|
|
1259
|
-
this.um.flipSignIfLmNeg(h1),
|
|
1260
|
-
this.um.flipSignIfLmNeg(h2),
|
|
1261
|
-
lcAtZero,
|
|
1262
|
-
prime,
|
|
1263
|
-
);
|
|
1264
|
-
if (lifted === null) continue;
|
|
1265
|
-
const candidates = lifted.map((factor) => this.translate(factor, liftVar, -point));
|
|
1266
|
-
if (evalVars.length === 0) {
|
|
1267
|
-
for (const candidate of candidates) {
|
|
1268
|
-
if (this.isConst(candidate) || this.degree(candidate, x) === 0) continue;
|
|
1269
|
-
this.pushSmallFactor(candidate, x, k, result);
|
|
1270
|
-
}
|
|
1271
|
-
return true;
|
|
1272
|
-
}
|
|
1273
|
-
for (const candidate of candidates) {
|
|
1274
|
-
if (this.isConst(candidate)) continue;
|
|
1275
|
-
const division = this.exactPseudoDivision(
|
|
1276
|
-
polynomial,
|
|
1277
|
-
candidate,
|
|
1278
|
-
this.maxVar(candidate),
|
|
1279
|
-
);
|
|
1280
|
-
if (division.remainder.size !== 0) continue;
|
|
1281
|
-
if (!this.eq(this.mul(candidate, division.quotient), polynomial)) continue;
|
|
1282
|
-
for (const part of [candidate, division.quotient]) {
|
|
1283
|
-
if (this.isConst(part)) result.constant *= part.as[0];
|
|
1284
|
-
else if (this.degree(part, x) !== 0) this.pushSmallFactor(part, x, k, result);
|
|
1285
|
-
}
|
|
1286
|
-
return true;
|
|
1287
|
-
}
|
|
1288
|
-
}
|
|
1289
|
-
}
|
|
1290
|
-
}
|
|
2783
|
+
this.limit.checkpoint();
|
|
2784
|
+
const pBivar = new PolynomialRef(this);
|
|
2785
|
+
const isFound = this.tryMultivarFactorCombo(
|
|
2786
|
+
polynomial,
|
|
2787
|
+
r,
|
|
2788
|
+
x,
|
|
2789
|
+
k,
|
|
2790
|
+
mainVar,
|
|
2791
|
+
degMain,
|
|
2792
|
+
liftVar,
|
|
2793
|
+
evalVars,
|
|
2794
|
+
combo,
|
|
2795
|
+
pBivar,
|
|
2796
|
+
);
|
|
2797
|
+
pBivar.reset();
|
|
2798
|
+
if (isFound) return true;
|
|
1291
2799
|
}
|
|
1292
2800
|
}
|
|
1293
2801
|
}
|
|
1294
2802
|
return false;
|
|
1295
2803
|
}
|
|
1296
2804
|
|
|
1297
|
-
private
|
|
1298
|
-
|
|
1299
|
-
|
|
1300
|
-
|
|
1301
|
-
|
|
2805
|
+
private tryMultivarFactorCombo(
|
|
2806
|
+
polynomial: Polynomial,
|
|
2807
|
+
r: Factors,
|
|
2808
|
+
x: number,
|
|
2809
|
+
k: number,
|
|
2810
|
+
mainVar: number,
|
|
2811
|
+
degMain: number,
|
|
2812
|
+
liftVar: number,
|
|
2813
|
+
evalVars: readonly number[],
|
|
2814
|
+
combo: number,
|
|
2815
|
+
pBivar: PolynomialRef,
|
|
2816
|
+
) {
|
|
2817
|
+
const nEval = evalVars.length;
|
|
2818
|
+
if (nEval > 0) {
|
|
2819
|
+
const evalValues: bigint[] = [];
|
|
2820
|
+
for (let index = 0; index < nEval; index++) {
|
|
2821
|
+
let c = combo;
|
|
2822
|
+
for (let skip = 0; skip < index; skip++) c = Math.floor(c / FACTOR_EVAL_VALUES.length);
|
|
2823
|
+
evalValues.push(FACTOR_EVAL_VALUES[c % FACTOR_EVAL_VALUES.length]);
|
|
2824
|
+
}
|
|
2825
|
+
pBivar.set(this.substitute(polynomial, evalVars, evalValues));
|
|
2826
|
+
} else pBivar.set(polynomial);
|
|
2827
|
+
if (this.degree(pBivar.get(), mainVar) !== degMain) return false;
|
|
2828
|
+
const degLift = this.degree(pBivar.get(), liftVar);
|
|
2829
|
+
if (degLift === 0) return false;
|
|
2830
|
+
for (const point of FACTOR_EVAL_VALUES) {
|
|
2831
|
+
const pUniv = new PolynomialRef(this);
|
|
2832
|
+
const pUnivRef = new PolynomialRef(this);
|
|
2833
|
+
const q = new PolynomialRef(this);
|
|
2834
|
+
const lcPoly = new PolynomialRef(this);
|
|
2835
|
+
const isFound = this.tryMultivarFactorPoint(
|
|
2836
|
+
polynomial,
|
|
2837
|
+
r,
|
|
2838
|
+
x,
|
|
2839
|
+
k,
|
|
2840
|
+
mainVar,
|
|
2841
|
+
degMain,
|
|
2842
|
+
liftVar,
|
|
2843
|
+
nEval,
|
|
2844
|
+
degLift,
|
|
2845
|
+
point,
|
|
2846
|
+
pBivar,
|
|
2847
|
+
pUniv,
|
|
2848
|
+
pUnivRef,
|
|
2849
|
+
q,
|
|
2850
|
+
lcPoly,
|
|
2851
|
+
);
|
|
2852
|
+
lcPoly.reset();
|
|
2853
|
+
q.reset();
|
|
2854
|
+
pUnivRef.reset();
|
|
2855
|
+
pUniv.reset();
|
|
2856
|
+
if (isFound) return true;
|
|
2857
|
+
}
|
|
2858
|
+
return false;
|
|
2859
|
+
}
|
|
2860
|
+
|
|
2861
|
+
private tryMultivarFactorPoint(
|
|
2862
|
+
polynomial: Polynomial,
|
|
2863
|
+
r: Factors,
|
|
2864
|
+
x: number,
|
|
2865
|
+
k: number,
|
|
2866
|
+
mainVar: number,
|
|
2867
|
+
degMain: number,
|
|
2868
|
+
liftVar: number,
|
|
2869
|
+
nEval: number,
|
|
2870
|
+
degLift: number,
|
|
2871
|
+
point: bigint,
|
|
2872
|
+
pBivar: PolynomialRef,
|
|
2873
|
+
pUniv: PolynomialRef,
|
|
2874
|
+
pUnivRef: PolynomialRef,
|
|
2875
|
+
q: PolynomialRef,
|
|
2876
|
+
lcPoly: PolynomialRef,
|
|
2877
|
+
) {
|
|
2878
|
+
pUniv.set(this.substitute(pBivar.get(), [liftVar], [point]));
|
|
2879
|
+
if (!this.isUnivariate(pUniv.get())) return false;
|
|
2880
|
+
if (this.degree(pUniv.get(), mainVar) !== degMain) return false;
|
|
2881
|
+
if (!this.isSquareFreeIn(pUniv.get(), mainVar)) return false;
|
|
2882
|
+
pUnivRef.copy(pUniv);
|
|
2883
|
+
const univariateFs = mkFactors();
|
|
2884
|
+
factorSquareFree(
|
|
2885
|
+
this.um,
|
|
2886
|
+
this.um.getPrimitive(this.toCoeffs(pUnivRef.get())),
|
|
2887
|
+
univariateFs,
|
|
2888
|
+
1,
|
|
2889
|
+
DEFAULT_FACTOR_PARAMS,
|
|
2890
|
+
);
|
|
2891
|
+
const nf = univariateFs.factors.length;
|
|
2892
|
+
if (nf <= 1) return false;
|
|
2893
|
+
q.set(this.translate(pBivar.get(), liftVar, point));
|
|
2894
|
+
lcPoly.set(this.coeff(q.get(), mainVar, degMain));
|
|
2895
|
+
let lcAtZero = 0n;
|
|
2896
|
+
if (this.isConst(lcPoly.get())) lcAtZero = lcPoly.get().as[0] ?? 0n;
|
|
2897
|
+
else {
|
|
2898
|
+
const lcEval = new PolynomialRef(this);
|
|
2899
|
+
lcEval.set(this.substitute(lcPoly.get(), [liftVar], [0n]));
|
|
2900
|
+
const isConstant = this.isConst(lcEval.get());
|
|
2901
|
+
if (isConstant) lcAtZero = lcEval.get().as[0] ?? 0n;
|
|
2902
|
+
lcEval.reset();
|
|
2903
|
+
if (!isConstant) return false;
|
|
2904
|
+
}
|
|
2905
|
+
for (const prime of FACTOR_PRIMES) {
|
|
2906
|
+
if (getGcd(prime, lcAtZero) !== 1n) continue;
|
|
2907
|
+
for (let split = 1; split <= Math.floor(nf / 2); split++) {
|
|
2908
|
+
this.limit.checkpoint();
|
|
2909
|
+
let h1 = this.um.set(univariateFs.factors[0]);
|
|
2910
|
+
for (let index = 1; index < split; index++)
|
|
2911
|
+
h1 = this.um.mul(h1, univariateFs.factors[index]);
|
|
2912
|
+
let h2 = this.um.set(univariateFs.factors[split]);
|
|
2913
|
+
for (let index = split + 1; index < nf; index++)
|
|
2914
|
+
h2 = this.um.mul(h2, univariateFs.factors[index]);
|
|
2915
|
+
if (h1.length > 0 && h1[h1.length - 1] < 0n) h1 = h1.map((coeff) => -coeff);
|
|
2916
|
+
if (h2.length > 0 && h2[h2.length - 1] < 0n) h2 = h2.map((coeff) => -coeff);
|
|
2917
|
+
const f1 = new PolynomialRef(this);
|
|
2918
|
+
const f2 = new PolynomialRef(this);
|
|
2919
|
+
const isFound =
|
|
2920
|
+
this.tryBivarHenselLift(
|
|
2921
|
+
q.get(),
|
|
2922
|
+
mainVar,
|
|
2923
|
+
liftVar,
|
|
2924
|
+
degLift,
|
|
2925
|
+
h1,
|
|
2926
|
+
h2,
|
|
2927
|
+
lcAtZero,
|
|
2928
|
+
prime,
|
|
2929
|
+
f1,
|
|
2930
|
+
f2,
|
|
2931
|
+
) && this.pushLiftedFactors(polynomial, r, x, k, nEval, liftVar, point, f1, f2);
|
|
2932
|
+
f2.reset();
|
|
2933
|
+
f1.reset();
|
|
2934
|
+
if (isFound) return true;
|
|
2935
|
+
}
|
|
2936
|
+
}
|
|
2937
|
+
return false;
|
|
1302
2938
|
}
|
|
1303
2939
|
|
|
1304
|
-
private
|
|
1305
|
-
|
|
1306
|
-
|
|
2940
|
+
private pushLiftedFactors(
|
|
2941
|
+
polynomial: Polynomial,
|
|
2942
|
+
r: Factors,
|
|
2943
|
+
x: number,
|
|
2944
|
+
k: number,
|
|
2945
|
+
nEval: number,
|
|
2946
|
+
liftVar: number,
|
|
2947
|
+
point: bigint,
|
|
2948
|
+
f1: PolynomialRef,
|
|
2949
|
+
f2: PolynomialRef,
|
|
2950
|
+
) {
|
|
2951
|
+
f1.set(this.translate(f1.get(), liftVar, -point));
|
|
2952
|
+
f2.set(this.translate(f2.get(), liftVar, -point));
|
|
2953
|
+
if (nEval === 0) {
|
|
2954
|
+
const bivarFs = [new PolynomialRef(this), new PolynomialRef(this)];
|
|
2955
|
+
bivarFs[0].copy(f1);
|
|
2956
|
+
bivarFs[1].copy(f2);
|
|
2957
|
+
for (const bf of bivarFs) {
|
|
2958
|
+
if (this.isConst(bf.get()) || this.degree(bf.get(), x) === 0) continue;
|
|
2959
|
+
this.pushSmallFactor(bf, r, x, k);
|
|
2960
|
+
}
|
|
2961
|
+
bivarFs[1].reset();
|
|
2962
|
+
bivarFs[0].reset();
|
|
2963
|
+
return true;
|
|
2964
|
+
}
|
|
2965
|
+
const cands = [new PolynomialRef(this), new PolynomialRef(this)];
|
|
2966
|
+
cands[0].copy(f1);
|
|
2967
|
+
cands[1].copy(f2);
|
|
2968
|
+
let isFound = false;
|
|
2969
|
+
for (const cand of cands) {
|
|
2970
|
+
if (this.isConst(cand.get())) continue;
|
|
2971
|
+
const qDiv = new PolynomialRef(this);
|
|
2972
|
+
const rDiv = new PolynomialRef(this);
|
|
2973
|
+
const divVar = this.maxVar(cand.get());
|
|
2974
|
+
this.exactPseudoDivision(polynomial, cand.get(), divVar, qDiv, rDiv);
|
|
2975
|
+
if (!this.isZero(rDiv.get())) {
|
|
2976
|
+
rDiv.reset();
|
|
2977
|
+
qDiv.reset();
|
|
2978
|
+
continue;
|
|
2979
|
+
}
|
|
2980
|
+
const check = new PolynomialRef(this);
|
|
2981
|
+
check.set(this.mul(cand.get(), qDiv.get()));
|
|
2982
|
+
if (this.eq(check.get(), polynomial)) {
|
|
2983
|
+
const parts = [new PolynomialRef(this), new PolynomialRef(this)];
|
|
2984
|
+
parts[0].copy(cand);
|
|
2985
|
+
parts[1].copy(qDiv);
|
|
2986
|
+
for (const part of parts) {
|
|
2987
|
+
if (this.isConst(part.get())) {
|
|
2988
|
+
r.constant *= part.get().as[0];
|
|
2989
|
+
continue;
|
|
2990
|
+
}
|
|
2991
|
+
if (this.degree(part.get(), x) === 0) continue;
|
|
2992
|
+
this.pushSmallFactor(part, r, x, k);
|
|
2993
|
+
}
|
|
2994
|
+
parts[1].reset();
|
|
2995
|
+
parts[0].reset();
|
|
2996
|
+
isFound = true;
|
|
2997
|
+
}
|
|
2998
|
+
check.reset();
|
|
2999
|
+
rDiv.reset();
|
|
3000
|
+
qDiv.reset();
|
|
3001
|
+
if (isFound) break;
|
|
3002
|
+
}
|
|
3003
|
+
cands[1].reset();
|
|
3004
|
+
cands[0].reset();
|
|
3005
|
+
return isFound;
|
|
1307
3006
|
}
|
|
1308
3007
|
|
|
1309
|
-
private
|
|
3008
|
+
private tryBivarHenselLift(
|
|
1310
3009
|
q: Polynomial,
|
|
1311
3010
|
x: number,
|
|
1312
3011
|
y: number,
|
|
1313
3012
|
degY: number,
|
|
1314
3013
|
h1: readonly bigint[],
|
|
1315
3014
|
h2: readonly bigint[],
|
|
1316
|
-
|
|
3015
|
+
lcValue: bigint,
|
|
1317
3016
|
prime: bigint,
|
|
3017
|
+
f1Out: PolynomialRef,
|
|
3018
|
+
f2Out: PolynomialRef,
|
|
1318
3019
|
) {
|
|
1319
|
-
const zp = new UpolynomialManager(prime);
|
|
3020
|
+
const zp = new UpolynomialManager(this.limit, prime);
|
|
1320
3021
|
const f1 = zp.mkMonic(zp.set(h1));
|
|
1321
3022
|
const f2 = zp.mkMonic(zp.set(h2));
|
|
1322
3023
|
const ext = zp.extGcd(f1, f2);
|
|
1323
|
-
if (ext.d.length !== 1 || ext.d[0] !== 1n) return
|
|
3024
|
+
if (ext.d.length !== 1 || ext.d[0] !== 1n) return false;
|
|
1324
3025
|
const qCoeffs: bigint[][] = [];
|
|
1325
|
-
for (let
|
|
1326
|
-
const
|
|
1327
|
-
|
|
1328
|
-
|
|
3026
|
+
for (let j = 0; j <= degY; j++) {
|
|
3027
|
+
const cj = new PolynomialRef(this);
|
|
3028
|
+
cj.set(this.coeff(q, y, j));
|
|
3029
|
+
const isBivariate = this.isZero(cj.get()) || this.isUnivariate(cj.get());
|
|
3030
|
+
if (isBivariate) qCoeffs.push(zp.set(this.isZero(cj.get()) ? [] : this.toCoeffs(cj.get())));
|
|
3031
|
+
cj.reset();
|
|
3032
|
+
if (!isBivariate) return false;
|
|
1329
3033
|
}
|
|
1330
3034
|
const f1Coeffs: bigint[][] = Array.from({ length: degY + 1 }, () => []);
|
|
1331
3035
|
const f2Coeffs: bigint[][] = Array.from({ length: degY + 1 }, () => []);
|
|
1332
3036
|
f1Coeffs[0] = zp.set(f1);
|
|
1333
|
-
f2Coeffs[0] = zp.mulConst(f2, zp.normalizeNumeral(
|
|
1334
|
-
const lcInv = zp.inv(
|
|
1335
|
-
for (let
|
|
1336
|
-
|
|
1337
|
-
|
|
1338
|
-
|
|
1339
|
-
|
|
3037
|
+
f2Coeffs[0] = zp.mulConst(zp.set(f2), zp.normalizeNumeral(lcValue));
|
|
3038
|
+
const lcInv = zp.inv(lcValue);
|
|
3039
|
+
for (let j = 1; j <= degY; j++) {
|
|
3040
|
+
this.limit.checkpoint();
|
|
3041
|
+
let e = zp.set(qCoeffs[j]);
|
|
3042
|
+
for (let first = 0; first <= j; first++) {
|
|
3043
|
+
const second = j - first;
|
|
3044
|
+
if (second > degY) continue;
|
|
3045
|
+
if (first === j && second === 0) continue;
|
|
3046
|
+
if (first === 0 && second === j) continue;
|
|
1340
3047
|
if (f1Coeffs[first].length === 0 || f2Coeffs[second].length === 0) continue;
|
|
1341
|
-
|
|
1342
|
-
}
|
|
1343
|
-
if (error.length === 0) continue;
|
|
1344
|
-
const a = zp.divRem(zp.mul(error, ext.v), f1).remainder;
|
|
1345
|
-
const b = zp.divRem(zp.mul(error, ext.u), f2).remainder;
|
|
1346
|
-
f1Coeffs[power] = zp.mulConst(a, lcInv);
|
|
1347
|
-
f2Coeffs[power] = zp.set(b);
|
|
1348
|
-
}
|
|
1349
|
-
const toPolynomial = (coeffs: readonly bigint[][]) => {
|
|
1350
|
-
let result = this.zero;
|
|
1351
|
-
for (let power = 0; power <= degY; power++) {
|
|
1352
|
-
if (coeffs[power].length === 0) continue;
|
|
1353
|
-
const univariate = this.fromCoeffs(coeffs[power], x);
|
|
1354
|
-
if (univariate.size === 0) continue;
|
|
1355
|
-
result = this.add(result, this.mulTerm(1n, this.mkPower(y, power), univariate));
|
|
3048
|
+
e = zp.sub(e, zp.mul(f1Coeffs[first], f2Coeffs[second]));
|
|
1356
3049
|
}
|
|
1357
|
-
|
|
1358
|
-
|
|
1359
|
-
|
|
1360
|
-
|
|
1361
|
-
|
|
1362
|
-
}
|
|
1363
|
-
|
|
1364
|
-
pscChain(first: Polynomial, second: Polynomial, variable: number) {
|
|
1365
|
-
const chain =
|
|
1366
|
-
this.degree(first, variable) >= this.degree(second, variable)
|
|
1367
|
-
? this.pscChainCore(first, second, variable)
|
|
1368
|
-
: this.pscChainCore(second, first, variable);
|
|
1369
|
-
return chain.length === 0 ? [this.zero] : chain.reverse();
|
|
1370
|
-
}
|
|
1371
|
-
|
|
1372
|
-
private pscChainCore(p: Polynomial, q: Polynomial, x: number) {
|
|
1373
|
-
const chain: Polynomial[] = [];
|
|
1374
|
-
let s = this.pw(this.lc(q, x), this.degree(p, x) - this.degree(q, x));
|
|
1375
|
-
let a = q;
|
|
1376
|
-
let b = this.exactPseudoRemainder(p, this.neg(q), x);
|
|
1377
|
-
while (b.size > 0) {
|
|
1378
|
-
const d = this.degree(a, x);
|
|
1379
|
-
const e = this.degree(b, x);
|
|
1380
|
-
const principal = this.coeff(b, x, d - 1);
|
|
1381
|
-
if (principal.size > 0) chain.push(principal);
|
|
1382
|
-
let c = b;
|
|
1383
|
-
if (d - e > 1) {
|
|
1384
|
-
c = this.getSeLazard(d, s, b, x);
|
|
1385
|
-
const principalE = this.coeff(c, x, e);
|
|
1386
|
-
if (principalE.size > 0) chain.push(principalE);
|
|
1387
|
-
}
|
|
1388
|
-
if (e === 0) break;
|
|
1389
|
-
b = this.getOptimizedSe1(d, e, a, b, c, s, x);
|
|
1390
|
-
a = c;
|
|
1391
|
-
s = this.lc(a, x);
|
|
3050
|
+
if (e.length === 0) continue;
|
|
3051
|
+
const a = zp.divRem(zp.mul(e, ext.v), f1).remainder;
|
|
3052
|
+
const b = zp.divRem(zp.mul(e, ext.u), f2).remainder;
|
|
3053
|
+
f1Coeffs[j] = zp.mulConst(a, lcInv);
|
|
3054
|
+
f2Coeffs[j] = zp.set(b);
|
|
1392
3055
|
}
|
|
1393
|
-
return
|
|
3056
|
+
return this.reconstructLiftedFactors(q, x, y, degY, f1Coeffs, f2Coeffs, f1Out, f2Out);
|
|
1394
3057
|
}
|
|
1395
3058
|
|
|
1396
|
-
private
|
|
1397
|
-
|
|
1398
|
-
|
|
1399
|
-
|
|
1400
|
-
|
|
1401
|
-
|
|
1402
|
-
|
|
1403
|
-
|
|
1404
|
-
|
|
1405
|
-
|
|
1406
|
-
|
|
1407
|
-
|
|
1408
|
-
|
|
3059
|
+
private reconstructLiftedFactors(
|
|
3060
|
+
q: Polynomial,
|
|
3061
|
+
x: number,
|
|
3062
|
+
y: number,
|
|
3063
|
+
degY: number,
|
|
3064
|
+
f1Coeffs: readonly bigint[][],
|
|
3065
|
+
f2Coeffs: readonly bigint[][],
|
|
3066
|
+
f1Out: PolynomialRef,
|
|
3067
|
+
f2Out: PolynomialRef,
|
|
3068
|
+
) {
|
|
3069
|
+
const f1Poly = new PolynomialRef(this);
|
|
3070
|
+
const f2Poly = new PolynomialRef(this);
|
|
3071
|
+
f1Poly.set(this.zero);
|
|
3072
|
+
f2Poly.set(this.zero);
|
|
3073
|
+
const addTerm = (coeffs: readonly bigint[], power: number, target: PolynomialRef) => {
|
|
3074
|
+
if (coeffs.length === 0) return;
|
|
3075
|
+
const univ = new PolynomialRef(this);
|
|
3076
|
+
univ.set(this.toPolynomial(coeffs, x));
|
|
3077
|
+
if (!this.isZero(univ.get())) {
|
|
3078
|
+
const term = new PolynomialRef(this);
|
|
3079
|
+
term.set(this.mulTerm(1n, this.mkPower(y, power), univ.get()));
|
|
3080
|
+
target.set(this.add(target.get(), term.get()));
|
|
3081
|
+
term.reset();
|
|
1409
3082
|
}
|
|
3083
|
+
univ.reset();
|
|
3084
|
+
};
|
|
3085
|
+
for (let j = 0; j <= degY; j++) {
|
|
3086
|
+
addTerm(f1Coeffs[j], j, f1Poly);
|
|
3087
|
+
addTerm(f2Coeffs[j], j, f2Poly);
|
|
1410
3088
|
}
|
|
1411
|
-
|
|
3089
|
+
const product = new PolynomialRef(this);
|
|
3090
|
+
product.set(this.mul(f1Poly.get(), f2Poly.get()));
|
|
3091
|
+
const isEqual = this.eq(product.get(), q);
|
|
3092
|
+
if (isEqual) {
|
|
3093
|
+
f1Out.copy(f1Poly);
|
|
3094
|
+
f2Out.copy(f2Poly);
|
|
3095
|
+
}
|
|
3096
|
+
product.reset();
|
|
3097
|
+
f2Poly.reset();
|
|
3098
|
+
f1Poly.reset();
|
|
3099
|
+
return isEqual;
|
|
1412
3100
|
}
|
|
1413
3101
|
|
|
1414
|
-
|
|
1415
|
-
|
|
1416
|
-
|
|
1417
|
-
|
|
1418
|
-
sd1: Polynomial,
|
|
1419
|
-
se: Polynomial,
|
|
1420
|
-
s: Polynomial,
|
|
1421
|
-
x: number,
|
|
1422
|
-
) {
|
|
1423
|
-
const cd1 = this.lc(sd1, x);
|
|
1424
|
-
const lcSe = this.lc(se, x);
|
|
1425
|
-
const getPower = (power: number) => (power === 0 ? this.one : this.mkVar(x, power));
|
|
1426
|
-
const h: Polynomial[] = [];
|
|
1427
|
-
for (let j = 0; j < e; j++) h.push(this.mul(lcSe, getPower(j)));
|
|
1428
|
-
h.push(this.sub(this.mul(lcSe, getPower(e)), se));
|
|
1429
|
-
const xPolynomial = this.mkVar(x);
|
|
1430
|
-
for (let j = e + 1; j < d; j++) {
|
|
1431
|
-
const xh = this.mul(xPolynomial, h[j - 1]);
|
|
1432
|
-
h.push(this.sub(xh, this.exactDiv(this.mul(this.coeff(xh, x, e), sd1), cd1)));
|
|
1433
|
-
}
|
|
1434
|
-
let sum = this.zero;
|
|
1435
|
-
for (let j = 0; j < d; j++) sum = this.add(sum, this.mul(this.coeff(a, x, j), h[j]));
|
|
1436
|
-
const dPolynomial = this.exactDiv(sum, this.lc(a, x));
|
|
1437
|
-
const xh = this.mul(xPolynomial, h[d - 1]);
|
|
1438
|
-
const result = this.exactDiv(
|
|
1439
|
-
this.sub(this.mul(cd1, this.add(xh, dPolynomial)), this.mul(this.coeff(xh, x, e), sd1)),
|
|
1440
|
-
s,
|
|
1441
|
-
);
|
|
1442
|
-
return (d - e + 1) % 2 === 1 ? this.neg(result) : result;
|
|
3102
|
+
evaluateWith<T>(polynomial: Polynomial, ops: ValueOps<T>, getValue: (variable: number) => T) {
|
|
3103
|
+
const result = this.evaluatePartially(polynomial, ops, getValue);
|
|
3104
|
+
if (result === null) throw new SmtInvariantError("a total evaluation stopped early");
|
|
3105
|
+
return result;
|
|
1443
3106
|
}
|
|
1444
3107
|
|
|
1445
|
-
|
|
3108
|
+
private evaluatePartially<T>(
|
|
3109
|
+
polynomial: Polynomial,
|
|
3110
|
+
ops: ValueOps<T>,
|
|
3111
|
+
getValue: (variable: number) => T | null,
|
|
3112
|
+
) {
|
|
1446
3113
|
if (polynomial.size === 0) return ops.fromInteger(0n);
|
|
1447
3114
|
if (this.isConst(polynomial)) return ops.fromInteger(polynomial.as[0]);
|
|
1448
3115
|
polynomial.lexSort();
|
|
@@ -1459,34 +3126,38 @@ export class PolynomialManager {
|
|
|
1459
3126
|
private evaluateCore<T>(
|
|
1460
3127
|
polynomial: Polynomial,
|
|
1461
3128
|
ops: ValueOps<T>,
|
|
1462
|
-
getValue: (variable: number) => T,
|
|
3129
|
+
getValue: (variable: number) => T | null,
|
|
1463
3130
|
start: number,
|
|
1464
3131
|
end: number,
|
|
1465
3132
|
x: number,
|
|
1466
|
-
): T {
|
|
3133
|
+
): T | null {
|
|
1467
3134
|
if (end === start + 1) {
|
|
1468
3135
|
let result = ops.fromInteger(polynomial.as[start]);
|
|
1469
3136
|
const monomial = polynomial.ms[start];
|
|
1470
3137
|
for (let index = 0; index < monomial.size; index++) {
|
|
1471
3138
|
const variable = monomial.vars[index];
|
|
1472
3139
|
if (variable > x) break;
|
|
1473
|
-
|
|
3140
|
+
const value = getValue(variable);
|
|
3141
|
+
if (value === null) return null;
|
|
3142
|
+
result = ops.mul(result, ops.power(value, monomial.degrees[index]));
|
|
1474
3143
|
}
|
|
1475
3144
|
return result;
|
|
1476
3145
|
}
|
|
1477
3146
|
const value = getValue(x);
|
|
3147
|
+
if (value === null) return null;
|
|
1478
3148
|
let result = ops.fromInteger(0n);
|
|
1479
3149
|
let index = start;
|
|
1480
3150
|
while (index < end) {
|
|
3151
|
+
this.limit.checkpoint();
|
|
1481
3152
|
const degree = polynomial.ms[index].degreeOf(x);
|
|
1482
3153
|
if (degree === 0) {
|
|
1483
3154
|
const below = this.maxSmallerThan(polynomial, index, end, x);
|
|
1484
|
-
|
|
1485
|
-
result,
|
|
3155
|
+
const rest =
|
|
1486
3156
|
below === NULL_VAR
|
|
1487
3157
|
? ops.fromInteger(polynomial.as[index])
|
|
1488
|
-
: this.evaluateCore(polynomial, ops, getValue, index, end, below)
|
|
1489
|
-
);
|
|
3158
|
+
: this.evaluateCore(polynomial, ops, getValue, index, end, below);
|
|
3159
|
+
if (rest === null) return null;
|
|
3160
|
+
result = ops.add(result, rest);
|
|
1490
3161
|
break;
|
|
1491
3162
|
}
|
|
1492
3163
|
let next = index + 1;
|
|
@@ -1499,13 +3170,12 @@ export class PolynomialManager {
|
|
|
1499
3170
|
}
|
|
1500
3171
|
}
|
|
1501
3172
|
const below = this.maxSmallerThan(polynomial, index, next, x);
|
|
1502
|
-
|
|
1503
|
-
result,
|
|
3173
|
+
const coeff =
|
|
1504
3174
|
below === NULL_VAR
|
|
1505
3175
|
? ops.fromInteger(polynomial.as[index])
|
|
1506
|
-
: this.evaluateCore(polynomial, ops, getValue, index, next, below)
|
|
1507
|
-
);
|
|
1508
|
-
result = ops.mul(result, ops.power(value, degree - nextDegree));
|
|
3176
|
+
: this.evaluateCore(polynomial, ops, getValue, index, next, below);
|
|
3177
|
+
if (coeff === null) return null;
|
|
3178
|
+
result = ops.mul(ops.add(result, coeff), ops.power(value, degree - nextDegree));
|
|
1509
3179
|
index = next;
|
|
1510
3180
|
}
|
|
1511
3181
|
return result;
|
|
@@ -1518,66 +3188,88 @@ export class PolynomialManager {
|
|
|
1518
3188
|
return max;
|
|
1519
3189
|
}
|
|
1520
3190
|
|
|
1521
|
-
|
|
1522
|
-
|
|
1523
|
-
|
|
1524
|
-
|
|
1525
|
-
|
|
1526
|
-
|
|
1527
|
-
|
|
1528
|
-
|
|
1529
|
-
getSign(polynomial: Polynomial, values: readonly (Rational | undefined)[]) {
|
|
1530
|
-
const value = this.evaluate(polynomial, values);
|
|
1531
|
-
return value.isZero() ? 0 : value.isPositive() ? 1 : -1;
|
|
3191
|
+
getRationalSign(polynomial: Polynomial, values: readonly (Rational | undefined)[]) {
|
|
3192
|
+
const value = this.evaluatePartially(
|
|
3193
|
+
polynomial,
|
|
3194
|
+
RATIONAL_OPS,
|
|
3195
|
+
(variable) => values[variable] ?? null,
|
|
3196
|
+
);
|
|
3197
|
+
return value === null ? null : value.isZero() ? 0 : value.isPositive() ? 1 : -1;
|
|
1532
3198
|
}
|
|
1533
3199
|
}
|
|
1534
3200
|
|
|
1535
3201
|
export class PolynomialCache {
|
|
1536
3202
|
private table = new Map<string, Polynomial>();
|
|
1537
|
-
private
|
|
3203
|
+
private cachedPolys: PolynomialRefVector;
|
|
3204
|
+
private inCache: boolean[] = [];
|
|
1538
3205
|
private pscChains = new Map<string, Polynomial[]>();
|
|
1539
3206
|
private factorizations = new Map<number, Polynomial[]>();
|
|
1540
3207
|
|
|
1541
|
-
constructor(readonly pm: PolynomialManager) {
|
|
3208
|
+
constructor(readonly pm: PolynomialManager) {
|
|
3209
|
+
this.cachedPolys = new PolynomialRefVector(pm);
|
|
3210
|
+
}
|
|
1542
3211
|
|
|
1543
3212
|
reset() {
|
|
1544
3213
|
this.table.clear();
|
|
1545
|
-
this.inCache.clear();
|
|
1546
3214
|
this.pscChains.clear();
|
|
1547
3215
|
this.factorizations.clear();
|
|
3216
|
+
this.inCache = [];
|
|
3217
|
+
this.cachedPolys.reset();
|
|
1548
3218
|
}
|
|
1549
3219
|
|
|
1550
3220
|
mkUnique(polynomial: Polynomial) {
|
|
1551
|
-
if (this.inCache
|
|
3221
|
+
if (this.inCache[polynomial.id] === true) return polynomial;
|
|
1552
3222
|
const key = this.pm.getKey(polynomial);
|
|
1553
3223
|
const existing = this.table.get(key);
|
|
1554
3224
|
if (existing !== undefined) return existing;
|
|
1555
3225
|
this.table.set(key, polynomial);
|
|
1556
|
-
this.
|
|
3226
|
+
this.cachedPolys.push(polynomial);
|
|
3227
|
+
this.inCache[polynomial.id] = true;
|
|
1557
3228
|
return polynomial;
|
|
1558
3229
|
}
|
|
1559
3230
|
|
|
1560
3231
|
contains(polynomial: Polynomial) {
|
|
1561
|
-
return this.inCache
|
|
3232
|
+
return this.inCache[polynomial.id] === true;
|
|
1562
3233
|
}
|
|
1563
3234
|
|
|
1564
|
-
pscChain(first: Polynomial, second: Polynomial, variable: number) {
|
|
3235
|
+
pscChain(first: Polynomial, second: Polynomial, variable: number, chain: PolynomialRefVector) {
|
|
1565
3236
|
const p = this.mkUnique(first);
|
|
1566
3237
|
const q = this.mkUnique(second);
|
|
1567
3238
|
const key = `${p.id},${q.id},${variable}`;
|
|
1568
3239
|
const cached = this.pscChains.get(key);
|
|
1569
|
-
if (cached !== undefined)
|
|
1570
|
-
|
|
1571
|
-
|
|
1572
|
-
|
|
1573
|
-
|
|
1574
|
-
|
|
1575
|
-
|
|
1576
|
-
|
|
1577
|
-
|
|
1578
|
-
|
|
1579
|
-
|
|
1580
|
-
|
|
1581
|
-
|
|
3240
|
+
if (cached !== undefined) {
|
|
3241
|
+
chain.reset();
|
|
3242
|
+
for (const element of cached) chain.push(element);
|
|
3243
|
+
return;
|
|
3244
|
+
}
|
|
3245
|
+
this.pm.pscChain(p, q, variable, chain);
|
|
3246
|
+
const result: Polynomial[] = [];
|
|
3247
|
+
for (let index = 0; index < chain.size; index++) {
|
|
3248
|
+
const unique = this.mkUnique(chain.get(index));
|
|
3249
|
+
chain.set(index, unique);
|
|
3250
|
+
result.push(unique);
|
|
3251
|
+
}
|
|
3252
|
+
this.pscChains.set(key, result);
|
|
3253
|
+
}
|
|
3254
|
+
|
|
3255
|
+
factor(polynomial: Polynomial, distinctFactors: PolynomialRefVector) {
|
|
3256
|
+
distinctFactors.reset();
|
|
3257
|
+
const p = this.mkUnique(polynomial);
|
|
3258
|
+
const cached = this.factorizations.get(p.id);
|
|
3259
|
+
if (cached !== undefined) {
|
|
3260
|
+
distinctFactors.reset();
|
|
3261
|
+
for (const factor of cached) distinctFactors.push(factor);
|
|
3262
|
+
return;
|
|
3263
|
+
}
|
|
3264
|
+
const fs = new Factors(this.pm);
|
|
3265
|
+
this.pm.factor(p, fs);
|
|
3266
|
+
const result: Polynomial[] = [];
|
|
3267
|
+
for (const factor of fs.factors) {
|
|
3268
|
+
const unique = this.mkUnique(factor);
|
|
3269
|
+
distinctFactors.push(unique);
|
|
3270
|
+
result.push(unique);
|
|
3271
|
+
}
|
|
3272
|
+
this.factorizations.set(p.id, result);
|
|
3273
|
+
fs.reset();
|
|
1582
3274
|
}
|
|
1583
3275
|
}
|