tla-ts 0.0.3 → 0.0.4-dev.1a3acf6
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 +46 -115
- 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 +194 -8
- package/dist/index.d.ts +194 -8
- 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 +1377 -18
- package/dist/transfer.js +1377 -18
- package/dist/worker.cjs +21 -0
- package/dist/worker.js +21 -0
- package/package.json +24 -11
- package/src/ast.ts +149 -8
- package/src/bags.ts +26 -30
- package/src/builtins.ts +45 -19
- package/src/bundled-modules.ts +3 -3
- package/src/check.ts +1182 -900
- package/src/cli/options.ts +109 -0
- package/src/cli/run.ts +63 -0
- package/src/cli/shared.ts +106 -0
- package/src/cli/tlapm.ts +374 -0
- package/src/cli/tlc.ts +941 -0
- package/src/cli/xml-exporter.ts +221 -0
- package/src/cli.ts +9 -2
- package/src/codegen.ts +112 -51
- package/src/config.ts +254 -181
- package/src/dependencies.ts +5 -7
- package/src/environment.ts +579 -184
- package/src/errors.ts +287 -4
- package/src/evaluate.ts +1095 -365
- package/src/exit-codes.ts +22 -43
- package/src/fingerprints.ts +49 -14
- package/src/index.ts +11 -0
- package/src/instances.ts +73 -60
- package/src/java-overrides.ts +183 -66
- package/src/json.ts +31 -36
- package/src/levels.ts +197 -54
- package/src/lexer.ts +127 -30
- package/src/liveness-checker.ts +894 -0
- package/src/liveness.ts +246 -596
- 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} +174 -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 +184 -235
- package/src/parallel.ts +156 -91
- package/src/parser.ts +490 -188
- package/src/pcal/ast.ts +755 -0
- package/src/pcal/parse.ts +1487 -0
- package/src/pcal/tokenize.ts +487 -0
- package/src/pcal/translate.ts +1151 -0
- package/src/pcal/validate.ts +444 -0
- 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 +648 -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 +79 -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 +39 -27
- package/src/resolve.ts +1474 -426
- package/src/runtime.ts +25 -7
- package/src/sany/builtins.ts +147 -0
- package/src/sany/generator.ts +3111 -0
- package/src/sany/levels.ts +1205 -0
- package/src/sany/lexer.ts +544 -0
- package/src/sany/linter.ts +122 -0
- package/src/sany/modules.ts +1398 -0
- package/src/sany/nodes.ts +463 -0
- package/src/sany/parse-error.ts +2161 -0
- package/src/sany/report.ts +355 -0
- package/src/sany/selectors.ts +736 -0
- package/src/sany/source.ts +247 -0
- package/src/sany/xml.ts +1016 -0
- package/src/search.ts +969 -0
- package/src/spec-description.ts +66 -29
- package/src/{standard-levels.ts → standard-definitions.ts} +118 -2
- package/src/standard-modules.ts +215 -164
- package/src/state-graph.ts +181 -0
- package/src/subexpressions.ts +231 -171
- package/src/substitution-levels.ts +40 -19
- package/src/successors.ts +253 -125
- package/src/symmetry.ts +194 -54
- package/src/tableau.ts +60 -32
- package/src/tlc/fingerprint.ts +214 -0
- package/src/{tlc-modules.ts → tlc/jar-data.ts} +4 -0
- package/src/tlc/messages.ts +441 -0
- package/src/{tlc-order.ts → tlc/order.ts} +84 -16
- package/src/{tlc-random.ts → tlc/random.ts} +30 -189
- package/src/tlc/replay.ts +659 -0
- package/src/{tlc-summary.ts → tlc/summary.ts} +20 -5
- package/src/{tlc-module.ts → tlc/tlc-operators.ts} +59 -50
- package/src/{tlc-ext.ts → tlc/tlcext-operators.ts} +63 -45
- package/src/tlc/version.ts +19 -0
- package/src/transfer.ts +44 -32
- package/src/values.ts +843 -241
- package/src/worker.ts +62 -0
- package/dist/parallel.cjs +0 -12
- package/dist/parallel.js +0 -12
- package/dist/run-cli.cjs +0 -28
- package/dist/run-cli.js +0 -28
- package/src/canonical.ts +0 -39
- package/src/cli-options.ts +0 -58
- package/src/obligation-expression.ts +0 -1060
- package/src/obligation-module.ts +0 -1042
- package/src/run-cli.ts +0 -478
|
@@ -0,0 +1,381 @@
|
|
|
1
|
+
// Ported from Z3 (src/math/lp/nex_creator.h, src/math/lp/nex_creator.cpp), MIT license, see
|
|
2
|
+
// z3-license.txt. Builds, orders, and simplifies nex expressions. The order compares variables by
|
|
3
|
+
// weight, then by index, and simplification sorts products and sums by it and merges like terms.
|
|
4
|
+
// Z3 keeps every expression it allocates so that it can free them; here the collector does.
|
|
5
|
+
import { Rational } from "../rational";
|
|
6
|
+
import {
|
|
7
|
+
type Nex,
|
|
8
|
+
type NexMul,
|
|
9
|
+
type NexPow,
|
|
10
|
+
type NexSum,
|
|
11
|
+
type NexVar,
|
|
12
|
+
containsVar,
|
|
13
|
+
getDegree,
|
|
14
|
+
getPowersFromMul,
|
|
15
|
+
getVarsOfExpr,
|
|
16
|
+
isElementary,
|
|
17
|
+
isZeroScalar,
|
|
18
|
+
} from "./nex";
|
|
19
|
+
|
|
20
|
+
// occ: how many summands a variable divides, and its smallest power among them.
|
|
21
|
+
interface Occ {
|
|
22
|
+
occs: number;
|
|
23
|
+
power: number;
|
|
24
|
+
}
|
|
25
|
+
|
|
26
|
+
interface MapEntry<Value> {
|
|
27
|
+
readonly key: Nex;
|
|
28
|
+
value: Value;
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
export class NexCreator {
|
|
32
|
+
readonly occurencesMap = new Map<number, Occ>();
|
|
33
|
+
readonly powers = new Map<number, number>();
|
|
34
|
+
private activeVarsWeights: number[] = [];
|
|
35
|
+
|
|
36
|
+
// Assumes every variable is below k. Growing keeps the weights already set.
|
|
37
|
+
setNumberOfVars(count: number) {
|
|
38
|
+
const previousCount = this.activeVarsWeights.length;
|
|
39
|
+
this.activeVarsWeights.length = count;
|
|
40
|
+
this.activeVarsWeights.fill(0, previousCount);
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
setVarWeight(variable: number, weight: number) {
|
|
44
|
+
this.activeVarsWeights[variable] = weight;
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
mkVar(variable: number): Nex {
|
|
48
|
+
return { kind: "var", variable };
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
mkScalar(value: Rational): Nex {
|
|
52
|
+
return { kind: "scalar", value };
|
|
53
|
+
}
|
|
54
|
+
|
|
55
|
+
mkSum(children: Nex[]): NexSum {
|
|
56
|
+
return { kind: "sum", children: [...children] };
|
|
57
|
+
}
|
|
58
|
+
|
|
59
|
+
// mk_mul(e, es...): a rational multiplies the coefficient, an expression is a factor.
|
|
60
|
+
mkMul(...factors: (Nex | Rational)[]): NexMul {
|
|
61
|
+
const children: NexPow[] = [];
|
|
62
|
+
let coeff = Rational.one;
|
|
63
|
+
for (const factor of factors) {
|
|
64
|
+
if (factor instanceof Rational) coeff = coeff.mul(factor);
|
|
65
|
+
else children.push({ expr: factor, power: 1 });
|
|
66
|
+
}
|
|
67
|
+
return this.mkMulWithPowers(coeff, children);
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
mkMulWithPowers(coeff: Rational, children: NexPow[]): NexMul {
|
|
71
|
+
return { kind: "mul", coeff, children: [...children] };
|
|
72
|
+
}
|
|
73
|
+
|
|
74
|
+
// mul_factory::mk_reduced.
|
|
75
|
+
private mkReducedMul(coeff: Rational, children: NexPow[]) {
|
|
76
|
+
if (children.length === 0) return this.mkScalar(coeff);
|
|
77
|
+
if (coeff.equals(Rational.one) && children.length === 1 && children[0].power === 1)
|
|
78
|
+
return children[0].expr;
|
|
79
|
+
return this.mkMulWithPowers(coeff, children);
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
gtVar(first: number, second: number) {
|
|
83
|
+
const firstWeight = this.activeVarsWeights[first];
|
|
84
|
+
const secondWeight = this.activeVarsWeights[second];
|
|
85
|
+
return firstWeight !== secondWeight ? firstWeight > secondWeight : first > second;
|
|
86
|
+
}
|
|
87
|
+
|
|
88
|
+
// Scalars are the smallest, and the coefficient of a product does not count. Z3's
|
|
89
|
+
// gt_for_sort_join_sum is the same order.
|
|
90
|
+
gt(first: Nex, second: Nex): boolean {
|
|
91
|
+
if (first === second) return false;
|
|
92
|
+
if (first.kind === "var") return this.gtOnVarNex(first, second);
|
|
93
|
+
if (first.kind === "scalar")
|
|
94
|
+
return second.kind === "scalar" && first.value.compare(second.value) > 0;
|
|
95
|
+
if (first.kind === "mul") return this.gtOnMulNex(first, second);
|
|
96
|
+
if (second.kind === "sum") return this.gtOnSumSum(first, second);
|
|
97
|
+
return this.gt(first.children[0], second);
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
private gtOnVarNex(first: NexVar, second: Nex): boolean {
|
|
101
|
+
if (second.kind === "scalar") return true;
|
|
102
|
+
if (second.kind === "var") return this.gtVar(first.variable, second.variable);
|
|
103
|
+
if (second.kind === "mul")
|
|
104
|
+
return getDegree(second) <= 1 && this.gtOnVarNex(first, second.children[0].expr);
|
|
105
|
+
if (this.gt(first, second.children[0])) return true;
|
|
106
|
+
return !this.gt(second.children[0], first);
|
|
107
|
+
}
|
|
108
|
+
|
|
109
|
+
private gtOnMulNex(mul: NexMul, second: Nex): boolean {
|
|
110
|
+
if (second.kind === "scalar") return false;
|
|
111
|
+
if (second.kind === "var") return getDegree(mul) > 1 || this.gt(mul.children[0].expr, second);
|
|
112
|
+
if (second.kind === "mul") return this.gtOnMulMul(mul, second);
|
|
113
|
+
return this.gtOnMulNex(mul, second.children[0]);
|
|
114
|
+
}
|
|
115
|
+
|
|
116
|
+
private gtOnMulMul(first: NexMul, second: NexMul) {
|
|
117
|
+
const firstDegree = getDegree(first);
|
|
118
|
+
const secondDegree = getDegree(second);
|
|
119
|
+
return firstDegree === secondDegree
|
|
120
|
+
? this.gtOnPowersMulSameDegree(first, second)
|
|
121
|
+
: firstDegree > secondDegree;
|
|
122
|
+
}
|
|
123
|
+
|
|
124
|
+
private gtOnPowersMulSameDegree(first: NexMul, second: NexMul) {
|
|
125
|
+
let firstPower = first.children[0].power;
|
|
126
|
+
let secondPower = second.children[0].power;
|
|
127
|
+
for (
|
|
128
|
+
let firstIndex = 0, secondIndex = 0;
|
|
129
|
+
firstIndex < first.children.length && secondIndex < second.children.length;
|
|
130
|
+
) {
|
|
131
|
+
if (this.gt(first.children[firstIndex].expr, second.children[secondIndex].expr)) return true;
|
|
132
|
+
if (this.gt(second.children[secondIndex].expr, first.children[firstIndex].expr)) return false;
|
|
133
|
+
if (firstPower > secondPower) return true;
|
|
134
|
+
if (firstPower < secondPower) return false;
|
|
135
|
+
firstIndex++;
|
|
136
|
+
secondIndex++;
|
|
137
|
+
if (firstIndex < first.children.length) firstPower = first.children[firstIndex].power;
|
|
138
|
+
if (secondIndex < second.children.length) secondPower = second.children[secondIndex].power;
|
|
139
|
+
}
|
|
140
|
+
return false;
|
|
141
|
+
}
|
|
142
|
+
|
|
143
|
+
private gtOnSumSum(first: NexSum, second: NexSum) {
|
|
144
|
+
const size = Math.min(first.children.length, second.children.length);
|
|
145
|
+
for (let index = 0; index < size; index++) {
|
|
146
|
+
if (this.gt(first.children[index], second.children[index])) return true;
|
|
147
|
+
if (this.gt(second.children[index], first.children[index])) return false;
|
|
148
|
+
}
|
|
149
|
+
return first.children.length > size;
|
|
150
|
+
}
|
|
151
|
+
|
|
152
|
+
// A std::map ordered by gt, greatest first: the index of the key, inserting it when absent.
|
|
153
|
+
private findOrInsert<Value>(entries: MapEntry<Value>[], key: Nex, value: Value) {
|
|
154
|
+
let low = 0;
|
|
155
|
+
let high = entries.length;
|
|
156
|
+
while (low < high) {
|
|
157
|
+
const middle = (low + high) >> 1;
|
|
158
|
+
if (this.gt(entries[middle].key, key)) low = middle + 1;
|
|
159
|
+
else high = middle;
|
|
160
|
+
}
|
|
161
|
+
if (low < entries.length && !this.gt(key, entries[low].key))
|
|
162
|
+
return { index: low, isFound: true };
|
|
163
|
+
entries.splice(low, 0, { key, value });
|
|
164
|
+
return { index: low, isFound: false };
|
|
165
|
+
}
|
|
166
|
+
|
|
167
|
+
simplify(expr: Nex): Nex {
|
|
168
|
+
if (expr.kind === "mul") return this.simplifyMul(expr);
|
|
169
|
+
if (expr.kind === "sum") return this.simplifySum(expr);
|
|
170
|
+
return expr;
|
|
171
|
+
}
|
|
172
|
+
|
|
173
|
+
// eat_scalar_pow: the coefficient times the factor raised to power when the factor is a
|
|
174
|
+
// constant, else null.
|
|
175
|
+
private eatScalarPow(coeff: Rational, child: NexPow, power: number) {
|
|
176
|
+
if (child.expr.kind === "mul" && child.expr.children.length === 0)
|
|
177
|
+
return child.expr.coeff.equals(Rational.one)
|
|
178
|
+
? coeff
|
|
179
|
+
: coeff.mul(child.expr.coeff.pow(child.power * power));
|
|
180
|
+
if (child.expr.kind !== "scalar") return null;
|
|
181
|
+
return child.expr.value.equals(Rational.one)
|
|
182
|
+
? coeff
|
|
183
|
+
: coeff.mul(child.expr.value.pow(child.power * power));
|
|
184
|
+
}
|
|
185
|
+
|
|
186
|
+
// simplify_mul with simplify_children_of_mul: folds the constant factors into the coefficient,
|
|
187
|
+
// flattens the product factors, and merges equal factors into powers.
|
|
188
|
+
simplifyMul(mul: NexMul): Nex {
|
|
189
|
+
const children: NexPow[] = [];
|
|
190
|
+
const toPromote: NexPow[] = [];
|
|
191
|
+
for (const child of mul.children) {
|
|
192
|
+
const eaten = this.eatScalarPow(mul.coeff, child, 1);
|
|
193
|
+
if (eaten !== null) {
|
|
194
|
+
mul.coeff = eaten;
|
|
195
|
+
continue;
|
|
196
|
+
}
|
|
197
|
+
const simplified = { expr: this.simplify(child.expr), power: child.power };
|
|
198
|
+
if (simplified.expr.kind === "mul") toPromote.push(simplified);
|
|
199
|
+
else children.push(simplified);
|
|
200
|
+
}
|
|
201
|
+
for (const child of toPromote) {
|
|
202
|
+
if (child.expr.kind !== "mul") continue;
|
|
203
|
+
for (const grandchild of child.expr.children) {
|
|
204
|
+
const eaten = this.eatScalarPow(mul.coeff, grandchild, child.power);
|
|
205
|
+
if (eaten !== null) mul.coeff = eaten;
|
|
206
|
+
else children.push({ expr: grandchild.expr, power: grandchild.power * child.power });
|
|
207
|
+
}
|
|
208
|
+
mul.coeff = mul.coeff.mul(child.expr.coeff.pow(child.power));
|
|
209
|
+
}
|
|
210
|
+
mul.children = this.mulToPowers(children);
|
|
211
|
+
if (mul.children.length === 1 && mul.children[0].power === 1 && mul.coeff.equals(Rational.one))
|
|
212
|
+
return mul.children[0].expr;
|
|
213
|
+
if (mul.children.length === 0 || mul.coeff.isZero()) return this.mkScalar(mul.coeff);
|
|
214
|
+
return mul;
|
|
215
|
+
}
|
|
216
|
+
|
|
217
|
+
// The map already orders the factors by gt, so Z3's sort that follows changes nothing.
|
|
218
|
+
private mulToPowers(children: NexPow[]): NexPow[] {
|
|
219
|
+
const entries: MapEntry<number>[] = [];
|
|
220
|
+
for (const child of children) {
|
|
221
|
+
const found = this.findOrInsert(entries, child.expr, child.power);
|
|
222
|
+
if (found.isFound) entries[found.index].value += child.power;
|
|
223
|
+
}
|
|
224
|
+
return entries.map((entry) => ({ expr: entry.key, power: entry.value }));
|
|
225
|
+
}
|
|
226
|
+
|
|
227
|
+
simplifySum(sum: NexSum): Nex {
|
|
228
|
+
this.simplifyChildrenOfSum(sum);
|
|
229
|
+
if (sum.children.length === 1) return sum.children[0];
|
|
230
|
+
if (sum.children.length === 0) return this.mkScalar(Rational.zero);
|
|
231
|
+
return sum;
|
|
232
|
+
}
|
|
233
|
+
|
|
234
|
+
private simplifyChildrenOfSum(sum: NexSum) {
|
|
235
|
+
const children: Nex[] = [];
|
|
236
|
+
const toPromote: NexSum[] = [];
|
|
237
|
+
for (const child of sum.children) {
|
|
238
|
+
const simplified = this.simplify(child);
|
|
239
|
+
if (simplified.kind === "sum") toPromote.push(simplified);
|
|
240
|
+
else if (isZeroScalar(simplified)) continue;
|
|
241
|
+
else if (simplified.kind === "mul" && simplified.coeff.isZero()) continue;
|
|
242
|
+
else children.push(simplified);
|
|
243
|
+
}
|
|
244
|
+
for (const promoted of toPromote)
|
|
245
|
+
for (const grandchild of promoted.children)
|
|
246
|
+
if (!isZeroScalar(grandchild)) children.push(grandchild);
|
|
247
|
+
sum.children = children;
|
|
248
|
+
this.sortJoinSum(sum);
|
|
249
|
+
}
|
|
250
|
+
|
|
251
|
+
// sort_join_sum: merges the summands that differ only in their coefficient, a + 3bc + 2bc into
|
|
252
|
+
// a + 5bc, sorts them by gt, and puts the sum of the scalars last. Like Z3, a merged product
|
|
253
|
+
// takes the new coefficient in place.
|
|
254
|
+
private sortJoinSum(sum: NexSum) {
|
|
255
|
+
const entries: MapEntry<Rational>[] = [];
|
|
256
|
+
let commonScalar = Rational.zero;
|
|
257
|
+
for (const child of sum.children) {
|
|
258
|
+
if (child.kind === "scalar") {
|
|
259
|
+
commonScalar = commonScalar.add(child.value);
|
|
260
|
+
continue;
|
|
261
|
+
}
|
|
262
|
+
const coeff = child.kind === "mul" ? child.coeff : Rational.one;
|
|
263
|
+
const found = this.findOrInsert(entries, child, coeff);
|
|
264
|
+
if (found.isFound) entries[found.index].value = entries[found.index].value.add(coeff);
|
|
265
|
+
}
|
|
266
|
+
sum.children = [];
|
|
267
|
+
for (const entry of entries) {
|
|
268
|
+
if (entry.value.isZero()) continue;
|
|
269
|
+
if (entry.key.kind === "mul") {
|
|
270
|
+
entry.key.coeff = entry.value;
|
|
271
|
+
sum.children.push(this.simplify(entry.key));
|
|
272
|
+
} else if (entry.value.equals(Rational.one)) sum.children.push(entry.key);
|
|
273
|
+
else sum.children.push(this.mkMul(entry.value, entry.key));
|
|
274
|
+
}
|
|
275
|
+
if (!commonScalar.isZero()) sum.children.push(this.mkScalar(commonScalar));
|
|
276
|
+
}
|
|
277
|
+
|
|
278
|
+
clone(expr: Nex): Nex {
|
|
279
|
+
if (expr.kind === "var") return this.mkVar(expr.variable);
|
|
280
|
+
if (expr.kind === "scalar") return this.mkScalar(expr.value);
|
|
281
|
+
if (expr.kind === "mul")
|
|
282
|
+
return this.mkMulWithPowers(
|
|
283
|
+
expr.coeff,
|
|
284
|
+
expr.children.map((child) => ({ expr: this.clone(child.expr), power: child.power })),
|
|
285
|
+
);
|
|
286
|
+
return this.mkSum(expr.children.map((child) => this.clone(child)));
|
|
287
|
+
}
|
|
288
|
+
|
|
289
|
+
// mk_div(a, j): a, a product or the variable itself, divided by the variable once.
|
|
290
|
+
mkDivByVar(expr: Nex, variable: number): Nex {
|
|
291
|
+
if (expr.kind !== "mul") return this.mkScalar(Rational.one);
|
|
292
|
+
const children: NexPow[] = [];
|
|
293
|
+
let isSeen = false;
|
|
294
|
+
for (const child of expr.children) {
|
|
295
|
+
if (isSeen || !containsVar(child.expr, variable)) {
|
|
296
|
+
children.push({ expr: this.clone(child.expr), power: child.power });
|
|
297
|
+
continue;
|
|
298
|
+
}
|
|
299
|
+
if (child.expr.kind !== "var")
|
|
300
|
+
children.push({ expr: this.mkDivByVar(child.expr, variable), power: 1 });
|
|
301
|
+
if (child.power !== 1)
|
|
302
|
+
children.push({ expr: this.clone(child.expr), power: child.power - 1 });
|
|
303
|
+
isSeen = true;
|
|
304
|
+
}
|
|
305
|
+
return this.mkReducedMul(expr.coeff, children);
|
|
306
|
+
}
|
|
307
|
+
|
|
308
|
+
// mk_div_by_mul: each summand, a product or a variable, divided by the product of powers.
|
|
309
|
+
mkDiv(expr: Nex, divisor: NexMul): Nex {
|
|
310
|
+
if (expr.kind === "sum")
|
|
311
|
+
return this.mkSum(expr.children.map((child) => this.mkDiv(child, divisor)));
|
|
312
|
+
if (expr.kind !== "mul") return this.mkScalar(Rational.one);
|
|
313
|
+
getPowersFromMul(divisor, this.powers);
|
|
314
|
+
const children: NexPow[] = [];
|
|
315
|
+
for (const child of expr.children) {
|
|
316
|
+
if (child.expr.kind !== "var") {
|
|
317
|
+
children.push({ expr: this.clone(child.expr), power: child.power });
|
|
318
|
+
continue;
|
|
319
|
+
}
|
|
320
|
+
const variable = child.expr.variable;
|
|
321
|
+
const divisorPower = this.powers.get(variable);
|
|
322
|
+
if (divisorPower === undefined) {
|
|
323
|
+
children.push({ expr: this.clone(child.expr), power: child.power });
|
|
324
|
+
continue;
|
|
325
|
+
}
|
|
326
|
+
if (child.power > divisorPower) {
|
|
327
|
+
children.push({ expr: this.mkVar(variable), power: child.power - divisorPower });
|
|
328
|
+
this.powers.delete(variable);
|
|
329
|
+
} else if (child.power === divisorPower) this.powers.delete(variable);
|
|
330
|
+
// The factor is eaten by the divisor, whose variable keeps the rest of its power.
|
|
331
|
+
else this.powers.set(variable, divisorPower - child.power);
|
|
332
|
+
}
|
|
333
|
+
return this.mkReducedMul(expr.coeff.div(divisor.coeff), children);
|
|
334
|
+
}
|
|
335
|
+
|
|
336
|
+
// canonize: a simplified copy with every product of a sum multiplied out. Z3's canonize_mul drops
|
|
337
|
+
// the coefficient of the product; here the summands keep it.
|
|
338
|
+
canonize(expr: Nex): Nex {
|
|
339
|
+
if (isElementary(expr)) return this.clone(expr);
|
|
340
|
+
const simplified = this.simplify(this.clone(expr));
|
|
341
|
+
if (simplified.kind === "sum") {
|
|
342
|
+
simplified.children = simplified.children.map((child) => this.canonize(child));
|
|
343
|
+
return this.simplify(simplified);
|
|
344
|
+
}
|
|
345
|
+
return simplified.kind === "mul" ? this.canonizeMul(simplified) : simplified;
|
|
346
|
+
}
|
|
347
|
+
|
|
348
|
+
private canonizeMul(mul: NexMul): Nex {
|
|
349
|
+
const sumIndex = mul.children.findIndex((child) => child.expr.kind === "sum");
|
|
350
|
+
if (sumIndex === -1) return mul;
|
|
351
|
+
const sumPow = mul.children[sumIndex];
|
|
352
|
+
if (sumPow.expr.kind !== "sum") return mul;
|
|
353
|
+
const sumClone = sumPow.power > 1 ? this.clone(sumPow.expr) : null;
|
|
354
|
+
const summands = sumPow.expr.children.map((summand) => {
|
|
355
|
+
const children: NexPow[] = [];
|
|
356
|
+
if (sumClone !== null) children.push({ expr: sumClone, power: sumPow.power - 1 });
|
|
357
|
+
children.push({ expr: summand, power: 1 });
|
|
358
|
+
mul.children.forEach((child, index) => {
|
|
359
|
+
if (index !== sumIndex) children.push({ expr: this.clone(child.expr), power: child.power });
|
|
360
|
+
});
|
|
361
|
+
return this.mkMulWithPowers(mul.coeff, children);
|
|
362
|
+
});
|
|
363
|
+
return this.canonize(this.mkSum(summands));
|
|
364
|
+
}
|
|
365
|
+
|
|
366
|
+
// equal: whether the canonical forms agree when each variable weighs its index.
|
|
367
|
+
static equal(first: Nex, second: Nex) {
|
|
368
|
+
const creator = new NexCreator();
|
|
369
|
+
const count = Math.max(
|
|
370
|
+
0,
|
|
371
|
+
...[...getVarsOfExpr(first), ...getVarsOfExpr(second)].map((variable) => variable + 1),
|
|
372
|
+
);
|
|
373
|
+
creator.setNumberOfVars(count);
|
|
374
|
+
for (let variable = 0; variable < count; variable++) creator.setVarWeight(variable, variable);
|
|
375
|
+
const firstCanonical = creator.canonize(first);
|
|
376
|
+
const secondCanonical = creator.canonize(second);
|
|
377
|
+
return !(
|
|
378
|
+
creator.gt(firstCanonical, secondCanonical) || creator.gt(secondCanonical, firstCanonical)
|
|
379
|
+
);
|
|
380
|
+
}
|
|
381
|
+
}
|
|
@@ -0,0 +1,120 @@
|
|
|
1
|
+
// Ported from Z3 (src/math/lp/nex.h), MIT license, see z3-license.txt. The nonlinear expressions
|
|
2
|
+
// that horner splits into cross-nested forms: scalars, variables, products of powers with a
|
|
3
|
+
// coefficient, and sums. Products and sums are mutable, since nex_creator simplifies them in place
|
|
4
|
+
// and cross_nested rewrites their children.
|
|
5
|
+
import { Rational } from "../rational";
|
|
6
|
+
|
|
7
|
+
interface NexScalar {
|
|
8
|
+
readonly kind: "scalar";
|
|
9
|
+
readonly value: Rational;
|
|
10
|
+
}
|
|
11
|
+
|
|
12
|
+
export interface NexVar {
|
|
13
|
+
readonly kind: "var";
|
|
14
|
+
readonly variable: number;
|
|
15
|
+
}
|
|
16
|
+
|
|
17
|
+
export interface NexPow {
|
|
18
|
+
readonly expr: Nex;
|
|
19
|
+
readonly power: number;
|
|
20
|
+
}
|
|
21
|
+
|
|
22
|
+
export interface NexMul {
|
|
23
|
+
readonly kind: "mul";
|
|
24
|
+
coeff: Rational;
|
|
25
|
+
children: NexPow[];
|
|
26
|
+
}
|
|
27
|
+
|
|
28
|
+
export interface NexSum {
|
|
29
|
+
readonly kind: "sum";
|
|
30
|
+
children: Nex[];
|
|
31
|
+
}
|
|
32
|
+
|
|
33
|
+
export type Nex = NexScalar | NexVar | NexMul | NexSum;
|
|
34
|
+
|
|
35
|
+
export const isElementary = (expr: Nex) => expr.kind === "scalar" || expr.kind === "var";
|
|
36
|
+
|
|
37
|
+
export const isZeroScalar = (expr: Nex) => expr.kind === "scalar" && expr.value.isZero();
|
|
38
|
+
|
|
39
|
+
export const containsVar = (expr: Nex, variable: number): boolean => {
|
|
40
|
+
if (expr.kind === "var") return expr.variable === variable;
|
|
41
|
+
if (expr.kind === "mul") return expr.children.some((child) => containsVar(child.expr, variable));
|
|
42
|
+
return false;
|
|
43
|
+
};
|
|
44
|
+
|
|
45
|
+
export const getDegree = (expr: Nex): number => {
|
|
46
|
+
if (expr.kind === "scalar") return 0;
|
|
47
|
+
if (expr.kind === "var") return 1;
|
|
48
|
+
if (expr.kind === "mul")
|
|
49
|
+
return expr.children.reduce((degree, child) => degree + getDegree(child.expr) * child.power, 0);
|
|
50
|
+
return expr.children.reduce((degree, child) => Math.max(degree, getDegree(child)), 0);
|
|
51
|
+
};
|
|
52
|
+
|
|
53
|
+
export const isLinear = (expr: Nex): boolean => {
|
|
54
|
+
if (expr.kind === "mul") return getDegree(expr) < 2;
|
|
55
|
+
if (expr.kind === "sum") return expr.children.every(isLinear);
|
|
56
|
+
return true;
|
|
57
|
+
};
|
|
58
|
+
|
|
59
|
+
// is_a_linear_term: a linear combination of at least two variables.
|
|
60
|
+
export const isALinearTerm = (sum: NexSum) => {
|
|
61
|
+
let numberOfNonScalars = 0;
|
|
62
|
+
for (const child of sum.children) {
|
|
63
|
+
const degree = getDegree(child);
|
|
64
|
+
if (degree === 0) continue;
|
|
65
|
+
if (degree > 1) return false;
|
|
66
|
+
numberOfNonScalars++;
|
|
67
|
+
}
|
|
68
|
+
return numberOfNonScalars > 1;
|
|
69
|
+
};
|
|
70
|
+
|
|
71
|
+
// get_powers_from_mul: refills powers with the power of each variable child.
|
|
72
|
+
export const getPowersFromMul = (mul: NexMul, powers: Map<number, number>) => {
|
|
73
|
+
powers.clear();
|
|
74
|
+
for (const child of mul.children)
|
|
75
|
+
if (child.expr.kind === "var") powers.set(child.expr.variable, child.power);
|
|
76
|
+
};
|
|
77
|
+
|
|
78
|
+
export const getNexVal = (expr: Nex, getVarVal: (variable: number) => Rational): Rational => {
|
|
79
|
+
if (expr.kind === "scalar") return expr.value;
|
|
80
|
+
if (expr.kind === "var") return getVarVal(expr.variable);
|
|
81
|
+
if (expr.kind === "sum")
|
|
82
|
+
return expr.children.reduce(
|
|
83
|
+
(value, child) => value.add(getNexVal(child, getVarVal)),
|
|
84
|
+
Rational.zero,
|
|
85
|
+
);
|
|
86
|
+
return expr.children.reduce(
|
|
87
|
+
(value, child) => value.mul(getNexVal(child.expr, getVarVal).pow(child.power)),
|
|
88
|
+
expr.coeff,
|
|
89
|
+
);
|
|
90
|
+
};
|
|
91
|
+
|
|
92
|
+
export const getVarsOfExpr = (expr: Nex): Set<number> => {
|
|
93
|
+
if (expr.kind === "scalar") return new Set();
|
|
94
|
+
if (expr.kind === "var") return new Set([expr.variable]);
|
|
95
|
+
const children = expr.kind === "sum" ? expr.children : expr.children.map((child) => child.expr);
|
|
96
|
+
return new Set(children.flatMap((child) => [...getVarsOfExpr(child)]));
|
|
97
|
+
};
|
|
98
|
+
|
|
99
|
+
const printNexPow = (child: NexPow) => {
|
|
100
|
+
const printed = printNex(child.expr);
|
|
101
|
+
if (child.power === 1) return isElementary(child.expr) ? printed : `(${printed})`;
|
|
102
|
+
return isElementary(child.expr) ? `(${printed}^${child.power})` : `((${printed})^${child.power})`;
|
|
103
|
+
};
|
|
104
|
+
|
|
105
|
+
export const printNex = (expr: Nex): string => {
|
|
106
|
+
if (expr.kind === "scalar") return expr.value.toString();
|
|
107
|
+
if (expr.kind === "var") return `j${expr.variable}`;
|
|
108
|
+
// Like Z3, a coefficient other than one is followed by a space and a star before each factor.
|
|
109
|
+
if (expr.kind === "mul")
|
|
110
|
+
return expr.coeff.equals(Rational.one)
|
|
111
|
+
? expr.children.map(printNexPow).join("*")
|
|
112
|
+
: `${expr.coeff.toString()} ${expr.children.map((child) => `*${printNexPow(child)}`).join("")}`;
|
|
113
|
+
return expr.children
|
|
114
|
+
.map((child, index) => {
|
|
115
|
+
const printed = printNex(child);
|
|
116
|
+
if (!isElementary(child)) return index === 0 ? `(${printed})` : `+(${printed})`;
|
|
117
|
+
return index === 0 || printed.startsWith("-") ? printed : `+${printed}`;
|
|
118
|
+
})
|
|
119
|
+
.join("");
|
|
120
|
+
};
|
|
@@ -0,0 +1,43 @@
|
|
|
1
|
+
// Ported from Z3 (src/math/lp/nla_backoff.h), MIT license, see z3-license.txt. When the core runs
|
|
2
|
+
// its expensive engines.
|
|
3
|
+
|
|
4
|
+
// backoff: how many calls to skip before the next run of an expensive engine.
|
|
5
|
+
export class Backoff {
|
|
6
|
+
private delay = 0;
|
|
7
|
+
|
|
8
|
+
constructor(private delayBound: number) {}
|
|
9
|
+
|
|
10
|
+
shouldRun() {
|
|
11
|
+
if (this.delay > 0) this.delay--;
|
|
12
|
+
return this.delay < 2;
|
|
13
|
+
}
|
|
14
|
+
|
|
15
|
+
update(isSuccess: boolean) {
|
|
16
|
+
if (isSuccess) this.delayBound = Math.floor(this.delayBound / 2);
|
|
17
|
+
else if (this.delayBound < 1 << 20) this.delayBound = Math.max(2 * this.delayBound, 1);
|
|
18
|
+
this.delay = this.delayBound;
|
|
19
|
+
}
|
|
20
|
+
}
|
|
21
|
+
|
|
22
|
+
// squeeze_schedule: when to run the bounds optimization of the monomials.
|
|
23
|
+
export class SqueezeSchedule {
|
|
24
|
+
private failStreak = 0;
|
|
25
|
+
private squeezesSinceSatCheck = 0;
|
|
26
|
+
|
|
27
|
+
get isEnabled() {
|
|
28
|
+
return this.squeezesSinceSatCheck < 50;
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
get isEager() {
|
|
32
|
+
return this.failStreak < 3;
|
|
33
|
+
}
|
|
34
|
+
|
|
35
|
+
onSqueeze(isImproved: boolean) {
|
|
36
|
+
this.squeezesSinceSatCheck++;
|
|
37
|
+
this.failStreak = isImproved ? 0 : this.failStreak + 1;
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
onNothingToRefine() {
|
|
41
|
+
this.squeezesSinceSatCheck = Math.floor(this.squeezesSinceSatCheck / 2);
|
|
42
|
+
}
|
|
43
|
+
}
|