tla-ts 0.0.9 → 0.0.10-dev.06b481ee0
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 +30 -1
- package/dist/compile.cjs +23 -0
- package/dist/compile.js +23 -0
- package/dist/deciders.cjs +41 -37
- package/dist/deciders.js +48 -44
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +122 -12
- package/dist/index.d.ts +122 -12
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +1 -1
- package/dist/prove-worker.cjs +1 -1
- package/dist/prove-worker.js +1 -1
- package/dist/prove.cjs +2746 -410
- package/dist/prove.js +2745 -409
- package/dist/run.cjs +144 -31
- package/dist/run.js +144 -31
- package/dist/tlapm.cjs +2 -2
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +134 -104
- package/dist/transfer.js +134 -104
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +3 -1
- package/src/ast.ts +56 -60
- package/src/bags.ts +128 -110
- package/src/builtins.ts +31 -77
- package/src/bundled-modules.ts +1 -8
- package/src/check-failure.ts +118 -0
- package/src/check-trace.ts +320 -0
- package/src/check.ts +1156 -888
- package/src/cli/options.ts +12 -32
- package/src/cli/run.ts +0 -2
- package/src/cli/runtime-invariants.ts +100 -0
- package/src/cli/shared.ts +19 -12
- package/src/cli/tlapm.ts +433 -82
- package/src/cli/tlc-arguments.ts +652 -0
- package/src/cli/tlc-output.ts +701 -0
- package/src/cli/tlc-usage.ts +360 -0
- package/src/cli/tlc.ts +330 -659
- package/src/cli/typescript.ts +23 -0
- package/src/cli/xml-exporter.ts +27 -49
- package/src/cli.ts +0 -1
- package/src/codegen.ts +217 -82
- package/src/config.ts +140 -109
- package/src/coverage.ts +1019 -0
- package/src/dependencies.ts +101 -66
- package/src/dfid.ts +683 -0
- package/src/environment-config.ts +315 -0
- package/src/environment.ts +263 -370
- package/src/errors.ts +107 -57
- package/src/evaluate.ts +898 -369
- package/src/exit-codes.ts +63 -13
- package/src/fingerprints.ts +75 -11
- package/src/index.ts +3 -0
- package/src/instances.ts +137 -22
- package/src/java-hash.ts +21 -0
- package/src/java-overrides.ts +6 -21
- package/src/json-reader.ts +455 -0
- package/src/json.ts +252 -139
- package/src/levels.ts +231 -154
- package/src/lexer.ts +83 -101
- package/src/liveness-checker.ts +743 -322
- package/src/liveness.ts +230 -133
- package/src/obligations/action.ts +17 -44
- package/src/obligations/anonymize.ts +120 -95
- package/src/obligations/enabled-axioms.ts +218 -0
- package/src/obligations/equality.ts +1 -3
- package/src/obligations/expression.ts +37 -26
- package/src/obligations/format.ts +0 -10
- package/src/obligations/generate.ts +66 -64
- package/src/obligations/index.ts +39 -20
- package/src/obligations/levels.ts +27 -18
- package/src/obligations/module.ts +28 -55
- package/src/obligations/normalize.ts +31 -41
- package/src/obligations/operators.ts +0 -3
- package/src/obligations/pragma.ts +52 -24
- package/src/obligations/printer.ts +94 -63
- package/src/obligations/proof.ts +3 -6
- package/src/obligations/regroup.ts +0 -5
- package/src/obligations/simplify.ts +57 -63
- package/src/obligations/source.ts +121 -95
- package/src/obligations/subexpression.ts +49 -28
- package/src/obligations/substitution.ts +1 -5
- package/src/obligations/temporal.ts +12 -20
- package/src/obligations/tuples.ts +2 -10
- package/src/parallel-worker.ts +36 -60
- package/src/parallel.ts +64 -73
- package/src/parser.ts +1184 -531
- package/src/pcal/ast.ts +53 -86
- package/src/pcal/parse.ts +144 -219
- package/src/pcal/tokenize.ts +91 -131
- package/src/pcal/translate.ts +83 -130
- package/src/pcal/validate.ts +48 -68
- package/src/pretty-print.ts +7 -8
- package/src/prover/decide-pool.ts +8 -13
- package/src/prover/deciders.ts +12 -13
- package/src/prover/first-order.ts +0 -11
- package/src/prover/isabelle/decide.ts +3 -31
- package/src/prover/isabelle/encode.ts +82 -64
- package/src/prover/isabelle/isar/attrib.ts +250 -0
- package/src/prover/isabelle/isar/context.ts +335 -0
- package/src/prover/isabelle/isar/induct.ts +382 -0
- package/src/prover/isabelle/isar/inner-syntax.ts +262 -117
- package/src/prover/isabelle/isar/method.ts +510 -226
- package/src/prover/isabelle/isar/proof.ts +570 -23
- package/src/prover/isabelle/isar/rule-cases.ts +226 -0
- package/src/prover/isabelle/isar/theory.ts +488 -88
- package/src/prover/isabelle/isar/toplevel.ts +331 -0
- package/src/prover/isabelle/isar/type-check.ts +99 -38
- package/src/prover/isabelle/provers/blast/blast.ts +16 -105
- package/src/prover/isabelle/provers/blast/branch.ts +0 -33
- package/src/prover/isabelle/provers/blast/prove.ts +0 -36
- package/src/prover/isabelle/provers/blast/rules.ts +5 -45
- package/src/prover/isabelle/provers/blast/state.ts +1 -29
- package/src/prover/isabelle/provers/blast/term.ts +8 -37
- package/src/prover/isabelle/provers/clasimp.ts +1 -15
- package/src/prover/isabelle/provers/classical.ts +58 -61
- package/src/prover/isabelle/provers/hypsubst.ts +29 -54
- package/src/prover/isabelle/pure/bicompose.ts +24 -39
- package/src/prover/isabelle/pure/consts.ts +0 -8
- package/src/prover/isabelle/pure/conv.ts +2 -18
- package/src/prover/isabelle/pure/drule.ts +95 -45
- package/src/prover/isabelle/pure/envir.ts +2 -53
- package/src/prover/isabelle/pure/goal.ts +1 -9
- package/src/prover/isabelle/pure/interrupt.ts +0 -5
- package/src/prover/isabelle/pure/list.ts +0 -3
- package/src/prover/isabelle/pure/logic.ts +1 -16
- package/src/prover/isabelle/pure/name.ts +1 -10
- package/src/prover/isabelle/pure/net.ts +2 -60
- package/src/prover/isabelle/pure/object-logic.ts +15 -16
- package/src/prover/isabelle/pure/pattern.ts +1 -20
- package/src/prover/isabelle/pure/raw-simplifier.ts +16 -63
- package/src/prover/isabelle/pure/rewriter.ts +34 -77
- package/src/prover/isabelle/pure/search.ts +2 -11
- package/src/prover/isabelle/pure/seq.ts +0 -11
- package/src/prover/isabelle/pure/simplifier.ts +27 -16
- package/src/prover/isabelle/pure/table.ts +2 -33
- package/src/prover/isabelle/pure/tactic.ts +11 -23
- package/src/prover/isabelle/pure/tactical.ts +47 -48
- package/src/prover/isabelle/pure/term-ord.ts +1 -7
- package/src/prover/isabelle/pure/term.ts +4 -47
- package/src/prover/isabelle/pure/thm.ts +26 -48
- package/src/prover/isabelle/pure/type.ts +1 -16
- package/src/prover/isabelle/pure/unify.ts +19 -31
- package/src/prover/isabelle/pure/variable.ts +2 -8
- package/src/prover/isabelle/tla/classical-setup.ts +17 -25
- package/src/prover/isabelle/tla/context.ts +65 -26
- package/src/prover/isabelle/tla/logic-data.ts +1 -1
- package/src/prover/isabelle/tla/logic.ts +53 -32
- package/src/prover/isabelle/tla/simpdata.ts +45 -44
- package/src/prover/isabelle/tools/intuitionistic.ts +28 -21
- package/src/prover/ocaml.ts +4 -7
- package/src/prover/prep/action.ts +33 -66
- package/src/prover/prep/enabled-axioms.ts +22 -20
- package/src/prover/prep/fingerprint.ts +2 -21
- package/src/prover/prep/level-comparison.ts +8 -12
- package/src/prover/prep/md5.ts +26 -31
- package/src/prover/prep/methods.ts +189 -86
- package/src/prover/prep/normalize.ts +42 -37
- package/src/prover/prove-worker.ts +0 -2
- package/src/prover/prove.ts +398 -133
- package/src/prover/ptl/decide.ts +96 -56
- package/src/prover/ptl/encode.ts +15 -38
- package/src/prover/ptl/sat.ts +24 -32
- package/src/prover/ptl/tableau.ts +40 -28
- package/src/prover/smt/arithmetic.ts +310 -0
- package/src/prover/smt/axioms.ts +12 -15
- package/src/prover/smt/context.ts +60 -32
- package/src/prover/smt/data.ts +517 -401
- package/src/prover/smt/encode.ts +155 -85
- package/src/prover/smt/extensionality.ts +5 -13
- package/src/prover/smt/flatten.ts +7 -28
- package/src/prover/smt/format.ts +33 -14
- package/src/prover/smt/instances.ts +7 -11
- package/src/prover/smt/layout.ts +91 -0
- package/src/prover/smt/rewrite.ts +1021 -658
- package/src/prover/smt/simplify.ts +441 -0
- package/src/prover/smt/solver/ackermannize-bv-tactic.ts +61 -0
- package/src/prover/smt/solver/ackr-helper.ts +179 -0
- package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
- package/src/prover/smt/solver/act-cache.ts +0 -16
- package/src/prover/smt/solver/add-bounds-tactic.ts +59 -0
- package/src/prover/smt/solver/aig-tactic.ts +52 -0
- package/src/prover/smt/solver/aig.ts +889 -0
- package/src/prover/smt/solver/arith-rewriter.ts +626 -56
- package/src/prover/smt/solver/arith-terms.ts +121 -0
- package/src/prover/smt/solver/array-decl-plugin.ts +175 -0
- package/src/prover/smt/solver/array-rewriter.ts +319 -0
- package/src/prover/smt/solver/array.ts +1 -3
- package/src/prover/smt/solver/asserted-formulas.ts +241 -99
- package/src/prover/smt/solver/ast-lt.ts +165 -21
- package/src/prover/smt/solver/ast-util.ts +160 -7
- package/src/prover/smt/solver/ast.ts +1480 -184
- package/src/prover/smt/solver/auf-solver.ts +30 -56
- package/src/prover/smt/solver/bit-blast-tactic.ts +608 -0
- package/src/prover/smt/solver/bit-blaster.ts +871 -0
- package/src/prover/smt/solver/blast-term-ite.ts +47 -0
- package/src/prover/smt/solver/bound-manager.ts +196 -0
- package/src/prover/smt/solver/bound-simplifier.ts +598 -0
- package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
- package/src/prover/smt/solver/bv-decl-plugin.ts +341 -0
- package/src/prover/smt/solver/bv-divrem-bounds.ts +95 -0
- package/src/prover/smt/solver/bv-rewriter.ts +1901 -0
- package/src/prover/smt/solver/bv1-blast.ts +214 -0
- package/src/prover/smt/solver/bv2fpa-converter.ts +174 -0
- package/src/prover/smt/solver/bv2int-rewriter.ts +544 -0
- package/src/prover/smt/solver/bv2real-rewriter.ts +533 -0
- package/src/prover/smt/solver/card2bv.ts +127 -0
- package/src/prover/smt/solver/case-split-queue.ts +0 -10
- package/src/prover/smt/solver/cg-table.ts +39 -42
- package/src/prover/smt/solver/check-logic.ts +330 -0
- package/src/prover/smt/solver/clause.ts +0 -27
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +293 -0
- package/src/prover/smt/solver/conflict-resolution.ts +78 -11
- package/src/prover/smt/solver/context.ts +600 -187
- package/src/prover/smt/solver/ctx-simplify.ts +34 -52
- package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
- package/src/prover/smt/solver/datatype-decl-plugin.ts +580 -0
- package/src/prover/smt/solver/datatype-rewriter.ts +82 -0
- package/src/prover/smt/solver/demodulator.ts +786 -0
- package/src/prover/smt/solver/dependent-expr-state.ts +93 -0
- package/src/prover/smt/solver/der.ts +39 -30
- package/src/prover/smt/solver/diff-neq.ts +205 -0
- package/src/prover/smt/solver/distribute-forall.ts +57 -0
- package/src/prover/smt/solver/dom-simplify.ts +511 -0
- package/src/prover/smt/solver/dt2bv-tactic.ts +296 -0
- package/src/prover/smt/solver/dyn-ack.ts +0 -11
- package/src/prover/smt/solver/e-matching.ts +9 -41
- package/src/prover/smt/solver/elim-bounds.ts +89 -0
- package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
- package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
- package/src/prover/smt/solver/elim-uncnstr.ts +542 -0
- package/src/prover/smt/solver/enode.ts +100 -23
- package/src/prover/smt/solver/eq2bv-tactic.ts +218 -0
- package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
- package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
- package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
- package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
- package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
- package/src/prover/smt/solver/euf/array-solver.ts +306 -0
- package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
- package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
- package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
- package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
- package/src/prover/smt/solver/euf/egraph.ts +901 -0
- package/src/prover/smt/solver/euf/euf-solver.ts +1204 -0
- package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
- package/src/prover/smt/solver/euf/mam.ts +1046 -0
- package/src/prover/smt/solver/euf/q-ematch.ts +829 -0
- package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
- package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
- package/src/prover/smt/solver/euf/q-solver.ts +361 -0
- package/src/prover/smt/solver/euf/th-solver.ts +328 -0
- package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
- package/src/prover/smt/solver/expr-ref.ts +0 -5
- package/src/prover/smt/solver/expr-safe-replace.ts +26 -7
- package/src/prover/smt/solver/expr2polynomial.ts +271 -0
- package/src/prover/smt/solver/factor.ts +163 -0
- package/src/prover/smt/solver/fd-solver.ts +734 -0
- package/src/prover/smt/solver/fingerprints.ts +15 -26
- package/src/prover/smt/solver/fix-dl-var.ts +147 -0
- package/src/prover/smt/solver/flat-literals.ts +0 -9
- package/src/prover/smt/solver/fm-tactic.ts +884 -0
- package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
- package/src/prover/smt/solver/fpa-rewriter.ts +639 -0
- package/src/prover/smt/solver/fpa2bv-converter.ts +2251 -0
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +349 -0
- package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
- package/src/prover/smt/solver/goal.ts +179 -28
- package/src/prover/smt/solver/goal2nlsat.ts +216 -0
- package/src/prover/smt/solver/guard-set.ts +219 -0
- package/src/prover/smt/solver/hash.ts +0 -9
- package/src/prover/smt/solver/hashtable.ts +30 -23
- package/src/prover/smt/solver/inf-eps.ts +63 -0
- package/src/prover/smt/solver/inj-axiom.ts +101 -0
- package/src/prover/smt/solver/internalizer.ts +113 -133
- package/src/prover/smt/solver/lackr.ts +381 -0
- package/src/prover/smt/solver/lbool.ts +0 -2
- package/src/prover/smt/solver/lia2card.ts +268 -0
- package/src/prover/smt/solver/lia2pb.ts +154 -0
- package/src/prover/smt/solver/literal.ts +0 -4
- package/src/prover/smt/solver/logic-tactics.ts +355 -0
- package/src/prover/smt/solver/lp/bound-propagator.ts +7 -26
- package/src/prover/smt/solver/lp/constraints.ts +1 -8
- package/src/prover/smt/solver/lp/containers.ts +18 -31
- package/src/prover/smt/solver/lp/core-solver.ts +35 -37
- package/src/prover/smt/solver/lp/cross-nested.ts +4 -21
- package/src/prover/smt/solver/lp/dep-intervals.ts +6 -24
- package/src/prover/smt/solver/lp/dependency.ts +0 -5
- package/src/prover/smt/solver/lp/dioph-eq.ts +8 -103
- package/src/prover/smt/solver/lp/explanation.ts +0 -6
- package/src/prover/smt/solver/lp/gomory.ts +8 -22
- package/src/prover/smt/solver/lp/hnf-cutter.ts +16 -23
- package/src/prover/smt/solver/lp/hnf.ts +10 -28
- package/src/prover/smt/solver/lp/int-cube.ts +17 -39
- package/src/prover/smt/solver/lp/int-solver.ts +3 -35
- package/src/prover/smt/solver/lp/lar-solver.ts +70 -83
- package/src/prover/smt/solver/lp/lar-term.ts +0 -5
- package/src/prover/smt/solver/lp/lp-settings.ts +6 -16
- package/src/prover/smt/solver/lp/maximize-term.ts +76 -52
- package/src/prover/smt/solver/lp/nex-creator.ts +7 -30
- package/src/prover/smt/solver/lp/nex.ts +2 -7
- package/src/prover/smt/solver/lp/nla-backoff.ts +0 -5
- package/src/prover/smt/solver/lp/nla-basics.ts +48 -30
- package/src/prover/smt/solver/lp/nla-core.ts +92 -136
- package/src/prover/smt/solver/lp/nla-divisions.ts +31 -43
- package/src/prover/smt/solver/lp/nla-emonics.ts +3 -21
- package/src/prover/smt/solver/lp/nla-factorization.ts +0 -4
- package/src/prover/smt/solver/lp/nla-grobner.ts +177 -149
- package/src/prover/smt/solver/lp/nla-horner.ts +2 -12
- package/src/prover/smt/solver/lp/nla-intervals.ts +1 -12
- package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +15 -42
- package/src/prover/smt/solver/lp/nla-monotone.ts +1 -6
- package/src/prover/smt/solver/lp/nla-order.ts +0 -13
- package/src/prover/smt/solver/lp/nla-patcher.ts +3 -7
- package/src/prover/smt/solver/lp/nla-powers.ts +220 -0
- package/src/prover/smt/solver/lp/nla-tangents.ts +0 -10
- package/src/prover/smt/solver/lp/nla-throttle.ts +0 -6
- package/src/prover/smt/solver/lp/nla-transcendentals.ts +324 -0
- package/src/prover/smt/solver/lp/nla-types.ts +0 -12
- package/src/prover/smt/solver/lp/nla-var-eqs.ts +4 -26
- package/src/prover/smt/solver/lp/nra-solver.ts +164 -147
- package/src/prover/smt/solver/lp/numeric-pair.ts +0 -4
- package/src/prover/smt/solver/lp/pdd-interval.ts +6 -5
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +61 -34
- package/src/prover/smt/solver/lp/pdd-solver.ts +74 -72
- package/src/prover/smt/solver/lp/pdd.ts +730 -358
- package/src/prover/smt/solver/lp/random-updater.ts +0 -9
- package/src/prover/smt/solver/lp/static-matrix.ts +8 -19
- package/src/prover/smt/solver/lp/union-find.ts +5 -5
- package/src/prover/smt/solver/macro-finder.ts +530 -0
- package/src/prover/smt/solver/mam-compiler.ts +129 -139
- package/src/prover/smt/solver/mam-interpreter.ts +0 -21
- package/src/prover/smt/solver/max-bv-sharing-tactic.ts +17 -0
- package/src/prover/smt/solver/max-cliques.ts +105 -0
- package/src/prover/smt/solver/maxcore.ts +310 -0
- package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -21
- package/src/prover/smt/solver/maxlex.ts +115 -0
- package/src/prover/smt/solver/maxsmt-base.ts +106 -0
- package/src/prover/smt/solver/maxsmt.ts +92 -0
- package/src/prover/smt/solver/mbp/mbp-arith.ts +467 -0
- package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +101 -0
- package/src/prover/smt/solver/mbp/mbp-plugin.ts +287 -0
- package/src/prover/smt/solver/mbp/mbp-qel.ts +48 -0
- package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +271 -0
- package/src/prover/smt/solver/mbp/mbp-term-graph.ts +606 -0
- package/src/prover/smt/solver/model-based-opt.ts +844 -0
- package/src/prover/smt/solver/model-checker.ts +20 -63
- package/src/prover/smt/solver/model-evaluator.ts +192 -40
- package/src/prover/smt/solver/model-finder.ts +14 -32
- package/src/prover/smt/solver/model-generator.ts +104 -46
- package/src/prover/smt/solver/model-macro-solver.ts +60 -114
- package/src/prover/smt/solver/model-printer.ts +214 -0
- package/src/prover/smt/solver/mpf.ts +709 -0
- package/src/prover/smt/solver/mus.ts +50 -0
- package/src/prover/smt/solver/muz/dl-context.ts +382 -0
- package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +97 -0
- package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +167 -0
- package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +125 -0
- package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +299 -0
- package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +455 -0
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +340 -0
- package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +163 -0
- package/src/prover/smt/solver/muz/dl-rule-set.ts +273 -0
- package/src/prover/smt/solver/muz/dl-rule-transformer.ts +123 -0
- package/src/prover/smt/solver/muz/dl-rule.ts +495 -0
- package/src/prover/smt/solver/muz/hnf.ts +201 -0
- package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
- package/src/prover/smt/solver/muz/horn-tactic.ts +214 -0
- package/src/prover/smt/solver/muz/rule-properties.ts +359 -0
- package/src/prover/smt/solver/muz/spacer-context.ts +1404 -0
- package/src/prover/smt/solver/muz/spacer-dl-interface.ts +52 -0
- package/src/prover/smt/solver/muz/spacer-generalizers.ts +241 -0
- package/src/prover/smt/solver/muz/spacer-manager.ts +127 -0
- package/src/prover/smt/solver/muz/spacer-pdr.ts +219 -0
- package/src/prover/smt/solver/muz/spacer-prop-solver.ts +333 -0
- package/src/prover/smt/solver/muz/spacer-util.ts +282 -0
- package/src/prover/smt/solver/muz/substitution.ts +203 -0
- package/src/prover/smt/solver/nla2bv-tactic.ts +285 -0
- package/src/prover/smt/solver/nlqsat.ts +484 -0
- package/src/prover/smt/solver/nlsat/algebraic.ts +357 -236
- package/src/prover/smt/solver/nlsat/atoms.ts +73 -54
- package/src/prover/smt/solver/nlsat/evaluator.ts +16 -22
- package/src/prover/smt/solver/nlsat/explain.ts +429 -275
- package/src/prover/smt/solver/nlsat/interval-set.ts +9 -51
- package/src/prover/smt/solver/nlsat/levelwise.ts +477 -344
- package/src/prover/smt/solver/nlsat/mpbq.ts +47 -14
- package/src/prover/smt/solver/nlsat/polynomial.ts +2385 -832
- package/src/prover/smt/solver/nlsat/solver.ts +297 -156
- package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
- package/src/prover/smt/solver/nlsat/transcendentals.ts +391 -0
- package/src/prover/smt/solver/nlsat/types.ts +0 -9
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +9 -51
- package/src/prover/smt/solver/nlsat/upolynomial.ts +49 -109
- package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
- package/src/prover/smt/solver/nnf.ts +112 -61
- package/src/prover/smt/solver/normalize-bounds.ts +53 -0
- package/src/prover/smt/solver/occf.ts +97 -0
- package/src/prover/smt/solver/opt-context.ts +801 -0
- package/src/prover/smt/solver/opt-nlsat.ts +386 -0
- package/src/prover/smt/solver/opt-pareto.ts +301 -0
- package/src/prover/smt/solver/opt-preprocess.ts +101 -0
- package/src/prover/smt/solver/opt-solver.ts +312 -0
- package/src/prover/smt/solver/opt-value.ts +55 -0
- package/src/prover/smt/solver/optsmt.ts +692 -0
- package/src/prover/smt/solver/parallel-tactic.ts +299 -0
- package/src/prover/smt/solver/pattern-inference.ts +21 -26
- package/src/prover/smt/solver/pb-rewriter.ts +281 -0
- package/src/prover/smt/solver/pb2bv-tactic.ts +540 -0
- package/src/prover/smt/solver/poly-rewriter.ts +261 -79
- package/src/prover/smt/solver/probes.ts +577 -0
- package/src/prover/smt/solver/propagate-values.ts +37 -30
- package/src/prover/smt/solver/proto-model.ts +650 -66
- package/src/prover/smt/solver/pull-quant.ts +28 -23
- package/src/prover/smt/solver/purify-arith.ts +632 -0
- package/src/prover/smt/solver/push-app-ite.ts +37 -0
- package/src/prover/smt/solver/qe-arith-plugin.ts +1096 -0
- package/src/prover/smt/solver/qe-lite-der.ts +2 -31
- package/src/prover/smt/solver/qe-lite-fm.ts +4 -28
- package/src/prover/smt/solver/qe-lite.ts +41 -51
- package/src/prover/smt/solver/qe-mbp.ts +270 -0
- package/src/prover/smt/solver/qe.ts +1499 -0
- package/src/prover/smt/solver/qel.ts +25 -0
- package/src/prover/smt/solver/qi-queue.ts +0 -16
- package/src/prover/smt/solver/qsat.ts +829 -0
- package/src/prover/smt/solver/quant-hoist.ts +196 -0
- package/src/prover/smt/solver/quant-tactics.ts +17 -74
- package/src/prover/smt/solver/quantifier-analyzer.ts +26 -47
- package/src/prover/smt/solver/quantifier-manager.ts +22 -32
- package/src/prover/smt/solver/quasi-macros.ts +243 -0
- package/src/prover/smt/solver/random-gen.ts +0 -2
- package/src/prover/smt/solver/rational.ts +45 -8
- package/src/prover/smt/solver/recfun-decl-plugin.ts +262 -0
- package/src/prover/smt/solver/recfun-rewriter.ts +107 -0
- package/src/prover/smt/solver/reduce-args.ts +225 -0
- package/src/prover/smt/solver/reduce-bv-size.ts +119 -0
- package/src/prover/smt/solver/ref-vector.ts +0 -6
- package/src/prover/smt/solver/relevancy.ts +2 -16
- package/src/prover/smt/solver/rewriter-tpl.ts +59 -135
- package/src/prover/smt/solver/rewriter.ts +507 -144
- package/src/prover/smt/solver/rlimit.ts +46 -24
- package/src/prover/smt/solver/sat/asymm-branch.ts +325 -0
- package/src/prover/smt/solver/sat/big.ts +177 -0
- package/src/prover/smt/solver/sat/clause-use-list.ts +71 -0
- package/src/prover/smt/solver/sat/clause.ts +203 -0
- package/src/prover/smt/solver/sat/cleaner.ts +94 -0
- package/src/prover/smt/solver/sat/config.ts +122 -0
- package/src/prover/smt/solver/sat/consequences.ts +203 -0
- package/src/prover/smt/solver/sat/elim-eqs.ts +142 -0
- package/src/prover/smt/solver/sat/goal2sat.ts +579 -0
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +464 -0
- package/src/prover/smt/solver/sat/model-converter.ts +136 -0
- package/src/prover/smt/solver/sat/pb-constraint.ts +268 -0
- package/src/prover/smt/solver/sat/pb-solver.ts +1596 -0
- package/src/prover/smt/solver/sat/probing.ts +170 -0
- package/src/prover/smt/solver/sat/sat-tactic.ts +53 -0
- package/src/prover/smt/solver/sat/sat2goal.ts +189 -0
- package/src/prover/smt/solver/sat/scc.ts +142 -0
- package/src/prover/smt/solver/sat/simplifier.ts +1618 -0
- package/src/prover/smt/solver/sat/solver.ts +2107 -0
- package/src/prover/smt/solver/sat/var-queue.ts +117 -0
- package/src/prover/smt/solver/sat/watch-list.ts +140 -0
- package/src/prover/smt/solver/search-tree.ts +284 -0
- package/src/prover/smt/solver/seq-axioms.ts +995 -0
- package/src/prover/smt/solver/seq-decl-plugin.ts +819 -0
- package/src/prover/smt/solver/seq-derive.ts +1298 -0
- package/src/prover/smt/solver/seq-eq-approx.ts +236 -0
- package/src/prover/smt/solver/seq-eq-solver.ts +439 -0
- package/src/prover/smt/solver/seq-factory.ts +89 -0
- package/src/prover/smt/solver/seq-monadic.ts +730 -0
- package/src/prover/smt/solver/seq-range-predicate.ts +235 -0
- package/src/prover/smt/solver/seq-re-rewriter.ts +1171 -0
- package/src/prover/smt/solver/seq-re-util.ts +758 -0
- package/src/prover/smt/solver/seq-regex-bisim.ts +144 -0
- package/src/prover/smt/solver/seq-regex-live.ts +200 -0
- package/src/prover/smt/solver/seq-rewriter.ts +2404 -0
- package/src/prover/smt/solver/seq-skolem.ts +294 -0
- package/src/prover/smt/solver/seq-subset.ts +165 -0
- package/src/prover/smt/solver/seq-view-witness.ts +353 -0
- package/src/prover/smt/solver/smt-consequences.ts +297 -0
- package/src/prover/smt/solver/smt-kernel.ts +124 -0
- package/src/prover/smt/solver/smt-logics.ts +66 -0
- package/src/prover/smt/solver/smt-setup.ts +589 -0
- package/src/prover/smt/solver/smt2-printer.ts +765 -0
- package/src/prover/smt/solver/smtlib-parser.ts +3546 -406
- package/src/prover/smt/solver/smtlib-script.ts +2134 -0
- package/src/prover/smt/solver/solve-eqs.ts +928 -0
- package/src/prover/smt/solver/solver.ts +135 -40
- package/src/prover/smt/solver/sort.ts +1 -5
- package/src/prover/smt/solver/static-features.ts +314 -0
- package/src/prover/smt/solver/sticky-generations.ts +0 -6
- package/src/prover/smt/solver/tactic.ts +2141 -0
- package/src/prover/smt/solver/term-enumeration.ts +205 -0
- package/src/prover/smt/solver/theory-array.ts +1240 -0
- package/src/prover/smt/solver/theory-bv.ts +1210 -0
- package/src/prover/smt/solver/theory-char.ts +355 -0
- package/src/prover/smt/solver/theory-datatype.ts +598 -0
- package/src/prover/smt/solver/theory-finite-set.ts +30 -0
- package/src/prover/smt/solver/theory-fpa.ts +389 -0
- package/src/prover/smt/solver/theory-lra-axioms.ts +55 -25
- package/src/prover/smt/solver/theory-lra-bounds.ts +31 -11
- package/src/prover/smt/solver/theory-lra-final-check.ts +60 -91
- package/src/prover/smt/solver/theory-lra-internalize.ts +96 -53
- package/src/prover/smt/solver/theory-lra-model.ts +23 -53
- package/src/prover/smt/solver/theory-lra-propagate.ts +34 -42
- package/src/prover/smt/solver/theory-lra-state.ts +7 -28
- package/src/prover/smt/solver/theory-lra.ts +189 -9
- package/src/prover/smt/solver/theory-pb.ts +951 -0
- package/src/prover/smt/solver/theory-polymorphism.ts +58 -0
- package/src/prover/smt/solver/theory-recfun.ts +307 -0
- package/src/prover/smt/solver/theory-seq-regex.ts +867 -0
- package/src/prover/smt/solver/theory-seq-solve.ts +1373 -0
- package/src/prover/smt/solver/theory-seq-state.ts +852 -0
- package/src/prover/smt/solver/theory-seq.ts +961 -0
- package/src/prover/smt/solver/theory-without-terms.ts +24 -0
- package/src/prover/smt/solver/theory.ts +189 -0
- package/src/prover/smt/solver/tseitin-cnf.ts +486 -0
- package/src/prover/smt/solver/var-subst.ts +37 -39
- package/src/prover/smt/table.ts +3 -10
- package/src/prover/smt/types.ts +146 -0
- package/src/prover/tlapm/cache.ts +74 -48
- package/src/prover/tlapm/ocaml-marshal.ts +19 -21
- package/src/prover/tlapm/tlapm.ts +21 -20
- package/src/prover/tlapm-library.ts +3208 -0
- package/src/prover/verdict.ts +9 -2
- package/src/prover/zenon/check/check.ts +1 -11
- package/src/prover/zenon/check/definitions.ts +5 -15
- package/src/prover/zenon/check/equality.ts +0 -8
- package/src/prover/zenon/check/functions.ts +0 -4
- package/src/prover/zenon/check/keys.ts +0 -7
- package/src/prover/zenon/check/propositional.ts +0 -3
- package/src/prover/zenon/check/records.ts +1 -6
- package/src/prover/zenon/check/relations.ts +2 -14
- package/src/prover/zenon/check/rewrites.ts +2 -21
- package/src/prover/zenon/check/sets.ts +40 -61
- package/src/prover/zenon/check/terms.ts +1 -19
- package/src/prover/zenon/check/tla.ts +0 -6
- package/src/prover/zenon/decide.ts +10 -19
- package/src/prover/zenon/encode.ts +0 -9
- package/src/prover/zenon/eqrel.ts +2 -15
- package/src/prover/zenon/equality-rules.ts +24 -6
- package/src/prover/zenon/expr.ts +29 -28
- package/src/prover/zenon/index-table.ts +33 -61
- package/src/prover/zenon/isar-case.ts +9 -21
- package/src/prover/zenon/isar.ts +37 -67
- package/src/prover/zenon/limits.ts +0 -4
- package/src/prover/zenon/llproof.ts +2 -22
- package/src/prover/zenon/mltoll.ts +66 -106
- package/src/prover/zenon/node.ts +20 -15
- package/src/prover/zenon/ocaml.ts +1 -17
- package/src/prover/zenon/parse.ts +9 -13
- package/src/prover/zenon/phrase.ts +2 -14
- package/src/prover/zenon/proof.ts +0 -11
- package/src/prover/zenon/propositional-rules.ts +0 -7
- package/src/prover/zenon/rules.ts +3 -8
- package/src/prover/zenon/search.ts +11 -35
- package/src/prover/zenon/tla/functions.ts +59 -33
- package/src/prover/zenon/tla/llproof.ts +67 -78
- package/src/prover/zenon/tla/records.ts +57 -35
- package/src/prover/zenon/tla/rewrites.ts +12 -21
- package/src/prover/zenon/tla/sets.ts +88 -59
- package/src/prover/zenon/tla/terms.ts +0 -8
- package/src/prover/zenon/tla/tla.ts +66 -66
- package/src/randomization.ts +81 -35
- package/src/resolve.ts +1132 -430
- package/src/runtime.ts +33 -23
- package/src/sany/builtins.ts +11 -14
- package/src/sany/generation.ts +383 -0
- package/src/sany/generator-def-entries.ts +210 -0
- package/src/sany/generator-definitions.ts +688 -0
- package/src/sany/generator-expressions.ts +1108 -0
- package/src/sany/generator-proofs.ts +665 -0
- package/src/sany/generator.ts +192 -2764
- package/src/sany/levels.ts +5 -35
- package/src/sany/lexer.ts +61 -80
- package/src/sany/linter.ts +0 -10
- package/src/sany/modules.ts +5 -7
- package/src/sany/nodes.ts +6 -44
- package/src/sany/parse-error.ts +39 -117
- package/src/sany/report.ts +32 -69
- package/src/sany/selectors.ts +60 -82
- package/src/sany/source.ts +1 -17
- package/src/sany/xml.ts +37 -120
- package/src/search.ts +913 -227
- package/src/simulate.ts +765 -0
- package/src/spec-description.ts +198 -104
- package/src/standard-definitions.ts +4 -4
- package/src/standard-modules.ts +302 -99
- package/src/state-graph.ts +52 -33
- package/src/subexpressions.ts +578 -166
- package/src/substitution-levels.ts +7 -7
- package/src/successors.ts +299 -108
- package/src/symmetry.ts +37 -28
- package/src/tableau.ts +29 -26
- package/src/tlc/fingerprint.ts +267 -79
- package/src/tlc/jar-data.ts +122 -6
- package/src/tlc/messages.ts +127 -56
- package/src/tlc/order.ts +53 -72
- package/src/tlc/random.ts +38 -49
- package/src/tlc/replay.ts +579 -230
- package/src/tlc/summary.ts +64 -60
- package/src/tlc/tlc-operators.ts +83 -47
- package/src/tlc/tlcext-operators.ts +205 -127
- package/src/tlc/trace-spec.ts +235 -0
- package/src/tlc/value-stream.ts +139 -0
- package/src/tlc/version.ts +1 -4
- package/src/trace-liveness.ts +529 -0
- package/src/transfer.ts +22 -25
- package/src/typed-tier.ts +6556 -0
- package/src/typescript/actions.ts +479 -0
- package/src/typescript/collections.ts +614 -0
- package/src/typescript/compile.ts +63 -0
- package/src/typescript/context.ts +94 -0
- package/src/typescript/emit.ts +121 -0
- package/src/typescript/expressions.ts +496 -0
- package/src/typescript/formula.ts +154 -0
- package/src/typescript/functions.ts +284 -0
- package/src/typescript/model.ts +162 -0
- package/src/typescript/names.ts +114 -0
- package/src/typescript/program.ts +48 -0
- package/src/typescript/properties.ts +139 -0
- package/src/typescript/scope.ts +112 -0
- package/src/typescript/steps.ts +167 -0
- package/src/typescript/types.ts +171 -0
- package/src/values.ts +945 -526
- package/src/worker.ts +7 -8
- package/src/prover/isabelle/isar/statement.ts +0 -57
- package/src/prover/smt/solver/z3-license.txt +0 -10
- package/src/prover/tlaps-module.ts +0 -510
- package/src/prover/zenon/LICENSE +0 -32
|
@@ -1,12 +1,3 @@
|
|
|
1
|
-
// Ported from Z3 (src/math/dd/dd_pdd.h, src/math/dd/dd_pdd.cpp, src/math/dd/pdd_eval.h), MIT
|
|
2
|
-
// license, see z3-license.txt. Polynomial decision diagrams over the rationals, which nla's Grobner
|
|
3
|
-
// solver works on: a node is x*hi + lo for the variable x at its level, lo has no x, and the leaves
|
|
4
|
-
// are values. Only the free semantics is ported, the one nla and dd::solver use: not mod2, mod2N or
|
|
5
|
-
// zero_one_vars, nor what only those or polysat use (the boolean operations, substitution of
|
|
6
|
-
// values, resolve, quot_rem, and division without the inverse). Nodes are never freed, so there is
|
|
7
|
-
// no garbage collection: node indices match Z3's until its first collection, and the node limit
|
|
8
|
-
// counts every node made. The op cache keys on both operands, where Z3's eq_entry compares the
|
|
9
|
-
// first operand of one entry with the second of the other.
|
|
10
1
|
import { PddMemoryOutError } from "../../../../errors";
|
|
11
2
|
import { getGcd, Rational } from "../rational";
|
|
12
3
|
import { shrink } from "../array";
|
|
@@ -18,9 +9,8 @@ const SUB_OP = 3;
|
|
|
18
9
|
const MINUS_OP = 4;
|
|
19
10
|
const MUL_OP = 5;
|
|
20
11
|
const REDUCE_OP = 6;
|
|
21
|
-
// Nodes below this index stand for the operations in the op cache, besides 0 and 1.
|
|
22
12
|
const NO_OP = 10;
|
|
23
|
-
const
|
|
13
|
+
const MAX_RC = (1 << 10) - 1;
|
|
24
14
|
|
|
25
15
|
interface PddMonomial {
|
|
26
16
|
coeff: Rational;
|
|
@@ -37,9 +27,9 @@ interface PddPower {
|
|
|
37
27
|
degree: number;
|
|
38
28
|
}
|
|
39
29
|
|
|
40
|
-
interface
|
|
41
|
-
lc:
|
|
42
|
-
rest:
|
|
30
|
+
interface FactorEntry {
|
|
31
|
+
lc: number;
|
|
32
|
+
rest: number;
|
|
43
33
|
}
|
|
44
34
|
|
|
45
35
|
interface PddVarFactors {
|
|
@@ -59,81 +49,99 @@ interface CommonFactors {
|
|
|
59
49
|
secondCoeff: Rational;
|
|
60
50
|
}
|
|
61
51
|
|
|
52
|
+
const getNodeKey = (level: number, lo: number, hi: number) => `${level},${lo},${hi}`;
|
|
53
|
+
|
|
62
54
|
export class PddManager {
|
|
63
55
|
private levels: number[] = [];
|
|
64
56
|
private los: number[] = [];
|
|
65
57
|
private his: number[] = [];
|
|
58
|
+
private refcounts: number[] = [];
|
|
66
59
|
private values: Rational[] = [];
|
|
60
|
+
private opCache = new Map<number, number>();
|
|
61
|
+
private factorCache = new Map<string, FactorEntry>();
|
|
67
62
|
private nodeTable = new Map<string, number>();
|
|
68
63
|
private valueTable = new Map<string, number>();
|
|
69
|
-
private
|
|
70
|
-
private
|
|
71
|
-
private
|
|
72
|
-
private numAllocated = 0;
|
|
73
|
-
private maxNumNodes = 1 << 24;
|
|
74
|
-
private isApplying = false;
|
|
75
|
-
var2pdd: number[] = [];
|
|
64
|
+
private pddStack: number[] = [];
|
|
65
|
+
private pddStackSize = 0;
|
|
66
|
+
private var2pdd: number[] = [];
|
|
76
67
|
var2level: number[] = [];
|
|
77
68
|
level2var: number[] = [];
|
|
69
|
+
private freeNodes: number[] = [];
|
|
70
|
+
private dmarks: number[] = [];
|
|
71
|
+
private dmarkLevel = 0;
|
|
72
|
+
private degrees: number[] = [];
|
|
73
|
+
private degreeTodo: number[] = [];
|
|
74
|
+
private maxNumNodes = 1 << 24;
|
|
75
|
+
private freeValues: number[] = [];
|
|
76
|
+
private freezeValue = Rational.zero;
|
|
78
77
|
|
|
79
78
|
constructor(numVars: number) {
|
|
80
|
-
this.initNodes(Array.from({ length: numVars }, (
|
|
79
|
+
this.initNodes(Array.from({ length: numVars }, (_value, index) => index));
|
|
81
80
|
}
|
|
82
81
|
|
|
83
82
|
reset(level2var: number[]) {
|
|
83
|
+
this.opCache.clear();
|
|
84
|
+
this.factorCache.clear();
|
|
85
|
+
this.nodeTable.clear();
|
|
84
86
|
this.levels = [];
|
|
85
87
|
this.los = [];
|
|
86
88
|
this.his = [];
|
|
89
|
+
this.refcounts = [];
|
|
90
|
+
this.dmarks = [];
|
|
91
|
+
this.degrees = [];
|
|
92
|
+
this.freeNodes = [];
|
|
93
|
+
this.pddStackSize = 0;
|
|
87
94
|
this.values = [];
|
|
88
|
-
this.
|
|
95
|
+
this.freeValues = [];
|
|
89
96
|
this.valueTable.clear();
|
|
90
|
-
this.opCache.clear();
|
|
91
|
-
this.factorCache.clear();
|
|
92
|
-
this.degrees = [];
|
|
93
97
|
this.initNodes(level2var);
|
|
94
98
|
}
|
|
95
99
|
|
|
100
|
+
setMaxNumNodes(limit: number) {
|
|
101
|
+
this.maxNumNodes = limit + this.level2var.length;
|
|
102
|
+
}
|
|
103
|
+
|
|
104
|
+
numNodes() {
|
|
105
|
+
return this.levels.length - this.freeNodes.length;
|
|
106
|
+
}
|
|
107
|
+
|
|
96
108
|
private initNodes(level2var: number[]) {
|
|
97
109
|
for (let index = 0; index < NO_OP; index++) {
|
|
98
110
|
this.levels.push(0);
|
|
99
111
|
this.los.push(0);
|
|
100
112
|
this.his.push(0);
|
|
113
|
+
this.refcounts.push(MAX_RC);
|
|
114
|
+
this.dmarks.push(0);
|
|
115
|
+
this.degrees.push(0);
|
|
101
116
|
}
|
|
102
117
|
this.los[ONE_PDD] = 1;
|
|
103
118
|
this.values.push(Rational.zero, Rational.one);
|
|
104
|
-
this.
|
|
105
|
-
this.
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
|
|
119
|
+
this.allocFreeNodes(1024 + level2var.length);
|
|
120
|
+
this.initVars(level2var);
|
|
121
|
+
}
|
|
122
|
+
|
|
123
|
+
private initVars(level2var: number[]) {
|
|
124
|
+
const count = level2var.length;
|
|
125
|
+
this.level2var = Array.from({ length: count }, () => 0);
|
|
126
|
+
this.var2level = Array.from({ length: count }, () => 0);
|
|
127
|
+
this.var2pdd = Array.from({ length: count }, () => 0);
|
|
128
|
+
for (let level = 0; level < count; level++) {
|
|
109
129
|
const variable = level2var[level];
|
|
110
130
|
this.var2pdd[variable] = this.makeNode(level, ZERO_PDD, ONE_PDD);
|
|
131
|
+
this.refcounts[this.var2pdd[variable]] = MAX_RC;
|
|
111
132
|
this.var2level[variable] = level;
|
|
112
133
|
this.level2var[level] = variable;
|
|
113
134
|
}
|
|
114
135
|
}
|
|
115
136
|
|
|
116
|
-
setMaxNumNodes(limit: number) {
|
|
117
|
-
this.maxNumNodes = limit + this.level2var.length;
|
|
118
|
-
}
|
|
119
|
-
|
|
120
|
-
numNodes() {
|
|
121
|
-
return this.levels.length;
|
|
122
|
-
}
|
|
123
|
-
|
|
124
|
-
numVars() {
|
|
125
|
-
return this.var2pdd.length;
|
|
126
|
-
}
|
|
127
|
-
|
|
128
137
|
isVal(node: number) {
|
|
129
138
|
return this.his[node] === 0;
|
|
130
139
|
}
|
|
131
140
|
|
|
132
|
-
level(node: number) {
|
|
141
|
+
private level(node: number) {
|
|
133
142
|
return this.levels[node];
|
|
134
143
|
}
|
|
135
144
|
|
|
136
|
-
// A value node is at level 0, so its var is the lowest variable, as in Z3.
|
|
137
145
|
var(node: number) {
|
|
138
146
|
return this.level2var[this.levels[node]];
|
|
139
147
|
}
|
|
@@ -150,19 +158,26 @@ export class PddManager {
|
|
|
150
158
|
return this.values[this.los[node]];
|
|
151
159
|
}
|
|
152
160
|
|
|
153
|
-
|
|
154
|
-
|
|
155
|
-
while (!this.isVal(current)) current = this.lo(current);
|
|
156
|
-
return this.val(current);
|
|
161
|
+
incRef(node: number) {
|
|
162
|
+
if (this.refcounts[node] !== MAX_RC) this.refcounts[node]++;
|
|
157
163
|
}
|
|
158
164
|
|
|
159
|
-
|
|
165
|
+
decRef(node: number) {
|
|
166
|
+
if (this.refcounts[node] !== MAX_RC) this.refcounts[node]--;
|
|
167
|
+
}
|
|
168
|
+
|
|
169
|
+
private reserveVar(variable: number) {
|
|
160
170
|
while (this.var2level.length <= variable) {
|
|
161
171
|
const next = this.var2level.length;
|
|
162
172
|
this.var2pdd.push(this.makeNode(next, ZERO_PDD, ONE_PDD));
|
|
173
|
+
this.refcounts[this.var2pdd[next]] = MAX_RC;
|
|
163
174
|
this.var2level.push(next);
|
|
164
175
|
this.level2var.push(next);
|
|
165
176
|
}
|
|
177
|
+
}
|
|
178
|
+
|
|
179
|
+
mkVar(variable: number) {
|
|
180
|
+
this.reserveVar(variable);
|
|
166
181
|
return new Pdd(this, this.var2pdd[variable]);
|
|
167
182
|
}
|
|
168
183
|
|
|
@@ -174,7 +189,7 @@ export class PddManager {
|
|
|
174
189
|
return new Pdd(this, ZERO_PDD);
|
|
175
190
|
}
|
|
176
191
|
|
|
177
|
-
one() {
|
|
192
|
+
private one() {
|
|
178
193
|
return new Pdd(this, ONE_PDD);
|
|
179
194
|
}
|
|
180
195
|
|
|
@@ -194,165 +209,230 @@ export class PddManager {
|
|
|
194
209
|
return new Pdd(this, this.apply(first.root, second.root, REDUCE_OP));
|
|
195
210
|
}
|
|
196
211
|
|
|
212
|
+
mulValue(value: Rational, poly: Pdd) {
|
|
213
|
+
const constant = this.mkVal(value);
|
|
214
|
+
const result = new Pdd(this, this.apply(constant.root, poly.root, MUL_OP));
|
|
215
|
+
constant.release();
|
|
216
|
+
return result;
|
|
217
|
+
}
|
|
218
|
+
|
|
219
|
+
addValue(value: Rational, poly: Pdd) {
|
|
220
|
+
const constant = this.mkVal(value);
|
|
221
|
+
const result = new Pdd(this, this.apply(constant.root, poly.root, ADD_OP));
|
|
222
|
+
constant.release();
|
|
223
|
+
return result;
|
|
224
|
+
}
|
|
225
|
+
|
|
197
226
|
minus(poly: Pdd) {
|
|
198
|
-
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
|
|
227
|
+
const size = this.pddStackSize;
|
|
228
|
+
try {
|
|
229
|
+
for (let count = 0; ; count++) {
|
|
230
|
+
try {
|
|
231
|
+
return new Pdd(this, this.minusRec(poly.root));
|
|
232
|
+
} catch (error) {
|
|
233
|
+
if (!(error instanceof PddMemoryOutError)) throw error;
|
|
234
|
+
this.tryGc();
|
|
235
|
+
if (count > 0) this.maxNumNodes *= 2;
|
|
236
|
+
}
|
|
237
|
+
}
|
|
238
|
+
} finally {
|
|
239
|
+
this.pddStackSize = size;
|
|
240
|
+
}
|
|
202
241
|
}
|
|
203
242
|
|
|
204
|
-
pow(poly: Pdd, exponent: number)
|
|
205
|
-
|
|
206
|
-
if (exponent === 1 || poly.isZero() || poly.isOne()) return poly;
|
|
207
|
-
if (poly.isVal()) return this.mkVal(poly.val().pow(exponent));
|
|
208
|
-
// j even: pow(p,2*j') = pow(p*p,j'); j odd: pow(p,2*j'+1) = p*pow(p*p,j')
|
|
209
|
-
const half = this.pow(this.mul(poly, poly), Math.floor(exponent / 2));
|
|
210
|
-
return exponent % 2 === 1 ? this.mul(half, poly) : half;
|
|
243
|
+
pow(poly: Pdd, exponent: number) {
|
|
244
|
+
return new Pdd(this, this.powNode(poly.root, exponent));
|
|
211
245
|
}
|
|
212
246
|
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
|
|
216
|
-
|
|
247
|
+
private powNode(node: number, exponent: number) {
|
|
248
|
+
if (exponent === 0) return ONE_PDD;
|
|
249
|
+
if (exponent === 1) return node;
|
|
250
|
+
if (node === ZERO_PDD) return ZERO_PDD;
|
|
251
|
+
if (node === ONE_PDD) return ONE_PDD;
|
|
252
|
+
if (this.isVal(node)) return this.imkVal(this.val(node).pow(exponent));
|
|
253
|
+
return this.powRec(node, exponent);
|
|
217
254
|
}
|
|
218
255
|
|
|
219
|
-
private
|
|
220
|
-
|
|
256
|
+
private powRec(node: number, exponent: number): number {
|
|
257
|
+
if (exponent === 1) return node;
|
|
258
|
+
const half = this.powRec(this.apply(node, node, MUL_OP), Math.floor(exponent / 2));
|
|
259
|
+
return exponent % 2 === 1 ? this.apply(half, node, MUL_OP) : half;
|
|
260
|
+
}
|
|
261
|
+
|
|
262
|
+
private apply(first: number, second: number, op: number) {
|
|
263
|
+
const size = this.pddStackSize;
|
|
221
264
|
try {
|
|
222
|
-
|
|
265
|
+
for (let count = 0; ; count++) {
|
|
266
|
+
try {
|
|
267
|
+
return this.applyRec(first, second, op);
|
|
268
|
+
} catch (error) {
|
|
269
|
+
if (!(error instanceof PddMemoryOutError)) throw error;
|
|
270
|
+
this.tryGc();
|
|
271
|
+
if (count > 0) this.maxNumNodes *= 2;
|
|
272
|
+
}
|
|
273
|
+
}
|
|
223
274
|
} finally {
|
|
224
|
-
this.
|
|
275
|
+
this.pddStackSize = size;
|
|
225
276
|
}
|
|
226
277
|
}
|
|
227
278
|
|
|
228
279
|
private applyRec(first: number, second: number, op: number): number {
|
|
280
|
+
let p = first;
|
|
281
|
+
let q = second;
|
|
229
282
|
switch (op) {
|
|
230
283
|
case SUB_OP:
|
|
231
|
-
if (
|
|
232
|
-
if (this.isVal(
|
|
233
|
-
return this.imkVal(this.val(first).sub(this.val(second)));
|
|
234
|
-
}
|
|
284
|
+
if (q === ZERO_PDD) return p;
|
|
285
|
+
if (this.isVal(p) && this.isVal(q)) return this.imkVal(this.val(p).sub(this.val(q)));
|
|
235
286
|
break;
|
|
236
287
|
case ADD_OP:
|
|
237
|
-
if (
|
|
238
|
-
if (
|
|
239
|
-
if (this.isVal(
|
|
240
|
-
|
|
241
|
-
|
|
242
|
-
|
|
243
|
-
return this.applyRec(second, first, op);
|
|
288
|
+
if (p === ZERO_PDD) return q;
|
|
289
|
+
if (q === ZERO_PDD) return p;
|
|
290
|
+
if (this.isVal(p) && this.isVal(q)) return this.imkVal(this.val(p).add(this.val(q)));
|
|
291
|
+
if (this.isVal(p) || (!this.isVal(q) && this.level(p) < this.level(q))) {
|
|
292
|
+
p = second;
|
|
293
|
+
q = first;
|
|
244
294
|
}
|
|
245
295
|
break;
|
|
246
296
|
case MUL_OP:
|
|
247
|
-
if (
|
|
248
|
-
if (
|
|
249
|
-
if (
|
|
250
|
-
if (this.isVal(
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
|
|
254
|
-
return this.applyRec(second, first, op);
|
|
297
|
+
if (p === ZERO_PDD || q === ZERO_PDD) return ZERO_PDD;
|
|
298
|
+
if (p === ONE_PDD) return q;
|
|
299
|
+
if (q === ONE_PDD) return p;
|
|
300
|
+
if (this.isVal(p) && this.isVal(q)) return this.imkVal(this.val(p).mul(this.val(q)));
|
|
301
|
+
if (this.isVal(p) || (!this.isVal(q) && this.level(p) < this.level(q))) {
|
|
302
|
+
p = second;
|
|
303
|
+
q = first;
|
|
255
304
|
}
|
|
256
305
|
break;
|
|
257
|
-
|
|
258
|
-
if (
|
|
259
|
-
if (this.degree(
|
|
260
|
-
if (this.level(this.firstLeading(
|
|
306
|
+
default:
|
|
307
|
+
if (q === ZERO_PDD || this.isVal(p)) return p;
|
|
308
|
+
if (this.degree(p) < this.degree(q)) return p;
|
|
309
|
+
if (this.level(this.firstLeading(q)) > this.level(p)) return p;
|
|
261
310
|
break;
|
|
262
311
|
}
|
|
263
|
-
|
|
264
|
-
|
|
265
|
-
|
|
266
|
-
|
|
267
|
-
|
|
268
|
-
|
|
269
|
-
|
|
270
|
-
|
|
271
|
-
|
|
272
|
-
const
|
|
273
|
-
|
|
274
|
-
const firstLo = this.lo(first);
|
|
275
|
-
const firstHi = this.hi(first);
|
|
312
|
+
// Z3's op_entry equality compares the cached first operand with the new second one, so only equal operands hit.
|
|
313
|
+
// Deviation from Z3: on a hash collision Z3 returns that result for unequal operands too.
|
|
314
|
+
const isCached = p === q;
|
|
315
|
+
if (isCached) {
|
|
316
|
+
const cached = this.opCache.get(q * NO_OP + op);
|
|
317
|
+
if (cached !== undefined) return cached;
|
|
318
|
+
}
|
|
319
|
+
let result: number;
|
|
320
|
+
const levelP = this.level(p);
|
|
321
|
+
const levelQ = this.level(q);
|
|
322
|
+
let npop = 2;
|
|
276
323
|
switch (op) {
|
|
277
|
-
case ADD_OP:
|
|
278
|
-
if (this.isVal(
|
|
279
|
-
|
|
280
|
-
|
|
281
|
-
|
|
282
|
-
|
|
283
|
-
|
|
284
|
-
|
|
285
|
-
|
|
286
|
-
|
|
287
|
-
|
|
288
|
-
|
|
289
|
-
|
|
290
|
-
if (this.isVal(second) || firstLevel > secondLevel) {
|
|
291
|
-
// (ax + b) - k = ax + (b - k)
|
|
292
|
-
return this.makeNode(firstLevel, this.applyRec(firstLo, second, op), firstHi);
|
|
293
|
-
}
|
|
294
|
-
// (ax + b) - (cx + d) = (a - c)x + (b - d)
|
|
295
|
-
const lo = this.applyRec(firstLo, this.lo(second), op);
|
|
296
|
-
return this.makeNode(firstLevel, lo, this.applyRec(firstHi, this.hi(second), op));
|
|
297
|
-
}
|
|
298
|
-
case MUL_OP: {
|
|
299
|
-
if (this.isVal(second) || firstLevel !== secondLevel) {
|
|
300
|
-
// (x*hi(p)+lo(p))*b = x*hi(p)*b + lo(p)*b
|
|
301
|
-
const lo = this.applyRec(firstLo, second, op);
|
|
302
|
-
return this.makeNode(firstLevel, lo, this.applyRec(firstHi, second, op));
|
|
324
|
+
case ADD_OP:
|
|
325
|
+
if (this.isVal(q)) {
|
|
326
|
+
this.push(this.applyRec(this.lo(p), q, op));
|
|
327
|
+
result = this.makeNode(levelP, this.read(1), this.hi(p));
|
|
328
|
+
npop = 1;
|
|
329
|
+
} else if (levelP === levelQ) {
|
|
330
|
+
this.push(this.applyRec(this.lo(p), this.lo(q), op));
|
|
331
|
+
this.push(this.applyRec(this.hi(p), this.hi(q), op));
|
|
332
|
+
result = this.makeNode(levelP, this.read(2), this.read(1));
|
|
333
|
+
} else {
|
|
334
|
+
this.push(this.applyRec(this.lo(p), q, op));
|
|
335
|
+
result = this.makeNode(levelP, this.read(1), this.hi(p));
|
|
336
|
+
npop = 1;
|
|
303
337
|
}
|
|
304
|
-
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
|
|
310
|
-
|
|
311
|
-
|
|
312
|
-
|
|
313
|
-
|
|
338
|
+
break;
|
|
339
|
+
case SUB_OP:
|
|
340
|
+
if (this.isVal(p) || (!this.isVal(q) && levelP < levelQ)) {
|
|
341
|
+
this.push(this.applyRec(p, this.lo(q), op));
|
|
342
|
+
this.push(this.minusRec(this.hi(q)));
|
|
343
|
+
result = this.makeNode(levelQ, this.read(2), this.read(1));
|
|
344
|
+
} else if (this.isVal(q) || levelP > levelQ) {
|
|
345
|
+
this.push(this.applyRec(this.lo(p), q, op));
|
|
346
|
+
result = this.makeNode(levelP, this.read(1), this.hi(p));
|
|
347
|
+
npop = 1;
|
|
348
|
+
} else {
|
|
349
|
+
this.push(this.applyRec(this.lo(p), this.lo(q), op));
|
|
350
|
+
this.push(this.applyRec(this.hi(p), this.hi(q), op));
|
|
351
|
+
result = this.makeNode(levelP, this.read(2), this.read(1));
|
|
314
352
|
}
|
|
315
|
-
|
|
316
|
-
|
|
317
|
-
|
|
318
|
-
|
|
319
|
-
|
|
353
|
+
break;
|
|
354
|
+
case MUL_OP:
|
|
355
|
+
if (this.isVal(q) || levelP !== levelQ) {
|
|
356
|
+
this.push(this.applyRec(this.lo(p), q, op));
|
|
357
|
+
this.push(this.applyRec(this.hi(p), q, op));
|
|
358
|
+
result = this.makeNode(levelP, this.read(2), this.read(1));
|
|
359
|
+
} else {
|
|
360
|
+
this.push(this.applyRec(this.hi(p), this.hi(q), op));
|
|
361
|
+
this.push(this.applyRec(this.hi(p), this.lo(q), op));
|
|
362
|
+
this.push(this.applyRec(this.lo(p), this.hi(q), op));
|
|
363
|
+
this.push(this.applyRec(this.lo(p), this.lo(q), op));
|
|
364
|
+
const ac = this.read(4);
|
|
365
|
+
const ad = this.read(3);
|
|
366
|
+
const bc = this.read(2);
|
|
367
|
+
const bd = this.read(1);
|
|
368
|
+
this.push(this.applyRec(ad, bc, ADD_OP));
|
|
369
|
+
const sum = this.read(1);
|
|
370
|
+
if (!this.isVal(sum) && this.level(sum) === levelP) {
|
|
371
|
+
this.push(this.applyRec(ac, this.hi(sum), ADD_OP));
|
|
372
|
+
this.push(this.makeNode(levelP, this.lo(sum), this.read(1)));
|
|
373
|
+
result = this.makeNode(levelP, bd, this.read(1));
|
|
374
|
+
npop = 7;
|
|
375
|
+
} else {
|
|
376
|
+
this.push(this.makeNode(levelP, sum, ac));
|
|
377
|
+
result = this.makeNode(levelP, bd, this.read(1));
|
|
378
|
+
npop = 6;
|
|
379
|
+
}
|
|
320
380
|
}
|
|
321
|
-
|
|
322
|
-
|
|
323
|
-
if (
|
|
324
|
-
|
|
325
|
-
|
|
381
|
+
break;
|
|
382
|
+
default:
|
|
383
|
+
if (this.level(this.firstLeading(q)) < levelP) {
|
|
384
|
+
this.push(this.applyRec(this.lo(p), q, op));
|
|
385
|
+
this.push(this.applyRec(this.hi(p), q, op));
|
|
386
|
+
const lo = this.read(2);
|
|
387
|
+
const hi = this.read(1);
|
|
388
|
+
if (lo === this.lo(p) && hi === this.hi(p)) {
|
|
389
|
+
result = p;
|
|
390
|
+
} else if (this.level(lo) < levelP && this.level(hi) <= levelP) {
|
|
391
|
+
result = this.makeNode(levelP, lo, hi);
|
|
392
|
+
} else {
|
|
393
|
+
this.push(this.applyRec(hi, this.var2pdd[this.var(p)], MUL_OP));
|
|
394
|
+
this.push(this.applyRec(this.read(1), lo, ADD_OP));
|
|
395
|
+
result = this.read(1);
|
|
396
|
+
npop = 4;
|
|
397
|
+
}
|
|
398
|
+
} else {
|
|
399
|
+
result = this.reduceOnMatch(p, q);
|
|
400
|
+
npop = 0;
|
|
326
401
|
}
|
|
327
|
-
const product = this.applyRec(hi, this.var2pdd[this.var(first)], MUL_OP);
|
|
328
|
-
return this.applyRec(product, lo, ADD_OP);
|
|
329
|
-
}
|
|
330
402
|
}
|
|
403
|
+
this.pop(npop);
|
|
404
|
+
if (isCached) this.opCache.set(q * NO_OP + op, result);
|
|
405
|
+
return result;
|
|
331
406
|
}
|
|
332
407
|
|
|
333
408
|
private minusRec(node: number): number {
|
|
334
409
|
if (node === ZERO_PDD) return ZERO_PDD;
|
|
335
410
|
if (this.isVal(node)) return this.imkVal(this.val(node).neg());
|
|
336
|
-
const
|
|
337
|
-
const cached = this.opCache.get(key);
|
|
411
|
+
const cached = this.opCache.get(node * NO_OP + MINUS_OP);
|
|
338
412
|
if (cached !== undefined) return cached;
|
|
339
|
-
|
|
340
|
-
|
|
341
|
-
this.
|
|
413
|
+
this.push(this.minusRec(this.lo(node)));
|
|
414
|
+
this.push(this.minusRec(this.hi(node)));
|
|
415
|
+
const result = this.makeNode(this.level(node), this.read(2), this.read(1));
|
|
416
|
+
this.pop(2);
|
|
417
|
+
this.opCache.set(node * NO_OP + MINUS_OP, result);
|
|
342
418
|
return result;
|
|
343
419
|
}
|
|
344
420
|
|
|
345
|
-
// reduce_on_match: the monomials of a that lm(b) divides become (b - lt(b))/lm(b).
|
|
346
421
|
private reduceOnMatch(first: number, second: number) {
|
|
347
422
|
let current = first;
|
|
423
|
+
this.push(current);
|
|
348
424
|
while (this.lmOccurs(second, current)) {
|
|
349
|
-
|
|
350
|
-
|
|
425
|
+
this.push(this.ltQuotient(second, current));
|
|
426
|
+
this.push(this.applyRec(this.read(1), second, MUL_OP));
|
|
427
|
+
this.push(this.applyRec(current, this.read(1), ADD_OP));
|
|
428
|
+
current = this.read(1);
|
|
429
|
+
this.pop(4);
|
|
430
|
+
this.push(current);
|
|
351
431
|
}
|
|
432
|
+
this.pop(1);
|
|
352
433
|
return current;
|
|
353
434
|
}
|
|
354
435
|
|
|
355
|
-
// lm_occurs: whether the leading monomial of p divides a monomial of q.
|
|
356
436
|
private lmOccurs(first: number, second: number): boolean {
|
|
357
437
|
let divisor = this.firstLeading(first);
|
|
358
438
|
let target = second;
|
|
@@ -371,7 +451,6 @@ export class PddManager {
|
|
|
371
451
|
}
|
|
372
452
|
}
|
|
373
453
|
|
|
374
|
-
// lt_quotient: minus the r such that lt(p)*r is a monomial of q, given lm_occurs(p, q).
|
|
375
454
|
private ltQuotient(first: number, second: number): number {
|
|
376
455
|
let divisor = this.firstLeading(first);
|
|
377
456
|
let target = second;
|
|
@@ -390,24 +469,45 @@ export class PddManager {
|
|
|
390
469
|
}
|
|
391
470
|
|
|
392
471
|
private ltQuotientHi(first: number, second: number) {
|
|
393
|
-
|
|
394
|
-
|
|
472
|
+
this.push(this.ltQuotient(first, this.hi(second)));
|
|
473
|
+
const result = this.applyRec(this.var2pdd[this.var(second)], this.read(1), MUL_OP);
|
|
474
|
+
this.pop(1);
|
|
475
|
+
return result;
|
|
395
476
|
}
|
|
396
477
|
|
|
397
|
-
|
|
398
|
-
// and qc are the leading coefficients of a and b, when the leading monomials share a variable.
|
|
399
|
-
trySpoly(first: Pdd, second: Pdd) {
|
|
478
|
+
trySpoly(first: Pdd, second: Pdd, result: Pdd) {
|
|
400
479
|
const factors = this.commonFactors(first, second);
|
|
401
|
-
if (factors === null) return
|
|
402
|
-
|
|
403
|
-
|
|
404
|
-
|
|
405
|
-
|
|
406
|
-
|
|
407
|
-
|
|
408
|
-
|
|
480
|
+
if (factors === null) return false;
|
|
481
|
+
const spoly = this.spoly(first, second, factors);
|
|
482
|
+
result.assign(spoly);
|
|
483
|
+
spoly.release();
|
|
484
|
+
return true;
|
|
485
|
+
}
|
|
486
|
+
|
|
487
|
+
private spoly(first: Pdd, second: Pdd, factors: CommonFactors) {
|
|
488
|
+
const firstMultiplier = this.mkVal(factors.secondCoeff);
|
|
489
|
+
try {
|
|
490
|
+
for (let index = factors.second.length; index-- > 0;) {
|
|
491
|
+
const variable = this.mkVar(factors.second[index]);
|
|
492
|
+
firstMultiplier.mulAssign(variable);
|
|
493
|
+
variable.release();
|
|
494
|
+
}
|
|
495
|
+
const secondMultiplier = this.mkVal(factors.firstCoeff.neg());
|
|
496
|
+
for (let index = factors.first.length; index-- > 0;) {
|
|
497
|
+
const variable = this.mkVar(factors.first[index]);
|
|
498
|
+
secondMultiplier.mulAssign(variable);
|
|
499
|
+
variable.release();
|
|
500
|
+
}
|
|
501
|
+
const firstProduct = firstMultiplier.mul(first);
|
|
502
|
+
const secondProduct = secondMultiplier.mul(second);
|
|
503
|
+
const result = firstProduct.add(secondProduct);
|
|
504
|
+
secondProduct.release();
|
|
505
|
+
firstProduct.release();
|
|
506
|
+
secondMultiplier.release();
|
|
507
|
+
return result;
|
|
508
|
+
} finally {
|
|
509
|
+
firstMultiplier.release();
|
|
409
510
|
}
|
|
410
|
-
return firstMultiplier.mul(first).add(secondMultiplier.mul(second));
|
|
411
511
|
}
|
|
412
512
|
|
|
413
513
|
private commonFactors(first: Pdd, second: Pdd): CommonFactors | null {
|
|
@@ -454,7 +554,6 @@ export class PddManager {
|
|
|
454
554
|
}
|
|
455
555
|
}
|
|
456
556
|
|
|
457
|
-
// lm_lt: compares the leading monomials, then the monomials in degree-lex order.
|
|
458
557
|
lmLt(first: Pdd, second: Pdd) {
|
|
459
558
|
let firstNode = this.firstLeading(first.root);
|
|
460
559
|
let secondNode = this.firstLeading(second.root);
|
|
@@ -497,8 +596,6 @@ export class PddManager {
|
|
|
497
596
|
}
|
|
498
597
|
}
|
|
499
598
|
|
|
500
|
-
// first_leading: the first node with a term of the leading monomial, the monomial of highest
|
|
501
|
-
// degree and then highest variables.
|
|
502
599
|
private firstLeading(node: number) {
|
|
503
600
|
let current = node;
|
|
504
601
|
while (
|
|
@@ -514,60 +611,111 @@ export class PddManager {
|
|
|
514
611
|
return this.firstLeading(this.hi(node));
|
|
515
612
|
}
|
|
516
613
|
|
|
517
|
-
degree(node: number)
|
|
614
|
+
degree(node: number) {
|
|
518
615
|
if (node === ZERO_PDD || node === ONE_PDD) return 0;
|
|
519
|
-
const
|
|
520
|
-
if (
|
|
521
|
-
const
|
|
522
|
-
|
|
523
|
-
|
|
524
|
-
|
|
525
|
-
|
|
616
|
+
const dmarkLevel = this.dmarkLevel;
|
|
617
|
+
if (this.dmarks[node] === dmarkLevel) return this.degrees[node];
|
|
618
|
+
const todo = this.degreeTodo;
|
|
619
|
+
todo.push(node);
|
|
620
|
+
while (todo.length > 0) {
|
|
621
|
+
const current = todo[todo.length - 1];
|
|
622
|
+
if (this.dmarks[current] === dmarkLevel) {
|
|
623
|
+
todo.pop();
|
|
624
|
+
} else if (this.isVal(current)) {
|
|
625
|
+
this.degrees[current] = 0;
|
|
626
|
+
this.dmarks[current] = dmarkLevel;
|
|
627
|
+
} else {
|
|
628
|
+
const lo = this.lo(current);
|
|
629
|
+
const hi = this.hi(current);
|
|
630
|
+
if (this.dmarks[lo] !== dmarkLevel || this.dmarks[hi] !== dmarkLevel) {
|
|
631
|
+
todo.push(lo, hi);
|
|
632
|
+
} else {
|
|
633
|
+
this.degrees[current] = Math.max(this.degrees[lo], this.degrees[hi] + 1);
|
|
634
|
+
this.dmarks[current] = dmarkLevel;
|
|
635
|
+
}
|
|
636
|
+
}
|
|
637
|
+
}
|
|
638
|
+
return this.degrees[node];
|
|
526
639
|
}
|
|
527
640
|
|
|
528
|
-
|
|
529
|
-
factor(poly: Pdd, variable: number, degree: number): PddFactor {
|
|
641
|
+
factor(poly: Pdd, variable: number, degree: number, lc: Pdd, rest: Pdd) {
|
|
530
642
|
const variableLevel = this.var2level[variable];
|
|
531
643
|
if (degree === 0 || this.level(poly.root) < variableLevel) {
|
|
532
|
-
|
|
644
|
+
const zero = this.zero();
|
|
645
|
+
lc.assign(zero);
|
|
646
|
+
zero.release();
|
|
647
|
+
rest.assign(poly);
|
|
648
|
+
return;
|
|
533
649
|
}
|
|
534
650
|
const key = `${poly.root},${variable},${degree}`;
|
|
535
651
|
const cached = this.factorCache.get(key);
|
|
536
|
-
if (cached !== undefined)
|
|
537
|
-
|
|
538
|
-
|
|
539
|
-
|
|
540
|
-
|
|
541
|
-
|
|
542
|
-
|
|
543
|
-
|
|
652
|
+
if (cached !== undefined) {
|
|
653
|
+
const cachedLc = new Pdd(this, cached.lc);
|
|
654
|
+
lc.assign(cachedLc);
|
|
655
|
+
cachedLc.release();
|
|
656
|
+
const cachedRest = new Pdd(this, cached.rest);
|
|
657
|
+
rest.assign(cachedRest);
|
|
658
|
+
cachedRest.release();
|
|
659
|
+
return;
|
|
660
|
+
}
|
|
544
661
|
if (this.level(poly.root) > variableLevel) {
|
|
662
|
+
const lc1 = this.zero();
|
|
663
|
+
const rest1 = this.zero();
|
|
545
664
|
const node = this.mkVar(poly.var());
|
|
546
|
-
const
|
|
547
|
-
|
|
548
|
-
|
|
549
|
-
const
|
|
550
|
-
|
|
551
|
-
|
|
552
|
-
|
|
553
|
-
|
|
554
|
-
|
|
555
|
-
|
|
556
|
-
|
|
557
|
-
|
|
558
|
-
|
|
559
|
-
|
|
560
|
-
|
|
561
|
-
|
|
562
|
-
|
|
563
|
-
|
|
564
|
-
|
|
565
|
-
|
|
566
|
-
|
|
567
|
-
|
|
568
|
-
|
|
569
|
-
|
|
570
|
-
|
|
665
|
+
const hi = poly.hi();
|
|
666
|
+
this.factor(hi, variable, degree, lc, rest);
|
|
667
|
+
hi.release();
|
|
668
|
+
const lo = poly.lo();
|
|
669
|
+
this.factor(lo, variable, degree, lc1, rest1);
|
|
670
|
+
lo.release();
|
|
671
|
+
lc.mulAssign(node);
|
|
672
|
+
rest.mulAssign(node);
|
|
673
|
+
lc.addAssign(lc1);
|
|
674
|
+
rest.addAssign(rest1);
|
|
675
|
+
node.release();
|
|
676
|
+
rest1.release();
|
|
677
|
+
lc1.release();
|
|
678
|
+
} else {
|
|
679
|
+
let found = 0;
|
|
680
|
+
const current = poly.copy();
|
|
681
|
+
while (found < degree && !current.isVal() && this.level(current.root) === variableLevel) {
|
|
682
|
+
found++;
|
|
683
|
+
const hi = current.hi();
|
|
684
|
+
current.assign(hi);
|
|
685
|
+
hi.release();
|
|
686
|
+
}
|
|
687
|
+
if (found === degree) {
|
|
688
|
+
lc.assign(current);
|
|
689
|
+
current.assign(poly);
|
|
690
|
+
const zero = this.zero();
|
|
691
|
+
rest.assign(zero);
|
|
692
|
+
zero.release();
|
|
693
|
+
const power = this.one();
|
|
694
|
+
for (let index = 0; index < degree; index++) {
|
|
695
|
+
const lo = current.lo();
|
|
696
|
+
const term = power.mul(lo);
|
|
697
|
+
rest.addAssign(term);
|
|
698
|
+
term.release();
|
|
699
|
+
lo.release();
|
|
700
|
+
const hi = current.hi();
|
|
701
|
+
current.assign(hi);
|
|
702
|
+
const variablePdd = this.mkVar(variable);
|
|
703
|
+
power.mulAssign(variablePdd);
|
|
704
|
+
variablePdd.release();
|
|
705
|
+
hi.release();
|
|
706
|
+
}
|
|
707
|
+
power.release();
|
|
708
|
+
} else {
|
|
709
|
+
const zero = this.zero();
|
|
710
|
+
lc.assign(zero);
|
|
711
|
+
zero.release();
|
|
712
|
+
rest.assign(poly);
|
|
713
|
+
}
|
|
714
|
+
current.release();
|
|
715
|
+
}
|
|
716
|
+
this.factorCache.set(key, { lc: lc.root, rest: rest.root });
|
|
717
|
+
}
|
|
718
|
+
|
|
571
719
|
isBinary(node: number) {
|
|
572
720
|
const lo = this.lo(node);
|
|
573
721
|
return (
|
|
@@ -577,8 +725,6 @@ export class PddManager {
|
|
|
577
725
|
);
|
|
578
726
|
}
|
|
579
727
|
|
|
580
|
-
// get_powers: the variables with a power above 1. The var of a value node is the lowest
|
|
581
|
-
// variable, so Z3 counts a value under that variable as one more power of it.
|
|
582
728
|
getPowers(poly: Pdd) {
|
|
583
729
|
const powers: PddPower[] = [];
|
|
584
730
|
const marked = new Set<number>();
|
|
@@ -589,6 +735,7 @@ export class PddManager {
|
|
|
589
735
|
const variable = this.var(node);
|
|
590
736
|
let current = node;
|
|
591
737
|
let degree = 1;
|
|
738
|
+
// Like Z3, a value under the lowest variable counts as one more power of it.
|
|
592
739
|
while (!this.isVal(current) && this.var(this.hi(current)) === variable) {
|
|
593
740
|
degree++;
|
|
594
741
|
todo.push(this.lo(current));
|
|
@@ -600,7 +747,6 @@ export class PddManager {
|
|
|
600
747
|
return powers;
|
|
601
748
|
}
|
|
602
749
|
|
|
603
|
-
// var_is_leaf: whether every node of v has values as children.
|
|
604
750
|
varIsLeaf(poly: Pdd, variable: number) {
|
|
605
751
|
const marked = new Set<number>();
|
|
606
752
|
const todo = [poly.root];
|
|
@@ -645,14 +791,36 @@ export class PddManager {
|
|
|
645
791
|
return vars;
|
|
646
792
|
}
|
|
647
793
|
|
|
794
|
+
private push(node: number) {
|
|
795
|
+
this.pddStack[this.pddStackSize++] = node;
|
|
796
|
+
}
|
|
797
|
+
|
|
798
|
+
private pop(count: number) {
|
|
799
|
+
this.pddStackSize -= count;
|
|
800
|
+
}
|
|
801
|
+
|
|
802
|
+
private read(index: number) {
|
|
803
|
+
return this.pddStack[this.pddStackSize - index];
|
|
804
|
+
}
|
|
805
|
+
|
|
648
806
|
private imkVal(value: Rational) {
|
|
649
807
|
if (value.isZero()) return ZERO_PDD;
|
|
650
808
|
if (value.equals(Rational.one)) return ONE_PDD;
|
|
651
809
|
const key = value.toString();
|
|
652
|
-
|
|
653
|
-
|
|
654
|
-
|
|
655
|
-
|
|
810
|
+
return this.valueTable.get(key) ?? this.initValue(value, key);
|
|
811
|
+
}
|
|
812
|
+
|
|
813
|
+
private initValue(value: Rational, key: string) {
|
|
814
|
+
let valueIndex = this.values.length;
|
|
815
|
+
if (this.freeValues.length === 0) {
|
|
816
|
+
this.values.push(value);
|
|
817
|
+
} else {
|
|
818
|
+
valueIndex = this.freeValues[this.freeValues.length - 1];
|
|
819
|
+
this.freeValues.pop();
|
|
820
|
+
this.values[valueIndex] = value;
|
|
821
|
+
}
|
|
822
|
+
this.freezeValue = value;
|
|
823
|
+
const node = this.insertNode(0, valueIndex, 0);
|
|
656
824
|
this.valueTable.set(key, node);
|
|
657
825
|
return node;
|
|
658
826
|
}
|
|
@@ -661,31 +829,159 @@ export class PddManager {
|
|
|
661
829
|
return hi === ZERO_PDD ? lo : this.insertNode(level, lo, hi);
|
|
662
830
|
}
|
|
663
831
|
|
|
664
|
-
// insert_node: Z3 adds half as many free nodes again when they run out, and is out of memory
|
|
665
|
-
// when the nodes already number more than the limit.
|
|
666
832
|
private insertNode(level: number, lo: number, hi: number) {
|
|
667
|
-
const key =
|
|
833
|
+
const key = getNodeKey(level, lo, hi);
|
|
668
834
|
const existing = this.nodeTable.get(key);
|
|
669
835
|
if (existing !== undefined) return existing;
|
|
670
|
-
if (this.
|
|
671
|
-
|
|
672
|
-
|
|
673
|
-
this.
|
|
674
|
-
}
|
|
675
|
-
const node = this.
|
|
676
|
-
this.
|
|
677
|
-
this.
|
|
678
|
-
this.
|
|
836
|
+
if (this.freeNodes.length === 0) {
|
|
837
|
+
this.gc();
|
|
838
|
+
if (this.levels.length > this.maxNumNodes) throw new PddMemoryOutError();
|
|
839
|
+
this.allocFreeNodes(Math.floor(this.levels.length / 2));
|
|
840
|
+
}
|
|
841
|
+
const node = this.freeNodes[this.freeNodes.length - 1];
|
|
842
|
+
this.freeNodes.pop();
|
|
843
|
+
this.levels[node] = level;
|
|
844
|
+
this.los[node] = lo;
|
|
845
|
+
this.his[node] = hi;
|
|
846
|
+
this.refcounts[node] = 0;
|
|
679
847
|
this.nodeTable.set(key, node);
|
|
680
848
|
return node;
|
|
681
849
|
}
|
|
850
|
+
|
|
851
|
+
private tryGc() {
|
|
852
|
+
this.gc();
|
|
853
|
+
this.opCache.clear();
|
|
854
|
+
}
|
|
855
|
+
|
|
856
|
+
private allocFreeNodes(count: number) {
|
|
857
|
+
for (let index = 0; index < count; index++) {
|
|
858
|
+
this.freeNodes.push(this.levels.length);
|
|
859
|
+
this.levels.push(0);
|
|
860
|
+
this.los.push(0);
|
|
861
|
+
this.his.push(0);
|
|
862
|
+
this.refcounts.push(0);
|
|
863
|
+
this.dmarks.push(0);
|
|
864
|
+
this.degrees.push(0);
|
|
865
|
+
}
|
|
866
|
+
this.freeNodes.sort((first, second) => second - first);
|
|
867
|
+
this.initDmark();
|
|
868
|
+
}
|
|
869
|
+
|
|
870
|
+
private computeReachable(reachable: Uint8Array) {
|
|
871
|
+
const todo: number[] = [];
|
|
872
|
+
for (let index = this.pddStackSize; index-- > 0;) {
|
|
873
|
+
reachable[this.pddStack[index]] = 1;
|
|
874
|
+
todo.push(this.pddStack[index]);
|
|
875
|
+
}
|
|
876
|
+
for (let node = NO_OP; node-- > 0;) reachable[node] = 1;
|
|
877
|
+
for (let node = this.levels.length; node-- > NO_OP;) {
|
|
878
|
+
if (this.refcounts[node] > 0) {
|
|
879
|
+
reachable[node] = 1;
|
|
880
|
+
todo.push(node);
|
|
881
|
+
}
|
|
882
|
+
}
|
|
883
|
+
for (let node = todo.pop(); node !== undefined; node = todo.pop()) {
|
|
884
|
+
if (this.isVal(node)) continue;
|
|
885
|
+
const lo = this.lo(node);
|
|
886
|
+
const hi = this.hi(node);
|
|
887
|
+
if (reachable[lo] === 0) {
|
|
888
|
+
reachable[lo] = 1;
|
|
889
|
+
todo.push(lo);
|
|
890
|
+
}
|
|
891
|
+
if (reachable[hi] === 0) {
|
|
892
|
+
reachable[hi] = 1;
|
|
893
|
+
todo.push(hi);
|
|
894
|
+
}
|
|
895
|
+
}
|
|
896
|
+
}
|
|
897
|
+
|
|
898
|
+
private gc() {
|
|
899
|
+
this.initDmark();
|
|
900
|
+
this.freeNodes = [];
|
|
901
|
+
const size = this.levels.length;
|
|
902
|
+
const reachable = new Uint8Array(size);
|
|
903
|
+
this.computeReachable(reachable);
|
|
904
|
+
for (let node = size; node-- > NO_OP;) {
|
|
905
|
+
if (reachable[node] === 1) continue;
|
|
906
|
+
if (this.his[node] === 0 && this.los[node] !== 0) {
|
|
907
|
+
const value = this.values[this.los[node]];
|
|
908
|
+
if (this.freezeValue.equals(value)) continue;
|
|
909
|
+
this.freeValues.push(this.los[node]);
|
|
910
|
+
this.valueTable.delete(value.toString());
|
|
911
|
+
}
|
|
912
|
+
this.los[node] = 0;
|
|
913
|
+
this.his[node] = 0;
|
|
914
|
+
this.freeNodes.push(node);
|
|
915
|
+
}
|
|
916
|
+
this.opCache.clear();
|
|
917
|
+
this.factorCache.clear();
|
|
918
|
+
this.nodeTable.clear();
|
|
919
|
+
for (let node = size; node-- > 2;) {
|
|
920
|
+
if (reachable[node] === 0) continue;
|
|
921
|
+
this.nodeTable.set(getNodeKey(this.levels[node], this.los[node], this.his[node]), node);
|
|
922
|
+
}
|
|
923
|
+
}
|
|
924
|
+
|
|
925
|
+
private initDmark() {
|
|
926
|
+
this.dmarkLevel++;
|
|
927
|
+
}
|
|
682
928
|
}
|
|
683
929
|
|
|
930
|
+
const getMonomials = (poly: Pdd): PddMonomial[] => {
|
|
931
|
+
if (poly.isVal()) return poly.val().isZero() ? [] : [{ coeff: poly.val(), vars: [] }];
|
|
932
|
+
const hi = poly.hi();
|
|
933
|
+
const monomials = getMonomials(hi);
|
|
934
|
+
hi.release();
|
|
935
|
+
for (const monomial of monomials) monomial.vars.push(poly.var());
|
|
936
|
+
const lo = poly.lo();
|
|
937
|
+
monomials.push(...getMonomials(lo));
|
|
938
|
+
lo.release();
|
|
939
|
+
return monomials;
|
|
940
|
+
};
|
|
941
|
+
|
|
684
942
|
export class Pdd {
|
|
685
943
|
constructor(
|
|
686
|
-
readonly manager: PddManager,
|
|
687
|
-
|
|
688
|
-
) {
|
|
944
|
+
private readonly manager: PddManager,
|
|
945
|
+
public root: number,
|
|
946
|
+
) {
|
|
947
|
+
manager.incRef(root);
|
|
948
|
+
}
|
|
949
|
+
|
|
950
|
+
copy() {
|
|
951
|
+
const result = new Pdd(this.manager, this.root);
|
|
952
|
+
// Like Z3, whose copy constructor delegates to a counting constructor and then counts again.
|
|
953
|
+
this.manager.incRef(this.root);
|
|
954
|
+
return result;
|
|
955
|
+
}
|
|
956
|
+
|
|
957
|
+
release() {
|
|
958
|
+
this.manager.decRef(this.root);
|
|
959
|
+
}
|
|
960
|
+
|
|
961
|
+
assign(other: Pdd) {
|
|
962
|
+
const previous = this.root;
|
|
963
|
+
this.root = other.root;
|
|
964
|
+
this.manager.incRef(this.root);
|
|
965
|
+
this.manager.decRef(previous);
|
|
966
|
+
}
|
|
967
|
+
|
|
968
|
+
addAssign(other: Pdd) {
|
|
969
|
+
const sum = this.add(other);
|
|
970
|
+
this.assign(sum);
|
|
971
|
+
sum.release();
|
|
972
|
+
}
|
|
973
|
+
|
|
974
|
+
subAssign(value: Rational) {
|
|
975
|
+
const difference = this.sub(value);
|
|
976
|
+
this.assign(difference);
|
|
977
|
+
difference.release();
|
|
978
|
+
}
|
|
979
|
+
|
|
980
|
+
mulAssign(other: Pdd | Rational) {
|
|
981
|
+
const product = this.mul(other);
|
|
982
|
+
this.assign(product);
|
|
983
|
+
product.release();
|
|
984
|
+
}
|
|
689
985
|
|
|
690
986
|
lo() {
|
|
691
987
|
return new Pdd(this.manager, this.manager.lo(this.root));
|
|
@@ -703,10 +999,6 @@ export class Pdd {
|
|
|
703
999
|
return this.manager.val(this.root);
|
|
704
1000
|
}
|
|
705
1001
|
|
|
706
|
-
offset() {
|
|
707
|
-
return this.manager.offset(this.root);
|
|
708
|
-
}
|
|
709
|
-
|
|
710
1002
|
isVal() {
|
|
711
1003
|
return this.manager.isVal(this.root);
|
|
712
1004
|
}
|
|
@@ -723,18 +1015,30 @@ export class Pdd {
|
|
|
723
1015
|
return this.manager.degree(this.root) === 1;
|
|
724
1016
|
}
|
|
725
1017
|
|
|
726
|
-
isVar() {
|
|
727
|
-
return !this.isVal() && this.lo().isZero() && this.hi().isOne();
|
|
728
|
-
}
|
|
729
|
-
|
|
730
|
-
// a*x for a value a.
|
|
731
1018
|
isUnary() {
|
|
732
|
-
|
|
1019
|
+
if (this.isVal()) return false;
|
|
1020
|
+
const lo = this.lo();
|
|
1021
|
+
let isUnary = lo.isZero();
|
|
1022
|
+
if (isUnary) {
|
|
1023
|
+
const hi = this.hi();
|
|
1024
|
+
isUnary = hi.isVal();
|
|
1025
|
+
hi.release();
|
|
1026
|
+
}
|
|
1027
|
+
lo.release();
|
|
1028
|
+
return isUnary;
|
|
733
1029
|
}
|
|
734
1030
|
|
|
735
|
-
// x + b for a value b.
|
|
736
1031
|
isOffset() {
|
|
737
|
-
|
|
1032
|
+
if (this.isVal()) return false;
|
|
1033
|
+
const lo = this.lo();
|
|
1034
|
+
let isOffset = lo.isVal();
|
|
1035
|
+
if (isOffset) {
|
|
1036
|
+
const hi = this.hi();
|
|
1037
|
+
isOffset = hi.isOne();
|
|
1038
|
+
hi.release();
|
|
1039
|
+
}
|
|
1040
|
+
lo.release();
|
|
1041
|
+
return isOffset;
|
|
738
1042
|
}
|
|
739
1043
|
|
|
740
1044
|
isBinary() {
|
|
@@ -751,25 +1055,22 @@ export class Pdd {
|
|
|
751
1055
|
|
|
752
1056
|
add(other: Pdd | Rational) {
|
|
753
1057
|
return other instanceof Rational
|
|
754
|
-
? this.manager.
|
|
1058
|
+
? this.manager.addValue(other, this)
|
|
755
1059
|
: this.manager.add(this, other);
|
|
756
1060
|
}
|
|
757
1061
|
|
|
758
1062
|
sub(other: Pdd | Rational) {
|
|
759
|
-
return other instanceof Rational
|
|
1063
|
+
return other instanceof Rational
|
|
1064
|
+
? this.manager.addValue(other.neg(), this)
|
|
1065
|
+
: this.manager.sub(this, other);
|
|
760
1066
|
}
|
|
761
1067
|
|
|
762
1068
|
mul(other: Pdd | Rational) {
|
|
763
1069
|
return other instanceof Rational
|
|
764
|
-
? this.manager.
|
|
1070
|
+
? this.manager.mulValue(other, this)
|
|
765
1071
|
: this.manager.mul(this, other);
|
|
766
1072
|
}
|
|
767
1073
|
|
|
768
|
-
// div: in the free semantics, multiplication by the inverse, which shares the op cache.
|
|
769
|
-
div(divisor: Rational) {
|
|
770
|
-
return this.mul(Rational.one.div(divisor));
|
|
771
|
-
}
|
|
772
|
-
|
|
773
1074
|
pow(exponent: number) {
|
|
774
1075
|
return this.manager.pow(this, exponent);
|
|
775
1076
|
}
|
|
@@ -778,8 +1079,8 @@ export class Pdd {
|
|
|
778
1079
|
return this.manager.reduce(this, other);
|
|
779
1080
|
}
|
|
780
1081
|
|
|
781
|
-
factor(variable: number, degree: number) {
|
|
782
|
-
|
|
1082
|
+
factor(variable: number, degree: number, lc: Pdd, rest: Pdd) {
|
|
1083
|
+
this.manager.factor(this, variable, degree, lc, rest);
|
|
783
1084
|
}
|
|
784
1085
|
|
|
785
1086
|
differentLeadingTerm(other: Pdd) {
|
|
@@ -806,22 +1107,36 @@ export class Pdd {
|
|
|
806
1107
|
return this.manager.getPowers(this);
|
|
807
1108
|
}
|
|
808
1109
|
|
|
809
|
-
// var_factors: the variables that divide every monomial, with their product divided out.
|
|
810
1110
|
varFactors(): PddVarFactors {
|
|
811
|
-
if (this.isVal()) return { vars: [], poly: this };
|
|
1111
|
+
if (this.isVal()) return { vars: [], poly: this.copy() };
|
|
812
1112
|
const manager = this.manager;
|
|
813
1113
|
const variable = this.var();
|
|
814
|
-
|
|
815
|
-
|
|
816
|
-
|
|
1114
|
+
const firstLo = this.lo();
|
|
1115
|
+
const isLoVal = firstLo.isVal();
|
|
1116
|
+
firstLo.release();
|
|
1117
|
+
if (isLoVal) {
|
|
1118
|
+
const secondLo = this.lo();
|
|
1119
|
+
const isLoZero = secondLo.isZero();
|
|
1120
|
+
secondLo.release();
|
|
1121
|
+
if (!isLoZero) return { vars: [], poly: this.copy() };
|
|
1122
|
+
const hi = this.hi();
|
|
1123
|
+
const factors = hi.varFactors();
|
|
1124
|
+
hi.release();
|
|
817
1125
|
factors.vars.push(variable);
|
|
818
|
-
|
|
1126
|
+
const result = { vars: factors.vars, poly: factors.poly.copy() };
|
|
1127
|
+
factors.poly.release();
|
|
1128
|
+
return result;
|
|
819
1129
|
}
|
|
820
|
-
const
|
|
1130
|
+
const lo = this.lo();
|
|
1131
|
+
const loFactors = lo.varFactors();
|
|
1132
|
+
lo.release();
|
|
821
1133
|
const loVars = loFactors.vars;
|
|
822
|
-
if (loVars.length === 0)
|
|
1134
|
+
if (loVars.length === 0) {
|
|
1135
|
+
const result = { vars: [], poly: this.copy() };
|
|
1136
|
+
loFactors.poly.release();
|
|
1137
|
+
return result;
|
|
1138
|
+
}
|
|
823
1139
|
const loAndHi: number[] = [];
|
|
824
|
-
// Moves the variables in both lists to loAndHi and keeps the rest in place, by level.
|
|
825
1140
|
const merge = (hiVars: number[]) => {
|
|
826
1141
|
let loKept = 0;
|
|
827
1142
|
let hiKept = 0;
|
|
@@ -845,107 +1160,161 @@ export class Pdd {
|
|
|
845
1160
|
shrink(loVars, loKept);
|
|
846
1161
|
shrink(hiVars, hiKept);
|
|
847
1162
|
};
|
|
848
|
-
const multiply = (vars: number[], poly: Pdd) =>
|
|
849
|
-
|
|
850
|
-
|
|
1163
|
+
const multiply = (vars: number[], poly: Pdd) => {
|
|
1164
|
+
const product = poly.copy();
|
|
1165
|
+
for (const innerVar of vars) {
|
|
1166
|
+
const variablePdd = manager.mkVar(innerVar);
|
|
1167
|
+
product.mulAssign(variablePdd);
|
|
1168
|
+
variablePdd.release();
|
|
1169
|
+
}
|
|
1170
|
+
return product;
|
|
1171
|
+
};
|
|
1172
|
+
const hi = this.hi();
|
|
1173
|
+
const hiFactors = hi.varFactors();
|
|
1174
|
+
hi.release();
|
|
851
1175
|
const hiVars = hiFactors.vars;
|
|
852
1176
|
if (loVars[loVars.length - 1] === variable) {
|
|
853
1177
|
loVars.pop();
|
|
854
1178
|
merge(hiVars);
|
|
855
1179
|
loAndHi.push(variable);
|
|
856
|
-
|
|
857
|
-
|
|
858
|
-
|
|
859
|
-
|
|
860
|
-
|
|
861
|
-
if (
|
|
862
|
-
|
|
863
|
-
|
|
864
|
-
|
|
865
|
-
|
|
866
|
-
vars: loAndHi,
|
|
867
|
-
|
|
868
|
-
|
|
1180
|
+
} else if (hiVars.length > 0) {
|
|
1181
|
+
merge(hiVars);
|
|
1182
|
+
hiVars.push(variable);
|
|
1183
|
+
}
|
|
1184
|
+
let result: PddVarFactors;
|
|
1185
|
+
if (loAndHi.length === 0) {
|
|
1186
|
+
result = { vars: [], poly: this.copy() };
|
|
1187
|
+
} else {
|
|
1188
|
+
const loProduct = multiply(loVars, loFactors.poly);
|
|
1189
|
+
const hiProduct = multiply(hiVars, hiFactors.poly);
|
|
1190
|
+
result = { vars: loAndHi, poly: loProduct.add(hiProduct) };
|
|
1191
|
+
hiProduct.release();
|
|
1192
|
+
loProduct.release();
|
|
1193
|
+
}
|
|
1194
|
+
hiFactors.poly.release();
|
|
1195
|
+
loFactors.poly.release();
|
|
1196
|
+
return result;
|
|
869
1197
|
}
|
|
870
1198
|
|
|
871
|
-
// subst_pdd: replaces the variable by the polynomial, without the op cache.
|
|
872
1199
|
substPdd(variable: number, replacement: Pdd): Pdd {
|
|
873
1200
|
const manager = this.manager;
|
|
874
|
-
if (this.isVal() || manager.var2level[this.var()] < manager.var2level[variable])
|
|
875
|
-
|
|
876
|
-
|
|
877
|
-
|
|
878
|
-
|
|
879
|
-
|
|
1201
|
+
if (this.isVal() || manager.var2level[this.var()] < manager.var2level[variable]) {
|
|
1202
|
+
return this.copy();
|
|
1203
|
+
}
|
|
1204
|
+
const lo = this.lo();
|
|
1205
|
+
const substitutedLo = lo.substPdd(variable, replacement);
|
|
1206
|
+
lo.release();
|
|
1207
|
+
const hi = this.hi();
|
|
1208
|
+
const substitutedHi = hi.substPdd(variable, replacement);
|
|
1209
|
+
hi.release();
|
|
1210
|
+
let result: Pdd;
|
|
1211
|
+
if (this.var() === variable) {
|
|
1212
|
+
const product = replacement.mul(substitutedHi);
|
|
1213
|
+
result = product.add(substitutedLo);
|
|
1214
|
+
product.release();
|
|
1215
|
+
} else {
|
|
1216
|
+
const thisLo = this.lo();
|
|
1217
|
+
let isUnchanged = substitutedLo.equals(thisLo);
|
|
1218
|
+
if (isUnchanged) {
|
|
1219
|
+
const thisHi = this.hi();
|
|
1220
|
+
isUnchanged = substitutedHi.equals(thisHi);
|
|
1221
|
+
thisHi.release();
|
|
1222
|
+
}
|
|
1223
|
+
thisLo.release();
|
|
1224
|
+
if (isUnchanged) {
|
|
1225
|
+
result = this.copy();
|
|
1226
|
+
} else {
|
|
1227
|
+
const variablePdd = manager.mkVar(this.var());
|
|
1228
|
+
const product = variablePdd.mul(substitutedHi);
|
|
1229
|
+
result = product.add(substitutedLo);
|
|
1230
|
+
product.release();
|
|
1231
|
+
variablePdd.release();
|
|
1232
|
+
}
|
|
1233
|
+
}
|
|
1234
|
+
substitutedHi.release();
|
|
1235
|
+
substitutedLo.release();
|
|
1236
|
+
return result;
|
|
880
1237
|
}
|
|
881
1238
|
|
|
882
|
-
// The monomials, hi before lo, each with its variables from the highest level down.
|
|
883
1239
|
*[Symbol.iterator](): Generator<PddMonomial> {
|
|
884
|
-
const
|
|
885
|
-
const
|
|
886
|
-
|
|
887
|
-
|
|
888
|
-
|
|
889
|
-
|
|
890
|
-
|
|
891
|
-
|
|
892
|
-
|
|
893
|
-
|
|
894
|
-
|
|
895
|
-
return;
|
|
896
|
-
}
|
|
897
|
-
yield { coeff: manager.val(node), vars: [...vars] };
|
|
898
|
-
while (nodes.length > 0) {
|
|
899
|
-
const top = nodes[nodes.length - 1];
|
|
900
|
-
if (!top.isFirst) {
|
|
901
|
-
nodes.pop();
|
|
902
|
-
continue;
|
|
1240
|
+
const begin = this.copy();
|
|
1241
|
+
const end = this.copy();
|
|
1242
|
+
try {
|
|
1243
|
+
const manager = this.manager;
|
|
1244
|
+
const nodes: IteratorNode[] = [];
|
|
1245
|
+
const vars: number[] = [];
|
|
1246
|
+
let node = begin.root;
|
|
1247
|
+
while (!manager.isVal(node)) {
|
|
1248
|
+
nodes.push({ isFirst: true, node });
|
|
1249
|
+
vars.push(manager.var(node));
|
|
1250
|
+
node = manager.hi(node);
|
|
903
1251
|
}
|
|
904
|
-
|
|
905
|
-
|
|
906
|
-
|
|
907
|
-
if (next === ZERO_PDD) {
|
|
908
|
-
nodes.pop();
|
|
909
|
-
continue;
|
|
1252
|
+
if (nodes.length === 0) {
|
|
1253
|
+
if (!manager.val(node).isZero()) yield { coeff: manager.val(node), vars: [] };
|
|
1254
|
+
return;
|
|
910
1255
|
}
|
|
911
|
-
|
|
912
|
-
|
|
913
|
-
|
|
914
|
-
|
|
1256
|
+
yield { coeff: manager.val(node), vars: [...vars] };
|
|
1257
|
+
while (nodes.length > 0) {
|
|
1258
|
+
const top = nodes[nodes.length - 1];
|
|
1259
|
+
if (!top.isFirst) {
|
|
1260
|
+
nodes.pop();
|
|
1261
|
+
continue;
|
|
1262
|
+
}
|
|
1263
|
+
top.isFirst = false;
|
|
1264
|
+
vars.pop();
|
|
1265
|
+
let next = manager.lo(top.node);
|
|
1266
|
+
if (next === ZERO_PDD) {
|
|
1267
|
+
nodes.pop();
|
|
1268
|
+
continue;
|
|
1269
|
+
}
|
|
1270
|
+
while (!manager.isVal(next)) {
|
|
1271
|
+
nodes.push({ isFirst: true, node: next });
|
|
1272
|
+
vars.push(manager.var(next));
|
|
1273
|
+
next = manager.hi(next);
|
|
1274
|
+
}
|
|
1275
|
+
yield { coeff: manager.val(next), vars: [...vars] };
|
|
915
1276
|
}
|
|
916
|
-
|
|
1277
|
+
} finally {
|
|
1278
|
+
end.release();
|
|
1279
|
+
begin.release();
|
|
917
1280
|
}
|
|
918
1281
|
}
|
|
919
1282
|
|
|
920
|
-
// The coefficients, each marked as the constant term or not. Zero yields one constant 0.
|
|
921
1283
|
*coefficients(): Generator<PddCoefficient> {
|
|
922
|
-
const
|
|
923
|
-
const
|
|
924
|
-
|
|
925
|
-
|
|
926
|
-
nodes
|
|
927
|
-
node =
|
|
928
|
-
|
|
929
|
-
|
|
930
|
-
|
|
931
|
-
let next = manager.lo(top);
|
|
932
|
-
if (next === ZERO_PDD) continue;
|
|
933
|
-
while (!manager.isVal(next)) {
|
|
934
|
-
nodes.push(next);
|
|
935
|
-
next = manager.hi(next);
|
|
1284
|
+
const begin = this.copy();
|
|
1285
|
+
const end = this.copy();
|
|
1286
|
+
try {
|
|
1287
|
+
const manager = this.manager;
|
|
1288
|
+
const nodes: number[] = [];
|
|
1289
|
+
let node = begin.root;
|
|
1290
|
+
while (!manager.isVal(node)) {
|
|
1291
|
+
nodes.push(node);
|
|
1292
|
+
node = manager.hi(node);
|
|
936
1293
|
}
|
|
937
|
-
yield { coeff: manager.val(
|
|
1294
|
+
yield { coeff: manager.val(node), isConstant: nodes.length === 0 };
|
|
1295
|
+
for (let top = nodes.pop(); top !== undefined; top = nodes.pop()) {
|
|
1296
|
+
let next = manager.lo(top);
|
|
1297
|
+
if (next === ZERO_PDD) continue;
|
|
1298
|
+
while (!manager.isVal(next)) {
|
|
1299
|
+
nodes.push(next);
|
|
1300
|
+
next = manager.hi(next);
|
|
1301
|
+
}
|
|
1302
|
+
yield { coeff: manager.val(next), isConstant: nodes.length === 0 };
|
|
1303
|
+
}
|
|
1304
|
+
} finally {
|
|
1305
|
+
end.release();
|
|
1306
|
+
begin.release();
|
|
938
1307
|
}
|
|
939
1308
|
}
|
|
940
1309
|
|
|
941
1310
|
toString() {
|
|
942
1311
|
let text = "";
|
|
943
|
-
for (const monomial of this) {
|
|
1312
|
+
for (const monomial of getMonomials(this)) {
|
|
944
1313
|
if (text !== "") text += " ";
|
|
945
1314
|
if (monomial.coeff.isNegative()) text += "- ";
|
|
946
1315
|
else if (text !== "") text += "+ ";
|
|
947
1316
|
const coeff = monomial.coeff.abs();
|
|
948
|
-
const vars = monomial.vars;
|
|
1317
|
+
const vars = monomial.vars.reverse();
|
|
949
1318
|
if (!coeff.equals(Rational.one) || vars.length === 0) {
|
|
950
1319
|
text += vars.length === 0 ? `${coeff}` : `${coeff}*`;
|
|
951
1320
|
}
|
|
@@ -962,10 +1331,13 @@ export class Pdd {
|
|
|
962
1331
|
}
|
|
963
1332
|
}
|
|
964
1333
|
|
|
965
|
-
|
|
966
|
-
|
|
967
|
-
poly.
|
|
968
|
-
|
|
969
|
-
|
|
970
|
-
|
|
971
|
-
|
|
1334
|
+
export const evaluatePdd = (poly: Pdd, getValue: (variable: number) => Rational): Rational => {
|
|
1335
|
+
if (poly.isVal()) return poly.val();
|
|
1336
|
+
const hi = poly.hi();
|
|
1337
|
+
const product = evaluatePdd(hi, getValue).mul(getValue(poly.var()));
|
|
1338
|
+
const lo = poly.lo();
|
|
1339
|
+
const result = product.add(evaluatePdd(lo, getValue));
|
|
1340
|
+
lo.release();
|
|
1341
|
+
hi.release();
|
|
1342
|
+
return result;
|
|
1343
|
+
};
|