tla-ts 0.0.4 → 0.0.5-dev.5b2dea1
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 +38 -127
- package/dist/cli.cjs +1 -1
- package/dist/cli.js +1 -1
- package/dist/deciders.cjs +366 -0
- package/dist/deciders.js +366 -0
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +46 -12
- package/dist/index.d.ts +46 -12
- 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 +1006 -0
- package/dist/prove.js +1006 -0
- package/dist/run.cjs +45 -0
- package/dist/run.js +45 -0
- package/dist/tlapm.cjs +10 -0
- package/dist/tlapm.js +10 -0
- package/dist/transfer.cjs +76 -92
- package/dist/transfer.js +76 -92
- package/dist/worker.cjs +21 -0
- package/dist/worker.js +21 -0
- package/package.json +21 -12
- package/src/ast.ts +2 -2
- package/src/bags.ts +22 -23
- package/src/builtins.ts +16 -8
- package/src/check.ts +131 -1153
- package/src/{cli-options.ts → cli/options.ts} +54 -9
- package/src/cli/run.ts +63 -0
- package/src/cli/shared.ts +106 -0
- package/src/cli/tlapm.ts +374 -0
- package/src/{run-cli.ts → cli/tlc.ts} +115 -721
- package/src/cli/xml-exporter.ts +221 -0
- package/src/cli.ts +1 -1
- package/src/codegen.ts +43 -22
- package/src/config.ts +5 -5
- package/src/dependencies.ts +4 -6
- package/src/environment.ts +55 -60
- package/src/errors.ts +97 -35
- package/src/evaluate.ts +361 -181
- package/src/exit-codes.ts +1 -1
- package/src/fingerprints.ts +3 -3
- package/src/index.ts +10 -0
- package/src/instances.ts +56 -46
- package/src/java-overrides.ts +79 -41
- package/src/json.ts +31 -36
- package/src/levels.ts +10 -13
- package/src/{live-check.ts → liveness-checker.ts} +207 -141
- package/src/liveness.ts +38 -34
- package/src/{obligation-action.ts → obligations/action.ts} +248 -74
- package/src/{obligation-anon.ts → obligations/anonymize.ts} +55 -57
- package/src/obligations/equality.ts +260 -0
- package/src/obligations/expression.ts +618 -0
- package/src/{obligation-format.ts → obligations/format.ts} +7 -8
- package/src/obligations/generate.ts +457 -0
- package/src/{obligations.ts → obligations/index.ts} +46 -32
- package/src/{obligation-levels.ts → obligations/levels.ts} +44 -40
- package/src/obligations/module.ts +445 -0
- package/src/obligations/normalize.ts +554 -0
- package/src/obligations/operators.ts +176 -0
- package/src/obligations/pragma.ts +195 -0
- package/src/{obligation-printer.ts → obligations/printer.ts} +65 -230
- package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
- package/src/obligations/regroup.ts +100 -0
- package/src/{obligation-generate.ts → obligations/simplify.ts} +130 -536
- package/src/{obligation-source.ts → obligations/source.ts} +172 -216
- package/src/{obligation-deref.ts → obligations/subexpression.ts} +84 -115
- package/src/obligations/substitution.ts +261 -0
- package/src/obligations/temporal.ts +321 -0
- package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
- package/src/parallel-worker.ts +39 -51
- package/src/parallel.ts +39 -66
- package/src/parser.ts +67 -74
- package/src/{pcal-ast.ts → pcal/ast.ts} +2 -17
- package/src/{pcal-parse.ts → pcal/parse.ts} +28 -64
- package/src/{pcal-tokenize.ts → pcal/tokenize.ts} +10 -39
- package/src/{pcal-translate.ts → pcal/translate.ts} +30 -109
- package/src/{pcal-validate.ts → pcal/validate.ts} +10 -20
- package/src/prover/decide-pool.ts +95 -0
- package/src/prover/deciders.ts +33 -0
- package/src/prover/first-order.ts +175 -0
- package/src/prover/isabelle/LICENSE +36 -0
- package/src/prover/isabelle/LICENSE-tlapm +26 -0
- package/src/prover/isabelle/decide.ts +44 -0
- package/src/prover/isabelle/encode.ts +445 -0
- package/src/prover/isabelle/isar/inner-syntax.ts +579 -0
- package/src/prover/isabelle/isar/method.ts +367 -0
- package/src/prover/isabelle/isar/proof.ts +28 -0
- package/src/prover/isabelle/isar/statement.ts +57 -0
- package/src/prover/isabelle/isar/theory.ts +192 -0
- package/src/prover/isabelle/isar/type-check.ts +278 -0
- package/src/prover/isabelle/provers/blast/blast.ts +258 -0
- package/src/prover/isabelle/provers/blast/branch.ts +322 -0
- package/src/prover/isabelle/provers/blast/prove.ts +347 -0
- package/src/prover/isabelle/provers/blast/rules.ts +330 -0
- package/src/prover/isabelle/provers/blast/state.ts +180 -0
- package/src/prover/isabelle/provers/blast/term.ts +546 -0
- package/src/prover/isabelle/provers/clasimp.ts +150 -0
- package/src/prover/isabelle/provers/classical.ts +389 -0
- package/src/prover/isabelle/provers/hypsubst.ts +433 -0
- package/src/prover/isabelle/pure/bicompose.ts +174 -0
- package/src/prover/isabelle/pure/consts.ts +32 -0
- package/src/prover/isabelle/pure/conv.ts +79 -0
- package/src/prover/isabelle/pure/drule.ts +264 -0
- package/src/prover/isabelle/pure/envir.ts +331 -0
- package/src/prover/isabelle/pure/goal.ts +53 -0
- package/src/prover/isabelle/pure/interrupt.ts +16 -0
- package/src/prover/isabelle/pure/list.ts +12 -0
- package/src/prover/isabelle/pure/logic.ts +330 -0
- package/src/prover/isabelle/pure/name.ts +98 -0
- package/src/prover/isabelle/pure/net.ts +215 -0
- package/src/prover/isabelle/pure/object-logic.ts +41 -0
- package/src/prover/isabelle/pure/pattern.ts +631 -0
- package/src/prover/isabelle/pure/raw-simplifier.ts +338 -0
- package/src/prover/isabelle/pure/rewriter.ts +602 -0
- package/src/prover/isabelle/pure/search.ts +68 -0
- package/src/prover/isabelle/pure/seq.ts +133 -0
- package/src/prover/isabelle/pure/simplifier.ts +106 -0
- package/src/prover/isabelle/pure/table.ts +201 -0
- package/src/prover/isabelle/pure/tactic.ts +168 -0
- package/src/prover/isabelle/pure/tactical.ts +264 -0
- package/src/prover/isabelle/pure/term-ord.ts +105 -0
- package/src/prover/isabelle/pure/term.ts +688 -0
- package/src/prover/isabelle/pure/thm.ts +783 -0
- package/src/prover/isabelle/pure/type.ts +121 -0
- package/src/prover/isabelle/pure/unify.ts +753 -0
- package/src/prover/isabelle/pure/variable.ts +25 -0
- package/src/prover/isabelle/tla/classical-setup.ts +101 -0
- package/src/prover/isabelle/tla/context.ts +74 -0
- package/src/prover/isabelle/tla/logic-data.ts +5 -0
- package/src/prover/isabelle/tla/logic.ts +215 -0
- package/src/prover/isabelle/tla/simpdata.ts +241 -0
- package/src/prover/isabelle/tools/intuitionistic.ts +132 -0
- package/src/prover/ocaml.ts +22 -0
- package/src/prover/prep/action.ts +508 -0
- package/src/prover/prep/enabled-axioms.ts +189 -0
- package/src/prover/prep/fingerprint.ts +388 -0
- package/src/prover/prep/level-comparison.ts +529 -0
- package/src/prover/prep/md5.ts +60 -0
- package/src/prover/prep/methods.ts +221 -0
- package/src/prover/prep/normalize.ts +309 -0
- package/src/prover/prove-worker.ts +22 -0
- package/src/prover/prove.ts +492 -0
- package/src/prover/ptl/decide.ts +68 -0
- package/src/prover/ptl/encode.ts +244 -0
- package/src/prover/ptl/sat.ts +151 -0
- package/src/prover/ptl/tableau.ts +276 -0
- package/src/prover/smt/axioms.ts +209 -0
- package/src/prover/smt/context.ts +108 -0
- package/src/prover/smt/data.ts +636 -0
- package/src/prover/smt/encode.ts +275 -0
- package/src/prover/smt/extensionality.ts +65 -0
- package/src/prover/smt/flatten.ts +112 -0
- package/src/prover/smt/format.ts +154 -0
- package/src/prover/smt/instances.ts +181 -0
- package/src/prover/smt/rewrite.ts +766 -0
- package/src/prover/smt/solver/act-cache.ts +265 -0
- package/src/prover/smt/solver/arith-rewriter.ts +962 -0
- package/src/prover/smt/solver/array.ts +22 -0
- package/src/prover/smt/solver/asserted-formulas.ts +469 -0
- package/src/prover/smt/solver/ast-lt.ts +157 -0
- package/src/prover/smt/solver/ast-util.ts +91 -0
- package/src/prover/smt/solver/ast.ts +1315 -0
- package/src/prover/smt/solver/auf-solver.ts +572 -0
- package/src/prover/smt/solver/case-split-queue.ts +178 -0
- package/src/prover/smt/solver/cg-table.ts +175 -0
- package/src/prover/smt/solver/clause.ts +276 -0
- package/src/prover/smt/solver/conflict-resolution.ts +343 -0
- package/src/prover/smt/solver/context.ts +1292 -0
- package/src/prover/smt/solver/ctx-simplify.ts +334 -0
- package/src/prover/smt/solver/der.ts +224 -0
- package/src/prover/smt/solver/dyn-ack.ts +141 -0
- package/src/prover/smt/solver/e-matching.ts +659 -0
- package/src/prover/smt/solver/enode.ts +259 -0
- package/src/prover/smt/solver/expr-ref.ts +21 -0
- package/src/prover/smt/solver/expr-safe-replace.ts +172 -0
- package/src/prover/smt/solver/fingerprints.ts +92 -0
- package/src/prover/smt/solver/flat-literals.ts +51 -0
- package/src/prover/smt/solver/goal.ts +138 -0
- package/src/prover/smt/solver/hash.ts +173 -0
- package/src/prover/smt/solver/hashtable.ts +166 -0
- package/src/prover/smt/solver/internalizer.ts +1381 -0
- package/src/prover/smt/solver/lbool.ts +5 -0
- package/src/prover/smt/solver/literal.ts +24 -0
- package/src/prover/smt/solver/lp/bound-propagator.ts +391 -0
- package/src/prover/smt/solver/lp/constraints.ts +78 -0
- package/src/prover/smt/solver/lp/containers.ts +296 -0
- package/src/prover/smt/solver/lp/core-solver.ts +504 -0
- package/src/prover/smt/solver/lp/cross-nested.ts +224 -0
- package/src/prover/smt/solver/lp/dep-intervals.ts +642 -0
- package/src/prover/smt/solver/lp/dependency.ts +51 -0
- package/src/prover/smt/solver/lp/dioph-eq.ts +1181 -0
- package/src/prover/smt/solver/lp/explanation.ts +46 -0
- package/src/prover/smt/solver/lp/gomory.ts +255 -0
- package/src/prover/smt/solver/lp/hnf-cutter.ts +125 -0
- package/src/prover/smt/solver/lp/hnf.ts +281 -0
- package/src/prover/smt/solver/lp/int-cube.ts +295 -0
- package/src/prover/smt/solver/lp/int-solver.ts +514 -0
- package/src/prover/smt/solver/lp/lar-solver.ts +816 -0
- package/src/prover/smt/solver/lp/lar-term.ts +62 -0
- package/src/prover/smt/solver/lp/lp-settings.ts +91 -0
- package/src/prover/smt/solver/lp/maximize-term.ts +347 -0
- package/src/prover/smt/solver/lp/nex-creator.ts +381 -0
- package/src/prover/smt/solver/lp/nex.ts +120 -0
- package/src/prover/smt/solver/lp/nla-backoff.ts +43 -0
- package/src/prover/smt/solver/lp/nla-basics.ts +398 -0
- package/src/prover/smt/solver/lp/nla-core.ts +968 -0
- package/src/prover/smt/solver/lp/nla-divisions.ts +332 -0
- package/src/prover/smt/solver/lp/nla-emonics.ts +373 -0
- package/src/prover/smt/solver/lp/nla-factorization.ts +30 -0
- package/src/prover/smt/solver/lp/nla-grobner.ts +904 -0
- package/src/prover/smt/solver/lp/nla-horner.ts +126 -0
- package/src/prover/smt/solver/lp/nla-intervals.ts +265 -0
- package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +715 -0
- package/src/prover/smt/solver/lp/nla-monotone.ts +59 -0
- package/src/prover/smt/solver/lp/nla-order.ts +307 -0
- package/src/prover/smt/solver/lp/nla-patcher.ts +112 -0
- package/src/prover/smt/solver/lp/nla-tangents.ts +251 -0
- package/src/prover/smt/solver/lp/nla-throttle.ts +85 -0
- package/src/prover/smt/solver/lp/nla-types.ts +124 -0
- package/src/prover/smt/solver/lp/nla-var-eqs.ts +141 -0
- package/src/prover/smt/solver/lp/nra-solver.ts +440 -0
- package/src/prover/smt/solver/lp/numeric-pair.ts +65 -0
- package/src/prover/smt/solver/lp/pdd-interval.ts +31 -0
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +184 -0
- package/src/prover/smt/solver/lp/pdd-solver.ts +408 -0
- package/src/prover/smt/solver/lp/pdd.ts +971 -0
- package/src/prover/smt/solver/lp/random-updater.ts +138 -0
- package/src/prover/smt/solver/lp/static-matrix.ts +246 -0
- package/src/prover/smt/solver/lp/union-find.ts +96 -0
- package/src/prover/smt/solver/mam-compiler.ts +847 -0
- package/src/prover/smt/solver/mam-interpreter.ts +400 -0
- package/src/prover/smt/solver/maximize-ac-sharing.ts +118 -0
- package/src/prover/smt/solver/model-checker.ts +347 -0
- package/src/prover/smt/solver/model-evaluator.ts +262 -0
- package/src/prover/smt/solver/model-finder.ts +155 -0
- package/src/prover/smt/solver/model-generator.ts +97 -0
- package/src/prover/smt/solver/model-macro-solver.ts +728 -0
- package/src/prover/smt/solver/nlsat/algebraic.ts +1161 -0
- package/src/prover/smt/solver/nlsat/atoms.ts +238 -0
- package/src/prover/smt/solver/nlsat/evaluator.ts +303 -0
- package/src/prover/smt/solver/nlsat/explain.ts +607 -0
- package/src/prover/smt/solver/nlsat/interval-set.ts +351 -0
- package/src/prover/smt/solver/nlsat/levelwise.ts +737 -0
- package/src/prover/smt/solver/nlsat/mpbq.ts +161 -0
- package/src/prover/smt/solver/nlsat/polynomial.ts +1722 -0
- package/src/prover/smt/solver/nlsat/solver.ts +911 -0
- package/src/prover/smt/solver/nlsat/types.ts +43 -0
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +645 -0
- package/src/prover/smt/solver/nlsat/upolynomial.ts +996 -0
- package/src/prover/smt/solver/nnf.ts +469 -0
- package/src/prover/smt/solver/pattern-inference.ts +351 -0
- package/src/prover/smt/solver/poly-rewriter.ts +477 -0
- package/src/prover/smt/solver/propagate-values.ts +83 -0
- package/src/prover/smt/solver/proto-model.ts +551 -0
- package/src/prover/smt/solver/pull-quant.ts +139 -0
- package/src/prover/smt/solver/qe-lite-der.ts +526 -0
- package/src/prover/smt/solver/qe-lite-fm.ts +576 -0
- package/src/prover/smt/solver/qe-lite.ts +381 -0
- package/src/prover/smt/solver/qi-queue.ts +362 -0
- package/src/prover/smt/solver/quant-tactics.ts +117 -0
- package/src/prover/smt/solver/quantifier-analyzer.ts +562 -0
- package/src/prover/smt/solver/quantifier-manager.ts +186 -0
- package/src/prover/smt/solver/random-gen.ts +10 -0
- package/src/prover/smt/solver/rational.ts +165 -0
- package/src/prover/smt/solver/ref-vector.ts +62 -0
- package/src/prover/smt/solver/relevancy.ts +247 -0
- package/src/prover/smt/solver/rewriter-tpl.ts +1159 -0
- package/src/prover/smt/solver/rewriter.ts +843 -0
- package/src/prover/smt/solver/rlimit.ts +84 -0
- package/src/prover/smt/solver/smtlib-parser.ts +526 -0
- package/src/prover/smt/solver/solver.ts +71 -0
- package/src/prover/smt/solver/sort.ts +35 -0
- package/src/prover/smt/solver/sticky-generations.ts +69 -0
- package/src/prover/smt/solver/theory-lra-axioms.ts +340 -0
- package/src/prover/smt/solver/theory-lra-bounds.ts +226 -0
- package/src/prover/smt/solver/theory-lra-final-check.ts +252 -0
- package/src/prover/smt/solver/theory-lra-internalize.ts +476 -0
- package/src/prover/smt/solver/theory-lra-model.ts +243 -0
- package/src/prover/smt/solver/theory-lra-propagate.ts +405 -0
- package/src/prover/smt/solver/theory-lra-state.ts +43 -0
- package/src/prover/smt/solver/theory-lra.ts +56 -0
- package/src/prover/smt/solver/var-subst.ts +258 -0
- package/src/prover/smt/solver/z3-license.txt +10 -0
- package/src/prover/smt/table.ts +170 -0
- package/src/prover/tlapm/cache.ts +236 -0
- package/src/prover/tlapm/ocaml-marshal.ts +166 -0
- package/src/prover/tlapm/tlapm.ts +96 -0
- package/src/prover/tlaps-module.ts +510 -0
- package/src/prover/verdict.ts +13 -0
- package/src/prover/zenon/LICENSE +32 -0
- package/src/prover/zenon/check/check.ts +105 -0
- package/src/prover/zenon/check/definitions.ts +144 -0
- package/src/prover/zenon/check/equality.ts +182 -0
- package/src/prover/zenon/check/functions.ts +62 -0
- package/src/prover/zenon/check/keys.ts +125 -0
- package/src/prover/zenon/check/propositional.ts +104 -0
- package/src/prover/zenon/check/records.ts +188 -0
- package/src/prover/zenon/check/relations.ts +121 -0
- package/src/prover/zenon/check/rewrites.ts +224 -0
- package/src/prover/zenon/check/sets.ts +302 -0
- package/src/prover/zenon/check/terms.ts +127 -0
- package/src/prover/zenon/check/tla.ts +126 -0
- package/src/prover/zenon/decide.ts +107 -0
- package/src/prover/zenon/encode.ts +378 -0
- package/src/prover/zenon/eqrel.ts +300 -0
- package/src/prover/zenon/equality-rules.ts +435 -0
- package/src/prover/zenon/expr.ts +551 -0
- package/src/prover/zenon/index-table.ts +350 -0
- package/src/prover/zenon/isar-case.ts +513 -0
- package/src/prover/zenon/isar.ts +1249 -0
- package/src/prover/zenon/limits.ts +15 -0
- package/src/prover/zenon/llproof.ts +173 -0
- package/src/prover/zenon/mltoll.ts +1566 -0
- package/src/prover/zenon/node.ts +297 -0
- package/src/prover/zenon/ocaml.ts +169 -0
- package/src/prover/zenon/parse.ts +247 -0
- package/src/prover/zenon/phrase.ts +191 -0
- package/src/prover/zenon/proof.ts +198 -0
- package/src/prover/zenon/propositional-rules.ts +387 -0
- package/src/prover/zenon/rules.ts +94 -0
- package/src/prover/zenon/search.ts +288 -0
- package/src/prover/zenon/tla/functions.ts +151 -0
- package/src/prover/zenon/tla/llproof.ts +480 -0
- package/src/prover/zenon/tla/records.ts +225 -0
- package/src/prover/zenon/tla/rewrites.ts +447 -0
- package/src/prover/zenon/tla/sets.ts +304 -0
- package/src/prover/zenon/tla/terms.ts +162 -0
- package/src/prover/zenon/tla/tla.ts +506 -0
- package/src/randomization.ts +19 -24
- package/src/resolve.ts +15 -22
- package/src/runtime.ts +8 -8
- package/src/{sany-builtins.ts → sany/builtins.ts} +1 -1
- package/src/{sany-generator.ts → sany/generator.ts} +38 -55
- package/src/{sany-levels.ts → sany/levels.ts} +45 -48
- package/src/{sany-lexer.ts → sany/lexer.ts} +2 -3
- package/src/{sany-linter.ts → sany/linter.ts} +1 -1
- package/src/{sany-modules.ts → sany/modules.ts} +2 -2
- package/src/{sany-nodes.ts → sany/nodes.ts} +2 -2
- package/src/{sany-parse-error.ts → sany/parse-error.ts} +2 -2
- package/src/{sany-report.ts → sany/report.ts} +16 -17
- package/src/{sany-selectors.ts → sany/selectors.ts} +3 -5
- package/src/{sany-source.ts → sany/source.ts} +6 -7
- package/src/{sany-xml.ts → sany/xml.ts} +5 -6
- package/src/search.ts +969 -0
- package/src/spec-description.ts +26 -20
- package/src/{standard-levels.ts → standard-definitions.ts} +118 -2
- package/src/standard-modules.ts +21 -22
- package/src/state-graph.ts +9 -8
- package/src/substitution-levels.ts +2 -2
- package/src/successors.ts +39 -23
- package/src/symmetry.ts +1 -1
- package/src/tableau.ts +6 -7
- package/src/tlc/fingerprint.ts +214 -0
- package/src/{tlc-messages.ts → tlc/messages.ts} +119 -7
- package/src/{tlc-order.ts → tlc/order.ts} +7 -7
- package/src/{tlc-random.ts → tlc/random.ts} +3 -190
- package/src/{tlc-replay.ts → tlc/replay.ts} +40 -36
- package/src/{tlc-module.ts → tlc/tlc-operators.ts} +9 -9
- package/src/{tlc-ext.ts → tlc/tlcext-operators.ts} +30 -25
- package/src/{tlc-version.ts → tlc/version.ts} +8 -7
- package/src/transfer.ts +32 -32
- package/src/values.ts +166 -111
- package/src/worker.ts +62 -0
- package/dist/parallel.cjs +0 -12
- package/dist/parallel.js +0 -12
- package/dist/run-cli.cjs +0 -55
- package/dist/run-cli.js +0 -55
- package/src/canonical.ts +0 -40
- package/src/obligation-expression.ts +0 -1060
- package/src/obligation-module.ts +0 -1042
- package/src/standard-ranges.ts +0 -116
- package/src/value-sources.ts +0 -29
- /package/src/{tlc-modules.ts → tlc/jar-data.ts} +0 -0
- /package/src/{tlc-summary.ts → tlc/summary.ts} +0 -0
|
@@ -0,0 +1,737 @@
|
|
|
1
|
+
// Ported from Z3 (src/nlsat/levelwise.cpp, src/nlsat/nlsat_common.cpp,
|
|
2
|
+
// src/util/index_sort_with_mutations.h), MIT license, see z3-license.txt. The levelwise single cell
|
|
3
|
+
// construction: around the sample, for each variable below the top one, the interval of root
|
|
4
|
+
// functions in which the projected polynomials keep their signs and orders.
|
|
5
|
+
//
|
|
6
|
+
// Deviation: Z3 breaks two ties by polynomial id: between root functions of equal value and degree,
|
|
7
|
+
// and in the order of the arguments of a top-level resultant. Z3 recycles the ids of freed
|
|
8
|
+
// polynomials (id_gen in polynomial.cpp), so its ids depend on its reference counting. Here ids
|
|
9
|
+
// follow creation order. Either choice bounds a valid cell, but the bounding polynomial can be a
|
|
10
|
+
// different one with the same root, such as x0 for -x0. Differential tests count these as ties.
|
|
11
|
+
import { NlsatUnsupportedError } from "../../../../errors";
|
|
12
|
+
import { Rational } from "../rational";
|
|
13
|
+
import type { AlgebraicManager, Anum } from "./algebraic";
|
|
14
|
+
import {
|
|
15
|
+
NULL_VAR,
|
|
16
|
+
type Polynomial,
|
|
17
|
+
type PolynomialCache,
|
|
18
|
+
type PolynomialManager,
|
|
19
|
+
} from "./polynomial";
|
|
20
|
+
|
|
21
|
+
// A section is the index-th root of lower. A sector lies between the lowerIndex-th root of lower
|
|
22
|
+
// and the upperIndex-th root of upper, and a null bound is infinite.
|
|
23
|
+
interface CellInterval {
|
|
24
|
+
isSection: boolean;
|
|
25
|
+
lower: Polynomial | null;
|
|
26
|
+
lowerIndex: number;
|
|
27
|
+
upper: Polynomial | null;
|
|
28
|
+
upperIndex: number;
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
// lws_spt_threshold, lws_witness_subs_lc and lws_witness_subs_disc.
|
|
32
|
+
interface LevelwiseParams {
|
|
33
|
+
spanningTreeThreshold: number;
|
|
34
|
+
isWitnessSubsLc: boolean;
|
|
35
|
+
isWitnessSubsDisc: boolean;
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
const DEFAULT_LEVELWISE_PARAMS: LevelwiseParams = {
|
|
39
|
+
spanningTreeThreshold: 4,
|
|
40
|
+
isWitnessSubsLc: true,
|
|
41
|
+
isWitnessSubsDisc: true,
|
|
42
|
+
};
|
|
43
|
+
|
|
44
|
+
interface RootFunction {
|
|
45
|
+
value: Anum;
|
|
46
|
+
polynomial: Polynomial;
|
|
47
|
+
index: number;
|
|
48
|
+
psIndex: number;
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
type ProjectionMode = "section" | "sector" | "spanningTree";
|
|
52
|
+
|
|
53
|
+
const UNSET = -1;
|
|
54
|
+
// m_side_mask: bit 0 for a root at or below the sample, bit 1 above, 3 for both.
|
|
55
|
+
const BOTH_SIDES = 3;
|
|
56
|
+
|
|
57
|
+
// stable_index_merge_sort: bottom-up, so each pair is compared once even though comparing refines
|
|
58
|
+
// the numbers.
|
|
59
|
+
const sortIndicesStably = (count: number, isLess: (first: number, second: number) => boolean) => {
|
|
60
|
+
let source = Array.from({ length: count }, (_, index) => index);
|
|
61
|
+
for (let width = 1; width < count; width *= 2) {
|
|
62
|
+
const target: number[] = [];
|
|
63
|
+
for (let low = 0; low < count; low += 2 * width) {
|
|
64
|
+
const middle = Math.min(low + width, count);
|
|
65
|
+
const high = Math.min(low + 2 * width, count);
|
|
66
|
+
let left = low;
|
|
67
|
+
let right = middle;
|
|
68
|
+
while (left < middle && right < high)
|
|
69
|
+
target.push(isLess(source[right], source[left]) ? source[right++] : source[left++]);
|
|
70
|
+
while (left < middle) target.push(source[left++]);
|
|
71
|
+
while (right < high) target.push(source[right++]);
|
|
72
|
+
}
|
|
73
|
+
source = target;
|
|
74
|
+
}
|
|
75
|
+
return source;
|
|
76
|
+
};
|
|
77
|
+
|
|
78
|
+
// todo_set with canonicalization: the distinct primitive, sign-normalized polynomials still to
|
|
79
|
+
// project, in insertion order. A polynomial already in the cache goes in as it is.
|
|
80
|
+
export class TodoSet {
|
|
81
|
+
polynomials: Polynomial[] = [];
|
|
82
|
+
private inSet = new Set<number>();
|
|
83
|
+
|
|
84
|
+
constructor(
|
|
85
|
+
private pm: PolynomialManager,
|
|
86
|
+
private cache: PolynomialCache,
|
|
87
|
+
) {}
|
|
88
|
+
|
|
89
|
+
get isEmpty() {
|
|
90
|
+
return this.polynomials.length === 0;
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
reset() {
|
|
94
|
+
this.polynomials = [];
|
|
95
|
+
this.inSet.clear();
|
|
96
|
+
}
|
|
97
|
+
|
|
98
|
+
contains(polynomial: Polynomial) {
|
|
99
|
+
return this.inSet.has(polynomial.id);
|
|
100
|
+
}
|
|
101
|
+
|
|
102
|
+
insert(polynomial: Polynomial) {
|
|
103
|
+
if (this.inSet.has(polynomial.id)) return polynomial;
|
|
104
|
+
if (this.cache.contains(polynomial)) {
|
|
105
|
+
this.inSet.add(polynomial.id);
|
|
106
|
+
this.polynomials.push(polynomial);
|
|
107
|
+
return polynomial;
|
|
108
|
+
}
|
|
109
|
+
const primitive =
|
|
110
|
+
this.pm.isZero(polynomial) || this.pm.isConst(polynomial)
|
|
111
|
+
? polynomial
|
|
112
|
+
: this.pm.pp(polynomial, this.pm.maxVar(polynomial));
|
|
113
|
+
const unique = this.cache.mkUnique(this.pm.flipSignIfLmNeg(primitive));
|
|
114
|
+
if (!this.inSet.has(unique.id)) {
|
|
115
|
+
this.inSet.add(unique.id);
|
|
116
|
+
this.polynomials.push(unique);
|
|
117
|
+
}
|
|
118
|
+
return unique;
|
|
119
|
+
}
|
|
120
|
+
|
|
121
|
+
getMaxVar() {
|
|
122
|
+
let result = NULL_VAR;
|
|
123
|
+
for (const polynomial of this.polynomials) {
|
|
124
|
+
const variable = this.pm.maxVar(polynomial);
|
|
125
|
+
if (result === NULL_VAR || variable > result) result = variable;
|
|
126
|
+
}
|
|
127
|
+
return result;
|
|
128
|
+
}
|
|
129
|
+
|
|
130
|
+
// extract_max_polys: moves the polynomials of the maximal variable to out, after clearing it.
|
|
131
|
+
extractMaxPolys(out: Polynomial[]) {
|
|
132
|
+
out.length = 0;
|
|
133
|
+
const variable = this.getMaxVar();
|
|
134
|
+
this.extractPolysAtLevel(variable, out);
|
|
135
|
+
return variable;
|
|
136
|
+
}
|
|
137
|
+
|
|
138
|
+
// extract_polys_at_level: moves the polynomials whose maximal variable is x to out.
|
|
139
|
+
extractPolysAtLevel(variable: number, out: Polynomial[]) {
|
|
140
|
+
const kept: Polynomial[] = [];
|
|
141
|
+
for (const polynomial of this.polynomials) {
|
|
142
|
+
if (this.pm.maxVar(polynomial) !== variable) {
|
|
143
|
+
kept.push(polynomial);
|
|
144
|
+
continue;
|
|
145
|
+
}
|
|
146
|
+
out.push(polynomial);
|
|
147
|
+
this.inSet.delete(polynomial.id);
|
|
148
|
+
}
|
|
149
|
+
this.polynomials = kept;
|
|
150
|
+
}
|
|
151
|
+
}
|
|
152
|
+
|
|
153
|
+
class Levelwise {
|
|
154
|
+
private intervals: CellInterval[];
|
|
155
|
+
private todo: TodoSet;
|
|
156
|
+
private level = 0;
|
|
157
|
+
private levelPolys: Polynomial[] = [];
|
|
158
|
+
private witnesses: (Polynomial | null)[] = [];
|
|
159
|
+
private hasRoots: boolean[] = [];
|
|
160
|
+
private rootFunctions: RootFunction[] = [];
|
|
161
|
+
// m_rel.m_pairs: pairs of levelPolys indices, smaller first, iterated in order.
|
|
162
|
+
private pairs = new Map<string, [number, number]>();
|
|
163
|
+
private sideMask: number[] = [];
|
|
164
|
+
private isLcOmitted: boolean[] = [];
|
|
165
|
+
private lowerRf = UNSET;
|
|
166
|
+
private upperRf = UNSET;
|
|
167
|
+
|
|
168
|
+
constructor(
|
|
169
|
+
private pm: PolynomialManager,
|
|
170
|
+
private am: AlgebraicManager,
|
|
171
|
+
private cache: PolynomialCache,
|
|
172
|
+
private sample: readonly (Anum | undefined)[],
|
|
173
|
+
private maxVar: number,
|
|
174
|
+
private isLinear: boolean,
|
|
175
|
+
private params: LevelwiseParams,
|
|
176
|
+
) {
|
|
177
|
+
this.todo = new TodoSet(pm, cache);
|
|
178
|
+
this.intervals = Array.from({ length: maxVar }, () => ({
|
|
179
|
+
isSection: false,
|
|
180
|
+
lower: null,
|
|
181
|
+
lowerIndex: 0,
|
|
182
|
+
upper: null,
|
|
183
|
+
upperIndex: 0,
|
|
184
|
+
}));
|
|
185
|
+
}
|
|
186
|
+
|
|
187
|
+
private getSign(polynomial: Polynomial) {
|
|
188
|
+
return this.am.evalSignAt(this.pm, polynomial, this.sample);
|
|
189
|
+
}
|
|
190
|
+
|
|
191
|
+
private getValuesWithout(variable: number) {
|
|
192
|
+
return this.sample.map((value, index) => (index === variable ? undefined : value));
|
|
193
|
+
}
|
|
194
|
+
|
|
195
|
+
private requestFactorized(polynomial: Polynomial | null) {
|
|
196
|
+
if (polynomial === null || this.pm.isConst(polynomial)) return;
|
|
197
|
+
for (const factor of this.cache.factor(polynomial))
|
|
198
|
+
if (!this.pm.isConst(factor)) this.todo.insert(factor);
|
|
199
|
+
}
|
|
200
|
+
|
|
201
|
+
// The first element of the subresultant chain that is not zero, or null when it is constant.
|
|
202
|
+
private getFirstPsc(first: Polynomial, second: Polynomial, variable: number) {
|
|
203
|
+
for (const element of this.cache.pscChain(first, second, variable)) {
|
|
204
|
+
if (this.pm.isZero(element)) continue;
|
|
205
|
+
return this.pm.isConst(element) ? null : element;
|
|
206
|
+
}
|
|
207
|
+
return null;
|
|
208
|
+
}
|
|
209
|
+
|
|
210
|
+
private getPscDiscriminant(polynomial: Polynomial, variable: number) {
|
|
211
|
+
if (this.pm.isConst(polynomial) || this.pm.degree(polynomial, variable) < 2) return null;
|
|
212
|
+
return this.getFirstPsc(polynomial, this.pm.derivative(polynomial, variable), variable);
|
|
213
|
+
}
|
|
214
|
+
|
|
215
|
+
// handle_nullified_poly: p vanishes at the sample. Its coefficients, then its partial
|
|
216
|
+
// derivatives level by level, in non-decreasing variable order, until one does not vanish.
|
|
217
|
+
private handleNullifiedPoly(polynomial: Polynomial) {
|
|
218
|
+
const degree = this.pm.degree(polynomial, this.level);
|
|
219
|
+
for (let power = 0; power <= degree; power++)
|
|
220
|
+
this.requestFactorized(this.pm.coeff(polynomial, this.level, power));
|
|
221
|
+
let current = [{ polynomial, minVar: 0 }];
|
|
222
|
+
while (current.length > 0) {
|
|
223
|
+
const next: { polynomial: Polynomial; minVar: number }[] = [];
|
|
224
|
+
for (const entry of current) {
|
|
225
|
+
const maxVar = this.pm.maxVar(entry.polynomial);
|
|
226
|
+
if (maxVar === NULL_VAR) continue;
|
|
227
|
+
for (let variable = entry.minVar; variable <= maxVar; variable++) {
|
|
228
|
+
if (this.pm.degree(entry.polynomial, variable) === 0) continue;
|
|
229
|
+
const derivative = this.pm.derivative(entry.polynomial, variable);
|
|
230
|
+
if (this.pm.isConst(derivative)) continue;
|
|
231
|
+
if (this.getSign(derivative) !== 0) {
|
|
232
|
+
this.requestFactorized(derivative);
|
|
233
|
+
return;
|
|
234
|
+
}
|
|
235
|
+
next.push({ polynomial: derivative, minVar: variable });
|
|
236
|
+
}
|
|
237
|
+
}
|
|
238
|
+
for (const entry of next) this.requestFactorized(entry.polynomial);
|
|
239
|
+
current = next;
|
|
240
|
+
}
|
|
241
|
+
}
|
|
242
|
+
|
|
243
|
+
// choose_nonzero_coeff: a coefficient of p in x that is nonzero at the sample: a constant if
|
|
244
|
+
// there is one, else the least by total degree, size and maximal variable. Null when p vanishes.
|
|
245
|
+
private chooseNonzeroCoeff(polynomial: Polynomial, variable: number) {
|
|
246
|
+
const degree = this.pm.degree(polynomial, variable);
|
|
247
|
+
for (let power = 0; power <= degree; power++) {
|
|
248
|
+
const coeff = this.pm.coeff(polynomial, variable, power);
|
|
249
|
+
if (!this.pm.isZero(coeff) && this.pm.isConst(coeff)) return coeff;
|
|
250
|
+
}
|
|
251
|
+
let best: Polynomial | null = null;
|
|
252
|
+
for (let power = 0; power <= degree; power++) {
|
|
253
|
+
const coeff = this.pm.coeff(polynomial, variable, power);
|
|
254
|
+
if (this.pm.isZero(coeff) || this.getSign(coeff) === 0) continue;
|
|
255
|
+
const totalDegree = this.pm.totalDegree(coeff);
|
|
256
|
+
const bestDegree = best === null ? 0 : this.pm.totalDegree(best);
|
|
257
|
+
if (
|
|
258
|
+
best === null ||
|
|
259
|
+
totalDegree < bestDegree ||
|
|
260
|
+
(totalDegree === bestDegree &&
|
|
261
|
+
(coeff.size < best.size ||
|
|
262
|
+
(coeff.size === best.size && this.pm.maxVar(coeff) < this.pm.maxVar(best))))
|
|
263
|
+
)
|
|
264
|
+
best = coeff;
|
|
265
|
+
}
|
|
266
|
+
return best;
|
|
267
|
+
}
|
|
268
|
+
|
|
269
|
+
private addProjectionForPoly(
|
|
270
|
+
polynomial: Polynomial,
|
|
271
|
+
variable: number,
|
|
272
|
+
witness: Polynomial | null,
|
|
273
|
+
isLcAdded: boolean,
|
|
274
|
+
isDiscAdded: boolean,
|
|
275
|
+
) {
|
|
276
|
+
let isWitnessAdded = witness !== null && !this.pm.isConst(witness);
|
|
277
|
+
if (isLcAdded) {
|
|
278
|
+
const lc = this.pm.lc(polynomial, variable);
|
|
279
|
+
this.requestFactorized(lc);
|
|
280
|
+
if (isWitnessAdded && this.params.isWitnessSubsDisc && this.getSign(lc) !== 0)
|
|
281
|
+
isWitnessAdded = false;
|
|
282
|
+
}
|
|
283
|
+
if (isDiscAdded) {
|
|
284
|
+
const disc = this.getPscDiscriminant(polynomial, variable);
|
|
285
|
+
if (disc !== null) {
|
|
286
|
+
this.requestFactorized(disc);
|
|
287
|
+
if (isWitnessAdded && this.params.isWitnessSubsDisc && this.getSign(disc) !== 0)
|
|
288
|
+
isWitnessAdded = false;
|
|
289
|
+
}
|
|
290
|
+
}
|
|
291
|
+
if (isWitnessAdded) this.requestFactorized(witness);
|
|
292
|
+
}
|
|
293
|
+
|
|
294
|
+
private addPair(first: number, second: number) {
|
|
295
|
+
const firstIndex = this.rootFunctions[first].psIndex;
|
|
296
|
+
const secondIndex = this.rootFunctions[second].psIndex;
|
|
297
|
+
if (firstIndex !== secondIndex) this.addPsPair(firstIndex, secondIndex);
|
|
298
|
+
}
|
|
299
|
+
|
|
300
|
+
private addPsPair(first: number, second: number) {
|
|
301
|
+
const pair: [number, number] = first < second ? [first, second] : [second, first];
|
|
302
|
+
this.pairs.set(`${pair[0]},${pair[1]}`, pair);
|
|
303
|
+
}
|
|
304
|
+
|
|
305
|
+
private getSortedPairs() {
|
|
306
|
+
return [...this.pairs.values()].sort((first, second) =>
|
|
307
|
+
first[0] === second[0] ? first[1] - second[1] : first[0] - second[0],
|
|
308
|
+
);
|
|
309
|
+
}
|
|
310
|
+
|
|
311
|
+
private computeSideMask() {
|
|
312
|
+
if (this.lowerRf === UNSET) return;
|
|
313
|
+
while (this.sideMask.length < this.levelPolys.length) this.sideMask.push(0);
|
|
314
|
+
this.rootFunctions.forEach((rootFunction, index) => {
|
|
315
|
+
this.sideMask[rootFunction.psIndex] |= index <= this.lowerRf ? 1 : 2;
|
|
316
|
+
});
|
|
317
|
+
}
|
|
318
|
+
|
|
319
|
+
private getBoundIndex(rf: number) {
|
|
320
|
+
return rf === UNSET ? UNSET : this.rootFunctions[rf].psIndex;
|
|
321
|
+
}
|
|
322
|
+
|
|
323
|
+
// compute_omit_lc_both_sides: by projective delineability, the leading coefficient of a
|
|
324
|
+
// polynomial with roots on both sides that does not bound the cell may be left out. With
|
|
325
|
+
// isLeafRequired, only for the leaves of the resultant graph.
|
|
326
|
+
private computeOmitLcBothSides(isLeafRequired: boolean) {
|
|
327
|
+
this.isLcOmitted = this.levelPolys.map(() => false);
|
|
328
|
+
if (this.rootFunctions.length === 0 || this.pairs.size === 0 || this.sideMask.length === 0)
|
|
329
|
+
return;
|
|
330
|
+
const degrees = this.levelPolys.map(() => 0);
|
|
331
|
+
for (const pair of this.pairs.values()) {
|
|
332
|
+
degrees[pair[0]]++;
|
|
333
|
+
degrees[pair[1]]++;
|
|
334
|
+
}
|
|
335
|
+
const lowerBound = this.getBoundIndex(this.lowerRf);
|
|
336
|
+
const upperBound = this.getBoundIndex(this.upperRf);
|
|
337
|
+
for (let index = 0; index < this.levelPolys.length; index++) {
|
|
338
|
+
if (this.sideMask[index] !== BOTH_SIDES) continue;
|
|
339
|
+
if (isLeafRequired && degrees[index] !== 1) continue;
|
|
340
|
+
if (index === lowerBound || index === upperBound) continue;
|
|
341
|
+
this.isLcOmitted[index] = true;
|
|
342
|
+
}
|
|
343
|
+
}
|
|
344
|
+
|
|
345
|
+
private fillRelationSector() {
|
|
346
|
+
if (this.lowerRf !== UNSET)
|
|
347
|
+
for (let index = 0; index < this.lowerRf; index++) this.addPair(index, this.lowerRf);
|
|
348
|
+
if (this.upperRf !== UNSET)
|
|
349
|
+
for (let index = this.upperRf + 1; index < this.rootFunctions.length; index++)
|
|
350
|
+
this.addPair(this.upperRf, index);
|
|
351
|
+
if (this.lowerRf !== UNSET && this.upperRf !== UNSET) this.addPair(this.lowerRf, this.upperRf);
|
|
352
|
+
}
|
|
353
|
+
|
|
354
|
+
private fillRelationSection() {
|
|
355
|
+
for (let index = 0; index < this.lowerRf; index++) this.addPair(index, this.lowerRf);
|
|
356
|
+
for (let index = this.lowerRf + 1; index < this.rootFunctions.length; index++)
|
|
357
|
+
this.addPair(this.lowerRf, index);
|
|
358
|
+
}
|
|
359
|
+
|
|
360
|
+
// build_both_side_spanning_tree: by the reaching orders lemma, in order of the lower root, each
|
|
361
|
+
// polynomial with roots on both sides is joined to the remaining one whose upper root is least.
|
|
362
|
+
private buildBothSideSpanningTree() {
|
|
363
|
+
const lowerRfs = this.levelPolys.map(() => UNSET);
|
|
364
|
+
const upperRfs = this.levelPolys.map(() => UNSET);
|
|
365
|
+
for (let index = 0; index <= this.lowerRf; index++)
|
|
366
|
+
lowerRfs[this.rootFunctions[index].psIndex] = index;
|
|
367
|
+
for (let index = this.upperRf; index < this.rootFunctions.length; index++)
|
|
368
|
+
upperRfs[this.rootFunctions[index].psIndex] = index;
|
|
369
|
+
const both = this.levelPolys
|
|
370
|
+
.map((_, psIndex) => ({ psIndex, lowerRf: lowerRfs[psIndex], upperRf: upperRfs[psIndex] }))
|
|
371
|
+
.filter((info) => this.sideMask[info.psIndex] === BOTH_SIDES)
|
|
372
|
+
.sort((first, second) => first.lowerRf - second.lowerRf);
|
|
373
|
+
for (let first = 0; first < both.length - 1; first++) {
|
|
374
|
+
let closest = first + 1;
|
|
375
|
+
for (let index = first + 2; index < both.length; index++)
|
|
376
|
+
if (both[index].upperRf < both[closest].upperRf) closest = index;
|
|
377
|
+
this.addPsPair(both[first].psIndex, both[closest].psIndex);
|
|
378
|
+
}
|
|
379
|
+
}
|
|
380
|
+
|
|
381
|
+
private fillRelationSpanningTree() {
|
|
382
|
+
this.buildBothSideSpanningTree();
|
|
383
|
+
const isBoth = (rf: number) => this.sideMask[this.rootFunctions[rf].psIndex] === BOTH_SIDES;
|
|
384
|
+
// connect_non_tree_to_bounds
|
|
385
|
+
for (let index = 0; index < this.lowerRf; index++)
|
|
386
|
+
if (!isBoth(index)) this.addPair(index, this.lowerRf);
|
|
387
|
+
for (let index = this.upperRf + 1; index < this.rootFunctions.length; index++)
|
|
388
|
+
if (!isBoth(index)) this.addPair(this.upperRf, index);
|
|
389
|
+
// connect_tree_extremes_to_bounds
|
|
390
|
+
let maxLowerBoth = UNSET;
|
|
391
|
+
for (let index = 0; index < this.lowerRf; index++) if (isBoth(index)) maxLowerBoth = index;
|
|
392
|
+
let minUpperBoth = UNSET;
|
|
393
|
+
for (let index = this.upperRf + 1; index < this.rootFunctions.length; index++)
|
|
394
|
+
if (isBoth(index)) {
|
|
395
|
+
minUpperBoth = index;
|
|
396
|
+
break;
|
|
397
|
+
}
|
|
398
|
+
if (maxLowerBoth !== UNSET) this.addPair(maxLowerBoth, this.lowerRf);
|
|
399
|
+
if (minUpperBoth !== UNSET) this.addPair(this.upperRf, minUpperBoth);
|
|
400
|
+
this.addPair(this.lowerRf, this.upperRf);
|
|
401
|
+
}
|
|
402
|
+
|
|
403
|
+
// isolate_roots_around_sample: the roots of p closest to v, at or below it in lower and above
|
|
404
|
+
// it in upper, only the one at v for a section. Whether p has roots.
|
|
405
|
+
private isolateRootsAroundSample(
|
|
406
|
+
psIndex: number,
|
|
407
|
+
value: Anum,
|
|
408
|
+
lower: RootFunction[],
|
|
409
|
+
upper: RootFunction[],
|
|
410
|
+
) {
|
|
411
|
+
const polynomial = this.levelPolys[psIndex];
|
|
412
|
+
const values = this.getValuesWithout(this.level);
|
|
413
|
+
const mk = (root: Anum, index: number) => ({
|
|
414
|
+
value: this.am.copy(root),
|
|
415
|
+
polynomial,
|
|
416
|
+
index,
|
|
417
|
+
psIndex,
|
|
418
|
+
});
|
|
419
|
+
if (value.value instanceof Rational) {
|
|
420
|
+
const closest = this.am.isolateRootsClosest(this.pm, polynomial, values, value.value);
|
|
421
|
+
closest.roots.forEach((root, index) => {
|
|
422
|
+
(this.am.compare(root, value) <= 0 ? lower : upper).push(mk(root, closest.indices[index]));
|
|
423
|
+
});
|
|
424
|
+
return closest.roots.length > 0;
|
|
425
|
+
}
|
|
426
|
+
const roots = this.am.isolateRoots(this.pm, polynomial, values);
|
|
427
|
+
let lowerIndex = UNSET;
|
|
428
|
+
let upperIndex = UNSET;
|
|
429
|
+
let isSection = false;
|
|
430
|
+
for (const [index, root] of roots.entries()) {
|
|
431
|
+
const sign = this.am.compare(root, value);
|
|
432
|
+
if (sign > 0) {
|
|
433
|
+
upperIndex = index;
|
|
434
|
+
break;
|
|
435
|
+
}
|
|
436
|
+
lowerIndex = index;
|
|
437
|
+
if (sign === 0) {
|
|
438
|
+
isSection = true;
|
|
439
|
+
break;
|
|
440
|
+
}
|
|
441
|
+
}
|
|
442
|
+
if (lowerIndex !== UNSET) {
|
|
443
|
+
lower.push(mk(roots[lowerIndex], lowerIndex + 1));
|
|
444
|
+
if (isSection) return roots.length > 0;
|
|
445
|
+
}
|
|
446
|
+
if (upperIndex !== UNSET) upper.push(mk(roots[upperIndex], upperIndex + 1));
|
|
447
|
+
return roots.length > 0;
|
|
448
|
+
}
|
|
449
|
+
|
|
450
|
+
// root_function_lt: by value, ties by degree, descending for the lower partition, whose last
|
|
451
|
+
// element bounds the cell, then by polynomial id.
|
|
452
|
+
private isRootFunctionLess(first: RootFunction, second: RootFunction, isDegreeDesc: boolean) {
|
|
453
|
+
if (first.polynomial === second.polynomial) return first.index < second.index;
|
|
454
|
+
const sign = this.am.compare(first.value, second.value);
|
|
455
|
+
if (sign !== 0) return sign < 0;
|
|
456
|
+
const firstDegree = this.pm.degree(first.polynomial, this.level);
|
|
457
|
+
const secondDegree = this.pm.degree(second.polynomial, this.level);
|
|
458
|
+
if (firstDegree !== secondDegree)
|
|
459
|
+
return isDegreeDesc ? firstDegree > secondDegree : firstDegree < secondDegree;
|
|
460
|
+
return first.polynomial.id < second.polynomial.id;
|
|
461
|
+
}
|
|
462
|
+
|
|
463
|
+
private sortRootFunctions(rootFunctions: RootFunction[], isDegreeDesc: boolean) {
|
|
464
|
+
return sortIndicesStably(rootFunctions.length, (first, second) =>
|
|
465
|
+
this.isRootFunctionLess(rootFunctions[first], rootFunctions[second], isDegreeDesc),
|
|
466
|
+
).map((index) => rootFunctions[index]);
|
|
467
|
+
}
|
|
468
|
+
|
|
469
|
+
private setIntervalFromRootPartition(value: Anum, middle: number) {
|
|
470
|
+
const interval = this.intervals[this.level];
|
|
471
|
+
const rootFunctions = this.rootFunctions;
|
|
472
|
+
if (middle === 0) {
|
|
473
|
+
this.lowerRf = UNSET;
|
|
474
|
+
this.upperRf = 0;
|
|
475
|
+
interval.upper = rootFunctions[0].polynomial;
|
|
476
|
+
interval.upperIndex = rootFunctions[0].index;
|
|
477
|
+
return;
|
|
478
|
+
}
|
|
479
|
+
this.lowerRf = middle - 1;
|
|
480
|
+
const lower = rootFunctions[middle - 1];
|
|
481
|
+
interval.lower = lower.polynomial;
|
|
482
|
+
interval.lowerIndex = lower.index;
|
|
483
|
+
if (this.am.compare(lower.value, value) === 0) {
|
|
484
|
+
interval.isSection = true;
|
|
485
|
+
this.upperRf = this.lowerRf;
|
|
486
|
+
return;
|
|
487
|
+
}
|
|
488
|
+
if (middle < rootFunctions.length) {
|
|
489
|
+
this.upperRf = this.lowerRf + 1;
|
|
490
|
+
interval.upper = rootFunctions[middle].polynomial;
|
|
491
|
+
interval.upperIndex = rootFunctions[middle].index;
|
|
492
|
+
}
|
|
493
|
+
}
|
|
494
|
+
|
|
495
|
+
private addLinearPolyFromRoot(root: Anum, isLower: boolean) {
|
|
496
|
+
const value = root.value as Rational;
|
|
497
|
+
const polynomial = this.pm.sub(
|
|
498
|
+
this.pm.mul(this.pm.mkConst(value.den), this.pm.mkVar(this.level)),
|
|
499
|
+
this.pm.mkConst(value.num),
|
|
500
|
+
);
|
|
501
|
+
const interval = this.intervals[this.level];
|
|
502
|
+
if (isLower) {
|
|
503
|
+
interval.lower = polynomial;
|
|
504
|
+
interval.lowerIndex = 1;
|
|
505
|
+
} else {
|
|
506
|
+
interval.upper = polynomial;
|
|
507
|
+
interval.upperIndex = 1;
|
|
508
|
+
}
|
|
509
|
+
this.levelPolys.push(polynomial);
|
|
510
|
+
this.hasRoots.push(true);
|
|
511
|
+
this.witnesses.push(this.chooseNonzeroCoeff(polynomial, this.level));
|
|
512
|
+
return polynomial;
|
|
513
|
+
}
|
|
514
|
+
|
|
515
|
+
// add_linear_approximations: bounds of degree 2 or more are replaced by linear polynomials
|
|
516
|
+
// whose roots lie between them and the sample, so the cell only shrinks.
|
|
517
|
+
private addLinearApproximations(value: Anum) {
|
|
518
|
+
const interval = this.intervals[this.level];
|
|
519
|
+
const mkRootFunction = (polynomial: Polynomial, root: Anum) => ({
|
|
520
|
+
value: this.am.copy(root),
|
|
521
|
+
polynomial,
|
|
522
|
+
index: 1,
|
|
523
|
+
psIndex: this.levelPolys.length - 1,
|
|
524
|
+
});
|
|
525
|
+
if (interval.isSection) {
|
|
526
|
+
if (!this.am.isRational(value))
|
|
527
|
+
// Z3's NOT_IMPLEMENTED_YET exits the process here.
|
|
528
|
+
throw new NlsatUnsupportedError("a linear cell around an irrational section");
|
|
529
|
+
if (this.pm.totalDegree(interval.lower!) > 1) {
|
|
530
|
+
const polynomial = this.addLinearPolyFromRoot(value, true);
|
|
531
|
+
this.rootFunctions.splice(this.lowerRf, 0, mkRootFunction(polynomial, value));
|
|
532
|
+
}
|
|
533
|
+
return;
|
|
534
|
+
}
|
|
535
|
+
if (interval.lower !== null && this.pm.totalDegree(interval.lower) > 1) {
|
|
536
|
+
const between = this.am.select(this.rootFunctions[this.lowerRf].value, value);
|
|
537
|
+
const polynomial = this.addLinearPolyFromRoot(between, true);
|
|
538
|
+
this.rootFunctions.splice(this.lowerRf + 1, 0, mkRootFunction(polynomial, between));
|
|
539
|
+
this.lowerRf++;
|
|
540
|
+
if (this.upperRf !== UNSET) this.upperRf++;
|
|
541
|
+
}
|
|
542
|
+
if (interval.upper !== null && this.pm.totalDegree(interval.upper) > 1) {
|
|
543
|
+
const between = this.am.select(value, this.rootFunctions[this.upperRf].value);
|
|
544
|
+
const polynomial = this.addLinearPolyFromRoot(between, false);
|
|
545
|
+
this.rootFunctions.splice(this.upperRf, 0, mkRootFunction(polynomial, between));
|
|
546
|
+
}
|
|
547
|
+
}
|
|
548
|
+
|
|
549
|
+
// build_interval: the root functions around the sample, sorted, and the interval they bound.
|
|
550
|
+
private buildInterval() {
|
|
551
|
+
this.rootFunctions = [];
|
|
552
|
+
this.pairs.clear();
|
|
553
|
+
Object.assign(this.intervals[this.level], {
|
|
554
|
+
isSection: false,
|
|
555
|
+
lower: null,
|
|
556
|
+
lowerIndex: 0,
|
|
557
|
+
upper: null,
|
|
558
|
+
upperIndex: 0,
|
|
559
|
+
});
|
|
560
|
+
this.lowerRf = UNSET;
|
|
561
|
+
this.upperRf = UNSET;
|
|
562
|
+
const value = this.sample[this.level]!;
|
|
563
|
+
const lower: RootFunction[] = [];
|
|
564
|
+
const upper: RootFunction[] = [];
|
|
565
|
+
this.hasRoots = this.levelPolys.map((_, psIndex) =>
|
|
566
|
+
this.isolateRootsAroundSample(psIndex, value, lower, upper),
|
|
567
|
+
);
|
|
568
|
+
if (lower.length === 0 && upper.length === 0) return false;
|
|
569
|
+
this.rootFunctions = [
|
|
570
|
+
...this.sortRootFunctions(lower, true),
|
|
571
|
+
...this.sortRootFunctions(upper, false),
|
|
572
|
+
];
|
|
573
|
+
this.setIntervalFromRootPartition(value, lower.length);
|
|
574
|
+
if (this.isLinear) this.addLinearApproximations(value);
|
|
575
|
+
this.computeSideMask();
|
|
576
|
+
return true;
|
|
577
|
+
}
|
|
578
|
+
|
|
579
|
+
private addRelationResultants() {
|
|
580
|
+
for (const pair of this.getSortedPairs())
|
|
581
|
+
this.requestFactorized(
|
|
582
|
+
this.getFirstPsc(this.levelPolys[pair[0]], this.levelPolys[pair[1]], this.level),
|
|
583
|
+
);
|
|
584
|
+
}
|
|
585
|
+
|
|
586
|
+
// add_adjacent_root_resultants: at the top level, the resultants of the polynomials of adjacent
|
|
587
|
+
// roots.
|
|
588
|
+
private addAdjacentRootResultants() {
|
|
589
|
+
const rootValues: { root: Anum; polynomial: Polynomial }[] = [];
|
|
590
|
+
const values = this.getValuesWithout(this.maxVar);
|
|
591
|
+
this.hasRoots = this.levelPolys.map((polynomial) => {
|
|
592
|
+
const roots = this.am.isolateRoots(this.pm, polynomial, values);
|
|
593
|
+
for (const root of roots) rootValues.push({ root: this.am.copy(root), polynomial });
|
|
594
|
+
return roots.length > 0;
|
|
595
|
+
});
|
|
596
|
+
if (rootValues.length < 2) return;
|
|
597
|
+
const order = sortIndicesStably(
|
|
598
|
+
rootValues.length,
|
|
599
|
+
(first, second) => this.am.compare(rootValues[first].root, rootValues[second].root) < 0,
|
|
600
|
+
);
|
|
601
|
+
const added = new Set<string>();
|
|
602
|
+
for (let index = 0; index + 1 < order.length; index++) {
|
|
603
|
+
const first = rootValues[order[index]].polynomial;
|
|
604
|
+
const second = rootValues[order[index + 1]].polynomial;
|
|
605
|
+
if (first === second) continue;
|
|
606
|
+
const [low, high] = first.id < second.id ? [first, second] : [second, first];
|
|
607
|
+
const key = `${low.id},${high.id}`;
|
|
608
|
+
if (added.has(key)) continue;
|
|
609
|
+
added.add(key);
|
|
610
|
+
this.requestFactorized(this.getFirstPsc(low, high, this.maxVar));
|
|
611
|
+
}
|
|
612
|
+
}
|
|
613
|
+
|
|
614
|
+
// Polynomials with roots keep their order by resultants with the section's polynomial. Those
|
|
615
|
+
// without need their leading coefficient and discriminant to stay without.
|
|
616
|
+
private addSectionProjections() {
|
|
617
|
+
const sectionPolynomial = this.intervals[this.level].lower;
|
|
618
|
+
const withRoots = new Set(this.rootFunctions.map((rootFunction) => rootFunction.psIndex));
|
|
619
|
+
this.levelPolys.forEach((polynomial, index) => {
|
|
620
|
+
const isFull = polynomial === sectionPolynomial || !withRoots.has(index);
|
|
621
|
+
this.addProjectionForPoly(polynomial, this.level, this.witnesses[index], isFull, true);
|
|
622
|
+
});
|
|
623
|
+
}
|
|
624
|
+
|
|
625
|
+
private addSectorProjections() {
|
|
626
|
+
this.levelPolys.forEach((polynomial, index) => {
|
|
627
|
+
const isLcAdded = !(this.isLcOmitted[index] ?? false);
|
|
628
|
+
let witness = this.witnesses[index];
|
|
629
|
+
// coeffNonNull: a leading coefficient nonzero at the sample is its own witness.
|
|
630
|
+
if (
|
|
631
|
+
isLcAdded &&
|
|
632
|
+
witness !== null &&
|
|
633
|
+
!this.pm.isConst(witness) &&
|
|
634
|
+
this.params.isWitnessSubsLc &&
|
|
635
|
+
this.getSign(this.pm.lc(polynomial, this.level)) !== 0
|
|
636
|
+
)
|
|
637
|
+
witness = null;
|
|
638
|
+
this.addProjectionForPoly(polynomial, this.level, witness, isLcAdded, true);
|
|
639
|
+
});
|
|
640
|
+
}
|
|
641
|
+
|
|
642
|
+
private shouldUseSpanningTree() {
|
|
643
|
+
if (this.params.spanningTreeThreshold < 2) return false;
|
|
644
|
+
if (this.rootFunctions.length < 4 || this.sideMask.length === 0) return false;
|
|
645
|
+
if (this.lowerRf === UNSET || this.upperRf === UNSET) return false;
|
|
646
|
+
if (this.getBoundIndex(this.lowerRf) === this.getBoundIndex(this.upperRf)) return false;
|
|
647
|
+
let bothCount = 0;
|
|
648
|
+
for (let index = 0; index < this.levelPolys.length; index++)
|
|
649
|
+
if (this.sideMask[index] === BOTH_SIDES && ++bothCount >= this.params.spanningTreeThreshold)
|
|
650
|
+
return true;
|
|
651
|
+
return false;
|
|
652
|
+
}
|
|
653
|
+
|
|
654
|
+
private processLevelWithMode(mode: ProjectionMode, hasInterval: boolean) {
|
|
655
|
+
if (hasInterval) {
|
|
656
|
+
if (mode === "section") this.fillRelationSection();
|
|
657
|
+
else {
|
|
658
|
+
if (mode === "sector") this.fillRelationSector();
|
|
659
|
+
else this.fillRelationSpanningTree();
|
|
660
|
+
this.computeSideMask();
|
|
661
|
+
this.computeOmitLcBothSides(mode === "spanningTree");
|
|
662
|
+
}
|
|
663
|
+
}
|
|
664
|
+
if (mode === "section") this.addSectionProjections();
|
|
665
|
+
else this.addSectorProjections();
|
|
666
|
+
this.addRelationResultants();
|
|
667
|
+
}
|
|
668
|
+
|
|
669
|
+
// collect_non_null_witnesses: a witness per polynomial, until handling the vanishing ones adds
|
|
670
|
+
// no more polynomials at this level.
|
|
671
|
+
private collectNonNullWitnesses() {
|
|
672
|
+
this.witnesses = [];
|
|
673
|
+
for (let index = 0; index < this.levelPolys.length; index++) {
|
|
674
|
+
const polynomial = this.levelPolys[index];
|
|
675
|
+
const witness = this.chooseNonzeroCoeff(polynomial, this.level);
|
|
676
|
+
if (witness === null) this.handleNullifiedPoly(polynomial);
|
|
677
|
+
this.witnesses.push(witness);
|
|
678
|
+
if (index + 1 === this.levelPolys.length)
|
|
679
|
+
this.todo.extractPolysAtLevel(this.level, this.levelPolys);
|
|
680
|
+
}
|
|
681
|
+
}
|
|
682
|
+
|
|
683
|
+
private processLevel() {
|
|
684
|
+
this.isLcOmitted = [];
|
|
685
|
+
this.pairs.clear();
|
|
686
|
+
this.sideMask = [];
|
|
687
|
+
this.collectNonNullWitnesses();
|
|
688
|
+
const hasInterval = this.buildInterval();
|
|
689
|
+
const mode: ProjectionMode = this.intervals[this.level].isSection
|
|
690
|
+
? "section"
|
|
691
|
+
: this.shouldUseSpanningTree()
|
|
692
|
+
? "spanningTree"
|
|
693
|
+
: "sector";
|
|
694
|
+
this.processLevelWithMode(mode, hasInterval);
|
|
695
|
+
}
|
|
696
|
+
|
|
697
|
+
// The top level is projected out without an interval. By projective delineability, a
|
|
698
|
+
// polynomial without roots whose leading coefficient is nonzero needs only its discriminant.
|
|
699
|
+
private processTopLevel() {
|
|
700
|
+
this.collectNonNullWitnesses();
|
|
701
|
+
this.addAdjacentRootResultants();
|
|
702
|
+
this.levelPolys.forEach((polynomial, index) => {
|
|
703
|
+
const lc = this.pm.lc(polynomial, this.maxVar);
|
|
704
|
+
const isLcAdded = this.hasRoots[index] || this.pm.isZero(lc) || this.getSign(lc) === 0;
|
|
705
|
+
if (!isLcAdded) this.witnesses[index] = null;
|
|
706
|
+
this.addProjectionForPoly(polynomial, this.maxVar, this.witnesses[index], isLcAdded, true);
|
|
707
|
+
});
|
|
708
|
+
}
|
|
709
|
+
|
|
710
|
+
singleCell(polynomials: readonly Polynomial[]) {
|
|
711
|
+
if (this.maxVar === 0) return this.intervals;
|
|
712
|
+
for (const polynomial of polynomials) this.requestFactorized(polynomial);
|
|
713
|
+
if (this.todo.isEmpty) return this.intervals;
|
|
714
|
+
if (this.todo.getMaxVar() === this.maxVar) {
|
|
715
|
+
this.level = this.todo.extractMaxPolys(this.levelPolys);
|
|
716
|
+
this.processTopLevel();
|
|
717
|
+
}
|
|
718
|
+
while (!this.todo.isEmpty) {
|
|
719
|
+
this.level = this.todo.extractMaxPolys(this.levelPolys);
|
|
720
|
+
this.processLevel();
|
|
721
|
+
}
|
|
722
|
+
return this.intervals;
|
|
723
|
+
}
|
|
724
|
+
}
|
|
725
|
+
|
|
726
|
+
// levelwise::single_cell: the cell intervals of the variables below maxVar around the sample.
|
|
727
|
+
// isLinear forces linear bounds, for check_assignment's explanations.
|
|
728
|
+
export const getSingleCell = (
|
|
729
|
+
pm: PolynomialManager,
|
|
730
|
+
am: AlgebraicManager,
|
|
731
|
+
cache: PolynomialCache,
|
|
732
|
+
polynomials: readonly Polynomial[],
|
|
733
|
+
maxVar: number,
|
|
734
|
+
sample: readonly (Anum | undefined)[],
|
|
735
|
+
isLinear: boolean,
|
|
736
|
+
params = DEFAULT_LEVELWISE_PARAMS,
|
|
737
|
+
) => new Levelwise(pm, am, cache, sample, maxVar, isLinear, params).singleCell(polynomials);
|