tla-ts 0.0.4-dev.a297123 → 0.0.4-dev.c4929d7
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 +27 -141
- package/dist/deciders.cjs +366 -0
- package/dist/deciders.js +366 -0
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +35 -1
- package/dist/index.d.ts +35 -1
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -4
- package/dist/parallel-worker.js +1 -4
- package/dist/prove-worker.cjs +9 -0
- package/dist/prove-worker.d.cts +9 -0
- package/dist/prove-worker.d.ts +9 -0
- package/dist/prove-worker.js +9 -0
- package/dist/prove.cjs +996 -0
- package/dist/prove.js +996 -0
- package/dist/run-cli.cjs +37 -47
- package/dist/run-cli.js +37 -47
- package/dist/tlapm.cjs +10 -0
- package/dist/tlapm.js +10 -0
- package/dist/transfer.cjs +38 -44
- package/dist/transfer.js +38 -44
- package/dist/worker.cjs +21 -0
- package/dist/worker.js +21 -0
- package/package.json +21 -12
- package/src/check.ts +1 -0
- package/src/codegen.ts +5 -3
- package/src/errors.ts +86 -0
- package/src/evaluate.ts +54 -19
- package/src/index.ts +10 -0
- package/src/{obligation-action.ts → obligations/action.ts} +265 -55
- package/src/{obligation-anon.ts → obligations/anon.ts} +47 -37
- package/src/obligations/ctx.ts +64 -0
- package/src/{obligation-deref.ts → obligations/deref.ts} +38 -61
- package/src/{obligation-expression.ts → obligations/expression.ts} +78 -45
- package/src/{obligation-format.ts → obligations/format.ts} +7 -8
- package/src/{obligation-generate.ts → obligations/generate.ts} +147 -74
- package/src/{obligations.ts → obligations/index.ts} +29 -13
- package/src/{obligation-levels.ts → obligations/levels.ts} +14 -5
- package/src/{obligation-module.ts → obligations/module.ts} +56 -33
- package/src/obligations/pickle.ts +98 -0
- package/src/obligations/pragma.ts +189 -0
- package/src/{obligation-printer.ts → obligations/printer.ts} +22 -80
- package/src/{obligation-proof.ts → obligations/proof.ts} +7 -1
- package/src/{obligation-source.ts → obligations/source.ts} +159 -97
- package/src/obligations/temporal.ts +319 -0
- package/src/{obligation-tuples.ts → obligations/tuples.ts} +1 -1
- package/src/ocaml-marshal.ts +166 -0
- package/src/parallel-worker.ts +2 -18
- package/src/parallel.ts +10 -43
- package/src/prove/decide-pool.ts +100 -0
- package/src/prove/deciders.ts +33 -0
- package/src/prove/isabelle/LICENSE +36 -0
- package/src/prove/isabelle/LICENSE-tlapm +26 -0
- package/src/prove/isabelle/decide.ts +47 -0
- package/src/prove/isabelle/encode.ts +503 -0
- package/src/prove/isabelle/isar/inner-syntax.ts +579 -0
- package/src/prove/isabelle/isar/method.ts +367 -0
- package/src/prove/isabelle/isar/proof.ts +28 -0
- package/src/prove/isabelle/isar/statement.ts +57 -0
- package/src/prove/isabelle/isar/theory.ts +192 -0
- package/src/prove/isabelle/isar/type-check.ts +278 -0
- package/src/prove/isabelle/provers/blast/blast.ts +258 -0
- package/src/prove/isabelle/provers/blast/branch.ts +322 -0
- package/src/prove/isabelle/provers/blast/prove.ts +347 -0
- package/src/prove/isabelle/provers/blast/rules.ts +330 -0
- package/src/prove/isabelle/provers/blast/state.ts +180 -0
- package/src/prove/isabelle/provers/blast/term.ts +547 -0
- package/src/prove/isabelle/provers/clasimp.ts +150 -0
- package/src/prove/isabelle/provers/classical.ts +389 -0
- package/src/prove/isabelle/provers/hypsubst.ts +441 -0
- package/src/prove/isabelle/pure/bicompose.ts +174 -0
- package/src/prove/isabelle/pure/consts.ts +32 -0
- package/src/prove/isabelle/pure/conv.ts +79 -0
- package/src/prove/isabelle/pure/drule.ts +264 -0
- package/src/prove/isabelle/pure/envir.ts +363 -0
- package/src/prove/isabelle/pure/goal.ts +53 -0
- package/src/prove/isabelle/pure/interrupt.ts +16 -0
- package/src/prove/isabelle/pure/list.ts +12 -0
- package/src/prove/isabelle/pure/logic.ts +402 -0
- package/src/prove/isabelle/pure/name.ts +110 -0
- package/src/prove/isabelle/pure/net.ts +262 -0
- package/src/prove/isabelle/pure/object-logic.ts +41 -0
- package/src/prove/isabelle/pure/pattern.ts +650 -0
- package/src/prove/isabelle/pure/raw-simplifier.ts +353 -0
- package/src/prove/isabelle/pure/rewriter.ts +602 -0
- package/src/prove/isabelle/pure/search.ts +68 -0
- package/src/prove/isabelle/pure/seq.ts +156 -0
- package/src/prove/isabelle/pure/simplifier.ts +112 -0
- package/src/prove/isabelle/pure/table.ts +208 -0
- package/src/prove/isabelle/pure/tactic.ts +276 -0
- package/src/prove/isabelle/pure/tactical.ts +347 -0
- package/src/prove/isabelle/pure/term-ord.ts +159 -0
- package/src/prove/isabelle/pure/term.ts +808 -0
- package/src/prove/isabelle/pure/thm.ts +806 -0
- package/src/prove/isabelle/pure/type.ts +133 -0
- package/src/prove/isabelle/pure/unify.ts +753 -0
- package/src/prove/isabelle/pure/variable.ts +25 -0
- package/src/prove/isabelle/tla/classical-setup.ts +101 -0
- package/src/prove/isabelle/tla/context.ts +74 -0
- package/src/prove/isabelle/tla/logic-data.ts +5 -0
- package/src/prove/isabelle/tla/logic.ts +215 -0
- package/src/prove/isabelle/tla/simpdata.ts +241 -0
- package/src/prove/isabelle/tools/intuitionistic.ts +132 -0
- package/src/prove/ocaml.ts +22 -0
- package/src/prove/prep/action.ts +521 -0
- package/src/prove/prep/defs.ts +33 -0
- package/src/prove/prep/elab.ts +156 -0
- package/src/prove/prep/enabled-axioms.ts +189 -0
- package/src/prove/prep/enabled.ts +43 -0
- package/src/prove/prep/fingerprint.ts +388 -0
- package/src/prove/prep/flatten.ts +70 -0
- package/src/prove/prep/level-comparison.ts +557 -0
- package/src/prove/prep/md5.ts +67 -0
- package/src/prove/prep/pragma.ts +221 -0
- package/src/prove/prep/trivial.ts +22 -0
- package/src/prove/prove-worker.ts +25 -0
- package/src/prove/prove.ts +505 -0
- package/src/prove/ptl/decide.ts +68 -0
- package/src/prove/ptl/encode.ts +256 -0
- package/src/prove/ptl/sat.ts +151 -0
- package/src/prove/ptl/tableau.ts +276 -0
- package/src/prove/smt/axiomatize.ts +69 -0
- package/src/prove/smt/axioms.ts +222 -0
- package/src/prove/smt/context.ts +108 -0
- package/src/prove/smt/data.ts +636 -0
- package/src/prove/smt/encode.ts +166 -0
- package/src/prove/smt/extensionality.ts +65 -0
- package/src/prove/smt/flatten.ts +112 -0
- package/src/prove/smt/format.ts +154 -0
- package/src/prove/smt/instances.ts +182 -0
- package/src/prove/smt/rewrite.ts +773 -0
- package/src/prove/smt/simplify.ts +57 -0
- package/src/prove/smt/solver/act-cache.ts +265 -0
- package/src/prove/smt/solver/arith-rewriter.ts +962 -0
- package/src/prove/smt/solver/array.ts +22 -0
- package/src/prove/smt/solver/asserted-formulas.ts +469 -0
- package/src/prove/smt/solver/ast-lt.ts +157 -0
- package/src/prove/smt/solver/ast-util.ts +147 -0
- package/src/prove/smt/solver/ast.ts +1315 -0
- package/src/prove/smt/solver/auf-solver.ts +572 -0
- package/src/prove/smt/solver/case-split-queue.ts +178 -0
- package/src/prove/smt/solver/cg-table.ts +175 -0
- package/src/prove/smt/solver/clause.ts +276 -0
- package/src/prove/smt/solver/conflict-resolution.ts +343 -0
- package/src/prove/smt/solver/context.ts +1292 -0
- package/src/prove/smt/solver/ctx-simplify.ts +334 -0
- package/src/prove/smt/solver/der.ts +224 -0
- package/src/prove/smt/solver/dyn-ack.ts +141 -0
- package/src/prove/smt/solver/e-matching.ts +659 -0
- package/src/prove/smt/solver/enode.ts +259 -0
- package/src/prove/smt/solver/expr-ref.ts +21 -0
- package/src/prove/smt/solver/expr-safe-replace.ts +172 -0
- package/src/prove/smt/solver/fingerprints.ts +92 -0
- package/src/prove/smt/solver/flat-literals.ts +51 -0
- package/src/prove/smt/solver/goal.ts +138 -0
- package/src/prove/smt/solver/hash.ts +173 -0
- package/src/prove/smt/solver/hashtable.ts +166 -0
- package/src/prove/smt/solver/internalizer.ts +1381 -0
- package/src/prove/smt/solver/lbool.ts +5 -0
- package/src/prove/smt/solver/literal.ts +24 -0
- package/src/prove/smt/solver/lp/bound-propagator.ts +391 -0
- package/src/prove/smt/solver/lp/constraints.ts +78 -0
- package/src/prove/smt/solver/lp/containers.ts +296 -0
- package/src/prove/smt/solver/lp/core-solver.ts +504 -0
- package/src/prove/smt/solver/lp/cross-nested.ts +224 -0
- package/src/prove/smt/solver/lp/dep-intervals.ts +656 -0
- package/src/prove/smt/solver/lp/dependency.ts +51 -0
- package/src/prove/smt/solver/lp/dioph-eq.ts +1181 -0
- package/src/prove/smt/solver/lp/explanation.ts +46 -0
- package/src/prove/smt/solver/lp/gomory.ts +255 -0
- package/src/prove/smt/solver/lp/hnf-cutter.ts +125 -0
- package/src/prove/smt/solver/lp/hnf.ts +281 -0
- package/src/prove/smt/solver/lp/int-cube.ts +295 -0
- package/src/prove/smt/solver/lp/int-solver.ts +514 -0
- package/src/prove/smt/solver/lp/lar-solver.ts +816 -0
- package/src/prove/smt/solver/lp/lar-term.ts +62 -0
- package/src/prove/smt/solver/lp/lp-settings.ts +91 -0
- package/src/prove/smt/solver/lp/maximize-term.ts +347 -0
- package/src/prove/smt/solver/lp/nex-creator.ts +381 -0
- package/src/prove/smt/solver/lp/nex.ts +120 -0
- package/src/prove/smt/solver/lp/nla-backoff.ts +43 -0
- package/src/prove/smt/solver/lp/nla-basics.ts +398 -0
- package/src/prove/smt/solver/lp/nla-core.ts +968 -0
- package/src/prove/smt/solver/lp/nla-divisions.ts +332 -0
- package/src/prove/smt/solver/lp/nla-emonics.ts +373 -0
- package/src/prove/smt/solver/lp/nla-factorization.ts +30 -0
- package/src/prove/smt/solver/lp/nla-grobner.ts +904 -0
- package/src/prove/smt/solver/lp/nla-horner.ts +126 -0
- package/src/prove/smt/solver/lp/nla-intervals.ts +265 -0
- package/src/prove/smt/solver/lp/nla-monomial-bounds.ts +715 -0
- package/src/prove/smt/solver/lp/nla-monotone.ts +59 -0
- package/src/prove/smt/solver/lp/nla-order.ts +307 -0
- package/src/prove/smt/solver/lp/nla-patcher.ts +112 -0
- package/src/prove/smt/solver/lp/nla-tangents.ts +251 -0
- package/src/prove/smt/solver/lp/nla-throttle.ts +85 -0
- package/src/prove/smt/solver/lp/nla-types.ts +124 -0
- package/src/prove/smt/solver/lp/nla-var-eqs.ts +141 -0
- package/src/prove/smt/solver/lp/nra-solver.ts +440 -0
- package/src/prove/smt/solver/lp/numeric-pair.ts +65 -0
- package/src/prove/smt/solver/lp/pdd-interval.ts +31 -0
- package/src/prove/smt/solver/lp/pdd-simplifier.ts +184 -0
- package/src/prove/smt/solver/lp/pdd-solver.ts +408 -0
- package/src/prove/smt/solver/lp/pdd.ts +971 -0
- package/src/prove/smt/solver/lp/random-updater.ts +138 -0
- package/src/prove/smt/solver/lp/static-matrix.ts +246 -0
- package/src/prove/smt/solver/lp/union-find.ts +96 -0
- package/src/prove/smt/solver/mam-compiler.ts +847 -0
- package/src/prove/smt/solver/mam-interpreter.ts +400 -0
- package/src/prove/smt/solver/maximize-ac-sharing.ts +118 -0
- package/src/prove/smt/solver/model-checker.ts +347 -0
- package/src/prove/smt/solver/model-evaluator.ts +262 -0
- package/src/prove/smt/solver/model-finder.ts +155 -0
- package/src/prove/smt/solver/model-generator.ts +97 -0
- package/src/prove/smt/solver/model-macro-solver.ts +728 -0
- package/src/prove/smt/solver/nlsat/algebraic.ts +1161 -0
- package/src/prove/smt/solver/nlsat/atoms.ts +238 -0
- package/src/prove/smt/solver/nlsat/evaluator.ts +303 -0
- package/src/prove/smt/solver/nlsat/explain.ts +607 -0
- package/src/prove/smt/solver/nlsat/interval-set.ts +351 -0
- package/src/prove/smt/solver/nlsat/levelwise.ts +740 -0
- package/src/prove/smt/solver/nlsat/mpbq.ts +161 -0
- package/src/prove/smt/solver/nlsat/polynomial.ts +1722 -0
- package/src/prove/smt/solver/nlsat/solver.ts +911 -0
- package/src/prove/smt/solver/nlsat/types.ts +43 -0
- package/src/prove/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
- package/src/prove/smt/solver/nlsat/upolynomial.ts +996 -0
- package/src/prove/smt/solver/nnf.ts +469 -0
- package/src/prove/smt/solver/pattern-inference.ts +351 -0
- package/src/prove/smt/solver/poly-rewriter.ts +477 -0
- package/src/prove/smt/solver/propagate-values.ts +83 -0
- package/src/prove/smt/solver/proto-model.ts +551 -0
- package/src/prove/smt/solver/pull-quant.ts +139 -0
- package/src/prove/smt/solver/qe-lite-der.ts +526 -0
- package/src/prove/smt/solver/qe-lite-fm.ts +576 -0
- package/src/prove/smt/solver/qe-lite.ts +381 -0
- package/src/prove/smt/solver/qi-queue.ts +362 -0
- package/src/prove/smt/solver/quant-tactics.ts +117 -0
- package/src/prove/smt/solver/quantifier-analyzer.ts +562 -0
- package/src/prove/smt/solver/quantifier-manager.ts +186 -0
- package/src/prove/smt/solver/random-gen.ts +10 -0
- package/src/prove/smt/solver/rational.ts +165 -0
- package/src/prove/smt/solver/ref-vector.ts +62 -0
- package/src/prove/smt/solver/relevancy.ts +247 -0
- package/src/prove/smt/solver/rewriter-tpl.ts +1159 -0
- package/src/prove/smt/solver/rewriter.ts +843 -0
- package/src/prove/smt/solver/rlimit.ts +79 -0
- package/src/prove/smt/solver/smtlib-parser.ts +526 -0
- package/src/prove/smt/solver/solver.ts +71 -0
- package/src/prove/smt/solver/sort.ts +35 -0
- package/src/prove/smt/solver/sticky-generations.ts +69 -0
- package/src/prove/smt/solver/theory-lra-axioms.ts +340 -0
- package/src/prove/smt/solver/theory-lra-bounds.ts +226 -0
- package/src/prove/smt/solver/theory-lra-final-check.ts +252 -0
- package/src/prove/smt/solver/theory-lra-internalize.ts +476 -0
- package/src/prove/smt/solver/theory-lra-model.ts +243 -0
- package/src/prove/smt/solver/theory-lra-propagate.ts +405 -0
- package/src/prove/smt/solver/theory-lra-state.ts +43 -0
- package/src/prove/smt/solver/theory-lra.ts +56 -0
- package/src/prove/smt/solver/var-subst.ts +258 -0
- package/src/prove/smt/solver/z3-license.txt +10 -0
- package/src/prove/smt/table.ts +170 -0
- package/src/prove/tlapm/tlapm.ts +96 -0
- package/src/prove/tlaps-module.ts +510 -0
- package/src/prove/verdict.ts +18 -0
- package/src/prove/zenon/LICENSE +32 -0
- package/src/prove/zenon/check/check.ts +105 -0
- package/src/prove/zenon/check/definitions.ts +144 -0
- package/src/prove/zenon/check/equality.ts +182 -0
- package/src/prove/zenon/check/functions.ts +62 -0
- package/src/prove/zenon/check/keys.ts +125 -0
- package/src/prove/zenon/check/propositional.ts +104 -0
- package/src/prove/zenon/check/records.ts +188 -0
- package/src/prove/zenon/check/relations.ts +121 -0
- package/src/prove/zenon/check/rewrites.ts +224 -0
- package/src/prove/zenon/check/sets.ts +302 -0
- package/src/prove/zenon/check/terms.ts +127 -0
- package/src/prove/zenon/check/tla.ts +126 -0
- package/src/prove/zenon/decide.ts +113 -0
- package/src/prove/zenon/encode.ts +437 -0
- package/src/prove/zenon/eqrel.ts +300 -0
- package/src/prove/zenon/equality-rules.ts +435 -0
- package/src/prove/zenon/expr.ts +551 -0
- package/src/prove/zenon/index-table.ts +350 -0
- package/src/prove/zenon/isar-case.ts +513 -0
- package/src/prove/zenon/isar.ts +1249 -0
- package/src/prove/zenon/limits.ts +15 -0
- package/src/prove/zenon/llproof.ts +173 -0
- package/src/prove/zenon/mltoll.ts +1566 -0
- package/src/prove/zenon/node.ts +297 -0
- package/src/prove/zenon/ocaml.ts +169 -0
- package/src/prove/zenon/parse.ts +247 -0
- package/src/prove/zenon/phrase.ts +191 -0
- package/src/prove/zenon/proof.ts +198 -0
- package/src/prove/zenon/propositional-rules.ts +387 -0
- package/src/prove/zenon/rules.ts +94 -0
- package/src/prove/zenon/search.ts +288 -0
- package/src/prove/zenon/tla/functions.ts +151 -0
- package/src/prove/zenon/tla/llproof.ts +480 -0
- package/src/prove/zenon/tla/records.ts +225 -0
- package/src/prove/zenon/tla/rewrites.ts +447 -0
- package/src/prove/zenon/tla/sets.ts +304 -0
- package/src/prove/zenon/tla/terms.ts +181 -0
- package/src/prove/zenon/tla/tla.ts +506 -0
- package/src/run-cli.ts +334 -75
- package/src/standard-modules.ts +5 -2
- package/src/successors.ts +24 -5
- package/src/tlapm-cache.ts +236 -0
- package/src/tlc-random.ts +55 -32
- package/src/tlc-version.ts +8 -7
- package/src/values.ts +80 -35
- package/src/worker.ts +65 -0
- package/dist/parallel.cjs +0 -12
- package/dist/parallel.js +0 -12
|
@@ -0,0 +1,996 @@
|
|
|
1
|
+
// Ported from Z3 (src/math/polynomial/upolynomial.{h,cpp}, src/util/mpzzp.h,
|
|
2
|
+
// src/math/polynomial/polynomial_primes.h), MIT license, see z3-license.txt. Univariate
|
|
3
|
+
// polynomials with integer coefficients, as coefficient arrays from the constant term up with no
|
|
4
|
+
// leading zeros, over Z or over Z_p. Root isolation by Descartes' rule of signs, Sturm sequences
|
|
5
|
+
// and refinement of isolating intervals with binary rational endpoints.
|
|
6
|
+
import { SmtInvariantError } from "../../../../errors";
|
|
7
|
+
import { getGcd, Rational } from "../rational";
|
|
8
|
+
import { getLog2, Mpbq, refineLower, refineUpper } from "./mpbq";
|
|
9
|
+
|
|
10
|
+
export type Upolynomial = readonly bigint[];
|
|
11
|
+
|
|
12
|
+
// g_big_primes: the primes mod_gcd tries, in order.
|
|
13
|
+
const BIG_PRIMES = [
|
|
14
|
+
39103, 39107, 39113, 39119, 39133, 39139, 39157, 39161, 39163, 39181, 39191, 39199, 39209, 39217,
|
|
15
|
+
39227, 39229, 39233, 39239, 39241, 39251, 39293, 39301, 39313, 39317, 39323, 39341, 39343, 39359,
|
|
16
|
+
39367, 39371, 39373, 39383, 39397, 39409, 39419, 39439, 39443, 39451, 39461, 39499, 39503, 39509,
|
|
17
|
+
39511, 39521, 39541, 39551, 39563, 39569, 39581, 39607, 39619, 39623, 39631, 39659, 39667, 39671,
|
|
18
|
+
39679, 39703, 39709, 39719, 39727, 39733, 39749, 39761, 39769, 39779, 39791, 39799, 39821, 39827,
|
|
19
|
+
39829, 39839, 39841, 39847, 39857, 39863, 39869, 39877, 39883, 39887, 39901, 39929, 39937, 39953,
|
|
20
|
+
39971, 39979, 39983, 39989, 40009, 40013, 40031, 40037, 40039, 40063, 40087, 40093, 40099, 40111,
|
|
21
|
+
40123, 40127, 40129, 40151, 40153, 40163, 40169, 40177, 40189, 40193, 40213, 40231, 40237, 40241,
|
|
22
|
+
40253, 40277, 40283, 40289, 40343, 40351, 40357, 40361, 40387, 40423, 40427, 40429, 40433, 40459,
|
|
23
|
+
40471, 40483, 40487, 40493, 40499, 40507, 40519, 40529, 40531, 40543, 40559, 40577, 40583, 40591,
|
|
24
|
+
40597, 40609, 40627, 40637, 40639, 40693, 40697, 40699, 40709, 40739, 40751, 40759, 40763, 40771,
|
|
25
|
+
40787, 40801, 40813, 40819, 40823, 40829, 40841, 40847, 40849, 40853, 40867, 40879, 40883, 40897,
|
|
26
|
+
40903, 40927, 40933, 40939, 40949, 40961, 40973, 40993, 41011, 41017, 41023, 41039, 41047, 41051,
|
|
27
|
+
41057, 41077, 41081, 41113, 41117, 41131, 41141, 41143, 41149, 41161, 41177, 41179, 41183, 41189,
|
|
28
|
+
41201, 41203, 41213, 41221, 41227, 41231, 41233, 41243, 41257, 41263, 41269, 41281, 41299, 41333,
|
|
29
|
+
41341, 41351, 41357, 41381, 41387, 41389, 41399, 41411, 41413, 41443, 41453, 41467, 41479, 41491,
|
|
30
|
+
41507, 41513, 41519, 41521, 41539, 41543, 41549,
|
|
31
|
+
].map(BigInt);
|
|
32
|
+
|
|
33
|
+
const sign = (value: bigint) => (value > 0n ? 1 : value < 0n ? -1 : 0);
|
|
34
|
+
|
|
35
|
+
// mpz div: rounds toward minus infinity.
|
|
36
|
+
const floorDiv = (dividend: bigint, divisor: bigint) => {
|
|
37
|
+
const quotient = dividend / divisor;
|
|
38
|
+
return dividend % divisor !== 0n && dividend < 0n !== divisor < 0n ? quotient - 1n : quotient;
|
|
39
|
+
};
|
|
40
|
+
|
|
41
|
+
// mpz gcd(a, b, x, y, g): a*x + b*y = g.
|
|
42
|
+
const getExtendedGcd = (first: bigint, second: bigint) => {
|
|
43
|
+
let [oldR, r] = [first, second];
|
|
44
|
+
let [oldS, s] = [1n, 0n];
|
|
45
|
+
let [oldT, t] = [0n, 1n];
|
|
46
|
+
while (r !== 0n) {
|
|
47
|
+
const quotient = oldR / r;
|
|
48
|
+
[oldR, r] = [r, oldR - quotient * r];
|
|
49
|
+
[oldS, s] = [s, oldS - quotient * s];
|
|
50
|
+
[oldT, t] = [t, oldT - quotient * t];
|
|
51
|
+
}
|
|
52
|
+
return oldR < 0n ? { x: -oldS, y: -oldT, gcd: -oldR } : { x: oldS, y: oldT, gcd: oldR };
|
|
53
|
+
};
|
|
54
|
+
|
|
55
|
+
const trim = (coeffs: bigint[]) => {
|
|
56
|
+
let size = coeffs.length;
|
|
57
|
+
while (size > 0 && coeffs[size - 1] === 0n) size--;
|
|
58
|
+
coeffs.length = size;
|
|
59
|
+
return coeffs;
|
|
60
|
+
};
|
|
61
|
+
|
|
62
|
+
export interface IsolatedRoots {
|
|
63
|
+
roots: Mpbq[];
|
|
64
|
+
lowers: Mpbq[];
|
|
65
|
+
uppers: Mpbq[];
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
// An interval (a, b) refined around the root of a square-free polynomial, or the root itself.
|
|
69
|
+
export interface Refinement {
|
|
70
|
+
isInterval: boolean;
|
|
71
|
+
lower: Mpbq;
|
|
72
|
+
upper: Mpbq;
|
|
73
|
+
}
|
|
74
|
+
|
|
75
|
+
interface DrsFrame {
|
|
76
|
+
parent: number;
|
|
77
|
+
coeffs: bigint[];
|
|
78
|
+
isFirst: boolean;
|
|
79
|
+
isLeft: boolean;
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
export class UpolynomialManager {
|
|
83
|
+
// Z_p when set, else Z. Coefficients over Z_p lie in the symmetric range around zero. Hensel
|
|
84
|
+
// lifting also sets a prime power.
|
|
85
|
+
private isPrimeModulus = true;
|
|
86
|
+
|
|
87
|
+
constructor(private modulus: bigint | null = null) {}
|
|
88
|
+
|
|
89
|
+
get zp() {
|
|
90
|
+
return this.modulus;
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
// field: Z_p for a prime p. Over a prime power, division falls back to pseudo-division.
|
|
94
|
+
private get isField() {
|
|
95
|
+
return this.modulus !== null && this.isPrimeModulus;
|
|
96
|
+
}
|
|
97
|
+
|
|
98
|
+
// set_zp
|
|
99
|
+
setZp(prime: bigint) {
|
|
100
|
+
this.modulus = prime;
|
|
101
|
+
this.isPrimeModulus = true;
|
|
102
|
+
}
|
|
103
|
+
|
|
104
|
+
// set_p_sq: from Z_m to Z_(m^2).
|
|
105
|
+
squareModulus() {
|
|
106
|
+
if (this.modulus === null) throw new SmtInvariantError("squaring the modulus of Z");
|
|
107
|
+
this.modulus *= this.modulus;
|
|
108
|
+
this.isPrimeModulus = false;
|
|
109
|
+
}
|
|
110
|
+
|
|
111
|
+
// scoped_set_zp
|
|
112
|
+
withZp<T>(prime: bigint, body: () => T) {
|
|
113
|
+
const savedModulus = this.modulus;
|
|
114
|
+
const savedIsPrime = this.isPrimeModulus;
|
|
115
|
+
this.setZp(prime);
|
|
116
|
+
const result = body();
|
|
117
|
+
this.modulus = savedModulus;
|
|
118
|
+
this.isPrimeModulus = savedIsPrime;
|
|
119
|
+
return result;
|
|
120
|
+
}
|
|
121
|
+
|
|
122
|
+
// Numerals.
|
|
123
|
+
|
|
124
|
+
// p_normalize
|
|
125
|
+
normalizeNumeral(value: bigint) {
|
|
126
|
+
const modulus = this.modulus;
|
|
127
|
+
if (modulus === null) return value;
|
|
128
|
+
const upper = modulus / 2n;
|
|
129
|
+
const lower = modulus % 2n === 0n ? -upper + 1n : -upper;
|
|
130
|
+
const rest = value % modulus;
|
|
131
|
+
return rest > upper ? rest - modulus : rest < lower ? rest + modulus : rest;
|
|
132
|
+
}
|
|
133
|
+
|
|
134
|
+
inv(value: bigint) {
|
|
135
|
+
const modulus = this.modulus;
|
|
136
|
+
if (modulus === null) throw new SmtInvariantError("inverse over Z");
|
|
137
|
+
return this.normalizeNumeral(getExtendedGcd(this.normalizeNumeral(value), modulus).x);
|
|
138
|
+
}
|
|
139
|
+
|
|
140
|
+
// mpzzp div: exact over Z (rounding toward minus infinity), multiplication by the inverse over Z_p.
|
|
141
|
+
private divNumeral(dividend: bigint, divisor: bigint) {
|
|
142
|
+
return this.modulus === null
|
|
143
|
+
? floorDiv(dividend, divisor)
|
|
144
|
+
: this.normalizeNumeral(dividend * this.inv(divisor));
|
|
145
|
+
}
|
|
146
|
+
|
|
147
|
+
private dividesNumeral(divisor: bigint, dividend: bigint) {
|
|
148
|
+
if (this.isField && divisor !== 0n) return true;
|
|
149
|
+
return divisor === 0n ? dividend === 0n : dividend % divisor === 0n;
|
|
150
|
+
}
|
|
151
|
+
|
|
152
|
+
// set: the coefficients reduced to the current ring.
|
|
153
|
+
set(coeffs: Upolynomial) {
|
|
154
|
+
return trim(coeffs.map((coeff) => this.normalizeNumeral(coeff)));
|
|
155
|
+
}
|
|
156
|
+
|
|
157
|
+
// Core operations.
|
|
158
|
+
|
|
159
|
+
getContent(coeffs: Upolynomial) {
|
|
160
|
+
let content = 0n;
|
|
161
|
+
for (const coeff of coeffs) content = getGcd(content, coeff);
|
|
162
|
+
return content;
|
|
163
|
+
}
|
|
164
|
+
|
|
165
|
+
getPrimitive(coeffs: Upolynomial) {
|
|
166
|
+
const content = this.getContent(coeffs);
|
|
167
|
+
return content === 1n ? [...coeffs] : trim(coeffs.map((coeff) => coeff / content));
|
|
168
|
+
}
|
|
169
|
+
|
|
170
|
+
neg(coeffs: Upolynomial) {
|
|
171
|
+
return coeffs.map((coeff) => this.normalizeNumeral(-coeff));
|
|
172
|
+
}
|
|
173
|
+
|
|
174
|
+
add(first: Upolynomial, second: Upolynomial) {
|
|
175
|
+
const size = Math.max(first.length, second.length);
|
|
176
|
+
return trim(
|
|
177
|
+
Array.from({ length: size }, (_unused, index) =>
|
|
178
|
+
this.normalizeNumeral((first[index] ?? 0n) + (second[index] ?? 0n)),
|
|
179
|
+
),
|
|
180
|
+
);
|
|
181
|
+
}
|
|
182
|
+
|
|
183
|
+
sub(first: Upolynomial, second: Upolynomial) {
|
|
184
|
+
const size = Math.max(first.length, second.length);
|
|
185
|
+
return trim(
|
|
186
|
+
Array.from({ length: size }, (_unused, index) =>
|
|
187
|
+
this.normalizeNumeral((first[index] ?? 0n) - (second[index] ?? 0n)),
|
|
188
|
+
),
|
|
189
|
+
);
|
|
190
|
+
}
|
|
191
|
+
|
|
192
|
+
mul(first: Upolynomial, second: Upolynomial) {
|
|
193
|
+
if (first.length === 0 || second.length === 0) return [];
|
|
194
|
+
const result = Array.from({ length: first.length + second.length - 1 }, () => 0n);
|
|
195
|
+
for (let index = 0; index < first.length; index++) {
|
|
196
|
+
if (first[index] === 0n) continue;
|
|
197
|
+
for (let other = 0; other < second.length; other++)
|
|
198
|
+
if (second[other] !== 0n)
|
|
199
|
+
result[index + other] = this.normalizeNumeral(
|
|
200
|
+
result[index + other] + first[index] * second[other],
|
|
201
|
+
);
|
|
202
|
+
}
|
|
203
|
+
return trim(result);
|
|
204
|
+
}
|
|
205
|
+
|
|
206
|
+
mulConst(coeffs: Upolynomial, factor: bigint) {
|
|
207
|
+
if (factor === 0n) return [];
|
|
208
|
+
return trim(coeffs.map((coeff) => this.normalizeNumeral(coeff * factor)));
|
|
209
|
+
}
|
|
210
|
+
|
|
211
|
+
// div(p, b): each coefficient divided by b, which divides it.
|
|
212
|
+
divConst(coeffs: Upolynomial, divisor: bigint) {
|
|
213
|
+
if (divisor === 1n) return [...coeffs];
|
|
214
|
+
return trim(coeffs.map((coeff) => this.divNumeral(coeff, divisor)));
|
|
215
|
+
}
|
|
216
|
+
|
|
217
|
+
derivative(coeffs: Upolynomial) {
|
|
218
|
+
if (coeffs.length <= 1) return [];
|
|
219
|
+
return trim(
|
|
220
|
+
coeffs.slice(1).map((coeff, index) => this.normalizeNumeral(coeff * BigInt(index + 1))),
|
|
221
|
+
);
|
|
222
|
+
}
|
|
223
|
+
|
|
224
|
+
// normalize: the coefficients divided by their gcd, or the sign of a constant.
|
|
225
|
+
normalize(coeffs: Upolynomial) {
|
|
226
|
+
if (coeffs.length === 0) return [];
|
|
227
|
+
if (coeffs.length === 1) return [coeffs[0] > 0n ? 1n : this.normalizeNumeral(-1n)];
|
|
228
|
+
const content = this.getContent(coeffs);
|
|
229
|
+
if (content === 1n) return [...coeffs];
|
|
230
|
+
return coeffs.map((coeff) => this.divNumeral(coeff, content));
|
|
231
|
+
}
|
|
232
|
+
|
|
233
|
+
flipSignIfLmNeg(coeffs: Upolynomial) {
|
|
234
|
+
return coeffs.length > 0 && coeffs[coeffs.length - 1] < 0n ? this.neg(coeffs) : [...coeffs];
|
|
235
|
+
}
|
|
236
|
+
|
|
237
|
+
// mk_monic: the polynomial divided by its leading coefficient, over Z_p.
|
|
238
|
+
mkMonic(coeffs: Upolynomial) {
|
|
239
|
+
if (coeffs.length === 0 || coeffs[coeffs.length - 1] === 1n) return [...coeffs];
|
|
240
|
+
const inverse = this.inv(coeffs[coeffs.length - 1]);
|
|
241
|
+
return coeffs.map((coeff, index) =>
|
|
242
|
+
index === coeffs.length - 1 ? 1n : this.normalizeNumeral(coeff * inverse),
|
|
243
|
+
);
|
|
244
|
+
}
|
|
245
|
+
|
|
246
|
+
// div_rem: q and r with lc(p2)^d * p1 = q * p2 + r over Z, or p1 = q * p2 + r over a field.
|
|
247
|
+
divRem(dividend: Upolynomial, divisor: Upolynomial) {
|
|
248
|
+
const isField = this.isField;
|
|
249
|
+
if (divisor.length === 1) {
|
|
250
|
+
const quotient = isField ? this.divConst(dividend, divisor[0]) : this.set(dividend);
|
|
251
|
+
return { quotient, remainder: [] as bigint[], power: 0 };
|
|
252
|
+
}
|
|
253
|
+
const remainder = this.set(dividend);
|
|
254
|
+
if (dividend.length <= 1) return { quotient: [] as bigint[], remainder, power: 0 };
|
|
255
|
+
const quotientSize =
|
|
256
|
+
dividend.length >= divisor.length ? dividend.length - divisor.length + 1 : 0;
|
|
257
|
+
const quotient = Array.from({ length: quotientSize }, () => 0n);
|
|
258
|
+
const leading = divisor[divisor.length - 1];
|
|
259
|
+
let power = 0;
|
|
260
|
+
while (remainder.length >= divisor.length) {
|
|
261
|
+
const size = remainder.length;
|
|
262
|
+
const shift = size - divisor.length;
|
|
263
|
+
if (isField) {
|
|
264
|
+
const ratio = this.divNumeral(remainder[size - 1], leading);
|
|
265
|
+
quotient[shift] = this.normalizeNumeral(quotient[shift] + ratio);
|
|
266
|
+
for (let index = 0; index < divisor.length - 1; index++)
|
|
267
|
+
remainder[index + shift] = this.normalizeNumeral(
|
|
268
|
+
remainder[index + shift] - ratio * divisor[index],
|
|
269
|
+
);
|
|
270
|
+
} else {
|
|
271
|
+
power++;
|
|
272
|
+
const top = remainder[size - 1];
|
|
273
|
+
for (let index = 0; index < size - 1; index++)
|
|
274
|
+
remainder[index] = this.normalizeNumeral(remainder[index] * leading);
|
|
275
|
+
for (let index = 0; index < quotientSize; index++)
|
|
276
|
+
quotient[index] = this.normalizeNumeral(quotient[index] * leading);
|
|
277
|
+
quotient[shift] = this.normalizeNumeral(quotient[shift] + top);
|
|
278
|
+
for (let index = 0; index < divisor.length - 1; index++)
|
|
279
|
+
remainder[index + shift] = this.normalizeNumeral(
|
|
280
|
+
remainder[index + shift] - top * divisor[index],
|
|
281
|
+
);
|
|
282
|
+
}
|
|
283
|
+
remainder.length = size - 1;
|
|
284
|
+
trim(remainder);
|
|
285
|
+
}
|
|
286
|
+
return { quotient: trim(quotient), remainder, power };
|
|
287
|
+
}
|
|
288
|
+
|
|
289
|
+
div(dividend: Upolynomial, divisor: Upolynomial) {
|
|
290
|
+
return this.divRem(dividend, divisor).quotient;
|
|
291
|
+
}
|
|
292
|
+
|
|
293
|
+
// rem: the pseudo-remainder, with the number of pseudo-division steps.
|
|
294
|
+
remWithPower(dividend: Upolynomial, divisor: Upolynomial) {
|
|
295
|
+
if (divisor.length === 1) return { remainder: [] as bigint[], power: 0 };
|
|
296
|
+
const remainder = this.set(dividend);
|
|
297
|
+
if (dividend.length <= 1) return { remainder, power: 0 };
|
|
298
|
+
const isField = this.isField;
|
|
299
|
+
const leading = divisor[divisor.length - 1];
|
|
300
|
+
let power = 0;
|
|
301
|
+
while (remainder.length >= divisor.length) {
|
|
302
|
+
const size = remainder.length;
|
|
303
|
+
const shift = size - divisor.length;
|
|
304
|
+
if (isField) {
|
|
305
|
+
const ratio = this.divNumeral(remainder[size - 1], leading);
|
|
306
|
+
for (let index = 0; index < divisor.length - 1; index++)
|
|
307
|
+
remainder[index + shift] = this.normalizeNumeral(
|
|
308
|
+
remainder[index + shift] - ratio * divisor[index],
|
|
309
|
+
);
|
|
310
|
+
} else {
|
|
311
|
+
power++;
|
|
312
|
+
const top = remainder[size - 1];
|
|
313
|
+
for (let index = 0; index < size - 1; index++)
|
|
314
|
+
remainder[index] = this.normalizeNumeral(remainder[index] * leading);
|
|
315
|
+
for (let index = 0; index < divisor.length - 1; index++)
|
|
316
|
+
remainder[index + shift] = this.normalizeNumeral(
|
|
317
|
+
remainder[index + shift] - top * divisor[index],
|
|
318
|
+
);
|
|
319
|
+
}
|
|
320
|
+
remainder.length = size - 1;
|
|
321
|
+
trim(remainder);
|
|
322
|
+
}
|
|
323
|
+
return { remainder, power };
|
|
324
|
+
}
|
|
325
|
+
|
|
326
|
+
rem(dividend: Upolynomial, divisor: Upolynomial) {
|
|
327
|
+
return this.remWithPower(dividend, divisor).remainder;
|
|
328
|
+
}
|
|
329
|
+
|
|
330
|
+
// srem: the signed pseudo-remainder, negated unless an odd number of steps by a negative leading
|
|
331
|
+
// coefficient already flipped it.
|
|
332
|
+
srem(dividend: Upolynomial, divisor: Upolynomial) {
|
|
333
|
+
const result = this.remWithPower(dividend, divisor);
|
|
334
|
+
return result.power % 2 === 0 || (divisor.length > 0 && divisor[divisor.length - 1] > 0n)
|
|
335
|
+
? this.neg(result.remainder)
|
|
336
|
+
: result.remainder;
|
|
337
|
+
}
|
|
338
|
+
|
|
339
|
+
// divides: whether divisor divides dividend, checking only the leading coefficients.
|
|
340
|
+
divides(dividend: Upolynomial, divisor: Upolynomial) {
|
|
341
|
+
if (divisor.length === 0) return false;
|
|
342
|
+
if (dividend.length === 0) return true;
|
|
343
|
+
const leading = divisor[divisor.length - 1];
|
|
344
|
+
const rest = this.set(dividend);
|
|
345
|
+
while (rest.length > 0) {
|
|
346
|
+
if (divisor.length > rest.length || !this.dividesNumeral(leading, rest[rest.length - 1]))
|
|
347
|
+
return false;
|
|
348
|
+
const shift = rest.length - divisor.length;
|
|
349
|
+
const ratio = this.divNumeral(rest[rest.length - 1], leading);
|
|
350
|
+
for (let index = 0; index < divisor.length - 1; index++)
|
|
351
|
+
if (divisor[index] !== 0n)
|
|
352
|
+
rest[index + shift] = this.normalizeNumeral(rest[index + shift] - ratio * divisor[index]);
|
|
353
|
+
rest[rest.length - 1] = 0n;
|
|
354
|
+
trim(rest);
|
|
355
|
+
}
|
|
356
|
+
return true;
|
|
357
|
+
}
|
|
358
|
+
|
|
359
|
+
// exact_div: dividend / divisor when the division is exact, else null.
|
|
360
|
+
exactDiv(dividend: Upolynomial, divisor: Upolynomial): bigint[] | null {
|
|
361
|
+
if (divisor.length === 0) return null;
|
|
362
|
+
if (dividend.length === 0) return [];
|
|
363
|
+
const leading = divisor[divisor.length - 1];
|
|
364
|
+
if (divisor.length > dividend.length) return null;
|
|
365
|
+
const result = Array.from({ length: dividend.length - divisor.length + 1 }, () => 0n);
|
|
366
|
+
const rest = this.set(dividend);
|
|
367
|
+
while (rest.length > 0) {
|
|
368
|
+
if (
|
|
369
|
+
divisor.length > rest.length ||
|
|
370
|
+
!this.dividesNumeral(leading, rest[rest.length - 1]) ||
|
|
371
|
+
!this.dividesNumeral(divisor[0], rest[0])
|
|
372
|
+
)
|
|
373
|
+
return null;
|
|
374
|
+
const shift = rest.length - divisor.length;
|
|
375
|
+
const ratio = this.divNumeral(rest[rest.length - 1], leading);
|
|
376
|
+
result[shift] = ratio;
|
|
377
|
+
for (let index = 0; index < divisor.length - 1; index++)
|
|
378
|
+
if (divisor[index] !== 0n)
|
|
379
|
+
rest[index + shift] = this.normalizeNumeral(rest[index + shift] - ratio * divisor[index]);
|
|
380
|
+
rest[rest.length - 1] = 0n;
|
|
381
|
+
trim(rest);
|
|
382
|
+
}
|
|
383
|
+
return trim(result);
|
|
384
|
+
}
|
|
385
|
+
|
|
386
|
+
// GCD.
|
|
387
|
+
|
|
388
|
+
private euclidGcd(first: Upolynomial, second: Upolynomial) {
|
|
389
|
+
if (first.length === 0) return this.flipSignIfLmNeg(this.set(second));
|
|
390
|
+
if (second.length === 0) return this.flipSignIfLmNeg(this.set(first));
|
|
391
|
+
let a = this.set(first);
|
|
392
|
+
let b = this.set(second);
|
|
393
|
+
while (b.length > 0) {
|
|
394
|
+
const remainder = this.normalize(this.rem(a, b));
|
|
395
|
+
a = b;
|
|
396
|
+
b = remainder;
|
|
397
|
+
}
|
|
398
|
+
const normalized = this.normalize(a);
|
|
399
|
+
return this.isField ? this.mkMonic(normalized) : this.flipSignIfLmNeg(normalized);
|
|
400
|
+
}
|
|
401
|
+
|
|
402
|
+
// CRA_combine_images: the image modulo bound * prime, in the symmetric range.
|
|
403
|
+
private combineImages(image: Upolynomial, prime: bigint, combined: Upolynomial, bound: bigint) {
|
|
404
|
+
const inverses = getExtendedGcd(prime, bound);
|
|
405
|
+
const mod = (value: bigint, modulus: bigint) => ((value % modulus) + modulus) % modulus;
|
|
406
|
+
const inverse1 = mod(inverses.x, bound);
|
|
407
|
+
const inverse2 = mod(inverses.y, prime);
|
|
408
|
+
const factor1 = bound * inverse2;
|
|
409
|
+
const factor2 = prime * inverse1;
|
|
410
|
+
const newBound = prime * bound;
|
|
411
|
+
const upper = newBound / 2n;
|
|
412
|
+
const size = Math.max(image.length, combined.length);
|
|
413
|
+
const result: bigint[] = [];
|
|
414
|
+
for (let index = 0; index < size; index++) {
|
|
415
|
+
const value = mod(
|
|
416
|
+
(image[index] ?? 0n) * factor1 + (combined[index] ?? 0n) * factor2,
|
|
417
|
+
newBound,
|
|
418
|
+
);
|
|
419
|
+
result.push(value > upper ? value - newBound : value);
|
|
420
|
+
}
|
|
421
|
+
return { coeffs: result, bound: newBound };
|
|
422
|
+
}
|
|
423
|
+
|
|
424
|
+
// mod_gcd: the gcd over Z from images modulo big primes, combined by the Chinese remainder theorem.
|
|
425
|
+
private modGcd(first: Upolynomial, second: Upolynomial) {
|
|
426
|
+
const contentU = this.getContent(first);
|
|
427
|
+
const contentV = this.getContent(second);
|
|
428
|
+
const ppU = this.getPrimitive(first);
|
|
429
|
+
const ppV = this.getPrimitive(second);
|
|
430
|
+
const contentG = getGcd(contentU, contentV);
|
|
431
|
+
const degreeU = first.length - 1;
|
|
432
|
+
const degreeV = second.length - 1;
|
|
433
|
+
const lcG = getGcd(ppU[degreeU], ppV[degreeV]);
|
|
434
|
+
let combined: bigint[] = [];
|
|
435
|
+
let bound = 0n;
|
|
436
|
+
for (const prime of BIG_PRIMES) {
|
|
437
|
+
const image = this.withZp(prime, () => {
|
|
438
|
+
const uZp = this.set(ppU);
|
|
439
|
+
const vZp = this.set(ppV);
|
|
440
|
+
if (uZp.length - 1 < degreeU || vZp.length - 1 < degreeV) return null;
|
|
441
|
+
return this.mulConst(this.mkMonic(this.euclidGcd(uZp, vZp)), lcG);
|
|
442
|
+
});
|
|
443
|
+
if (image === null) continue;
|
|
444
|
+
if (image.length <= 1) return [contentG];
|
|
445
|
+
// The first image, or one of lower degree, replaces the accumulated image. Before the first
|
|
446
|
+
// image the bound is zero, which is even.
|
|
447
|
+
if (image.length < combined.length || bound % 2n === 0n) {
|
|
448
|
+
combined = image;
|
|
449
|
+
bound = prime;
|
|
450
|
+
} else {
|
|
451
|
+
const next = this.combineImages(image, prime, combined, bound);
|
|
452
|
+
combined = next.coeffs;
|
|
453
|
+
bound = next.bound;
|
|
454
|
+
}
|
|
455
|
+
const candidate = this.getPrimitive(combined);
|
|
456
|
+
if (
|
|
457
|
+
this.dividesNumeral(candidate[candidate.length - 1], lcG) &&
|
|
458
|
+
this.divides(ppU, candidate) &&
|
|
459
|
+
this.divides(ppV, candidate)
|
|
460
|
+
)
|
|
461
|
+
return this.flipSignIfLmNeg(this.mulConst(candidate, contentG));
|
|
462
|
+
}
|
|
463
|
+
return this.euclidGcd(first, second);
|
|
464
|
+
}
|
|
465
|
+
|
|
466
|
+
gcd(first: Upolynomial, second: Upolynomial) {
|
|
467
|
+
if (first.length === 0) return this.flipSignIfLmNeg(this.set(second));
|
|
468
|
+
if (second.length === 0) return this.flipSignIfLmNeg(this.set(first));
|
|
469
|
+
return this.modulus === null ? this.modGcd(first, second) : this.euclidGcd(first, second);
|
|
470
|
+
}
|
|
471
|
+
|
|
472
|
+
// square_free: p divided by gcd(p, p'), normalized.
|
|
473
|
+
squareFree(coeffs: Upolynomial) {
|
|
474
|
+
if (coeffs.length <= 1) return this.set(coeffs);
|
|
475
|
+
const common = this.gcd(coeffs, this.derivative(coeffs));
|
|
476
|
+
return common.length <= 1 ? this.set(coeffs) : this.normalize(this.div(coeffs, common));
|
|
477
|
+
}
|
|
478
|
+
|
|
479
|
+
isSquareFree(coeffs: Upolynomial) {
|
|
480
|
+
return coeffs.length <= 1 || this.gcd(coeffs, this.derivative(coeffs)).length <= 1;
|
|
481
|
+
}
|
|
482
|
+
|
|
483
|
+
pw(coeffs: Upolynomial, exponent: number) {
|
|
484
|
+
if (exponent === 0) return [1n];
|
|
485
|
+
let result = this.set(coeffs);
|
|
486
|
+
for (let index = 1; index < exponent; index++) result = this.mul(result, coeffs);
|
|
487
|
+
return result;
|
|
488
|
+
}
|
|
489
|
+
|
|
490
|
+
// ext_gcd over Z_p: u, v and the monic d with a*u + b*v = d.
|
|
491
|
+
extGcd(first: Upolynomial, second: Upolynomial) {
|
|
492
|
+
let u: bigint[] = [1n];
|
|
493
|
+
let d = this.mkMonic(this.set(first));
|
|
494
|
+
let v1: bigint[] = [];
|
|
495
|
+
let v3 = this.set(second);
|
|
496
|
+
while (v3.length > 0) {
|
|
497
|
+
const division = this.divRem(d, v3);
|
|
498
|
+
const t = this.sub(u, this.mul(v1, division.quotient));
|
|
499
|
+
u = v1;
|
|
500
|
+
d = v3;
|
|
501
|
+
v1 = t;
|
|
502
|
+
v3 = division.remainder;
|
|
503
|
+
}
|
|
504
|
+
const v = this.div(this.sub(d, this.mul(first, u)), second);
|
|
505
|
+
if (d.length === 0 || d[d.length - 1] === 1n) return { u, v, d };
|
|
506
|
+
const inverse = this.inv(d[d.length - 1]);
|
|
507
|
+
return {
|
|
508
|
+
u: this.mulConst(u, inverse),
|
|
509
|
+
v: this.mulConst(v, inverse),
|
|
510
|
+
d: this.mkMonic(d),
|
|
511
|
+
};
|
|
512
|
+
}
|
|
513
|
+
|
|
514
|
+
// Transformations.
|
|
515
|
+
|
|
516
|
+
hasZeroRoots(coeffs: Upolynomial) {
|
|
517
|
+
return coeffs.length > 0 && coeffs[0] === 0n;
|
|
518
|
+
}
|
|
519
|
+
|
|
520
|
+
removeZeroRoots(coeffs: Upolynomial) {
|
|
521
|
+
let index = 0;
|
|
522
|
+
while (coeffs[index] === 0n) index++;
|
|
523
|
+
return coeffs.slice(index);
|
|
524
|
+
}
|
|
525
|
+
|
|
526
|
+
// has_one_half_root: 2^n * p(1/2) = 0.
|
|
527
|
+
private hasOneHalfRoot(coeffs: Upolynomial) {
|
|
528
|
+
if (coeffs.length === 0) return true;
|
|
529
|
+
if (coeffs.length === 1) return false;
|
|
530
|
+
let result = coeffs[coeffs.length - 1];
|
|
531
|
+
for (let index = coeffs.length - 2, shift = 1n; index >= 0; index--, shift++)
|
|
532
|
+
result += coeffs[index] << shift;
|
|
533
|
+
return result === 0n;
|
|
534
|
+
}
|
|
535
|
+
|
|
536
|
+
// descartes_bound_0_1: the sign changes of (x+1)^n p(1/(x+1)), stopping above 1.
|
|
537
|
+
private descartesBound01(coeffs: Upolynomial) {
|
|
538
|
+
if (coeffs.length <= 1) return 0;
|
|
539
|
+
const work = [...coeffs];
|
|
540
|
+
let previous = 0;
|
|
541
|
+
let changes = 0;
|
|
542
|
+
for (let index = 0; index < work.length; index++) {
|
|
543
|
+
let position = 1;
|
|
544
|
+
for (; position < work.length - index; position++) work[position] += work[position - 1];
|
|
545
|
+
const current = sign(work[position - 1]);
|
|
546
|
+
if (current === 0) continue;
|
|
547
|
+
if (current !== previous && previous !== 0) {
|
|
548
|
+
changes++;
|
|
549
|
+
if (changes > 1) return changes;
|
|
550
|
+
}
|
|
551
|
+
previous = current;
|
|
552
|
+
}
|
|
553
|
+
return changes;
|
|
554
|
+
}
|
|
555
|
+
|
|
556
|
+
// translate: p(x + 1).
|
|
557
|
+
translate(coeffs: Upolynomial) {
|
|
558
|
+
const result = [...coeffs];
|
|
559
|
+
const degree = result.length - 1;
|
|
560
|
+
for (let step = 1; step <= degree; step++)
|
|
561
|
+
for (let index = degree - step; index <= degree - 1; index++)
|
|
562
|
+
result[index] += result[index + 1];
|
|
563
|
+
return result;
|
|
564
|
+
}
|
|
565
|
+
|
|
566
|
+
// translate_q: den^n * p(x + q).
|
|
567
|
+
translateQ(coeffs: Upolynomial, value: Rational) {
|
|
568
|
+
if (coeffs.length <= 1) return [...coeffs];
|
|
569
|
+
const result = this.composeAnPxDivA(coeffs, value.den);
|
|
570
|
+
const degree = result.length - 1;
|
|
571
|
+
for (let step = 1; step <= degree; step++) {
|
|
572
|
+
result[degree - step] += value.num * result[degree - step + 1];
|
|
573
|
+
for (let index = degree - step + 1; index <= degree - 1; index++)
|
|
574
|
+
result[index] = result[index] * value.den + value.num * result[index + 1];
|
|
575
|
+
result[degree] *= value.den;
|
|
576
|
+
}
|
|
577
|
+
return result;
|
|
578
|
+
}
|
|
579
|
+
|
|
580
|
+
// compose_2n_p_x_div_2: 2^n * p(x/2).
|
|
581
|
+
private compose2nPxDiv2(coeffs: Upolynomial) {
|
|
582
|
+
const degree = coeffs.length - 1;
|
|
583
|
+
return coeffs.map((coeff, index) => coeff << BigInt(degree - index));
|
|
584
|
+
}
|
|
585
|
+
|
|
586
|
+
// p_minus_x: p(-x).
|
|
587
|
+
pMinusX(coeffs: Upolynomial) {
|
|
588
|
+
return coeffs.map((coeff, index) => (index % 2 === 1 && coeff !== 0n ? -coeff : coeff));
|
|
589
|
+
}
|
|
590
|
+
|
|
591
|
+
// p_1_div_x: x^n * p(1/x).
|
|
592
|
+
p1DivX(coeffs: Upolynomial) {
|
|
593
|
+
return [...coeffs].reverse();
|
|
594
|
+
}
|
|
595
|
+
|
|
596
|
+
// compose_p_2k_x: p(2^k * x).
|
|
597
|
+
private composeP2kX(coeffs: Upolynomial, k: number) {
|
|
598
|
+
return coeffs.map((coeff, index) => coeff << BigInt(k * index));
|
|
599
|
+
}
|
|
600
|
+
|
|
601
|
+
// compose_an_p_x_div_a: a^n * p(x/a).
|
|
602
|
+
private composeAnPxDivA(coeffs: Upolynomial, factor: bigint) {
|
|
603
|
+
const degree = coeffs.length - 1;
|
|
604
|
+
return coeffs.map((coeff, index) =>
|
|
605
|
+
coeff === 0n ? 0n : coeff * factor ** BigInt(degree - index),
|
|
606
|
+
);
|
|
607
|
+
}
|
|
608
|
+
|
|
609
|
+
// compose_p_q_x: c^n * p(b*x/c) for q = b/c.
|
|
610
|
+
composePQX(coeffs: Upolynomial, value: Rational) {
|
|
611
|
+
const degree = coeffs.length - 1;
|
|
612
|
+
return coeffs.map((coeff, index) =>
|
|
613
|
+
coeff === 0n ? 0n : coeff * value.den ** BigInt(degree - index) * value.num ** BigInt(index),
|
|
614
|
+
);
|
|
615
|
+
}
|
|
616
|
+
|
|
617
|
+
// Signs.
|
|
618
|
+
|
|
619
|
+
// eval_sign_at for a binary rational: the sign of (2^k)^n * p(b).
|
|
620
|
+
evalSignAtBq(coeffs: Upolynomial, value: Mpbq) {
|
|
621
|
+
if (coeffs.length === 0) return 0;
|
|
622
|
+
if (coeffs.length === 1) return sign(coeffs[0]);
|
|
623
|
+
let result = coeffs[coeffs.length - 1];
|
|
624
|
+
let shift = value.k;
|
|
625
|
+
for (let index = coeffs.length - 2; index >= 0; index--, shift += value.k)
|
|
626
|
+
result =
|
|
627
|
+
coeffs[index] === 0n
|
|
628
|
+
? result * value.num
|
|
629
|
+
: (coeffs[index] << BigInt(shift)) + result * value.num;
|
|
630
|
+
return sign(result);
|
|
631
|
+
}
|
|
632
|
+
|
|
633
|
+
evalSignAtQ(coeffs: Upolynomial, value: Rational) {
|
|
634
|
+
if (coeffs.length === 0) return 0;
|
|
635
|
+
if (coeffs.length === 1) return sign(coeffs[0]);
|
|
636
|
+
let result = coeffs[coeffs.length - 1];
|
|
637
|
+
let denominator = value.den;
|
|
638
|
+
for (let index = coeffs.length - 2; index >= 0; index--, denominator *= value.den)
|
|
639
|
+
result =
|
|
640
|
+
coeffs[index] === 0n
|
|
641
|
+
? result * value.num
|
|
642
|
+
: coeffs[index] * denominator + result * value.num;
|
|
643
|
+
return sign(result);
|
|
644
|
+
}
|
|
645
|
+
|
|
646
|
+
evalSignAtZero(coeffs: Upolynomial) {
|
|
647
|
+
return coeffs.length === 0 ? 0 : sign(coeffs[0]);
|
|
648
|
+
}
|
|
649
|
+
|
|
650
|
+
evalSignAtPlusInf(coeffs: Upolynomial) {
|
|
651
|
+
return coeffs.length === 0 ? 0 : sign(coeffs[coeffs.length - 1]);
|
|
652
|
+
}
|
|
653
|
+
|
|
654
|
+
evalSignAtMinusInf(coeffs: Upolynomial) {
|
|
655
|
+
if (coeffs.length === 0) return 0;
|
|
656
|
+
const leading = sign(coeffs[coeffs.length - 1]);
|
|
657
|
+
return (coeffs.length - 1) % 2 === 0 ? leading : -leading;
|
|
658
|
+
}
|
|
659
|
+
|
|
660
|
+
private countSignVariations(signs: number[]) {
|
|
661
|
+
if (signs.length <= 1) return 0;
|
|
662
|
+
let variations = 0;
|
|
663
|
+
let previous = 0;
|
|
664
|
+
for (const current of signs) {
|
|
665
|
+
if (current === 0) continue;
|
|
666
|
+
if (current !== previous && previous !== 0) variations++;
|
|
667
|
+
previous = current;
|
|
668
|
+
}
|
|
669
|
+
return variations;
|
|
670
|
+
}
|
|
671
|
+
|
|
672
|
+
signVariationsAtMinusInf(sequence: Upolynomial[]) {
|
|
673
|
+
return this.countSignVariations(sequence.map((coeffs) => this.evalSignAtMinusInf(coeffs)));
|
|
674
|
+
}
|
|
675
|
+
|
|
676
|
+
signVariationsAtPlusInf(sequence: Upolynomial[]) {
|
|
677
|
+
return this.countSignVariations(sequence.map((coeffs) => this.evalSignAtPlusInf(coeffs)));
|
|
678
|
+
}
|
|
679
|
+
|
|
680
|
+
signVariationsAtZero(sequence: Upolynomial[]) {
|
|
681
|
+
return this.countSignVariations(sequence.map((coeffs) => this.evalSignAtZero(coeffs)));
|
|
682
|
+
}
|
|
683
|
+
|
|
684
|
+
signVariationsAt(sequence: Upolynomial[], value: Mpbq) {
|
|
685
|
+
return this.countSignVariations(sequence.map((coeffs) => this.evalSignAtBq(coeffs, value)));
|
|
686
|
+
}
|
|
687
|
+
|
|
688
|
+
// Root bounds.
|
|
689
|
+
|
|
690
|
+
// knuth_positive_root_upper_bound: k with every positive root below 2^k.
|
|
691
|
+
knuthPositiveRootUpperBound(coeffs: Upolynomial) {
|
|
692
|
+
if (coeffs.length === 0) return 0;
|
|
693
|
+
let max = 0;
|
|
694
|
+
const degree = coeffs.length - 1;
|
|
695
|
+
const isLeadingPositive = coeffs[degree] > 0n;
|
|
696
|
+
const log2Leading = getLog2(coeffs[degree]);
|
|
697
|
+
for (let k = 1; k <= degree; k++) {
|
|
698
|
+
const coeff = coeffs[degree - k];
|
|
699
|
+
if (coeff === 0n || coeff > 0n === isLeadingPositive) continue;
|
|
700
|
+
const log2Coeff = getLog2(coeff);
|
|
701
|
+
if (log2Leading > log2Coeff) continue;
|
|
702
|
+
const current = log2Coeff + 1 - log2Leading;
|
|
703
|
+
const bound = current % k === 0 ? current / k : Math.floor(current / k) + 1;
|
|
704
|
+
if (bound > max) max = bound;
|
|
705
|
+
}
|
|
706
|
+
return max + 1;
|
|
707
|
+
}
|
|
708
|
+
|
|
709
|
+
knuthNegativeRootUpperBound(coeffs: Upolynomial) {
|
|
710
|
+
return this.knuthPositiveRootUpperBound(this.pMinusX(coeffs));
|
|
711
|
+
}
|
|
712
|
+
|
|
713
|
+
// nonzero_root_lower_bound: k with every nonzero root of absolute value above 1/2^k.
|
|
714
|
+
nonzeroRootLowerBound(coeffs: Upolynomial) {
|
|
715
|
+
const reversed = this.removeZeroRoots(coeffs).reverse();
|
|
716
|
+
return Math.max(
|
|
717
|
+
this.knuthPositiveRootUpperBound(reversed),
|
|
718
|
+
this.knuthNegativeRootUpperBound(reversed),
|
|
719
|
+
);
|
|
720
|
+
}
|
|
721
|
+
|
|
722
|
+
// Root isolation by Descartes' rule of signs.
|
|
723
|
+
|
|
724
|
+
// push_child_frames: the halves (0, 1/2) and (1/2, 1), as 2^n p(x/2) and its translation.
|
|
725
|
+
private pushChildFrames(coeffs: Upolynomial, frames: DrsFrame[]) {
|
|
726
|
+
const parent = frames.length - 1;
|
|
727
|
+
const left = this.normalize(this.compose2nPxDiv2(coeffs));
|
|
728
|
+
frames.push({ parent, coeffs: left, isFirst: true, isLeft: true });
|
|
729
|
+
frames.push({
|
|
730
|
+
parent,
|
|
731
|
+
coeffs: this.normalize(this.translate(left)),
|
|
732
|
+
isFirst: true,
|
|
733
|
+
isLeft: false,
|
|
734
|
+
});
|
|
735
|
+
}
|
|
736
|
+
|
|
737
|
+
// The interval (0, 1), or the point 1/2, of the top frame mapped back through its ancestors.
|
|
738
|
+
private mapToRoot(frames: DrsFrame[], value: Mpbq) {
|
|
739
|
+
let result = value;
|
|
740
|
+
for (let index = frames.length - 1; index !== -1; index = frames[index].parent)
|
|
741
|
+
result = frames[index].isLeft ? result.div2() : result.add(Mpbq.one).div2();
|
|
742
|
+
return result;
|
|
743
|
+
}
|
|
744
|
+
|
|
745
|
+
private drsIsolate01Roots(coeffs: Upolynomial, result: IsolatedRoots) {
|
|
746
|
+
const bound = this.descartesBound01(coeffs);
|
|
747
|
+
if (bound === 0) return;
|
|
748
|
+
if (bound === 1) {
|
|
749
|
+
result.lowers.push(Mpbq.zero);
|
|
750
|
+
result.uppers.push(Mpbq.one);
|
|
751
|
+
return;
|
|
752
|
+
}
|
|
753
|
+
const half = Mpbq.of(1n, 1);
|
|
754
|
+
const frames: DrsFrame[] = [];
|
|
755
|
+
const twoXMinusOne = [-1n, 2n];
|
|
756
|
+
if (this.hasOneHalfRoot(coeffs)) {
|
|
757
|
+
result.roots.push(half);
|
|
758
|
+
this.pushChildFrames(this.div(coeffs, twoXMinusOne), frames);
|
|
759
|
+
} else this.pushChildFrames(coeffs, frames);
|
|
760
|
+
while (frames.length > 0) {
|
|
761
|
+
const frame = frames[frames.length - 1];
|
|
762
|
+
if (!frame.isFirst) {
|
|
763
|
+
frames.pop();
|
|
764
|
+
continue;
|
|
765
|
+
}
|
|
766
|
+
frame.isFirst = false;
|
|
767
|
+
const frameBound = this.descartesBound01(frame.coeffs);
|
|
768
|
+
if (frameBound === 0) {
|
|
769
|
+
frames.pop();
|
|
770
|
+
continue;
|
|
771
|
+
}
|
|
772
|
+
if (frameBound === 1) {
|
|
773
|
+
result.lowers.push(this.mapToRoot(frames, Mpbq.zero));
|
|
774
|
+
result.uppers.push(this.mapToRoot(frames, Mpbq.one));
|
|
775
|
+
frames.pop();
|
|
776
|
+
continue;
|
|
777
|
+
}
|
|
778
|
+
if (this.hasOneHalfRoot(frame.coeffs)) {
|
|
779
|
+
result.roots.push(this.mapToRoot(frames, half));
|
|
780
|
+
this.pushChildFrames(this.div(frame.coeffs, twoXMinusOne), frames);
|
|
781
|
+
} else this.pushChildFrames(frame.coeffs, frames);
|
|
782
|
+
}
|
|
783
|
+
}
|
|
784
|
+
|
|
785
|
+
// drs_isolate_roots: the positive roots in (0, 2^k) and the negative ones in (-2^k', 0), each
|
|
786
|
+
// found as the roots in (0, 1) of p(2^k x) or p(-2^k' x) and scaled back.
|
|
787
|
+
private drsIsolateRoots(coeffs: Upolynomial, result: IsolatedRoots) {
|
|
788
|
+
const normalized = this.normalize(coeffs);
|
|
789
|
+
const negativeK = this.knuthNegativeRootUpperBound(coeffs);
|
|
790
|
+
const positiveK = Math.max(negativeK, this.knuthPositiveRootUpperBound(coeffs));
|
|
791
|
+
const isolateScaled = (scaled: Upolynomial, k: number, isNegated: boolean) => {
|
|
792
|
+
const rootsStart = result.roots.length;
|
|
793
|
+
const boundsStart = result.lowers.length;
|
|
794
|
+
this.drsIsolate01Roots(this.composeP2kX(scaled, k), result);
|
|
795
|
+
const adjust = (values: Mpbq[], start: number) => {
|
|
796
|
+
for (let index = start; index < values.length; index++) {
|
|
797
|
+
const value = values[index].mul2k(k);
|
|
798
|
+
values[index] = isNegated ? value.neg() : value;
|
|
799
|
+
}
|
|
800
|
+
};
|
|
801
|
+
adjust(result.roots, rootsStart);
|
|
802
|
+
adjust(result.lowers, boundsStart);
|
|
803
|
+
adjust(result.uppers, boundsStart);
|
|
804
|
+
return boundsStart;
|
|
805
|
+
};
|
|
806
|
+
isolateScaled(normalized, positiveK, false);
|
|
807
|
+
const negativeStart = isolateScaled(this.pMinusX(normalized), negativeK, true);
|
|
808
|
+
for (let index = negativeStart; index < result.lowers.length; index++) {
|
|
809
|
+
const lower = result.lowers[index];
|
|
810
|
+
result.lowers[index] = result.uppers[index];
|
|
811
|
+
result.uppers[index] = lower;
|
|
812
|
+
}
|
|
813
|
+
}
|
|
814
|
+
|
|
815
|
+
// sqf_isolate_roots: the roots of a square-free polynomial, exact roots first when zero is one,
|
|
816
|
+
// then the isolating intervals of the others.
|
|
817
|
+
sqfIsolateRoots(coeffs: Upolynomial): IsolatedRoots {
|
|
818
|
+
const result: IsolatedRoots = { roots: [], lowers: [], uppers: [] };
|
|
819
|
+
if (this.hasZeroRoots(coeffs)) {
|
|
820
|
+
result.roots.push(Mpbq.zero);
|
|
821
|
+
this.drsIsolateRoots(this.removeZeroRoots(coeffs), result);
|
|
822
|
+
} else this.drsIsolateRoots(coeffs, result);
|
|
823
|
+
return result;
|
|
824
|
+
}
|
|
825
|
+
|
|
826
|
+
// Sturm sequences.
|
|
827
|
+
|
|
828
|
+
private sturmSeqCore(sequence: bigint[][]) {
|
|
829
|
+
while (true) {
|
|
830
|
+
const remainder = this.srem(sequence[sequence.length - 2], sequence[sequence.length - 1]);
|
|
831
|
+
if (remainder.length === 0) return sequence;
|
|
832
|
+
sequence.push(this.normalize(remainder));
|
|
833
|
+
}
|
|
834
|
+
}
|
|
835
|
+
|
|
836
|
+
sturmSeq(coeffs: Upolynomial) {
|
|
837
|
+
return this.sturmSeqCore([[...coeffs], this.derivative(coeffs)]);
|
|
838
|
+
}
|
|
839
|
+
|
|
840
|
+
sturmTarskiSeq(first: Upolynomial, second: Upolynomial) {
|
|
841
|
+
return this.sturmSeqCore([[...first], this.mul(this.derivative(first), second)]);
|
|
842
|
+
}
|
|
843
|
+
|
|
844
|
+
// Refinement.
|
|
845
|
+
|
|
846
|
+
// isolating2refinable: an isolating interval of a square-free polynomial turned into one whose
|
|
847
|
+
// endpoint signs differ, or the root it contains.
|
|
848
|
+
isolating2refinable(coeffs: Upolynomial, lower: Mpbq, upper: Mpbq): Refinement {
|
|
849
|
+
const signLower = this.evalSignAtBq(coeffs, lower);
|
|
850
|
+
const signUpper = this.evalSignAtBq(coeffs, upper);
|
|
851
|
+
if (signLower !== 0 && signUpper !== 0) return { isInterval: true, lower, upper };
|
|
852
|
+
if (signLower === 0 && signUpper !== 0) {
|
|
853
|
+
let a = lower;
|
|
854
|
+
let b = upper;
|
|
855
|
+
let newA = a.add(b).div2();
|
|
856
|
+
while (true) {
|
|
857
|
+
const signNewA = this.evalSignAtBq(coeffs, newA);
|
|
858
|
+
if (signNewA !== signUpper) return { isInterval: signNewA !== 0, lower: newA, upper: b };
|
|
859
|
+
b = newA;
|
|
860
|
+
newA = b.add(a).div2();
|
|
861
|
+
}
|
|
862
|
+
}
|
|
863
|
+
if (signLower !== 0 && signUpper === 0) {
|
|
864
|
+
let a = lower;
|
|
865
|
+
let b = upper;
|
|
866
|
+
let newB = a.add(b).div2();
|
|
867
|
+
while (true) {
|
|
868
|
+
const signNewB = this.evalSignAtBq(coeffs, newB);
|
|
869
|
+
if (signNewB !== signLower)
|
|
870
|
+
return signNewB === 0
|
|
871
|
+
? { isInterval: false, lower: newB, upper: b }
|
|
872
|
+
: { isInterval: true, lower: a, upper: newB };
|
|
873
|
+
a = newB;
|
|
874
|
+
newB = b.add(a).div2();
|
|
875
|
+
}
|
|
876
|
+
}
|
|
877
|
+
const a1 = lower;
|
|
878
|
+
const b2 = upper;
|
|
879
|
+
let b1 = a1.add(b2).div2();
|
|
880
|
+
let a2 = b1;
|
|
881
|
+
const signB1 = this.evalSignAtBq(coeffs, b1);
|
|
882
|
+
const signA2 = signB1;
|
|
883
|
+
if (signB1 === 0) return { isInterval: false, lower: b1, upper };
|
|
884
|
+
let newA1 = a1.add(b1).div2();
|
|
885
|
+
let newB2 = a2.add(b2).div2();
|
|
886
|
+
while (true) {
|
|
887
|
+
const signNewA1 = this.evalSignAtBq(coeffs, newA1);
|
|
888
|
+
if (signNewA1 === 0) return { isInterval: false, lower: newA1, upper };
|
|
889
|
+
if (signNewA1 === -signB1) return { isInterval: true, lower: newA1, upper: b1 };
|
|
890
|
+
const signNewB2 = this.evalSignAtBq(coeffs, newB2);
|
|
891
|
+
if (signNewB2 === 0) return { isInterval: false, lower: newB2, upper };
|
|
892
|
+
if (signNewB2 === -signA2) return { isInterval: true, lower: a2, upper: newB2 };
|
|
893
|
+
b1 = newA1;
|
|
894
|
+
newA1 = b1.add(a1).div2();
|
|
895
|
+
a2 = newB2;
|
|
896
|
+
newB2 = b2.add(a2).div2();
|
|
897
|
+
}
|
|
898
|
+
}
|
|
899
|
+
|
|
900
|
+
// refine_core: one bisection of a refinable interval, or the root at its midpoint.
|
|
901
|
+
refineCore(coeffs: Upolynomial, signLower: number, lower: Mpbq, upper: Mpbq): Refinement {
|
|
902
|
+
const middle = lower.add(upper).div2();
|
|
903
|
+
const signMiddle = this.evalSignAtBq(coeffs, middle);
|
|
904
|
+
if (signMiddle === 0) return { isInterval: false, lower: middle, upper };
|
|
905
|
+
return signMiddle === signLower
|
|
906
|
+
? { isInterval: true, lower: middle, upper }
|
|
907
|
+
: { isInterval: true, lower, upper: middle };
|
|
908
|
+
}
|
|
909
|
+
|
|
910
|
+
refine(coeffs: Upolynomial, lower: Mpbq, upper: Mpbq) {
|
|
911
|
+
return this.refineCore(coeffs, this.evalSignAtBq(coeffs, lower), lower, upper);
|
|
912
|
+
}
|
|
913
|
+
|
|
914
|
+
// refine_core with a precision: bisects until the interval is narrower than 1/2^k.
|
|
915
|
+
refineToPrecision(coeffs: Upolynomial, lower: Mpbq, upper: Mpbq, precision: number): Refinement {
|
|
916
|
+
const signLower = this.evalSignAtBq(coeffs, lower);
|
|
917
|
+
let current: Refinement = { isInterval: true, lower, upper };
|
|
918
|
+
while (true) {
|
|
919
|
+
if (current.upper.sub(current.lower).isLessThanOneDiv2k(precision)) return current;
|
|
920
|
+
current = this.refineCore(coeffs, signLower, current.lower, current.upper);
|
|
921
|
+
if (!current.isInterval) return current;
|
|
922
|
+
}
|
|
923
|
+
}
|
|
924
|
+
|
|
925
|
+
// convert_q2bq_interval: a rational isolating interval (a, b) as a binary rational one (c, d), or
|
|
926
|
+
// the root itself in c.
|
|
927
|
+
convertQ2bqInterval(coeffs: Upolynomial, a: Rational, b: Rational): Refinement {
|
|
928
|
+
const signA = this.evalSignAtQ(coeffs, a);
|
|
929
|
+
const signB = this.evalSignAtQ(coeffs, b);
|
|
930
|
+
let c = Mpbq.zero;
|
|
931
|
+
let d = Mpbq.zero;
|
|
932
|
+
let isFoundD = false;
|
|
933
|
+
const lowerOfA = Mpbq.fromRational(a);
|
|
934
|
+
if (lowerOfA.isExact) c = lowerOfA.value;
|
|
935
|
+
else {
|
|
936
|
+
let lower = lowerOfA.value;
|
|
937
|
+
let upper = lower.mul2k(1);
|
|
938
|
+
if (a.num < 0n) [lower, upper] = [upper, lower];
|
|
939
|
+
while (upper.compareRational(b) >= 0) {
|
|
940
|
+
const refined = refineUpper(a, lower, upper);
|
|
941
|
+
lower = refined.lower;
|
|
942
|
+
upper = refined.upper;
|
|
943
|
+
}
|
|
944
|
+
while (true) {
|
|
945
|
+
const signUpper = this.evalSignAtBq(coeffs, upper);
|
|
946
|
+
if (signUpper === 0) return { isInterval: false, lower: upper, upper };
|
|
947
|
+
if (signUpper === signA) {
|
|
948
|
+
c = upper;
|
|
949
|
+
break;
|
|
950
|
+
}
|
|
951
|
+
if (!isFoundD) {
|
|
952
|
+
isFoundD = true;
|
|
953
|
+
d = upper;
|
|
954
|
+
}
|
|
955
|
+
const refined = refineUpper(a, lower, upper);
|
|
956
|
+
lower = refined.lower;
|
|
957
|
+
upper = refined.upper;
|
|
958
|
+
}
|
|
959
|
+
}
|
|
960
|
+
if (isFoundD) return { isInterval: true, lower: c, upper: d };
|
|
961
|
+
const lowerOfB = Mpbq.fromRational(b);
|
|
962
|
+
if (lowerOfB.isExact) return { isInterval: true, lower: c, upper: lowerOfB.value };
|
|
963
|
+
let lower = lowerOfB.value;
|
|
964
|
+
let upper = lower.mul2k(1);
|
|
965
|
+
if (b.num < 0n) [lower, upper] = [upper, lower];
|
|
966
|
+
while (lower.compare(c) <= 0) {
|
|
967
|
+
const refined = refineLower(b, lower, upper);
|
|
968
|
+
lower = refined.lower;
|
|
969
|
+
upper = refined.upper;
|
|
970
|
+
}
|
|
971
|
+
while (true) {
|
|
972
|
+
const signLower = this.evalSignAtBq(coeffs, lower);
|
|
973
|
+
if (signLower === 0) return { isInterval: false, lower, upper };
|
|
974
|
+
if (signLower === signB) return { isInterval: true, lower: c, upper: lower };
|
|
975
|
+
const refined = refineLower(b, lower, upper);
|
|
976
|
+
lower = refined.lower;
|
|
977
|
+
upper = refined.upper;
|
|
978
|
+
}
|
|
979
|
+
}
|
|
980
|
+
|
|
981
|
+
// normalize_interval_core: a refinable interval around zero shrunk to the side of zero holding
|
|
982
|
+
// the root, given the sign at its lower end. Null when zero is the root.
|
|
983
|
+
normalizeInterval(coeffs: Upolynomial, lower: Mpbq, upper: Mpbq, signLower: number) {
|
|
984
|
+
if (!(lower.isNeg && upper.isPos)) return { lower, upper };
|
|
985
|
+
if (this.hasZeroRoots(coeffs)) return null;
|
|
986
|
+
return signLower === this.evalSignAtZero(coeffs)
|
|
987
|
+
? { lower: Mpbq.zero, upper }
|
|
988
|
+
: { lower, upper: Mpbq.zero };
|
|
989
|
+
}
|
|
990
|
+
|
|
991
|
+
// get_root_id: the number of roots up to l.
|
|
992
|
+
getRootId(coeffs: Upolynomial, lower: Mpbq) {
|
|
993
|
+
const sequence = this.sturmSeq(coeffs);
|
|
994
|
+
return this.signVariationsAtMinusInf(sequence) - this.signVariationsAt(sequence, lower);
|
|
995
|
+
}
|
|
996
|
+
}
|