tla-ts 0.0.4-dev.6dec595 → 0.0.4-dev.7714e32
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 +37 -126
- 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 -1154
- 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} +112 -718
- 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 +109 -108
- 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 +16 -19
- 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 -213
- 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/transfer.ts +32 -32
- package/src/values.ts +80 -70
- 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
- /package/src/{tlc-version.ts → tlc/version.ts} +0 -0
|
@@ -0,0 +1,816 @@
|
|
|
1
|
+
// Ported from Z3 (src/math/lp/lar_solver.h, src/math/lp/lar_solver.cpp, src/math/lp/column.h,
|
|
2
|
+
// src/math/lp/var_register.h), MIT license, see z3-license.txt. Columns for theory variables and
|
|
3
|
+
// for terms, whose rows the tableau keeps, bounds with dependencies on the constraints that set
|
|
4
|
+
// them, and the push and pop of all of it.
|
|
5
|
+
import { SmtInvariantError } from "../../../../errors";
|
|
6
|
+
import { Rational } from "../rational";
|
|
7
|
+
import { IndexedUintSet, StackedVector } from "./containers";
|
|
8
|
+
import {
|
|
9
|
+
type ConstraintKind,
|
|
10
|
+
ConstraintSet,
|
|
11
|
+
KIND_EQ,
|
|
12
|
+
KIND_GE,
|
|
13
|
+
KIND_GT,
|
|
14
|
+
KIND_LE,
|
|
15
|
+
KIND_LT,
|
|
16
|
+
} from "./constraints";
|
|
17
|
+
import {
|
|
18
|
+
COLUMN_BOXED,
|
|
19
|
+
COLUMN_FIXED,
|
|
20
|
+
COLUMN_FREE,
|
|
21
|
+
COLUMN_LOWER,
|
|
22
|
+
COLUMN_UPPER,
|
|
23
|
+
CoreSolver,
|
|
24
|
+
LP_CANCELLED,
|
|
25
|
+
LP_FEASIBLE,
|
|
26
|
+
LP_INFEASIBLE,
|
|
27
|
+
LP_OPTIMAL,
|
|
28
|
+
LP_UNKNOWN,
|
|
29
|
+
type ColumnType,
|
|
30
|
+
} from "./core-solver";
|
|
31
|
+
import { Dependency, linearize, mkJoin } from "./dependency";
|
|
32
|
+
import type { Explanation } from "./explanation";
|
|
33
|
+
import { LarTerm } from "./lar-term";
|
|
34
|
+
import { LpSettings } from "./lp-settings";
|
|
35
|
+
import { Impq } from "./numeric-pair";
|
|
36
|
+
import { shrink } from "../array";
|
|
37
|
+
|
|
38
|
+
export const NULL_LPVAR = -1;
|
|
39
|
+
|
|
40
|
+
interface AdjustedBound {
|
|
41
|
+
kind: ConstraintKind;
|
|
42
|
+
bound: Rational;
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
// The column of a term, under its normalized term, with the first coefficient it was divided by.
|
|
46
|
+
interface NormalizedTermColumn {
|
|
47
|
+
coeff: Rational;
|
|
48
|
+
column: number;
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
interface Column {
|
|
52
|
+
lowerWitness: Dependency;
|
|
53
|
+
upperWitness: Dependency;
|
|
54
|
+
readonly term: LarTerm | null;
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
const getTermKey = (term: LarTerm) =>
|
|
58
|
+
[...term.coeffs]
|
|
59
|
+
.map((entry) => `${entry[0]}:${entry[1]}`)
|
|
60
|
+
.sort()
|
|
61
|
+
.join(",");
|
|
62
|
+
|
|
63
|
+
export class LarSolver {
|
|
64
|
+
readonly settings: LpSettings;
|
|
65
|
+
readonly core: CoreSolver;
|
|
66
|
+
readonly constraints = new ConstraintSet();
|
|
67
|
+
readonly columns: Column[] = [];
|
|
68
|
+
readonly terms: LarTerm[] = [];
|
|
69
|
+
readonly touchedRows = new IndexedUintSet();
|
|
70
|
+
readonly columnsWithChangedBounds = new IndexedUintSet();
|
|
71
|
+
rowBoundsToReplay: number[] = [];
|
|
72
|
+
status = LP_UNKNOWN;
|
|
73
|
+
crossedBoundsColumn = NULL_LPVAR;
|
|
74
|
+
crossedBoundsDeps: Dependency = null;
|
|
75
|
+
private externalToLocal = new Map<number, number>();
|
|
76
|
+
private localToExternal: number[] = [];
|
|
77
|
+
private localIsInt: boolean[] = [];
|
|
78
|
+
private trail: (() => void)[] = [];
|
|
79
|
+
private trailScopes: number[] = [];
|
|
80
|
+
private usageInTerms = new StackedVector<number>();
|
|
81
|
+
private fixedVarTableInt = new Map<string, number>();
|
|
82
|
+
private fixedVarTableReal = new Map<string, number>();
|
|
83
|
+
private fixedBaseVarSet = new IndexedUintSet();
|
|
84
|
+
private normalizedTermsToColumns = new Map<string, NormalizedTermColumn>();
|
|
85
|
+
private isRegisteringTerms = false;
|
|
86
|
+
// m_delta: zero until init_model sets it.
|
|
87
|
+
private delta = Rational.zero;
|
|
88
|
+
// The callback of nla for the columns whose bounds changed.
|
|
89
|
+
onChangedBounds: ((columns: IndexedUintSet) => void) | undefined;
|
|
90
|
+
// m_add_term_callback and m_update_column_bound_callback, which the Diophantine solver sets.
|
|
91
|
+
onAddTerm: ((term: LarTerm) => void) | undefined;
|
|
92
|
+
onColumnBoundUpdate: ((column: number) => void) | undefined;
|
|
93
|
+
|
|
94
|
+
constructor(isCanceled: () => boolean) {
|
|
95
|
+
this.settings = new LpSettings(isCanceled);
|
|
96
|
+
this.core = new CoreSolver(this.settings);
|
|
97
|
+
this.core.touchedRows = this.touchedRows;
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
getColumnCount() {
|
|
101
|
+
return this.core.matrix.getColumnCount();
|
|
102
|
+
}
|
|
103
|
+
|
|
104
|
+
getRowCount() {
|
|
105
|
+
return this.core.matrix.getRowCount();
|
|
106
|
+
}
|
|
107
|
+
|
|
108
|
+
getValue(column: number) {
|
|
109
|
+
return this.core.x[column];
|
|
110
|
+
}
|
|
111
|
+
|
|
112
|
+
getLowerBound(column: number) {
|
|
113
|
+
return this.core.lowerBounds[column];
|
|
114
|
+
}
|
|
115
|
+
|
|
116
|
+
getUpperBound(column: number) {
|
|
117
|
+
return this.core.upperBounds[column];
|
|
118
|
+
}
|
|
119
|
+
|
|
120
|
+
isInt(column: number) {
|
|
121
|
+
return this.localIsInt[column];
|
|
122
|
+
}
|
|
123
|
+
|
|
124
|
+
isBase(column: number) {
|
|
125
|
+
return this.core.isBase(column);
|
|
126
|
+
}
|
|
127
|
+
|
|
128
|
+
isFixed(column: number) {
|
|
129
|
+
return this.core.isFixed(column);
|
|
130
|
+
}
|
|
131
|
+
|
|
132
|
+
isFree(column: number) {
|
|
133
|
+
return this.core.getColumnType(column) === COLUMN_FREE;
|
|
134
|
+
}
|
|
135
|
+
|
|
136
|
+
hasTerm(column: number) {
|
|
137
|
+
return this.columns[column].term !== null;
|
|
138
|
+
}
|
|
139
|
+
|
|
140
|
+
getTerm(column: number) {
|
|
141
|
+
const term = this.columns[column].term;
|
|
142
|
+
if (term === null) throw new SmtInvariantError(`column ${column} has no term`);
|
|
143
|
+
return term;
|
|
144
|
+
}
|
|
145
|
+
|
|
146
|
+
externalToLocalColumn(external: number) {
|
|
147
|
+
return this.externalToLocal.get(external) ?? NULL_LPVAR;
|
|
148
|
+
}
|
|
149
|
+
|
|
150
|
+
getExternal(column: number) {
|
|
151
|
+
return this.localToExternal[column];
|
|
152
|
+
}
|
|
153
|
+
|
|
154
|
+
isFeasible() {
|
|
155
|
+
return this.status === LP_OPTIMAL || this.status === LP_FEASIBLE;
|
|
156
|
+
}
|
|
157
|
+
|
|
158
|
+
getRow(rowIndex: number) {
|
|
159
|
+
return this.core.matrix.rows[rowIndex];
|
|
160
|
+
}
|
|
161
|
+
|
|
162
|
+
getUsageInTerms(column: number) {
|
|
163
|
+
return column < this.usageInTerms.values.length ? this.usageInTerms.get(column) : 0;
|
|
164
|
+
}
|
|
165
|
+
|
|
166
|
+
// Columns.
|
|
167
|
+
|
|
168
|
+
private registerExternal(external: number, isInt: boolean) {
|
|
169
|
+
const local = this.localToExternal.length;
|
|
170
|
+
this.localToExternal.push(external);
|
|
171
|
+
this.localIsInt.push(isInt);
|
|
172
|
+
if (external !== NULL_LPVAR) this.externalToLocal.set(external, local);
|
|
173
|
+
}
|
|
174
|
+
|
|
175
|
+
private addNewVarToCoreFields(isBasic: boolean) {
|
|
176
|
+
this.core.addColumn(isBasic);
|
|
177
|
+
if (isBasic) this.addTouchedRow(this.getRowCount() - 1);
|
|
178
|
+
}
|
|
179
|
+
|
|
180
|
+
private pushUndoAddColumn() {
|
|
181
|
+
this.trail.push(() => {
|
|
182
|
+
const column = this.columns[this.columns.length - 1];
|
|
183
|
+
if (column.term !== null) {
|
|
184
|
+
if (this.isRegisteringTerms) this.deregisterNormalizedTerm(column.term);
|
|
185
|
+
this.terms.pop();
|
|
186
|
+
}
|
|
187
|
+
this.removeLastColumnFromTableau();
|
|
188
|
+
this.columns.pop();
|
|
189
|
+
const index = this.columns.length;
|
|
190
|
+
if (this.columnsWithChangedBounds.has(index)) this.columnsWithChangedBounds.delete(index);
|
|
191
|
+
});
|
|
192
|
+
}
|
|
193
|
+
|
|
194
|
+
addVar(external: number, isInt: boolean) {
|
|
195
|
+
const existing = this.externalToLocal.get(external);
|
|
196
|
+
if (existing !== undefined) return existing;
|
|
197
|
+
const column = this.getColumnCount();
|
|
198
|
+
this.columns.push({ lowerWitness: null, upperWitness: null, term: null });
|
|
199
|
+
this.pushUndoAddColumn();
|
|
200
|
+
while (this.usageInTerms.values.length <= column) this.usageInTerms.push(0);
|
|
201
|
+
this.registerExternal(external, isInt);
|
|
202
|
+
this.core.columnTypes.push(COLUMN_FREE);
|
|
203
|
+
this.addNewVarToCoreFields(false);
|
|
204
|
+
return column;
|
|
205
|
+
}
|
|
206
|
+
|
|
207
|
+
private isTermInt(term: LarTerm) {
|
|
208
|
+
for (const entry of term.coeffs) if (!this.isInt(entry[0]) || !entry[1].isInt()) return false;
|
|
209
|
+
return true;
|
|
210
|
+
}
|
|
211
|
+
|
|
212
|
+
// subst_known_terms: replaces term columns by their terms, the smallest column first.
|
|
213
|
+
private substKnownTerms(term: LarTerm) {
|
|
214
|
+
const seen = new Set<number>();
|
|
215
|
+
for (const entry of term.coeffs) if (this.hasTerm(entry[0])) seen.add(entry[0]);
|
|
216
|
+
while (seen.size > 0) {
|
|
217
|
+
const column = Math.min(...seen);
|
|
218
|
+
seen.delete(column);
|
|
219
|
+
const other = this.getTerm(column);
|
|
220
|
+
for (const entry of other.coeffs) if (this.hasTerm(entry[0])) seen.add(entry[0]);
|
|
221
|
+
term.substByTerm(other, column);
|
|
222
|
+
}
|
|
223
|
+
}
|
|
224
|
+
|
|
225
|
+
addTerm(coeffs: [number, Rational][], external: number) {
|
|
226
|
+
const term = new LarTerm(coeffs);
|
|
227
|
+
this.substKnownTerms(term);
|
|
228
|
+
this.terms.push(term);
|
|
229
|
+
const column = this.getColumnCount();
|
|
230
|
+
this.registerExternal(external, this.isTermInt(term));
|
|
231
|
+
term.column = column;
|
|
232
|
+
this.columns.push({ lowerWitness: null, upperWitness: null, term });
|
|
233
|
+
this.pushUndoAddColumn();
|
|
234
|
+
this.core.columnTypes.push(COLUMN_FREE);
|
|
235
|
+
this.addNewVarToCoreFields(true);
|
|
236
|
+
this.core.matrix.fillLastRowWithPivoting(term, column, this.core.heading);
|
|
237
|
+
this.core.x[column] = this.getBasicVarValueFromRow(this.getRowCount() - 1);
|
|
238
|
+
for (const entry of term.coeffs) {
|
|
239
|
+
while (this.usageInTerms.values.length <= entry[0]) this.usageInTerms.push(0);
|
|
240
|
+
this.usageInTerms.set(entry[0], this.usageInTerms.get(entry[0]) + 1);
|
|
241
|
+
}
|
|
242
|
+
if (this.isRegisteringTerms) this.registerNormalizedTerm(term, column);
|
|
243
|
+
this.onAddTerm?.(term);
|
|
244
|
+
return column;
|
|
245
|
+
}
|
|
246
|
+
|
|
247
|
+
private getBasicVarValueFromRow(rowIndex: number) {
|
|
248
|
+
const basic = this.core.basis[rowIndex];
|
|
249
|
+
let result = Impq.zero;
|
|
250
|
+
for (const cell of this.core.matrix.rows[rowIndex]) {
|
|
251
|
+
if (cell.column === basic) continue;
|
|
252
|
+
const value = this.core.x[cell.column];
|
|
253
|
+
if (!value.isZero()) result = result.sub(value.mul(cell.coeff));
|
|
254
|
+
}
|
|
255
|
+
return result;
|
|
256
|
+
}
|
|
257
|
+
|
|
258
|
+
private registerNormalizedTerm(term: LarTerm, column: number) {
|
|
259
|
+
const normalized = term.getNormalized();
|
|
260
|
+
const key = getTermKey(normalized.term);
|
|
261
|
+
if (!this.normalizedTermsToColumns.has(key))
|
|
262
|
+
this.normalizedTermsToColumns.set(key, { coeff: normalized.coeff, column });
|
|
263
|
+
}
|
|
264
|
+
|
|
265
|
+
private deregisterNormalizedTerm(term: LarTerm) {
|
|
266
|
+
this.normalizedTermsToColumns.delete(getTermKey(term.getNormalized().term));
|
|
267
|
+
}
|
|
268
|
+
|
|
269
|
+
registerExistingTerms() {
|
|
270
|
+
if (!this.isRegisteringTerms)
|
|
271
|
+
for (const term of this.terms) this.registerNormalizedTerm(term, term.column);
|
|
272
|
+
this.isRegisteringTerms = true;
|
|
273
|
+
}
|
|
274
|
+
|
|
275
|
+
fetchNormalizedTermColumn(term: LarTerm) {
|
|
276
|
+
return this.normalizedTermsToColumns.get(getTermKey(term));
|
|
277
|
+
}
|
|
278
|
+
|
|
279
|
+
// Removing the last column on pop.
|
|
280
|
+
|
|
281
|
+
private removeLastColumnFromTableau() {
|
|
282
|
+
const core = this.core;
|
|
283
|
+
const matrix = core.matrix;
|
|
284
|
+
const column = matrix.getColumnCount() - 1;
|
|
285
|
+
if (this.columns[column].term !== null) {
|
|
286
|
+
const rowIndex = matrix.getRowCount() - 1;
|
|
287
|
+
const lastColumn = matrix.columns[column];
|
|
288
|
+
let nonZeroIndex = -1;
|
|
289
|
+
let isInRow = false;
|
|
290
|
+
for (let index = lastColumn.length; index-- > 0;) {
|
|
291
|
+
if (lastColumn[index].row === rowIndex) {
|
|
292
|
+
isInRow = true;
|
|
293
|
+
break;
|
|
294
|
+
}
|
|
295
|
+
nonZeroIndex = index;
|
|
296
|
+
}
|
|
297
|
+
if (!isInRow) core.transposeRows(lastColumn[nonZeroIndex].row, rowIndex);
|
|
298
|
+
if (core.heading[column] < 0) core.pivotColumnTableau(column, rowIndex);
|
|
299
|
+
const lastRow = matrix.rows[rowIndex];
|
|
300
|
+
for (let index = lastRow.length; index-- > 0;) matrix.removeElement(lastRow, lastRow[index]);
|
|
301
|
+
matrix.rows.pop();
|
|
302
|
+
matrix.popColumn();
|
|
303
|
+
if (core.heading[column] < 0)
|
|
304
|
+
core.changeBasisUnconditionally(column, core.basis[matrix.getRowCount()]);
|
|
305
|
+
} else matrix.popColumn();
|
|
306
|
+
core.removeLastColumn(column);
|
|
307
|
+
}
|
|
308
|
+
|
|
309
|
+
// Bounds.
|
|
310
|
+
|
|
311
|
+
private setUpperBoundWitness(column: number, dep: Dependency, bound: Impq) {
|
|
312
|
+
const info = this.columns[column];
|
|
313
|
+
const savedBound = this.core.upperBounds[column];
|
|
314
|
+
const savedWitness = info.upperWitness;
|
|
315
|
+
this.trail.push(() => {
|
|
316
|
+
this.core.upperBounds[column] = savedBound;
|
|
317
|
+
info.upperWitness = savedWitness;
|
|
318
|
+
});
|
|
319
|
+
info.upperWitness = dep;
|
|
320
|
+
this.core.upperBounds[column] = bound;
|
|
321
|
+
this.columnsWithChangedBounds.add(column);
|
|
322
|
+
}
|
|
323
|
+
|
|
324
|
+
private setLowerBoundWitness(column: number, dep: Dependency, bound: Impq) {
|
|
325
|
+
const info = this.columns[column];
|
|
326
|
+
const savedBound = this.core.lowerBounds[column];
|
|
327
|
+
const savedWitness = info.lowerWitness;
|
|
328
|
+
this.trail.push(() => {
|
|
329
|
+
this.core.lowerBounds[column] = savedBound;
|
|
330
|
+
info.lowerWitness = savedWitness;
|
|
331
|
+
});
|
|
332
|
+
info.lowerWitness = dep;
|
|
333
|
+
this.core.lowerBounds[column] = bound;
|
|
334
|
+
this.columnsWithChangedBounds.add(column);
|
|
335
|
+
}
|
|
336
|
+
|
|
337
|
+
private setCrossedBounds(column: number, isLower: boolean, dep: Dependency) {
|
|
338
|
+
if (this.crossedBoundsColumn !== NULL_LPVAR) return;
|
|
339
|
+
this.status = LP_INFEASIBLE;
|
|
340
|
+
this.crossedBoundsColumn = column;
|
|
341
|
+
const info = this.columns[column];
|
|
342
|
+
this.crossedBoundsDeps = mkJoin(isLower ? info.lowerWitness : info.upperWitness, dep);
|
|
343
|
+
}
|
|
344
|
+
|
|
345
|
+
// adjust_bound_for_int: a strict or fractional bound on an integer column, rounded.
|
|
346
|
+
private adjustBoundForInt(column: number, kind: ConstraintKind, bound: Rational): AdjustedBound {
|
|
347
|
+
if (!this.isInt(column) || bound.isInt()) return { kind, bound };
|
|
348
|
+
if (kind === KIND_LT || kind === KIND_LE) return { kind: KIND_LE, bound: bound.floor() };
|
|
349
|
+
if (kind === KIND_GT || kind === KIND_GE) return { kind: KIND_GE, bound: bound.ceil() };
|
|
350
|
+
return { kind, bound };
|
|
351
|
+
}
|
|
352
|
+
|
|
353
|
+
mkVarBound(column: number, kind: ConstraintKind, rhs: Rational) {
|
|
354
|
+
const adjusted = this.adjustBoundForInt(column, kind, rhs);
|
|
355
|
+
return this.constraints.add(column, adjusted.kind, new Impq(adjusted.bound));
|
|
356
|
+
}
|
|
357
|
+
|
|
358
|
+
// constraint_is_redundant: the current bound of the column is at least as strong.
|
|
359
|
+
constraintIsRedundant(index: number) {
|
|
360
|
+
const constraint = this.constraints.constraints[index];
|
|
361
|
+
const column = constraint.column;
|
|
362
|
+
const rhs = constraint.rhs;
|
|
363
|
+
if (this.isInt(column) && !rhs.x.isInt()) return false;
|
|
364
|
+
const kind = constraint.kind;
|
|
365
|
+
if (kind === KIND_LE || kind === KIND_LT) {
|
|
366
|
+
if (!this.core.hasUpperBound(column)) return false;
|
|
367
|
+
const upper = this.getUpperBound(column);
|
|
368
|
+
if (!upper.x.equals(rhs.x)) return upper.x.compare(rhs.x) < 0;
|
|
369
|
+
const shifted = kind === KIND_LT ? upper.y.add(Rational.one) : upper.y;
|
|
370
|
+
return shifted.compare(rhs.y) <= 0;
|
|
371
|
+
}
|
|
372
|
+
if (kind === KIND_GE || kind === KIND_GT) {
|
|
373
|
+
if (!this.core.hasLowerBound(column)) return false;
|
|
374
|
+
const lower = this.getLowerBound(column);
|
|
375
|
+
if (!lower.x.equals(rhs.x)) return lower.x.compare(rhs.x) > 0;
|
|
376
|
+
const shifted = kind === KIND_GT ? rhs.y.add(Rational.one) : rhs.y;
|
|
377
|
+
return shifted.compare(lower.y) <= 0;
|
|
378
|
+
}
|
|
379
|
+
return false;
|
|
380
|
+
}
|
|
381
|
+
|
|
382
|
+
activate(index: number) {
|
|
383
|
+
this.constraints.activate(index);
|
|
384
|
+
const constraint = this.constraints.constraints[index];
|
|
385
|
+
this.updateColumnTypeAndBound(
|
|
386
|
+
constraint.column,
|
|
387
|
+
constraint.kind,
|
|
388
|
+
constraint.rhs,
|
|
389
|
+
constraint.dep,
|
|
390
|
+
);
|
|
391
|
+
}
|
|
392
|
+
|
|
393
|
+
// activate_check_on_equal: also the other column fixed to the same value, if there is one.
|
|
394
|
+
activateCheckOnEqual(index: number) {
|
|
395
|
+
this.activate(index);
|
|
396
|
+
const column = this.constraints.constraints[index].column;
|
|
397
|
+
if (!this.isFixed(column)) return NULL_LPVAR;
|
|
398
|
+
const bound = this.getLowerBound(column);
|
|
399
|
+
if (!bound.y.isZero()) return NULL_LPVAR;
|
|
400
|
+
const key = bound.x.toString();
|
|
401
|
+
const table = this.isInt(column) ? this.fixedVarTableInt : this.fixedVarTableReal;
|
|
402
|
+
const other = table.get(key);
|
|
403
|
+
if (other === undefined) {
|
|
404
|
+
table.set(key, column);
|
|
405
|
+
return NULL_LPVAR;
|
|
406
|
+
}
|
|
407
|
+
return other !== column && this.isFixed(other) ? other : NULL_LPVAR;
|
|
408
|
+
}
|
|
409
|
+
|
|
410
|
+
findInFixedTables(value: Rational, isInt: boolean) {
|
|
411
|
+
return (isInt ? this.fixedVarTableInt : this.fixedVarTableReal).get(value.toString());
|
|
412
|
+
}
|
|
413
|
+
|
|
414
|
+
updateColumnTypeAndBound(column: number, inputKind: ConstraintKind, rhs: Impq, dep: Dependency) {
|
|
415
|
+
const adjusted = this.adjustBoundForInt(column, inputKind, rhs.x);
|
|
416
|
+
const kind = adjusted.kind;
|
|
417
|
+
const core = this.core;
|
|
418
|
+
const hasUpper = core.hasUpperBound(column);
|
|
419
|
+
const hasLower = core.hasLowerBound(column);
|
|
420
|
+
const setType = (type: ColumnType) => core.columnTypes.set(column, type);
|
|
421
|
+
const isUpperKind = kind === KIND_LE || kind === KIND_LT;
|
|
422
|
+
const isLowerKind = kind === KIND_GE || kind === KIND_GT;
|
|
423
|
+
const y =
|
|
424
|
+
kind === KIND_LT
|
|
425
|
+
? rhs.y.sub(Rational.one)
|
|
426
|
+
: kind === KIND_GT
|
|
427
|
+
? rhs.y.add(Rational.one)
|
|
428
|
+
: rhs.y;
|
|
429
|
+
const bound = new Impq(adjusted.bound, kind === KIND_EQ ? Rational.zero : y);
|
|
430
|
+
const lower = this.getLowerBound(column);
|
|
431
|
+
const upper = this.getUpperBound(column);
|
|
432
|
+
if (isUpperKind) {
|
|
433
|
+
if (hasLower && bound.compare(lower) < 0) this.setCrossedBounds(column, true, dep);
|
|
434
|
+
else if (!hasUpper || bound.compare(upper) < 0) {
|
|
435
|
+
this.setUpperBoundWitness(column, dep, bound);
|
|
436
|
+
if (!hasUpper)
|
|
437
|
+
setType(hasLower ? (bound.equals(lower) ? COLUMN_FIXED : COLUMN_BOXED) : COLUMN_UPPER);
|
|
438
|
+
}
|
|
439
|
+
} else if (isLowerKind) {
|
|
440
|
+
if (hasUpper && bound.compare(upper) > 0) this.setCrossedBounds(column, false, dep);
|
|
441
|
+
else if (!hasLower || bound.compare(lower) >= 0) {
|
|
442
|
+
this.setLowerBoundWitness(column, dep, bound);
|
|
443
|
+
if (hasUpper) setType(bound.equals(upper) ? COLUMN_FIXED : COLUMN_BOXED);
|
|
444
|
+
else if (!hasLower) setType(COLUMN_LOWER);
|
|
445
|
+
}
|
|
446
|
+
} else if (kind === KIND_EQ) {
|
|
447
|
+
if (hasUpper && bound.compare(upper) > 0) this.setCrossedBounds(column, false, dep);
|
|
448
|
+
else if (hasLower && bound.compare(lower) < 0) this.setCrossedBounds(column, true, dep);
|
|
449
|
+
else {
|
|
450
|
+
this.setUpperBoundWitness(column, dep, bound);
|
|
451
|
+
this.setLowerBoundWitness(column, dep, bound);
|
|
452
|
+
setType(COLUMN_FIXED);
|
|
453
|
+
}
|
|
454
|
+
}
|
|
455
|
+
if (hasUpper && hasLower && this.getLowerBound(column).equals(this.getUpperBound(column)))
|
|
456
|
+
setType(COLUMN_FIXED);
|
|
457
|
+
if (this.isBase(column) && this.isFixed(column)) this.fixedBaseVarSet.add(column);
|
|
458
|
+
this.onColumnBoundUpdate?.(column);
|
|
459
|
+
}
|
|
460
|
+
|
|
461
|
+
addTouchedRow(rowIndex: number) {
|
|
462
|
+
this.touchedRows.add(rowIndex);
|
|
463
|
+
}
|
|
464
|
+
|
|
465
|
+
addColumnRowsToTouchedRows(column: number) {
|
|
466
|
+
for (const cell of this.core.matrix.columns[column]) this.addTouchedRow(cell.row);
|
|
467
|
+
}
|
|
468
|
+
|
|
469
|
+
// Solving.
|
|
470
|
+
|
|
471
|
+
private changeBasicColumnsDependingOn(column: number, delta: Impq) {
|
|
472
|
+
const core = this.core;
|
|
473
|
+
for (const cell of core.matrix.columns[column])
|
|
474
|
+
core.submulFromXAndTrackFeasibility(core.basis[cell.row], delta, core.matrix.getVal(cell));
|
|
475
|
+
}
|
|
476
|
+
|
|
477
|
+
setValueForNbasicColumn(column: number, value: Impq) {
|
|
478
|
+
const delta = value.sub(this.core.x[column]);
|
|
479
|
+
this.core.x[column] = value;
|
|
480
|
+
this.changeBasicColumnsDependingOn(column, delta);
|
|
481
|
+
}
|
|
482
|
+
|
|
483
|
+
findFeasibleSolution() {
|
|
484
|
+
this.settings.stats.makeFeasible++;
|
|
485
|
+
if (this.status === LP_INFEASIBLE) return this.status;
|
|
486
|
+
const core = this.core;
|
|
487
|
+
for (const column of this.columnsWithChangedBounds.elems) {
|
|
488
|
+
if (core.isBase(column)) {
|
|
489
|
+
core.trackColumnFeasibility(column);
|
|
490
|
+
continue;
|
|
491
|
+
}
|
|
492
|
+
const delta = core.makeColumnFeasible(column);
|
|
493
|
+
if (delta !== undefined) this.changeBasicColumnsDependingOn(column, delta);
|
|
494
|
+
}
|
|
495
|
+
core.solve();
|
|
496
|
+
this.status = core.status;
|
|
497
|
+
if (this.status === LP_INFEASIBLE || this.status === LP_CANCELLED) return this.status;
|
|
498
|
+
for (const column of this.columnsWithChangedBounds.elems) {
|
|
499
|
+
if (core.isBase(column)) this.addTouchedRow(core.heading[column]);
|
|
500
|
+
else this.addColumnRowsToTouchedRows(column);
|
|
501
|
+
}
|
|
502
|
+
this.onChangedBounds?.(this.columnsWithChangedBounds);
|
|
503
|
+
this.columnsWithChangedBounds.clear();
|
|
504
|
+
return this.status;
|
|
505
|
+
}
|
|
506
|
+
|
|
507
|
+
// get_infeasibility_explanation: the crossed bounds, or the bounds of the infeasible row.
|
|
508
|
+
getInfeasibilityExplanation(explanation: Explanation) {
|
|
509
|
+
explanation.clear();
|
|
510
|
+
if (this.crossedBoundsColumn !== NULL_LPVAR) {
|
|
511
|
+
for (const constraint of linearize([this.crossedBoundsDeps]))
|
|
512
|
+
explanation.addPair(constraint, Rational.minusOne);
|
|
513
|
+
return;
|
|
514
|
+
}
|
|
515
|
+
const core = this.core;
|
|
516
|
+
const sign = core.infeasibleSumSign;
|
|
517
|
+
if (sign === 0) return;
|
|
518
|
+
for (const entry of core.infeasibleCombination) {
|
|
519
|
+
const adjustedSign = entry[0].isPositive() ? sign : -sign;
|
|
520
|
+
const info = this.columns[entry[1]];
|
|
521
|
+
const dep = adjustedSign < 0 ? info.upperWitness : info.lowerWitness;
|
|
522
|
+
for (const constraint of linearize([dep])) explanation.addPair(constraint, entry[0]);
|
|
523
|
+
}
|
|
524
|
+
}
|
|
525
|
+
|
|
526
|
+
// remove_fixed_vars_from_base: pivots fixed basic columns out of the basis.
|
|
527
|
+
removeFixedVarsFromBase() {
|
|
528
|
+
const core = this.core;
|
|
529
|
+
const columnCount = this.getColumnCount();
|
|
530
|
+
const toRemove: number[] = [];
|
|
531
|
+
core.withoutTouchedRows(() => {
|
|
532
|
+
for (const column of this.fixedBaseVarSet.elems) {
|
|
533
|
+
if (column >= columnCount || !this.isBase(column) || !this.isFixed(column)) {
|
|
534
|
+
toRemove.push(column);
|
|
535
|
+
continue;
|
|
536
|
+
}
|
|
537
|
+
for (const cell of core.matrix.rows[core.heading[column]]) {
|
|
538
|
+
if (this.isFixed(cell.column)) continue;
|
|
539
|
+
core.pivot(cell.column, column);
|
|
540
|
+
toRemove.push(column);
|
|
541
|
+
break;
|
|
542
|
+
}
|
|
543
|
+
}
|
|
544
|
+
});
|
|
545
|
+
for (const column of toRemove) this.fixedBaseVarSet.delete(column);
|
|
546
|
+
}
|
|
547
|
+
|
|
548
|
+
// remove_from_basis: pivots a basic column with the first non-fixed column of its row.
|
|
549
|
+
removeFromBasis(column: number) {
|
|
550
|
+
const core = this.core;
|
|
551
|
+
for (const cell of core.matrix.rows[core.heading[column]]) {
|
|
552
|
+
if (cell.column === column || this.isFixed(cell.column)) continue;
|
|
553
|
+
core.pivot(cell.column, column);
|
|
554
|
+
return true;
|
|
555
|
+
}
|
|
556
|
+
return false;
|
|
557
|
+
}
|
|
558
|
+
|
|
559
|
+
insideBounds(column: number, value: Impq) {
|
|
560
|
+
const core = this.core;
|
|
561
|
+
if (core.hasUpperBound(column) && value.compare(core.upperBounds[column]) > 0) return false;
|
|
562
|
+
return !(core.hasLowerBound(column) && value.compare(core.lowerBounds[column]) < 0);
|
|
563
|
+
}
|
|
564
|
+
|
|
565
|
+
// try_to_patch: sets a column to a value unless the column or a basic column it moves is blocked,
|
|
566
|
+
// reporting each changed column.
|
|
567
|
+
tryToPatch(
|
|
568
|
+
column: number,
|
|
569
|
+
value: Rational,
|
|
570
|
+
isBlocked: (column: number, value: Impq) => boolean,
|
|
571
|
+
changeReport: (column: number) => void,
|
|
572
|
+
) {
|
|
573
|
+
const core = this.core;
|
|
574
|
+
if (this.isBase(column) && !this.removeFromBasis(column)) return false;
|
|
575
|
+
const target = new Impq(value);
|
|
576
|
+
if (isBlocked(column, target)) return false;
|
|
577
|
+
const delta = core.x[column].sub(target);
|
|
578
|
+
for (const cell of core.matrix.columns[column]) {
|
|
579
|
+
const basic = core.basis[cell.row];
|
|
580
|
+
if (isBlocked(basic, delta.mul(core.matrix.getVal(cell)).add(core.x[basic]))) return false;
|
|
581
|
+
}
|
|
582
|
+
const change = target.sub(core.x[column]);
|
|
583
|
+
core.x[column] = target;
|
|
584
|
+
changeReport(column);
|
|
585
|
+
for (const cell of core.matrix.columns[column]) {
|
|
586
|
+
const basic = core.basis[cell.row];
|
|
587
|
+
core.addDeltaToXAndTrackFeasibility(basic, change.mul(core.matrix.getVal(cell).neg()));
|
|
588
|
+
changeReport(basic);
|
|
589
|
+
}
|
|
590
|
+
return true;
|
|
591
|
+
}
|
|
592
|
+
|
|
593
|
+
moveNonBasicColumnsToBounds() {
|
|
594
|
+
const core = this.core;
|
|
595
|
+
let isChanged = false;
|
|
596
|
+
for (const column of core.nbasis) if (this.moveNonBasicColumnToBounds(column)) isChanged = true;
|
|
597
|
+
if (isChanged) this.findFeasibleSolution();
|
|
598
|
+
}
|
|
599
|
+
|
|
600
|
+
private moveNonBasicColumnToBounds(column: number) {
|
|
601
|
+
const core = this.core;
|
|
602
|
+
const value = core.x[column];
|
|
603
|
+
const lower = core.lowerBounds[column];
|
|
604
|
+
const upper = core.upperBounds[column];
|
|
605
|
+
switch (core.getColumnType(column)) {
|
|
606
|
+
case COLUMN_BOXED:
|
|
607
|
+
if (value.equals(lower) || value.equals(upper)) return false;
|
|
608
|
+
this.setValueForNbasicColumn(column, lower);
|
|
609
|
+
return true;
|
|
610
|
+
case COLUMN_LOWER:
|
|
611
|
+
if (value.equals(lower)) return false;
|
|
612
|
+
this.setValueForNbasicColumn(column, lower);
|
|
613
|
+
return true;
|
|
614
|
+
case COLUMN_FIXED:
|
|
615
|
+
case COLUMN_UPPER:
|
|
616
|
+
if (value.equals(upper)) return false;
|
|
617
|
+
this.setValueForNbasicColumn(column, upper);
|
|
618
|
+
return true;
|
|
619
|
+
default:
|
|
620
|
+
if (!this.isInt(column) || value.isInt()) return false;
|
|
621
|
+
this.setValueForNbasicColumn(column, new Impq(value.floor()));
|
|
622
|
+
return true;
|
|
623
|
+
}
|
|
624
|
+
}
|
|
625
|
+
|
|
626
|
+
hasInfInt() {
|
|
627
|
+
for (let column = 0; column < this.getColumnCount(); column++)
|
|
628
|
+
if (this.isInt(column) && !this.core.x[column].isInt()) return true;
|
|
629
|
+
return false;
|
|
630
|
+
}
|
|
631
|
+
|
|
632
|
+
// The model.
|
|
633
|
+
|
|
634
|
+
// init_model: a δ that keeps strict bounds strict and distinct values distinct.
|
|
635
|
+
initModel() {
|
|
636
|
+
if (this.status !== LP_OPTIMAL && this.status !== LP_FEASIBLE) return false;
|
|
637
|
+
if (this.columnsWithChangedBounds.size > 0) return false;
|
|
638
|
+
const core = this.core;
|
|
639
|
+
let delta = Rational.one;
|
|
640
|
+
const updateDelta = (low: Impq, high: Impq) => {
|
|
641
|
+
if (low.x.compare(high.x) < 0 && low.y.compare(high.y) > 0) {
|
|
642
|
+
const candidate = high.x.sub(low.x).div(low.y.sub(high.y));
|
|
643
|
+
if (candidate.compare(delta) < 0) delta = candidate;
|
|
644
|
+
}
|
|
645
|
+
};
|
|
646
|
+
for (let column = 0; column < this.getColumnCount(); column++) {
|
|
647
|
+
if (core.hasLowerBound(column)) updateDelta(core.lowerBounds[column], core.x[column]);
|
|
648
|
+
if (core.hasUpperBound(column)) updateDelta(core.x[column], core.upperBounds[column]);
|
|
649
|
+
}
|
|
650
|
+
const pairs = new Map<string, Impq>();
|
|
651
|
+
for (const value of core.x) pairs.set(value.toString(), value);
|
|
652
|
+
for (;;) {
|
|
653
|
+
const singles = new Set<string>();
|
|
654
|
+
for (const value of pairs.values()) singles.add(value.x.add(delta.mul(value.y)).toString());
|
|
655
|
+
if (singles.size === pairs.size) break;
|
|
656
|
+
delta = delta.div(Rational.of(2n));
|
|
657
|
+
}
|
|
658
|
+
this.delta = delta;
|
|
659
|
+
return true;
|
|
660
|
+
}
|
|
661
|
+
|
|
662
|
+
getModelValue(column: number) {
|
|
663
|
+
const value = this.core.x[column];
|
|
664
|
+
return value.x.add(this.delta.mul(value.y));
|
|
665
|
+
}
|
|
666
|
+
|
|
667
|
+
// has_value: the value of a column, or of the term of a column, when δ does not occur in it.
|
|
668
|
+
getExactValue(column: number) {
|
|
669
|
+
const term = this.columns[column].term;
|
|
670
|
+
if (term === null) {
|
|
671
|
+
const value = this.core.x[column];
|
|
672
|
+
return value.y.isZero() ? value.x : undefined;
|
|
673
|
+
}
|
|
674
|
+
let result = Rational.zero;
|
|
675
|
+
for (const entry of term.coeffs) {
|
|
676
|
+
const value = this.core.x[entry[0]];
|
|
677
|
+
if (!value.y.isZero()) return undefined;
|
|
678
|
+
result = result.add(value.x.mul(entry[1]));
|
|
679
|
+
}
|
|
680
|
+
return result;
|
|
681
|
+
}
|
|
682
|
+
|
|
683
|
+
// has_lower_bound and has_upper_bound: the witness, value and strictness of a bound.
|
|
684
|
+
getBound(column: number, isUpper: boolean) {
|
|
685
|
+
if (column >= this.columns.length) return undefined;
|
|
686
|
+
const info = this.columns[column];
|
|
687
|
+
const dep = isUpper ? info.upperWitness : info.lowerWitness;
|
|
688
|
+
if (dep === null) return undefined;
|
|
689
|
+
const bound = isUpper ? this.core.upperBounds[column] : this.core.lowerBounds[column];
|
|
690
|
+
return {
|
|
691
|
+
dep,
|
|
692
|
+
value: bound.x,
|
|
693
|
+
isStrict: isUpper ? bound.y.isNegative() : bound.y.isPositive(),
|
|
694
|
+
};
|
|
695
|
+
}
|
|
696
|
+
|
|
697
|
+
// get_rid_of_inf_eps: the values with δ instantiated small enough to keep strict bounds strict.
|
|
698
|
+
getRidOfInfEps() {
|
|
699
|
+
const core = this.core;
|
|
700
|
+
const columnCount = this.getColumnCount();
|
|
701
|
+
if (core.x.slice(0, columnCount).every((value) => value.y.isZero())) return;
|
|
702
|
+
let delta = Rational.one;
|
|
703
|
+
const updateDelta = (low: Impq, high: Impq) => {
|
|
704
|
+
if (low.x.compare(high.x) < 0 && low.y.compare(high.y) > 0) {
|
|
705
|
+
const candidate = high.x.sub(low.x).div(low.y.sub(high.y));
|
|
706
|
+
if (candidate.compare(delta) < 0) delta = candidate;
|
|
707
|
+
}
|
|
708
|
+
};
|
|
709
|
+
for (let column = 0; column < columnCount; column++) {
|
|
710
|
+
if (core.hasLowerBound(column)) updateDelta(core.lowerBounds[column], core.x[column]);
|
|
711
|
+
if (core.hasUpperBound(column)) updateDelta(core.x[column], core.upperBounds[column]);
|
|
712
|
+
}
|
|
713
|
+
for (let column = 0; column < columnCount; column++) {
|
|
714
|
+
const value = core.x[column];
|
|
715
|
+
if (!value.y.isZero()) core.x[column] = new Impq(value.x.add(delta.mul(value.y)));
|
|
716
|
+
}
|
|
717
|
+
}
|
|
718
|
+
|
|
719
|
+
// get_bound_constraint_witnesses_for_column: the witnesses of both bounds.
|
|
720
|
+
getBoundWitnesses(column: number) {
|
|
721
|
+
return mkJoin(this.columns[column].lowerWitness, this.columns[column].upperWitness);
|
|
722
|
+
}
|
|
723
|
+
|
|
724
|
+
// collect_more_rows_for_lp_propagation: the rows of the columns whose bounds nla changed.
|
|
725
|
+
collectMoreRowsForLpPropagation() {
|
|
726
|
+
for (const column of this.columnsWithChangedBounds.elems) {
|
|
727
|
+
if (this.core.isBase(column)) this.addTouchedRow(this.core.heading[column]);
|
|
728
|
+
else this.addColumnRowsToTouchedRows(column);
|
|
729
|
+
}
|
|
730
|
+
}
|
|
731
|
+
|
|
732
|
+
getLowerWitness(column: number) {
|
|
733
|
+
return this.columns[column].lowerWitness;
|
|
734
|
+
}
|
|
735
|
+
|
|
736
|
+
getUpperWitness(column: number) {
|
|
737
|
+
return this.columns[column].upperWitness;
|
|
738
|
+
}
|
|
739
|
+
|
|
740
|
+
// Scopes.
|
|
741
|
+
|
|
742
|
+
pushTrail(undo: () => void) {
|
|
743
|
+
this.trail.push(undo);
|
|
744
|
+
}
|
|
745
|
+
|
|
746
|
+
push() {
|
|
747
|
+
this.trailScopes.push(this.trail.length);
|
|
748
|
+
this.crossedBoundsColumn = NULL_LPVAR;
|
|
749
|
+
this.crossedBoundsDeps = null;
|
|
750
|
+
this.core.pushScope();
|
|
751
|
+
this.constraints.pushScope();
|
|
752
|
+
this.usageInTerms.pushScope();
|
|
753
|
+
}
|
|
754
|
+
|
|
755
|
+
pop(count: number) {
|
|
756
|
+
this.crossedBoundsColumn = NULL_LPVAR;
|
|
757
|
+
this.crossedBoundsDeps = null;
|
|
758
|
+
const trailSize = this.trailScopes[this.trailScopes.length - count];
|
|
759
|
+
shrink(this.trailScopes, this.trailScopes.length - count);
|
|
760
|
+
while (this.trail.length > trailSize) this.trail.pop()?.();
|
|
761
|
+
const columnCount = this.columns.length;
|
|
762
|
+
for (let column = this.localToExternal.length; column-- > columnCount;) {
|
|
763
|
+
const external = this.localToExternal[column];
|
|
764
|
+
if (external !== NULL_LPVAR) this.externalToLocal.delete(external);
|
|
765
|
+
}
|
|
766
|
+
shrink(this.localToExternal, columnCount);
|
|
767
|
+
shrink(this.localIsInt, columnCount);
|
|
768
|
+
this.core.popScope(count);
|
|
769
|
+
for (const table of [this.fixedVarTableInt, this.fixedVarTableReal])
|
|
770
|
+
for (const entry of table)
|
|
771
|
+
if (entry[1] >= columnCount || !this.isFixed(entry[1])) table.delete(entry[0]);
|
|
772
|
+
for (const rowIndex of this.rowBoundsToReplay) this.addTouchedRow(rowIndex);
|
|
773
|
+
this.rowBoundsToReplay = [];
|
|
774
|
+
const rowCount = this.getRowCount();
|
|
775
|
+
for (const rowIndex of this.touchedRows.elems.filter((row) => row >= rowCount))
|
|
776
|
+
this.touchedRows.delete(rowIndex);
|
|
777
|
+
this.cleanInfHeapAfterPop();
|
|
778
|
+
this.constraints.popScope(count);
|
|
779
|
+
this.usageInTerms.popScope(count);
|
|
780
|
+
this.status = LP_UNKNOWN;
|
|
781
|
+
}
|
|
782
|
+
|
|
783
|
+
private cleanInfHeapAfterPop() {
|
|
784
|
+
const core = this.core;
|
|
785
|
+
const columnCount = this.getColumnCount();
|
|
786
|
+
for (const column of [...core.infHeap].filter((value) => value >= columnCount))
|
|
787
|
+
core.infHeap.erase(column);
|
|
788
|
+
const becameFeasible: number[] = [];
|
|
789
|
+
for (const column of Array.from(core.infHeap)) {
|
|
790
|
+
if (core.isBase(column)) continue;
|
|
791
|
+
const delta = core.makeColumnFeasible(column);
|
|
792
|
+
if (delta !== undefined) this.changeBasicColumnsDependingOn(column, delta);
|
|
793
|
+
becameFeasible.push(column);
|
|
794
|
+
}
|
|
795
|
+
for (const column of becameFeasible) if (core.infHeap.has(column)) core.infHeap.erase(column);
|
|
796
|
+
for (const column of Array.from(core.infHeap))
|
|
797
|
+
if (core.columnIsFeasible(column)) core.infHeap.erase(column);
|
|
798
|
+
}
|
|
799
|
+
|
|
800
|
+
// add_equality: the term j - k bounded above and below by 0.
|
|
801
|
+
addEquality(first: number, second: number) {
|
|
802
|
+
const column = this.addTerm(
|
|
803
|
+
[
|
|
804
|
+
[first, Rational.one],
|
|
805
|
+
[second, Rational.minusOne],
|
|
806
|
+
],
|
|
807
|
+
NULL_LPVAR,
|
|
808
|
+
);
|
|
809
|
+
if (!this.getValue(first).equals(this.getValue(second))) this.status = LP_UNKNOWN;
|
|
810
|
+
const le = this.mkVarBound(column, KIND_LE, Rational.zero);
|
|
811
|
+
this.activate(le);
|
|
812
|
+
const ge = this.mkVarBound(column, KIND_GE, Rational.zero);
|
|
813
|
+
this.activate(ge);
|
|
814
|
+
return [le, ge];
|
|
815
|
+
}
|
|
816
|
+
}
|