tla-ts 0.0.4-dev.0be9567 → 0.0.4-dev.22c041b
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 +77 -122
- 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 +44 -12
- package/dist/index.d.ts +44 -12
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -4
- package/dist/parallel-worker.js +1 -4
- package/dist/prove-worker.cjs +9 -0
- package/dist/prove-worker.d.cts +9 -0
- package/dist/prove-worker.d.ts +9 -0
- package/dist/prove-worker.js +9 -0
- package/dist/prove.cjs +1006 -0
- package/dist/prove.js +1006 -0
- package/dist/run.cjs +45 -0
- package/dist/run.js +45 -0
- package/dist/tlapm.cjs +10 -0
- package/dist/tlapm.js +10 -0
- package/dist/transfer.cjs +76 -92
- package/dist/transfer.js +76 -92
- package/dist/worker.cjs +21 -0
- package/dist/worker.js +21 -0
- package/package.json +21 -12
- package/src/ast.ts +2 -2
- package/src/bags.ts +22 -23
- package/src/builtins.ts +16 -8
- package/src/check.ts +131 -1153
- package/src/{cli-options.ts → cli/options.ts} +54 -9
- package/src/cli/run.ts +63 -0
- package/src/cli/shared.ts +106 -0
- package/src/cli/tlapm.ts +374 -0
- package/src/{run-cli.ts → cli/tlc.ts} +115 -721
- package/src/cli/xml-exporter.ts +221 -0
- package/src/cli.ts +1 -1
- package/src/codegen.ts +17 -15
- package/src/config.ts +5 -5
- package/src/dependencies.ts +4 -6
- package/src/environment.ts +55 -60
- package/src/errors.ts +97 -35
- package/src/evaluate.ts +135 -120
- package/src/exit-codes.ts +1 -1
- package/src/fingerprints.ts +3 -3
- package/src/index.ts +10 -0
- package/src/instances.ts +56 -46
- package/src/java-overrides.ts +79 -41
- package/src/json.ts +31 -36
- package/src/levels.ts +10 -13
- package/src/{live-check.ts → liveness-checker.ts} +169 -142
- package/src/liveness.ts +38 -34
- package/src/{obligation-action.ts → obligations/action.ts} +248 -74
- package/src/{obligation-anon.ts → obligations/anonymize.ts} +55 -57
- package/src/obligations/equality.ts +260 -0
- package/src/obligations/expression.ts +618 -0
- package/src/{obligation-format.ts → obligations/format.ts} +7 -8
- package/src/obligations/generate.ts +457 -0
- package/src/{obligations.ts → obligations/index.ts} +46 -32
- package/src/{obligation-levels.ts → obligations/levels.ts} +44 -40
- package/src/obligations/module.ts +445 -0
- package/src/obligations/normalize.ts +554 -0
- package/src/obligations/operators.ts +176 -0
- package/src/obligations/pragma.ts +195 -0
- package/src/{obligation-printer.ts → obligations/printer.ts} +65 -230
- package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
- package/src/obligations/regroup.ts +100 -0
- package/src/{obligation-generate.ts → obligations/simplify.ts} +130 -536
- package/src/{obligation-source.ts → obligations/source.ts} +172 -216
- package/src/{obligation-deref.ts → obligations/subexpression.ts} +84 -115
- package/src/obligations/substitution.ts +261 -0
- package/src/obligations/temporal.ts +321 -0
- package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
- package/src/parallel-worker.ts +39 -51
- package/src/parallel.ts +39 -66
- package/src/parser.ts +67 -74
- package/src/{pcal-ast.ts → pcal/ast.ts} +2 -17
- package/src/{pcal-parse.ts → pcal/parse.ts} +28 -64
- package/src/{pcal-tokenize.ts → pcal/tokenize.ts} +10 -39
- package/src/{pcal-translate.ts → pcal/translate.ts} +30 -109
- package/src/{pcal-validate.ts → pcal/validate.ts} +10 -20
- package/src/prover/decide-pool.ts +95 -0
- package/src/prover/deciders.ts +33 -0
- package/src/prover/first-order.ts +175 -0
- package/src/prover/isabelle/LICENSE +36 -0
- package/src/prover/isabelle/LICENSE-tlapm +26 -0
- package/src/prover/isabelle/decide.ts +44 -0
- package/src/prover/isabelle/encode.ts +445 -0
- package/src/prover/isabelle/isar/inner-syntax.ts +579 -0
- package/src/prover/isabelle/isar/method.ts +367 -0
- package/src/prover/isabelle/isar/proof.ts +28 -0
- package/src/prover/isabelle/isar/statement.ts +57 -0
- package/src/prover/isabelle/isar/theory.ts +192 -0
- package/src/prover/isabelle/isar/type-check.ts +278 -0
- package/src/prover/isabelle/provers/blast/blast.ts +258 -0
- package/src/prover/isabelle/provers/blast/branch.ts +322 -0
- package/src/prover/isabelle/provers/blast/prove.ts +347 -0
- package/src/prover/isabelle/provers/blast/rules.ts +330 -0
- package/src/prover/isabelle/provers/blast/state.ts +180 -0
- package/src/prover/isabelle/provers/blast/term.ts +546 -0
- package/src/prover/isabelle/provers/clasimp.ts +150 -0
- package/src/prover/isabelle/provers/classical.ts +389 -0
- package/src/prover/isabelle/provers/hypsubst.ts +433 -0
- package/src/prover/isabelle/pure/bicompose.ts +174 -0
- package/src/prover/isabelle/pure/consts.ts +32 -0
- package/src/prover/isabelle/pure/conv.ts +79 -0
- package/src/prover/isabelle/pure/drule.ts +264 -0
- package/src/prover/isabelle/pure/envir.ts +331 -0
- package/src/prover/isabelle/pure/goal.ts +53 -0
- package/src/prover/isabelle/pure/interrupt.ts +16 -0
- package/src/prover/isabelle/pure/list.ts +12 -0
- package/src/prover/isabelle/pure/logic.ts +330 -0
- package/src/prover/isabelle/pure/name.ts +98 -0
- package/src/prover/isabelle/pure/net.ts +215 -0
- package/src/prover/isabelle/pure/object-logic.ts +41 -0
- package/src/prover/isabelle/pure/pattern.ts +631 -0
- package/src/prover/isabelle/pure/raw-simplifier.ts +338 -0
- package/src/prover/isabelle/pure/rewriter.ts +602 -0
- package/src/prover/isabelle/pure/search.ts +68 -0
- package/src/prover/isabelle/pure/seq.ts +133 -0
- package/src/prover/isabelle/pure/simplifier.ts +106 -0
- package/src/prover/isabelle/pure/table.ts +201 -0
- package/src/prover/isabelle/pure/tactic.ts +168 -0
- package/src/prover/isabelle/pure/tactical.ts +264 -0
- package/src/prover/isabelle/pure/term-ord.ts +105 -0
- package/src/prover/isabelle/pure/term.ts +688 -0
- package/src/prover/isabelle/pure/thm.ts +783 -0
- package/src/prover/isabelle/pure/type.ts +121 -0
- package/src/prover/isabelle/pure/unify.ts +753 -0
- package/src/prover/isabelle/pure/variable.ts +25 -0
- package/src/prover/isabelle/tla/classical-setup.ts +101 -0
- package/src/prover/isabelle/tla/context.ts +74 -0
- package/src/prover/isabelle/tla/logic-data.ts +5 -0
- package/src/prover/isabelle/tla/logic.ts +215 -0
- package/src/prover/isabelle/tla/simpdata.ts +241 -0
- package/src/prover/isabelle/tools/intuitionistic.ts +132 -0
- package/src/prover/ocaml.ts +22 -0
- package/src/prover/prep/action.ts +508 -0
- package/src/prover/prep/enabled-axioms.ts +189 -0
- package/src/prover/prep/fingerprint.ts +388 -0
- package/src/prover/prep/level-comparison.ts +529 -0
- package/src/prover/prep/md5.ts +60 -0
- package/src/prover/prep/methods.ts +221 -0
- package/src/prover/prep/normalize.ts +309 -0
- package/src/prover/prove-worker.ts +22 -0
- package/src/prover/prove.ts +492 -0
- package/src/prover/ptl/decide.ts +68 -0
- package/src/prover/ptl/encode.ts +244 -0
- package/src/prover/ptl/sat.ts +151 -0
- package/src/prover/ptl/tableau.ts +276 -0
- package/src/prover/smt/axioms.ts +209 -0
- package/src/prover/smt/context.ts +108 -0
- package/src/prover/smt/data.ts +636 -0
- package/src/prover/smt/encode.ts +275 -0
- package/src/prover/smt/extensionality.ts +65 -0
- package/src/prover/smt/flatten.ts +112 -0
- package/src/prover/smt/format.ts +154 -0
- package/src/prover/smt/instances.ts +181 -0
- package/src/prover/smt/rewrite.ts +766 -0
- package/src/prover/smt/solver/act-cache.ts +265 -0
- package/src/prover/smt/solver/arith-rewriter.ts +962 -0
- package/src/prover/smt/solver/array.ts +22 -0
- package/src/prover/smt/solver/asserted-formulas.ts +469 -0
- package/src/prover/smt/solver/ast-lt.ts +157 -0
- package/src/prover/smt/solver/ast-util.ts +91 -0
- package/src/prover/smt/solver/ast.ts +1315 -0
- package/src/prover/smt/solver/auf-solver.ts +572 -0
- package/src/prover/smt/solver/case-split-queue.ts +178 -0
- package/src/prover/smt/solver/cg-table.ts +175 -0
- package/src/prover/smt/solver/clause.ts +276 -0
- package/src/prover/smt/solver/conflict-resolution.ts +343 -0
- package/src/prover/smt/solver/context.ts +1292 -0
- package/src/prover/smt/solver/ctx-simplify.ts +334 -0
- package/src/prover/smt/solver/der.ts +224 -0
- package/src/prover/smt/solver/dyn-ack.ts +141 -0
- package/src/prover/smt/solver/e-matching.ts +659 -0
- package/src/prover/smt/solver/enode.ts +259 -0
- package/src/prover/smt/solver/expr-ref.ts +21 -0
- package/src/prover/smt/solver/expr-safe-replace.ts +172 -0
- package/src/prover/smt/solver/fingerprints.ts +92 -0
- package/src/prover/smt/solver/flat-literals.ts +51 -0
- package/src/prover/smt/solver/goal.ts +138 -0
- package/src/prover/smt/solver/hash.ts +173 -0
- package/src/prover/smt/solver/hashtable.ts +166 -0
- package/src/prover/smt/solver/internalizer.ts +1381 -0
- package/src/prover/smt/solver/lbool.ts +5 -0
- package/src/prover/smt/solver/literal.ts +24 -0
- package/src/prover/smt/solver/lp/bound-propagator.ts +391 -0
- package/src/prover/smt/solver/lp/constraints.ts +78 -0
- package/src/prover/smt/solver/lp/containers.ts +296 -0
- package/src/prover/smt/solver/lp/core-solver.ts +504 -0
- package/src/prover/smt/solver/lp/cross-nested.ts +224 -0
- package/src/prover/smt/solver/lp/dep-intervals.ts +642 -0
- package/src/prover/smt/solver/lp/dependency.ts +51 -0
- package/src/prover/smt/solver/lp/dioph-eq.ts +1181 -0
- package/src/prover/smt/solver/lp/explanation.ts +46 -0
- package/src/prover/smt/solver/lp/gomory.ts +255 -0
- package/src/prover/smt/solver/lp/hnf-cutter.ts +125 -0
- package/src/prover/smt/solver/lp/hnf.ts +281 -0
- package/src/prover/smt/solver/lp/int-cube.ts +295 -0
- package/src/prover/smt/solver/lp/int-solver.ts +514 -0
- package/src/prover/smt/solver/lp/lar-solver.ts +816 -0
- package/src/prover/smt/solver/lp/lar-term.ts +62 -0
- package/src/prover/smt/solver/lp/lp-settings.ts +91 -0
- package/src/prover/smt/solver/lp/maximize-term.ts +347 -0
- package/src/prover/smt/solver/lp/nex-creator.ts +381 -0
- package/src/prover/smt/solver/lp/nex.ts +120 -0
- package/src/prover/smt/solver/lp/nla-backoff.ts +43 -0
- package/src/prover/smt/solver/lp/nla-basics.ts +398 -0
- package/src/prover/smt/solver/lp/nla-core.ts +968 -0
- package/src/prover/smt/solver/lp/nla-divisions.ts +332 -0
- package/src/prover/smt/solver/lp/nla-emonics.ts +373 -0
- package/src/prover/smt/solver/lp/nla-factorization.ts +30 -0
- package/src/prover/smt/solver/lp/nla-grobner.ts +904 -0
- package/src/prover/smt/solver/lp/nla-horner.ts +126 -0
- package/src/prover/smt/solver/lp/nla-intervals.ts +265 -0
- package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +715 -0
- package/src/prover/smt/solver/lp/nla-monotone.ts +59 -0
- package/src/prover/smt/solver/lp/nla-order.ts +307 -0
- package/src/prover/smt/solver/lp/nla-patcher.ts +112 -0
- package/src/prover/smt/solver/lp/nla-tangents.ts +251 -0
- package/src/prover/smt/solver/lp/nla-throttle.ts +85 -0
- package/src/prover/smt/solver/lp/nla-types.ts +124 -0
- package/src/prover/smt/solver/lp/nla-var-eqs.ts +141 -0
- package/src/prover/smt/solver/lp/nra-solver.ts +440 -0
- package/src/prover/smt/solver/lp/numeric-pair.ts +65 -0
- package/src/prover/smt/solver/lp/pdd-interval.ts +31 -0
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +184 -0
- package/src/prover/smt/solver/lp/pdd-solver.ts +408 -0
- package/src/prover/smt/solver/lp/pdd.ts +971 -0
- package/src/prover/smt/solver/lp/random-updater.ts +138 -0
- package/src/prover/smt/solver/lp/static-matrix.ts +246 -0
- package/src/prover/smt/solver/lp/union-find.ts +96 -0
- package/src/prover/smt/solver/mam-compiler.ts +847 -0
- package/src/prover/smt/solver/mam-interpreter.ts +400 -0
- package/src/prover/smt/solver/maximize-ac-sharing.ts +118 -0
- package/src/prover/smt/solver/model-checker.ts +347 -0
- package/src/prover/smt/solver/model-evaluator.ts +262 -0
- package/src/prover/smt/solver/model-finder.ts +155 -0
- package/src/prover/smt/solver/model-generator.ts +97 -0
- package/src/prover/smt/solver/model-macro-solver.ts +728 -0
- package/src/prover/smt/solver/nlsat/algebraic.ts +1161 -0
- package/src/prover/smt/solver/nlsat/atoms.ts +238 -0
- package/src/prover/smt/solver/nlsat/evaluator.ts +303 -0
- package/src/prover/smt/solver/nlsat/explain.ts +607 -0
- package/src/prover/smt/solver/nlsat/interval-set.ts +351 -0
- package/src/prover/smt/solver/nlsat/levelwise.ts +737 -0
- package/src/prover/smt/solver/nlsat/mpbq.ts +161 -0
- package/src/prover/smt/solver/nlsat/polynomial.ts +1722 -0
- package/src/prover/smt/solver/nlsat/solver.ts +911 -0
- package/src/prover/smt/solver/nlsat/types.ts +43 -0
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +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 +19 -24
- package/src/resolve.ts +15 -22
- package/src/runtime.ts +8 -8
- package/src/{sany-builtins.ts → sany/builtins.ts} +1 -1
- package/src/{sany-generator.ts → sany/generator.ts} +38 -55
- package/src/{sany-levels.ts → sany/levels.ts} +45 -48
- package/src/{sany-lexer.ts → sany/lexer.ts} +2 -3
- package/src/{sany-linter.ts → sany/linter.ts} +1 -1
- package/src/{sany-modules.ts → sany/modules.ts} +2 -2
- package/src/{sany-nodes.ts → sany/nodes.ts} +2 -2
- package/src/{sany-parse-error.ts → sany/parse-error.ts} +2 -2
- package/src/{sany-report.ts → sany/report.ts} +16 -17
- package/src/{sany-selectors.ts → sany/selectors.ts} +3 -5
- package/src/{sany-source.ts → sany/source.ts} +6 -7
- package/src/{sany-xml.ts → sany/xml.ts} +5 -6
- package/src/search.ts +969 -0
- package/src/spec-description.ts +26 -20
- package/src/{standard-levels.ts → standard-definitions.ts} +118 -2
- package/src/standard-modules.ts +16 -20
- package/src/state-graph.ts +9 -8
- package/src/substitution-levels.ts +2 -2
- package/src/successors.ts +38 -22
- package/src/symmetry.ts +1 -1
- package/src/tableau.ts +6 -7
- package/src/tlc/fingerprint.ts +214 -0
- package/src/{tlc-messages.ts → tlc/messages.ts} +119 -7
- package/src/{tlc-order.ts → tlc/order.ts} +7 -7
- package/src/{tlc-random.ts → tlc/random.ts} +3 -190
- package/src/{tlc-replay.ts → tlc/replay.ts} +40 -36
- package/src/{tlc-module.ts → tlc/tlc-operators.ts} +9 -9
- package/src/{tlc-ext.ts → tlc/tlcext-operators.ts} +30 -25
- package/src/{tlc-version.ts → tlc/version.ts} +8 -7
- package/src/transfer.ts +32 -32
- package/src/values.ts +119 -71
- package/src/worker.ts +62 -0
- package/dist/parallel.cjs +0 -12
- package/dist/parallel.js +0 -12
- package/dist/run-cli.cjs +0 -55
- package/dist/run-cli.js +0 -55
- package/src/canonical.ts +0 -40
- package/src/obligation-expression.ts +0 -1060
- package/src/obligation-module.ts +0 -1042
- package/src/standard-ranges.ts +0 -116
- package/src/value-sources.ts +0 -29
- /package/src/{tlc-modules.ts → tlc/jar-data.ts} +0 -0
- /package/src/{tlc-summary.ts → tlc/summary.ts} +0 -0
|
@@ -0,0 +1,576 @@
|
|
|
1
|
+
// Ported from Z3 (src/qe/lite/qe_lite_tactic.cpp), MIT license, see z3-license.txt. The fm of
|
|
2
|
+
// qe-lite: Fourier-Motzkin elimination of the integer variables of a quantifier that only occur in
|
|
3
|
+
// clauses with one linear inequality.
|
|
4
|
+
import {
|
|
5
|
+
KIND_QUANTIFIER,
|
|
6
|
+
KIND_VAR,
|
|
7
|
+
OP_ADD,
|
|
8
|
+
OP_GE,
|
|
9
|
+
OP_LE,
|
|
10
|
+
OP_MUL,
|
|
11
|
+
OP_NOT,
|
|
12
|
+
OP_OR,
|
|
13
|
+
SORT_BOOL,
|
|
14
|
+
SORT_INT,
|
|
15
|
+
type AstManager,
|
|
16
|
+
} from "./ast";
|
|
17
|
+
import { getGcd } from "./rational";
|
|
18
|
+
import { RefVector } from "./ref-vector";
|
|
19
|
+
|
|
20
|
+
// fm's parameters.
|
|
21
|
+
const FM_LIMIT = 5000000;
|
|
22
|
+
const FM_CUTOFF1 = 8;
|
|
23
|
+
const FM_CUTOFF2 = 256;
|
|
24
|
+
const FM_EXTRA = 0;
|
|
25
|
+
|
|
26
|
+
// A clause of Boolean literals and one linear inequality, a1*x1 + ... + an*xn <= c, or < c when
|
|
27
|
+
// strict. A literal is the index of a Boolean constant, negative when negated.
|
|
28
|
+
interface Constraint {
|
|
29
|
+
lits: number[];
|
|
30
|
+
xs: number[];
|
|
31
|
+
as: bigint[];
|
|
32
|
+
c: bigint;
|
|
33
|
+
isStrict: boolean;
|
|
34
|
+
isDead: boolean;
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
// fm: Fourier-Motzkin elimination of the integer variables that only occur in clauses with one
|
|
38
|
+
// linear inequality.
|
|
39
|
+
export class Fm {
|
|
40
|
+
private constraints: Constraint[] = [];
|
|
41
|
+
private bvar2expr: RefVector;
|
|
42
|
+
private bvar2sign: number[] = [];
|
|
43
|
+
private expr2bvar = new Map<number, number>();
|
|
44
|
+
private isInt: boolean[] = [];
|
|
45
|
+
private forbidden: boolean[] = [];
|
|
46
|
+
private var2expr: RefVector;
|
|
47
|
+
private expr2var = new Map<number, number>();
|
|
48
|
+
private var2pos: number[] = [];
|
|
49
|
+
private lowers: Constraint[][] = [];
|
|
50
|
+
private uppers: Constraint[][] = [];
|
|
51
|
+
private forbiddenSet = new Set<number>();
|
|
52
|
+
private newFmls: RefVector;
|
|
53
|
+
private counter = 0;
|
|
54
|
+
private isInconsistent = false;
|
|
55
|
+
// m_sub_todo: the constraints to check for backward subsumption.
|
|
56
|
+
private subTodo: Constraint[] = [];
|
|
57
|
+
numVars = 0;
|
|
58
|
+
|
|
59
|
+
constructor(private manager: AstManager) {
|
|
60
|
+
this.bvar2expr = new RefVector(manager);
|
|
61
|
+
this.var2expr = new RefVector(manager);
|
|
62
|
+
this.newFmls = new RefVector(manager);
|
|
63
|
+
}
|
|
64
|
+
|
|
65
|
+
// ~fm.
|
|
66
|
+
release() {
|
|
67
|
+
this.resetConstraints();
|
|
68
|
+
this.newFmls.reset();
|
|
69
|
+
this.var2expr.reset();
|
|
70
|
+
this.bvar2expr.reset();
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
apply(fmls: RefVector) {
|
|
74
|
+
const manager = this.manager;
|
|
75
|
+
this.init(fmls.items);
|
|
76
|
+
this.initUseList(fmls.items);
|
|
77
|
+
if (fmls.items.some((fml) => manager.hasQuantifierFlags[fml])) return;
|
|
78
|
+
if (this.isInconsistent) this.setFalse();
|
|
79
|
+
else {
|
|
80
|
+
this.subsume();
|
|
81
|
+
for (const variable of this.sortCandidates()) {
|
|
82
|
+
manager.limit.checkpoint();
|
|
83
|
+
if (this.counter > FM_LIMIT) break;
|
|
84
|
+
this.counter++;
|
|
85
|
+
this.tryEliminate(variable);
|
|
86
|
+
if (this.isInconsistent) {
|
|
87
|
+
this.setFalse();
|
|
88
|
+
break;
|
|
89
|
+
}
|
|
90
|
+
}
|
|
91
|
+
if (!this.isInconsistent) this.copyRemaining();
|
|
92
|
+
}
|
|
93
|
+
this.resetConstraints();
|
|
94
|
+
fmls.reset();
|
|
95
|
+
for (const fml of this.newFmls.items) fmls.push(fml);
|
|
96
|
+
}
|
|
97
|
+
|
|
98
|
+
private setFalse() {
|
|
99
|
+
this.newFmls.reset();
|
|
100
|
+
this.newFmls.push(this.manager.falseExpr);
|
|
101
|
+
}
|
|
102
|
+
|
|
103
|
+
// Z3 keeps m_expr2bvar from the previous run, whose indices then point into the new, shorter
|
|
104
|
+
// m_bvar2expr. This port clears it.
|
|
105
|
+
private init(fmls: number[]) {
|
|
106
|
+
this.subTodo = [];
|
|
107
|
+
this.resetConstraints();
|
|
108
|
+
this.bvar2expr.reset();
|
|
109
|
+
this.bvar2sign = [0];
|
|
110
|
+
this.bvar2expr.push(-1);
|
|
111
|
+
this.expr2bvar.clear();
|
|
112
|
+
this.expr2var.clear();
|
|
113
|
+
this.isInt = [];
|
|
114
|
+
this.var2pos = [];
|
|
115
|
+
this.forbidden = [];
|
|
116
|
+
this.var2expr.reset();
|
|
117
|
+
this.lowers = [];
|
|
118
|
+
this.uppers = [];
|
|
119
|
+
this.newFmls.reset();
|
|
120
|
+
this.counter = 0;
|
|
121
|
+
this.isInconsistent = false;
|
|
122
|
+
this.initForbiddenSet(fmls);
|
|
123
|
+
}
|
|
124
|
+
|
|
125
|
+
private isVariable(expr: number) {
|
|
126
|
+
const manager = this.manager;
|
|
127
|
+
return manager.kinds[expr] === KIND_VAR && manager.values[expr] < this.numVars;
|
|
128
|
+
}
|
|
129
|
+
|
|
130
|
+
private isLiteral(expr: number) {
|
|
131
|
+
const manager = this.manager;
|
|
132
|
+
return (
|
|
133
|
+
manager.isUninterpretedConst(expr) ||
|
|
134
|
+
(manager.isNot(expr) && manager.isUninterpretedConst(manager.getArg(expr, 0)))
|
|
135
|
+
);
|
|
136
|
+
}
|
|
137
|
+
|
|
138
|
+
// is_linear_mon_core: the variable of x or c*x.
|
|
139
|
+
private getMonomialVar(expr: number) {
|
|
140
|
+
const manager = this.manager;
|
|
141
|
+
if (manager.getOp(expr) === OP_MUL && manager.getNumArgs(expr) === 2) {
|
|
142
|
+
const coefficient = manager.getArg(expr, 0);
|
|
143
|
+
const variable = manager.getArg(expr, 1);
|
|
144
|
+
if (manager.isNumeral(coefficient) && this.isVariable(variable)) return variable;
|
|
145
|
+
}
|
|
146
|
+
return this.isVariable(expr) ? expr : -1;
|
|
147
|
+
}
|
|
148
|
+
|
|
149
|
+
private isLinearPol(expr: number) {
|
|
150
|
+
const manager = this.manager;
|
|
151
|
+
const isSum = manager.getOp(expr) === OP_ADD;
|
|
152
|
+
const numMonomials = isSum ? manager.getNumArgs(expr) : 1;
|
|
153
|
+
const visited = new Set<number>();
|
|
154
|
+
let isAllForbidden = true;
|
|
155
|
+
for (let index = 0; index < numMonomials; index++) {
|
|
156
|
+
const monomial = isSum ? manager.getArg(expr, index) : expr;
|
|
157
|
+
const variable = this.getMonomialVar(monomial);
|
|
158
|
+
if (variable === -1 || visited.has(variable)) return false;
|
|
159
|
+
visited.add(variable);
|
|
160
|
+
if (!this.forbiddenSet.has(manager.values[variable])) isAllForbidden = false;
|
|
161
|
+
}
|
|
162
|
+
return !isAllForbidden;
|
|
163
|
+
}
|
|
164
|
+
|
|
165
|
+
private isLinearIneq(expr: number) {
|
|
166
|
+
const manager = this.manager;
|
|
167
|
+
const atom = manager.isNot(expr) ? manager.getArg(expr, 0) : expr;
|
|
168
|
+
const op = manager.getOp(atom);
|
|
169
|
+
if ((op !== OP_LE && op !== OP_GE) || manager.getNumArgs(atom) !== 2) return false;
|
|
170
|
+
const lhs = manager.getArg(atom, 0);
|
|
171
|
+
const rhs = manager.getArg(atom, 1);
|
|
172
|
+
// Z3's fm also eliminates Real variables, whose rational coefficients the port does not keep.
|
|
173
|
+
return manager.isInt(lhs) && manager.isNumeral(rhs) && this.isLinearPol(lhs);
|
|
174
|
+
}
|
|
175
|
+
|
|
176
|
+
// is_occ: a clause of literals with one linear inequality.
|
|
177
|
+
private isOcc(expr: number) {
|
|
178
|
+
const manager = this.manager;
|
|
179
|
+
if (manager.getOp(expr) !== OP_OR) return this.isLinearIneq(expr);
|
|
180
|
+
let isFound = false;
|
|
181
|
+
for (let index = 0; index < manager.getNumArgs(expr); index++) {
|
|
182
|
+
const arg = manager.getArg(expr, index);
|
|
183
|
+
if (this.isLiteral(arg)) continue;
|
|
184
|
+
if (!this.isLinearIneq(arg) || isFound) return false;
|
|
185
|
+
isFound = true;
|
|
186
|
+
}
|
|
187
|
+
return isFound;
|
|
188
|
+
}
|
|
189
|
+
|
|
190
|
+
// init_forbidden_set: the integer variables that occur outside the clauses are not eliminated.
|
|
191
|
+
private initForbiddenSet(fmls: number[]) {
|
|
192
|
+
const manager = this.manager;
|
|
193
|
+
this.forbiddenSet.clear();
|
|
194
|
+
const visited = new Set<number>();
|
|
195
|
+
for (const fml of fmls) {
|
|
196
|
+
if (this.isOcc(fml)) continue;
|
|
197
|
+
const todo = [fml];
|
|
198
|
+
for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
|
|
199
|
+
if (visited.has(expr)) continue;
|
|
200
|
+
visited.add(expr);
|
|
201
|
+
const kind = manager.kinds[expr];
|
|
202
|
+
if (kind === KIND_VAR) {
|
|
203
|
+
if (this.isVariable(expr) && manager.sorts[expr] === SORT_INT)
|
|
204
|
+
this.forbiddenSet.add(manager.values[expr]);
|
|
205
|
+
} else if (kind === KIND_QUANTIFIER) {
|
|
206
|
+
const data = manager.getQuantifier(expr);
|
|
207
|
+
todo.push(data.body, ...data.patterns);
|
|
208
|
+
} else manager.pushArgs(expr, todo);
|
|
209
|
+
}
|
|
210
|
+
}
|
|
211
|
+
}
|
|
212
|
+
|
|
213
|
+
private initUseList(fmls: number[]) {
|
|
214
|
+
for (const fml of fmls) {
|
|
215
|
+
if (this.isInconsistent) break;
|
|
216
|
+
if (this.isOcc(fml)) this.addConstraint(fml);
|
|
217
|
+
else this.newFmls.push(fml);
|
|
218
|
+
}
|
|
219
|
+
}
|
|
220
|
+
|
|
221
|
+
private toVar(expr: number) {
|
|
222
|
+
const manager = this.manager;
|
|
223
|
+
const existing = this.expr2var.get(expr);
|
|
224
|
+
if (existing !== undefined) return existing;
|
|
225
|
+
const variable = this.var2expr.size;
|
|
226
|
+
this.var2expr.push(expr);
|
|
227
|
+
this.isInt.push(manager.sorts[expr] === SORT_INT);
|
|
228
|
+
this.var2pos.push(-1);
|
|
229
|
+
this.expr2var.set(expr, variable);
|
|
230
|
+
this.lowers.push([]);
|
|
231
|
+
this.uppers.push([]);
|
|
232
|
+
this.forbidden.push(this.forbiddenSet.has(manager.values[expr]));
|
|
233
|
+
return variable;
|
|
234
|
+
}
|
|
235
|
+
|
|
236
|
+
private toLiteral(expr: number) {
|
|
237
|
+
const manager = this.manager;
|
|
238
|
+
const isNegated = manager.isNot(expr);
|
|
239
|
+
const atom = isNegated ? manager.getArg(expr, 0) : expr;
|
|
240
|
+
let bvar = this.expr2bvar.get(atom);
|
|
241
|
+
if (bvar === undefined) {
|
|
242
|
+
bvar = this.bvar2expr.size;
|
|
243
|
+
this.bvar2expr.push(atom);
|
|
244
|
+
this.bvar2sign.push(0);
|
|
245
|
+
this.expr2bvar.set(atom, bvar);
|
|
246
|
+
}
|
|
247
|
+
return isNegated ? -bvar : bvar;
|
|
248
|
+
}
|
|
249
|
+
|
|
250
|
+
private addConstraint(fml: number) {
|
|
251
|
+
const manager = this.manager;
|
|
252
|
+
const isClause = manager.getOp(fml) === OP_OR;
|
|
253
|
+
const numArgs = isClause ? manager.getNumArgs(fml) : 1;
|
|
254
|
+
const lits: number[] = [];
|
|
255
|
+
const xs: number[] = [];
|
|
256
|
+
const as: bigint[] = [];
|
|
257
|
+
let c = 0n;
|
|
258
|
+
let isStrict = false;
|
|
259
|
+
for (let argIndex = 0; argIndex < numArgs; argIndex++) {
|
|
260
|
+
const arg = isClause ? manager.getArg(fml, argIndex) : fml;
|
|
261
|
+
if (this.isLiteral(arg)) {
|
|
262
|
+
lits.push(this.toLiteral(arg));
|
|
263
|
+
continue;
|
|
264
|
+
}
|
|
265
|
+
const isNegated = manager.isNot(arg);
|
|
266
|
+
const atom = isNegated ? manager.getArg(arg, 0) : arg;
|
|
267
|
+
isStrict = isNegated;
|
|
268
|
+
const isFlipped = manager.getOp(atom) === OP_GE ? !isNegated : isNegated;
|
|
269
|
+
const lhs = manager.getArg(atom, 0);
|
|
270
|
+
const rhs = manager.getArg(atom, 1);
|
|
271
|
+
c = isFlipped ? -manager.getNumeralValue(rhs) : manager.getNumeralValue(rhs);
|
|
272
|
+
const isSum = manager.getOp(lhs) === OP_ADD;
|
|
273
|
+
const numMonomials = isSum ? manager.getNumArgs(lhs) : 1;
|
|
274
|
+
let isAllInt = true;
|
|
275
|
+
for (let index = 0; index < numMonomials; index++) {
|
|
276
|
+
const monomial = isSum ? manager.getArg(lhs, index) : lhs;
|
|
277
|
+
const isScaled = manager.getOp(monomial) === OP_MUL && manager.getNumArgs(monomial) === 2;
|
|
278
|
+
const coefficient = isScaled ? manager.getNumeralValue(manager.getArg(monomial, 0)) : 1n;
|
|
279
|
+
const variable = this.toVar(isScaled ? manager.getArg(monomial, 1) : monomial);
|
|
280
|
+
xs.push(variable);
|
|
281
|
+
as.push(isFlipped ? -coefficient : coefficient);
|
|
282
|
+
if (!this.isInt[variable]) isAllInt = false;
|
|
283
|
+
}
|
|
284
|
+
if (isAllInt && isStrict) {
|
|
285
|
+
isStrict = false;
|
|
286
|
+
c--;
|
|
287
|
+
}
|
|
288
|
+
}
|
|
289
|
+
this.registerConstraint({ lits, xs, as, c, isStrict, isDead: false });
|
|
290
|
+
}
|
|
291
|
+
|
|
292
|
+
// normalize_coeffs: divides by the gcd of the coefficients and the constant.
|
|
293
|
+
private normalizeCoeffs(constraint: Constraint) {
|
|
294
|
+
if (constraint.xs.length === 0) return;
|
|
295
|
+
let divisor = constraint.c < 0n ? -constraint.c : constraint.c;
|
|
296
|
+
for (const coefficient of constraint.as) {
|
|
297
|
+
if (divisor === 1n) break;
|
|
298
|
+
divisor = getGcd(coefficient, divisor);
|
|
299
|
+
}
|
|
300
|
+
if (divisor === 1n) return;
|
|
301
|
+
constraint.c /= divisor;
|
|
302
|
+
constraint.as = constraint.as.map((coefficient) => coefficient / divisor);
|
|
303
|
+
}
|
|
304
|
+
|
|
305
|
+
private isFalseConstraint(constraint: Constraint) {
|
|
306
|
+
return (
|
|
307
|
+
constraint.lits.length === 0 &&
|
|
308
|
+
constraint.xs.length === 0 &&
|
|
309
|
+
(constraint.c < 0n || (constraint.isStrict && constraint.c === 0n))
|
|
310
|
+
);
|
|
311
|
+
}
|
|
312
|
+
|
|
313
|
+
private registerConstraint(constraint: Constraint) {
|
|
314
|
+
this.normalizeCoeffs(constraint);
|
|
315
|
+
if (this.isFalseConstraint(constraint)) {
|
|
316
|
+
this.delConstraint(constraint);
|
|
317
|
+
this.isInconsistent = true;
|
|
318
|
+
return;
|
|
319
|
+
}
|
|
320
|
+
let isIndexed = false;
|
|
321
|
+
constraint.xs.forEach((variable, index) => {
|
|
322
|
+
if (this.forbidden[variable]) return;
|
|
323
|
+
isIndexed = true;
|
|
324
|
+
(constraint.as[index] < 0n ? this.lowers : this.uppers)[variable].push(constraint);
|
|
325
|
+
});
|
|
326
|
+
if (isIndexed) {
|
|
327
|
+
if (!this.subTodo.includes(constraint)) this.subTodo.push(constraint);
|
|
328
|
+
this.constraints.push(constraint);
|
|
329
|
+
return;
|
|
330
|
+
}
|
|
331
|
+
this.newFmls.push(this.toExpr(constraint));
|
|
332
|
+
this.delConstraint(constraint);
|
|
333
|
+
}
|
|
334
|
+
|
|
335
|
+
private delConstraint(constraint: Constraint) {
|
|
336
|
+
const position = this.subTodo.indexOf(constraint);
|
|
337
|
+
if (position === -1) return;
|
|
338
|
+
this.subTodo[position] = this.subTodo[this.subTodo.length - 1];
|
|
339
|
+
this.subTodo.pop();
|
|
340
|
+
}
|
|
341
|
+
|
|
342
|
+
private resetConstraints() {
|
|
343
|
+
for (const constraint of this.constraints) this.delConstraint(constraint);
|
|
344
|
+
this.constraints = [];
|
|
345
|
+
}
|
|
346
|
+
|
|
347
|
+
// to_expr: the constraint as a formula, with a raw reference like Z3's.
|
|
348
|
+
private toExpr(constraint: Constraint) {
|
|
349
|
+
const manager = this.manager;
|
|
350
|
+
let ineq = -1;
|
|
351
|
+
if (constraint.xs.length === 0) {
|
|
352
|
+
if (constraint.c > 0n || (!constraint.isStrict && constraint.c === 0n))
|
|
353
|
+
return manager.trueExpr;
|
|
354
|
+
} else {
|
|
355
|
+
const monomials = constraint.xs.map((variable, index) => {
|
|
356
|
+
const expr = this.var2expr.items[variable];
|
|
357
|
+
const coefficient = constraint.as[index];
|
|
358
|
+
return coefficient === 1n
|
|
359
|
+
? expr
|
|
360
|
+
: manager.mkApp(OP_MUL, [manager.mkNumeral(coefficient), expr], SORT_INT);
|
|
361
|
+
});
|
|
362
|
+
const lhs =
|
|
363
|
+
monomials.length === 1 ? monomials[0] : manager.mkApp(OP_ADD, monomials, SORT_INT);
|
|
364
|
+
const rhs = manager.mkNumeral(constraint.c);
|
|
365
|
+
ineq = constraint.isStrict
|
|
366
|
+
? manager.mkApp(OP_NOT, [manager.mkApp(OP_GE, [lhs, rhs], SORT_BOOL)], SORT_BOOL)
|
|
367
|
+
: manager.mkApp(OP_LE, [lhs, rhs], SORT_BOOL);
|
|
368
|
+
}
|
|
369
|
+
if (constraint.lits.length === 0) return ineq === -1 ? manager.falseExpr : ineq;
|
|
370
|
+
const lits = constraint.lits.map((lit) => {
|
|
371
|
+
const atom = this.bvar2expr.items[Math.abs(lit)];
|
|
372
|
+
return lit < 0 ? manager.mkApp(OP_NOT, [atom], SORT_BOOL) : atom;
|
|
373
|
+
});
|
|
374
|
+
if (ineq !== -1) lits.push(ineq);
|
|
375
|
+
return lits.length === 1 ? lits[0] : manager.mkApp(OP_OR, lits, SORT_BOOL);
|
|
376
|
+
}
|
|
377
|
+
|
|
378
|
+
// subsumes: c1's literals are among c2's, the polynomials are the same, and c1's bound is at most
|
|
379
|
+
// c2's.
|
|
380
|
+
private isSubsuming(first: Constraint, second: Constraint) {
|
|
381
|
+
if (first === second) return false;
|
|
382
|
+
if (first.lits.length > second.lits.length || first.xs.length !== second.xs.length)
|
|
383
|
+
return false;
|
|
384
|
+
if (first.c > second.c) return false;
|
|
385
|
+
if (!first.isStrict && second.isStrict && first.c === second.c) return false;
|
|
386
|
+
this.counter += first.lits.length + second.lits.length;
|
|
387
|
+
first.xs.forEach((variable, index) => {
|
|
388
|
+
this.var2pos[variable] = index;
|
|
389
|
+
});
|
|
390
|
+
const isSamePol = second.xs.every((variable, index) => {
|
|
391
|
+
const position = this.var2pos[variable];
|
|
392
|
+
return position !== -1 && first.as[position] === second.as[index];
|
|
393
|
+
});
|
|
394
|
+
for (const variable of first.xs) this.var2pos[variable] = -1;
|
|
395
|
+
if (!isSamePol) return false;
|
|
396
|
+
for (const lit of second.lits) this.bvar2sign[Math.abs(lit)] = lit < 0 ? -1 : 1;
|
|
397
|
+
const isSubset = first.lits.every(
|
|
398
|
+
(lit) => this.bvar2sign[Math.abs(lit)] === (lit < 0 ? -1 : 1),
|
|
399
|
+
);
|
|
400
|
+
for (const lit of second.lits) this.bvar2sign[Math.abs(lit)] = 0;
|
|
401
|
+
return isSubset;
|
|
402
|
+
}
|
|
403
|
+
|
|
404
|
+
private backwardSubsumption(constraint: Constraint) {
|
|
405
|
+
if (constraint.xs.length === 0) return;
|
|
406
|
+
let best = -1;
|
|
407
|
+
let bestSize = Infinity;
|
|
408
|
+
let isBestLower = false;
|
|
409
|
+
constraint.xs.forEach((variable, index) => {
|
|
410
|
+
if (this.forbidden[variable]) return;
|
|
411
|
+
const isLower = constraint.as[index] < 0n;
|
|
412
|
+
const candidates = (isLower ? this.lowers : this.uppers)[variable];
|
|
413
|
+
if (candidates.length < bestSize) {
|
|
414
|
+
best = variable;
|
|
415
|
+
bestSize = candidates.length;
|
|
416
|
+
isBestLower = isLower;
|
|
417
|
+
}
|
|
418
|
+
});
|
|
419
|
+
if (bestSize === 0 || best === -1) return;
|
|
420
|
+
const lists = isBestLower ? this.lowers : this.uppers;
|
|
421
|
+
this.counter += lists[best].length;
|
|
422
|
+
lists[best] = lists[best].filter((other) => {
|
|
423
|
+
if (other.isDead) return false;
|
|
424
|
+
if (!this.isSubsuming(constraint, other)) return true;
|
|
425
|
+
other.isDead = true;
|
|
426
|
+
return false;
|
|
427
|
+
});
|
|
428
|
+
}
|
|
429
|
+
|
|
430
|
+
private subsume() {
|
|
431
|
+
for (
|
|
432
|
+
let constraint = this.subTodo.pop();
|
|
433
|
+
constraint !== undefined;
|
|
434
|
+
constraint = this.subTodo.pop()
|
|
435
|
+
)
|
|
436
|
+
if (!constraint.isDead) this.backwardSubsumption(constraint);
|
|
437
|
+
}
|
|
438
|
+
|
|
439
|
+
// sort_candidates: the variables without a lower or upper bound first, then by the number of
|
|
440
|
+
// constraints they would create.
|
|
441
|
+
private sortCandidates() {
|
|
442
|
+
const costs: [number, number][] = [];
|
|
443
|
+
this.forbidden.forEach((isForbidden, variable) => {
|
|
444
|
+
if (!isForbidden)
|
|
445
|
+
costs.push([variable, this.lowers[variable].length * this.uppers[variable].length]);
|
|
446
|
+
});
|
|
447
|
+
const isLess = (first: [number, number], second: [number, number]) => {
|
|
448
|
+
if (first[1] === 0) return second[1] > 0 || first[0] < second[0];
|
|
449
|
+
if (second[1] === 0) return false;
|
|
450
|
+
const isFirstInt = this.isInt[first[0]];
|
|
451
|
+
const isSecondInt = this.isInt[second[0]];
|
|
452
|
+
return (!isFirstInt && isSecondInt) || (isFirstInt === isSecondInt && first[1] < second[1]);
|
|
453
|
+
};
|
|
454
|
+
costs.sort((first, second) => (isLess(first, second) ? -1 : isLess(second, first) ? 1 : 0));
|
|
455
|
+
return costs.map((cost) => cost[0]);
|
|
456
|
+
}
|
|
457
|
+
|
|
458
|
+
// analyze: whether every variable is an integer, and whether x's coefficients are all 1 or -1.
|
|
459
|
+
private analyze(constraints: Constraint[], variable: number) {
|
|
460
|
+
let isUnit = true;
|
|
461
|
+
for (const constraint of constraints)
|
|
462
|
+
for (let index = 0; index < constraint.xs.length; index++) {
|
|
463
|
+
const other = constraint.xs[index];
|
|
464
|
+
if (!this.isInt[other]) return { isAllInt: false, isUnit };
|
|
465
|
+
if (other === variable && constraint.as[index] !== 1n && constraint.as[index] !== -1n)
|
|
466
|
+
isUnit = false;
|
|
467
|
+
}
|
|
468
|
+
return { isAllInt: true, isUnit };
|
|
469
|
+
}
|
|
470
|
+
|
|
471
|
+
private canEliminate(variable: number) {
|
|
472
|
+
if (!this.isInt[variable]) return true;
|
|
473
|
+
const lower = this.analyze(this.lowers[variable], variable);
|
|
474
|
+
if (!lower.isAllInt) return false;
|
|
475
|
+
const upper = this.analyze(this.uppers[variable], variable);
|
|
476
|
+
return upper.isAllInt && (lower.isUnit || upper.isUnit);
|
|
477
|
+
}
|
|
478
|
+
|
|
479
|
+
private markDead(variable: number) {
|
|
480
|
+
for (const constraint of this.lowers[variable]) constraint.isDead = true;
|
|
481
|
+
for (const constraint of this.uppers[variable]) constraint.isDead = true;
|
|
482
|
+
}
|
|
483
|
+
|
|
484
|
+
// resolve: the combination of a lower and an upper bound of x without x, or undefined when it
|
|
485
|
+
// holds.
|
|
486
|
+
private resolve(lower: Constraint, upper: Constraint, variable: number) {
|
|
487
|
+
this.counter += lower.xs.length + upper.xs.length + lower.lits.length + upper.lits.length;
|
|
488
|
+
const a = -lower.as[lower.xs.indexOf(variable)];
|
|
489
|
+
const b = upper.as[upper.xs.indexOf(variable)];
|
|
490
|
+
let c = lower.c * b + upper.c * a;
|
|
491
|
+
let isStrict = lower.isStrict || upper.isStrict;
|
|
492
|
+
const xs: number[] = [];
|
|
493
|
+
const as: bigint[] = [];
|
|
494
|
+
lower.xs.forEach((other, index) => {
|
|
495
|
+
if (other === variable) return;
|
|
496
|
+
this.var2pos[other] = xs.length;
|
|
497
|
+
xs.push(other);
|
|
498
|
+
as.push(lower.as[index] * b);
|
|
499
|
+
});
|
|
500
|
+
upper.xs.forEach((other, index) => {
|
|
501
|
+
if (other === variable) return;
|
|
502
|
+
const position = this.var2pos[other];
|
|
503
|
+
if (position === -1) {
|
|
504
|
+
xs.push(other);
|
|
505
|
+
as.push(upper.as[index] * a);
|
|
506
|
+
} else as[position] += upper.as[index] * a;
|
|
507
|
+
});
|
|
508
|
+
const kept = as.flatMap((coefficient, index) => (coefficient === 0n ? [] : [index]));
|
|
509
|
+
const newXs = kept.map((index) => xs[index]);
|
|
510
|
+
const newAs = kept.map((index) => as[index]);
|
|
511
|
+
if (isStrict && newXs.every((other) => this.isInt[other])) {
|
|
512
|
+
isStrict = false;
|
|
513
|
+
c--;
|
|
514
|
+
}
|
|
515
|
+
for (const other of lower.xs) this.var2pos[other] = -1;
|
|
516
|
+
if (newXs.length === 0 && (c > 0n || (!isStrict && c === 0n))) return undefined;
|
|
517
|
+
for (const lit of lower.lits) this.bvar2sign[Math.abs(lit)] = lit < 0 ? -1 : 1;
|
|
518
|
+
const lits = [...lower.lits];
|
|
519
|
+
let isTautology = false;
|
|
520
|
+
for (const lit of upper.lits) {
|
|
521
|
+
if (isTautology) break;
|
|
522
|
+
const sign = this.bvar2sign[Math.abs(lit)];
|
|
523
|
+
if (sign === 0) lits.push(lit);
|
|
524
|
+
else if (sign === -1 ? lit > 0 : lit < 0) isTautology = true;
|
|
525
|
+
}
|
|
526
|
+
for (const lit of lower.lits) this.bvar2sign[Math.abs(lit)] = 0;
|
|
527
|
+
if (isTautology) return undefined;
|
|
528
|
+
if (lits.length === 0 && newXs.length === 0 && (c < 0n || (isStrict && c === 0n))) {
|
|
529
|
+
this.isInconsistent = true;
|
|
530
|
+
return undefined;
|
|
531
|
+
}
|
|
532
|
+
return { lits, xs: newXs, as: newAs, c, isStrict, isDead: false };
|
|
533
|
+
}
|
|
534
|
+
|
|
535
|
+
private tryEliminate(variable: number) {
|
|
536
|
+
const lowers = this.lowers[variable].filter((constraint) => !constraint.isDead);
|
|
537
|
+
const uppers = this.uppers[variable].filter((constraint) => !constraint.isDead);
|
|
538
|
+
this.lowers[variable] = lowers;
|
|
539
|
+
this.uppers[variable] = uppers;
|
|
540
|
+
if (lowers.length === 0 || uppers.length === 0) {
|
|
541
|
+
this.markDead(variable);
|
|
542
|
+
return;
|
|
543
|
+
}
|
|
544
|
+
if (lowers.length > FM_CUTOFF1 && uppers.length > FM_CUTOFF1) return;
|
|
545
|
+
if (lowers.length * uppers.length > FM_CUTOFF2) return;
|
|
546
|
+
if (!this.canEliminate(variable)) return;
|
|
547
|
+
this.counter += lowers.length * uppers.length;
|
|
548
|
+
const limit = lowers.length + uppers.length + FM_EXTRA;
|
|
549
|
+
const created: Constraint[] = [];
|
|
550
|
+
for (const lower of lowers)
|
|
551
|
+
for (const upper of uppers) {
|
|
552
|
+
if (this.isInconsistent || created.length > limit) return;
|
|
553
|
+
const resolved = this.resolve(lower, upper, variable);
|
|
554
|
+
if (resolved !== undefined) created.push(resolved);
|
|
555
|
+
}
|
|
556
|
+
this.markDead(variable);
|
|
557
|
+
this.counter += created.length;
|
|
558
|
+
for (const constraint of created) {
|
|
559
|
+
this.backwardSubsumption(constraint);
|
|
560
|
+
this.registerConstraint(constraint);
|
|
561
|
+
}
|
|
562
|
+
}
|
|
563
|
+
|
|
564
|
+
// copy_remaining: the live constraints of the upper bounds, then of the lower bounds.
|
|
565
|
+
private copyRemaining() {
|
|
566
|
+
for (const lists of [this.uppers, this.lowers])
|
|
567
|
+
for (const constraints of lists)
|
|
568
|
+
for (const constraint of constraints) {
|
|
569
|
+
if (constraint.isDead) continue;
|
|
570
|
+
constraint.isDead = true;
|
|
571
|
+
this.newFmls.push(this.toExpr(constraint));
|
|
572
|
+
}
|
|
573
|
+
this.uppers = [];
|
|
574
|
+
this.lowers = [];
|
|
575
|
+
}
|
|
576
|
+
}
|