tla-ts 0.0.10-dev.f16792fed → 0.0.10-dev.fdc173479
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 +2 -1
- package/dist/compile.cjs +6 -6
- package/dist/compile.js +10 -10
- package/dist/deciders.cjs +41 -37
- package/dist/deciders.js +41 -37
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +21 -4
- package/dist/index.d.ts +21 -4
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +1 -1
- package/dist/prove-worker.cjs +1 -1
- package/dist/prove-worker.js +1 -1
- package/dist/prove.cjs +2681 -425
- package/dist/prove.js +2681 -425
- package/dist/run.cjs +41 -42
- package/dist/run.js +41 -42
- package/dist/tlapm.cjs +2 -2
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +97 -89
- package/dist/transfer.js +97 -89
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +1 -1
- package/src/ast.ts +72 -39
- package/src/bags.ts +50 -29
- package/src/builtins.ts +8 -16
- package/src/check-failure.ts +118 -0
- package/src/check-trace.ts +321 -0
- package/src/check.ts +828 -770
- package/src/cli/options.ts +6 -31
- package/src/cli/runtime-invariants.ts +20 -56
- package/src/cli/shared.ts +1 -1
- package/src/cli/tlapm.ts +433 -70
- package/src/cli/tlc-arguments.ts +224 -212
- package/src/cli/tlc-output.ts +701 -0
- package/src/cli/tlc-usage.ts +1 -2
- package/src/cli/tlc.ts +65 -712
- package/src/cli/xml-exporter.ts +23 -33
- package/src/codegen.ts +28 -20
- package/src/coverage.ts +255 -20
- package/src/dependencies.ts +96 -27
- package/src/dfid.ts +115 -50
- package/src/environment-config.ts +315 -0
- package/src/environment.ts +175 -373
- package/src/errors.ts +40 -5
- package/src/evaluate.ts +429 -139
- package/src/exit-codes.ts +28 -12
- package/src/fingerprints.ts +65 -1
- package/src/instances.ts +178 -17
- package/src/java-hash.ts +14 -0
- package/src/java-overrides.ts +2 -2
- package/src/json.ts +4 -7
- package/src/levels.ts +708 -272
- package/src/lexer.ts +17 -5
- package/src/liveness-checker.ts +707 -249
- package/src/liveness.ts +148 -95
- package/src/obligations/action.ts +14 -17
- package/src/obligations/anonymize.ts +37 -16
- package/src/obligations/enabled-axioms.ts +218 -0
- package/src/obligations/equality.ts +1 -3
- package/src/obligations/expression.ts +36 -8
- package/src/obligations/format.ts +0 -2
- package/src/obligations/generate.ts +66 -54
- package/src/obligations/index.ts +39 -9
- package/src/obligations/levels.ts +24 -11
- package/src/obligations/module.ts +28 -41
- package/src/obligations/normalize.ts +27 -18
- package/src/obligations/operators.ts +0 -2
- package/src/obligations/pragma.ts +53 -16
- package/src/obligations/printer.ts +48 -18
- package/src/obligations/proof.ts +3 -2
- package/src/obligations/regroup.ts +0 -2
- package/src/obligations/simplify.ts +55 -50
- package/src/obligations/source.ts +120 -74
- package/src/obligations/subexpression.ts +45 -18
- package/src/obligations/substitution.ts +1 -3
- package/src/obligations/temporal.ts +5 -7
- package/src/obligations/tuples.ts +0 -2
- package/src/parallel-worker.ts +17 -31
- package/src/parallel.ts +29 -47
- package/src/parser.ts +757 -326
- package/src/pretty-print.ts +1 -1
- package/src/prover/decide-pool.ts +3 -3
- package/src/prover/deciders.ts +12 -9
- package/src/prover/isabelle/decide.ts +3 -25
- package/src/prover/isabelle/encode.ts +72 -42
- package/src/prover/isabelle/isar/attrib.ts +250 -0
- package/src/prover/isabelle/isar/context.ts +335 -0
- package/src/prover/isabelle/isar/induct.ts +382 -0
- package/src/prover/isabelle/isar/inner-syntax.ts +158 -7
- package/src/prover/isabelle/isar/method.ts +509 -212
- package/src/prover/isabelle/isar/proof.ts +570 -14
- package/src/prover/isabelle/isar/rule-cases.ts +226 -0
- package/src/prover/isabelle/isar/theory.ts +487 -76
- package/src/prover/isabelle/isar/toplevel.ts +331 -0
- package/src/prover/isabelle/isar/type-check.ts +89 -14
- package/src/prover/isabelle/provers/blast/blast.ts +7 -65
- package/src/prover/isabelle/provers/blast/branch.ts +0 -2
- package/src/prover/isabelle/provers/blast/prove.ts +0 -2
- package/src/prover/isabelle/provers/blast/rules.ts +0 -2
- package/src/prover/isabelle/provers/blast/state.ts +0 -2
- package/src/prover/isabelle/provers/blast/term.ts +0 -2
- package/src/prover/isabelle/provers/clasimp.ts +1 -3
- package/src/prover/isabelle/provers/classical.ts +45 -20
- package/src/prover/isabelle/provers/hypsubst.ts +19 -30
- package/src/prover/isabelle/pure/bicompose.ts +9 -27
- package/src/prover/isabelle/pure/consts.ts +0 -2
- package/src/prover/isabelle/pure/conv.ts +2 -10
- package/src/prover/isabelle/pure/drule.ts +72 -6
- package/src/prover/isabelle/pure/envir.ts +0 -2
- package/src/prover/isabelle/pure/goal.ts +1 -3
- package/src/prover/isabelle/pure/logic.ts +1 -3
- package/src/prover/isabelle/pure/name.ts +0 -2
- package/src/prover/isabelle/pure/net.ts +0 -2
- package/src/prover/isabelle/pure/object-logic.ts +13 -7
- package/src/prover/isabelle/pure/pattern.ts +0 -2
- package/src/prover/isabelle/pure/raw-simplifier.ts +4 -15
- package/src/prover/isabelle/pure/rewriter.ts +9 -20
- package/src/prover/isabelle/pure/search.ts +0 -2
- package/src/prover/isabelle/pure/seq.ts +0 -2
- package/src/prover/isabelle/pure/simplifier.ts +26 -7
- package/src/prover/isabelle/pure/table.ts +2 -3
- package/src/prover/isabelle/pure/tactic.ts +0 -2
- package/src/prover/isabelle/pure/tactical.ts +42 -37
- package/src/prover/isabelle/pure/term-ord.ts +0 -2
- package/src/prover/isabelle/pure/term.ts +3 -5
- package/src/prover/isabelle/pure/thm.ts +14 -13
- package/src/prover/isabelle/pure/type.ts +0 -2
- package/src/prover/isabelle/pure/unify.ts +0 -2
- package/src/prover/isabelle/pure/variable.ts +0 -2
- package/src/prover/isabelle/tla/classical-setup.ts +18 -16
- package/src/prover/isabelle/tla/context.ts +58 -11
- package/src/prover/isabelle/tla/logic-data.ts +1 -1
- package/src/prover/isabelle/tla/logic.ts +49 -21
- package/src/prover/isabelle/tla/simpdata.ts +1 -12
- package/src/prover/isabelle/tools/intuitionistic.ts +28 -12
- package/src/prover/ocaml.ts +4 -1
- package/src/prover/prep/action.ts +30 -31
- package/src/prover/prep/enabled-axioms.ts +11 -2
- package/src/prover/prep/fingerprint.ts +2 -5
- package/src/prover/prep/md5.ts +26 -29
- package/src/prover/prep/methods.ts +181 -51
- package/src/prover/prep/normalize.ts +38 -9
- package/src/prover/prove.ts +395 -94
- package/src/prover/ptl/decide.ts +95 -50
- package/src/prover/ptl/encode.ts +2 -3
- package/src/prover/ptl/tableau.ts +28 -2
- package/src/prover/smt/arithmetic.ts +310 -0
- package/src/prover/smt/axioms.ts +12 -8
- package/src/prover/smt/context.ts +43 -8
- package/src/prover/smt/data.ts +498 -379
- package/src/prover/smt/encode.ts +148 -57
- package/src/prover/smt/extensionality.ts +5 -3
- package/src/prover/smt/flatten.ts +4 -6
- package/src/prover/smt/format.ts +28 -4
- package/src/prover/smt/instances.ts +7 -1
- package/src/prover/smt/layout.ts +91 -0
- package/src/prover/smt/rewrite.ts +1016 -618
- package/src/prover/smt/simplify.ts +441 -0
- package/src/prover/smt/solver/ackermannize-bv-tactic.ts +62 -0
- package/src/prover/smt/solver/ackr-helper.ts +179 -0
- package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
- package/src/prover/smt/solver/act-cache.ts +0 -1
- package/src/prover/smt/solver/add-bounds-tactic.ts +59 -0
- package/src/prover/smt/solver/aig-tactic.ts +52 -0
- package/src/prover/smt/solver/aig.ts +889 -0
- package/src/prover/smt/solver/arith-rewriter.ts +624 -9
- package/src/prover/smt/solver/arith-terms.ts +121 -0
- package/src/prover/smt/solver/array-decl-plugin.ts +175 -0
- package/src/prover/smt/solver/array-rewriter.ts +319 -0
- package/src/prover/smt/solver/asserted-formulas.ts +240 -56
- package/src/prover/smt/solver/ast-lt.ts +165 -11
- package/src/prover/smt/solver/ast-util.ts +160 -2
- package/src/prover/smt/solver/ast.ts +1483 -45
- package/src/prover/smt/solver/auf-solver.ts +25 -18
- package/src/prover/smt/solver/bit-blast-tactic.ts +608 -0
- package/src/prover/smt/solver/bit-blaster.ts +871 -0
- package/src/prover/smt/solver/blast-term-ite.ts +47 -0
- package/src/prover/smt/solver/bound-manager.ts +196 -0
- package/src/prover/smt/solver/bound-simplifier.ts +598 -0
- package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
- package/src/prover/smt/solver/bv-decl-plugin.ts +341 -0
- package/src/prover/smt/solver/bv-divrem-bounds.ts +95 -0
- package/src/prover/smt/solver/bv-rewriter.ts +1901 -0
- package/src/prover/smt/solver/bv1-blast.ts +214 -0
- package/src/prover/smt/solver/bv2fpa-converter.ts +174 -0
- package/src/prover/smt/solver/bv2int-rewriter.ts +544 -0
- package/src/prover/smt/solver/bv2real-rewriter.ts +533 -0
- package/src/prover/smt/solver/card2bv.ts +127 -0
- package/src/prover/smt/solver/case-split-queue.ts +0 -2
- package/src/prover/smt/solver/cg-table.ts +39 -25
- package/src/prover/smt/solver/check-logic.ts +330 -0
- package/src/prover/smt/solver/clause.ts +0 -1
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +293 -0
- package/src/prover/smt/solver/conflict-resolution.ts +78 -2
- package/src/prover/smt/solver/context.ts +598 -128
- package/src/prover/smt/solver/ctx-simplify.ts +29 -14
- package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
- package/src/prover/smt/solver/datatype-decl-plugin.ts +580 -0
- package/src/prover/smt/solver/datatype-rewriter.ts +82 -0
- package/src/prover/smt/solver/demodulator.ts +786 -0
- package/src/prover/smt/solver/dependent-expr-state.ts +93 -0
- package/src/prover/smt/solver/der.ts +38 -10
- package/src/prover/smt/solver/diff-neq.ts +207 -0
- package/src/prover/smt/solver/distribute-forall.ts +57 -0
- package/src/prover/smt/solver/dom-simplify.ts +511 -0
- package/src/prover/smt/solver/dt2bv-tactic.ts +298 -0
- package/src/prover/smt/solver/dyn-ack.ts +0 -1
- package/src/prover/smt/solver/e-matching.ts +7 -8
- package/src/prover/smt/solver/elim-bounds.ts +89 -0
- package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
- package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
- package/src/prover/smt/solver/elim-uncnstr.ts +548 -0
- package/src/prover/smt/solver/enode.ts +100 -3
- package/src/prover/smt/solver/eq2bv-tactic.ts +227 -0
- package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
- package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
- package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
- package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
- package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
- package/src/prover/smt/solver/euf/array-solver.ts +306 -0
- package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
- package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
- package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
- package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
- package/src/prover/smt/solver/euf/egraph.ts +901 -0
- package/src/prover/smt/solver/euf/euf-solver.ts +1204 -0
- package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
- package/src/prover/smt/solver/euf/mam.ts +1046 -0
- package/src/prover/smt/solver/euf/q-ematch.ts +829 -0
- package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
- package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
- package/src/prover/smt/solver/euf/q-solver.ts +361 -0
- package/src/prover/smt/solver/euf/th-solver.ts +328 -0
- package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
- package/src/prover/smt/solver/expr-ref.ts +0 -1
- package/src/prover/smt/solver/expr-safe-replace.ts +26 -2
- package/src/prover/smt/solver/expr2polynomial.ts +271 -0
- package/src/prover/smt/solver/factor.ts +163 -0
- package/src/prover/smt/solver/fd-solver.ts +734 -0
- package/src/prover/smt/solver/fingerprints.ts +15 -15
- package/src/prover/smt/solver/fix-dl-var.ts +147 -0
- package/src/prover/smt/solver/flat-literals.ts +0 -1
- package/src/prover/smt/solver/fm-tactic.ts +886 -0
- package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
- package/src/prover/smt/solver/fpa-rewriter.ts +639 -0
- package/src/prover/smt/solver/fpa2bv-converter.ts +2251 -0
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +349 -0
- package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
- package/src/prover/smt/solver/goal.ts +178 -15
- package/src/prover/smt/solver/goal2nlsat.ts +216 -0
- package/src/prover/smt/solver/guard-set.ts +219 -0
- package/src/prover/smt/solver/hash.ts +0 -1
- package/src/prover/smt/solver/hashtable.ts +34 -16
- package/src/prover/smt/solver/inf-eps.ts +63 -0
- package/src/prover/smt/solver/inj-axiom.ts +101 -0
- package/src/prover/smt/solver/internalizer.ts +111 -39
- package/src/prover/smt/solver/lackr.ts +381 -0
- package/src/prover/smt/solver/lbool.ts +0 -1
- package/src/prover/smt/solver/lia2card.ts +268 -0
- package/src/prover/smt/solver/lia2pb.ts +154 -0
- package/src/prover/smt/solver/literal.ts +0 -1
- package/src/prover/smt/solver/logic-tactics.ts +355 -0
- package/src/prover/smt/solver/lp/bound-propagator.ts +0 -1
- package/src/prover/smt/solver/lp/constraints.ts +0 -1
- package/src/prover/smt/solver/lp/containers.ts +7 -2
- package/src/prover/smt/solver/lp/core-solver.ts +30 -11
- package/src/prover/smt/solver/lp/cross-nested.ts +1 -4
- package/src/prover/smt/solver/lp/dep-intervals.ts +0 -3
- package/src/prover/smt/solver/lp/dependency.ts +0 -2
- package/src/prover/smt/solver/lp/dioph-eq.ts +1 -10
- package/src/prover/smt/solver/lp/explanation.ts +0 -1
- package/src/prover/smt/solver/lp/gomory.ts +0 -1
- package/src/prover/smt/solver/lp/hnf-cutter.ts +1 -2
- package/src/prover/smt/solver/lp/hnf.ts +0 -3
- package/src/prover/smt/solver/lp/int-cube.ts +3 -4
- package/src/prover/smt/solver/lp/int-solver.ts +0 -2
- package/src/prover/smt/solver/lp/lar-solver.ts +41 -5
- package/src/prover/smt/solver/lp/lar-term.ts +0 -1
- package/src/prover/smt/solver/lp/lp-settings.ts +6 -3
- package/src/prover/smt/solver/lp/maximize-term.ts +59 -10
- package/src/prover/smt/solver/lp/nex-creator.ts +3 -3
- package/src/prover/smt/solver/lp/nex.ts +2 -2
- package/src/prover/smt/solver/lp/nla-backoff.ts +0 -2
- package/src/prover/smt/solver/lp/nla-basics.ts +46 -3
- package/src/prover/smt/solver/lp/nla-core.ts +68 -17
- package/src/prover/smt/solver/lp/nla-divisions.ts +0 -2
- package/src/prover/smt/solver/lp/nla-emonics.ts +0 -1
- package/src/prover/smt/solver/lp/nla-factorization.ts +0 -1
- package/src/prover/smt/solver/lp/nla-grobner.ts +167 -85
- package/src/prover/smt/solver/lp/nla-horner.ts +0 -2
- package/src/prover/smt/solver/lp/nla-intervals.ts +0 -1
- package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +0 -2
- package/src/prover/smt/solver/lp/nla-monotone.ts +0 -1
- package/src/prover/smt/solver/lp/nla-order.ts +0 -2
- package/src/prover/smt/solver/lp/nla-patcher.ts +0 -1
- package/src/prover/smt/solver/lp/nla-powers.ts +220 -0
- package/src/prover/smt/solver/lp/nla-tangents.ts +0 -2
- package/src/prover/smt/solver/lp/nla-throttle.ts +0 -1
- package/src/prover/smt/solver/lp/nla-transcendentals.ts +324 -0
- package/src/prover/smt/solver/lp/nla-types.ts +0 -2
- package/src/prover/smt/solver/lp/nla-var-eqs.ts +0 -1
- package/src/prover/smt/solver/lp/nra-solver.ts +163 -99
- package/src/prover/smt/solver/lp/numeric-pair.ts +0 -1
- package/src/prover/smt/solver/lp/pdd-interval.ts +6 -3
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -21
- package/src/prover/smt/solver/lp/pdd-solver.ts +72 -41
- package/src/prover/smt/solver/lp/pdd.ts +725 -290
- package/src/prover/smt/solver/lp/random-updater.ts +0 -2
- package/src/prover/smt/solver/lp/static-matrix.ts +0 -1
- package/src/prover/smt/solver/lp/union-find.ts +7 -2
- package/src/prover/smt/solver/macro-finder.ts +530 -0
- package/src/prover/smt/solver/mam-compiler.ts +122 -90
- package/src/prover/smt/solver/mam-interpreter.ts +0 -1
- package/src/prover/smt/solver/max-bv-sharing-tactic.ts +17 -0
- package/src/prover/smt/solver/max-cliques.ts +105 -0
- package/src/prover/smt/solver/maxcore.ts +310 -0
- package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -6
- package/src/prover/smt/solver/maxlex.ts +115 -0
- package/src/prover/smt/solver/maxsmt-base.ts +106 -0
- package/src/prover/smt/solver/maxsmt.ts +92 -0
- package/src/prover/smt/solver/mbp/mbp-arith.ts +467 -0
- package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +101 -0
- package/src/prover/smt/solver/mbp/mbp-plugin.ts +287 -0
- package/src/prover/smt/solver/mbp/mbp-qel.ts +48 -0
- package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +271 -0
- package/src/prover/smt/solver/mbp/mbp-term-graph.ts +606 -0
- package/src/prover/smt/solver/model-based-opt.ts +844 -0
- package/src/prover/smt/solver/model-checker.ts +19 -28
- package/src/prover/smt/solver/model-evaluator.ts +190 -12
- package/src/prover/smt/solver/model-finder.ts +12 -18
- package/src/prover/smt/solver/model-generator.ts +104 -35
- package/src/prover/smt/solver/model-macro-solver.ts +49 -46
- package/src/prover/smt/solver/model-printer.ts +214 -0
- package/src/prover/smt/solver/mpf.ts +709 -0
- package/src/prover/smt/solver/mus.ts +50 -0
- package/src/prover/smt/solver/muz/dl-context.ts +382 -0
- package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +97 -0
- package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +167 -0
- package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +125 -0
- package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +299 -0
- package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +455 -0
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +340 -0
- package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +163 -0
- package/src/prover/smt/solver/muz/dl-rule-set.ts +273 -0
- package/src/prover/smt/solver/muz/dl-rule-transformer.ts +123 -0
- package/src/prover/smt/solver/muz/dl-rule.ts +495 -0
- package/src/prover/smt/solver/muz/hnf.ts +201 -0
- package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
- package/src/prover/smt/solver/muz/horn-tactic.ts +214 -0
- package/src/prover/smt/solver/muz/rule-properties.ts +359 -0
- package/src/prover/smt/solver/muz/spacer-context.ts +1404 -0
- package/src/prover/smt/solver/muz/spacer-dl-interface.ts +52 -0
- package/src/prover/smt/solver/muz/spacer-generalizers.ts +241 -0
- package/src/prover/smt/solver/muz/spacer-manager.ts +127 -0
- package/src/prover/smt/solver/muz/spacer-pdr.ts +219 -0
- package/src/prover/smt/solver/muz/spacer-prop-solver.ts +333 -0
- package/src/prover/smt/solver/muz/spacer-util.ts +282 -0
- package/src/prover/smt/solver/muz/substitution.ts +203 -0
- package/src/prover/smt/solver/nla2bv-tactic.ts +285 -0
- package/src/prover/smt/solver/nlqsat.ts +485 -0
- package/src/prover/smt/solver/nlsat/algebraic.ts +315 -98
- package/src/prover/smt/solver/nlsat/atoms.ts +71 -38
- package/src/prover/smt/solver/nlsat/evaluator.ts +0 -1
- package/src/prover/smt/solver/nlsat/explain.ts +427 -229
- package/src/prover/smt/solver/nlsat/interval-set.ts +1 -2
- package/src/prover/smt/solver/nlsat/levelwise.ts +460 -246
- package/src/prover/smt/solver/nlsat/mpbq.ts +45 -1
- package/src/prover/smt/solver/nlsat/polynomial.ts +2376 -684
- package/src/prover/smt/solver/nlsat/solver.ts +293 -92
- package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
- package/src/prover/smt/solver/nlsat/transcendentals.ts +391 -0
- package/src/prover/smt/solver/nlsat/types.ts +0 -2
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +9 -8
- package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -20
- package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
- package/src/prover/smt/solver/nnf.ts +110 -24
- package/src/prover/smt/solver/normalize-bounds.ts +53 -0
- package/src/prover/smt/solver/occf.ts +97 -0
- package/src/prover/smt/solver/opt-context.ts +801 -0
- package/src/prover/smt/solver/opt-nlsat.ts +386 -0
- package/src/prover/smt/solver/opt-pareto.ts +301 -0
- package/src/prover/smt/solver/opt-preprocess.ts +101 -0
- package/src/prover/smt/solver/opt-solver.ts +312 -0
- package/src/prover/smt/solver/opt-value.ts +55 -0
- package/src/prover/smt/solver/optsmt.ts +692 -0
- package/src/prover/smt/solver/parallel-tactic.ts +299 -0
- package/src/prover/smt/solver/pattern-inference.ts +19 -11
- package/src/prover/smt/solver/pb-rewriter.ts +281 -0
- package/src/prover/smt/solver/pb2bv-tactic.ts +546 -0
- package/src/prover/smt/solver/poly-rewriter.ts +259 -57
- package/src/prover/smt/solver/probes.ts +577 -0
- package/src/prover/smt/solver/propagate-values.ts +37 -21
- package/src/prover/smt/solver/proto-model.ts +648 -19
- package/src/prover/smt/solver/pull-quant.ts +28 -12
- package/src/prover/smt/solver/purify-arith.ts +634 -0
- package/src/prover/smt/solver/push-app-ite.ts +37 -0
- package/src/prover/smt/solver/qe-arith-plugin.ts +1096 -0
- package/src/prover/smt/solver/qe-lite-der.ts +2 -3
- package/src/prover/smt/solver/qe-lite-fm.ts +3 -4
- package/src/prover/smt/solver/qe-lite.ts +39 -19
- package/src/prover/smt/solver/qe-mbp.ts +270 -0
- package/src/prover/smt/solver/qe.ts +1499 -0
- package/src/prover/smt/solver/qel.ts +25 -0
- package/src/prover/smt/solver/qi-queue.ts +0 -1
- package/src/prover/smt/solver/qsat.ts +829 -0
- package/src/prover/smt/solver/quant-hoist.ts +196 -0
- package/src/prover/smt/solver/quant-tactics.ts +16 -56
- package/src/prover/smt/solver/quantifier-analyzer.ts +19 -20
- package/src/prover/smt/solver/quantifier-manager.ts +22 -25
- package/src/prover/smt/solver/quasi-macros.ts +243 -0
- package/src/prover/smt/solver/random-gen.ts +0 -1
- package/src/prover/smt/solver/rational.ts +45 -1
- package/src/prover/smt/solver/recfun-decl-plugin.ts +262 -0
- package/src/prover/smt/solver/recfun-rewriter.ts +107 -0
- package/src/prover/smt/solver/reduce-args.ts +225 -0
- package/src/prover/smt/solver/reduce-bv-size.ts +119 -0
- package/src/prover/smt/solver/ref-vector.ts +0 -1
- package/src/prover/smt/solver/relevancy.ts +1 -2
- package/src/prover/smt/solver/rewriter-tpl.ts +82 -14
- package/src/prover/smt/solver/rewriter.ts +505 -60
- package/src/prover/smt/solver/rlimit.ts +45 -5
- package/src/prover/smt/solver/sat/asymm-branch.ts +325 -0
- package/src/prover/smt/solver/sat/big.ts +177 -0
- package/src/prover/smt/solver/sat/clause-use-list.ts +71 -0
- package/src/prover/smt/solver/sat/clause.ts +203 -0
- package/src/prover/smt/solver/sat/cleaner.ts +94 -0
- package/src/prover/smt/solver/sat/config.ts +122 -0
- package/src/prover/smt/solver/sat/consequences.ts +203 -0
- package/src/prover/smt/solver/sat/elim-eqs.ts +142 -0
- package/src/prover/smt/solver/sat/goal2sat.ts +589 -0
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +480 -0
- package/src/prover/smt/solver/sat/model-converter.ts +136 -0
- package/src/prover/smt/solver/sat/pb-constraint.ts +268 -0
- package/src/prover/smt/solver/sat/pb-solver.ts +1596 -0
- package/src/prover/smt/solver/sat/probing.ts +170 -0
- package/src/prover/smt/solver/sat/sat-tactic.ts +72 -0
- package/src/prover/smt/solver/sat/sat2goal.ts +190 -0
- package/src/prover/smt/solver/sat/scc.ts +142 -0
- package/src/prover/smt/solver/sat/simplifier.ts +1618 -0
- package/src/prover/smt/solver/sat/solver.ts +2107 -0
- package/src/prover/smt/solver/sat/var-queue.ts +117 -0
- package/src/prover/smt/solver/sat/watch-list.ts +140 -0
- package/src/prover/smt/solver/search-tree.ts +284 -0
- package/src/prover/smt/solver/seq-axioms.ts +995 -0
- package/src/prover/smt/solver/seq-decl-plugin.ts +819 -0
- package/src/prover/smt/solver/seq-derive.ts +1298 -0
- package/src/prover/smt/solver/seq-eq-approx.ts +236 -0
- package/src/prover/smt/solver/seq-eq-solver.ts +439 -0
- package/src/prover/smt/solver/seq-factory.ts +89 -0
- package/src/prover/smt/solver/seq-monadic.ts +730 -0
- package/src/prover/smt/solver/seq-range-predicate.ts +235 -0
- package/src/prover/smt/solver/seq-re-rewriter.ts +1171 -0
- package/src/prover/smt/solver/seq-re-util.ts +758 -0
- package/src/prover/smt/solver/seq-regex-bisim.ts +144 -0
- package/src/prover/smt/solver/seq-regex-live.ts +200 -0
- package/src/prover/smt/solver/seq-rewriter.ts +2404 -0
- package/src/prover/smt/solver/seq-skolem.ts +294 -0
- package/src/prover/smt/solver/seq-subset.ts +165 -0
- package/src/prover/smt/solver/seq-view-witness.ts +353 -0
- package/src/prover/smt/solver/smt-consequences.ts +297 -0
- package/src/prover/smt/solver/smt-kernel.ts +124 -0
- package/src/prover/smt/solver/smt-logics.ts +66 -0
- package/src/prover/smt/solver/smt-setup.ts +589 -0
- package/src/prover/smt/solver/smt2-printer.ts +765 -0
- package/src/prover/smt/solver/smtlib-parser.ts +3535 -360
- package/src/prover/smt/solver/smtlib-script.ts +2136 -0
- package/src/prover/smt/solver/solve-eqs.ts +928 -0
- package/src/prover/smt/solver/solver.ts +128 -23
- package/src/prover/smt/solver/static-features.ts +314 -0
- package/src/prover/smt/solver/sticky-generations.ts +0 -1
- package/src/prover/smt/solver/tactic.ts +2176 -0
- package/src/prover/smt/solver/term-enumeration.ts +205 -0
- package/src/prover/smt/solver/theory-array.ts +1240 -0
- package/src/prover/smt/solver/theory-bv.ts +1210 -0
- package/src/prover/smt/solver/theory-char.ts +355 -0
- package/src/prover/smt/solver/theory-datatype.ts +598 -0
- package/src/prover/smt/solver/theory-finite-set.ts +30 -0
- package/src/prover/smt/solver/theory-fpa.ts +389 -0
- package/src/prover/smt/solver/theory-lra-axioms.ts +53 -2
- package/src/prover/smt/solver/theory-lra-bounds.ts +31 -6
- package/src/prover/smt/solver/theory-lra-final-check.ts +57 -70
- package/src/prover/smt/solver/theory-lra-internalize.ts +96 -27
- package/src/prover/smt/solver/theory-lra-model.ts +20 -35
- package/src/prover/smt/solver/theory-lra-propagate.ts +35 -28
- package/src/prover/smt/solver/theory-lra-state.ts +7 -23
- package/src/prover/smt/solver/theory-lra.ts +189 -2
- package/src/prover/smt/solver/theory-pb.ts +951 -0
- package/src/prover/smt/solver/theory-polymorphism.ts +58 -0
- package/src/prover/smt/solver/theory-recfun.ts +307 -0
- package/src/prover/smt/solver/theory-seq-regex.ts +867 -0
- package/src/prover/smt/solver/theory-seq-solve.ts +1373 -0
- package/src/prover/smt/solver/theory-seq-state.ts +852 -0
- package/src/prover/smt/solver/theory-seq.ts +961 -0
- package/src/prover/smt/solver/theory-without-terms.ts +24 -0
- package/src/prover/smt/solver/theory.ts +189 -0
- package/src/prover/smt/solver/tseitin-cnf.ts +495 -0
- package/src/prover/smt/solver/var-subst.ts +36 -14
- package/src/prover/smt/table.ts +3 -2
- package/src/prover/smt/types.ts +146 -0
- package/src/prover/tlapm/cache.ts +57 -26
- package/src/prover/tlapm/tlapm.ts +15 -9
- package/src/prover/tlapm-library.ts +3208 -0
- package/src/prover/verdict.ts +9 -0
- package/src/prover/zenon/check/check.ts +1 -2
- package/src/prover/zenon/check/records.ts +1 -1
- package/src/prover/zenon/check/relations.ts +2 -1
- package/src/prover/zenon/check/rewrites.ts +2 -15
- package/src/prover/zenon/check/sets.ts +40 -58
- package/src/prover/zenon/check/terms.ts +1 -2
- package/src/prover/zenon/decide.ts +10 -7
- package/src/prover/zenon/encode.ts +0 -2
- package/src/prover/zenon/eqrel.ts +2 -2
- package/src/prover/zenon/equality-rules.ts +24 -2
- package/src/prover/zenon/expr.ts +28 -2
- package/src/prover/zenon/index-table.ts +16 -23
- package/src/prover/zenon/isar-case.ts +1 -3
- package/src/prover/zenon/isar.ts +37 -39
- package/src/prover/zenon/llproof.ts +2 -13
- package/src/prover/zenon/mltoll.ts +12 -30
- package/src/prover/zenon/node.ts +20 -5
- package/src/prover/zenon/parse.ts +9 -8
- package/src/prover/zenon/phrase.ts +1 -3
- package/src/prover/zenon/proof.ts +0 -2
- package/src/prover/zenon/propositional-rules.ts +0 -2
- package/src/prover/zenon/rules.ts +2 -3
- package/src/prover/zenon/search.ts +11 -19
- package/src/prover/zenon/tla/functions.ts +2 -4
- package/src/prover/zenon/tla/llproof.ts +9 -13
- package/src/prover/zenon/tla/records.ts +1 -8
- package/src/prover/zenon/tla/rewrites.ts +0 -2
- package/src/prover/zenon/tla/sets.ts +22 -22
- package/src/prover/zenon/tla/terms.ts +0 -2
- package/src/prover/zenon/tla/tla.ts +7 -8
- package/src/resolve.ts +1327 -328
- package/src/runtime.ts +25 -2
- package/src/sany/builtins.ts +10 -10
- package/src/sany/generation.ts +384 -0
- package/src/sany/generator-def-entries.ts +297 -0
- package/src/sany/generator-definitions.ts +688 -0
- package/src/sany/generator-expressions.ts +1123 -0
- package/src/sany/generator-proofs.ts +668 -0
- package/src/sany/generator.ts +161 -2625
- package/src/sany/levels.ts +0 -2
- package/src/sany/lexer.ts +32 -23
- package/src/sany/linter.ts +0 -2
- package/src/sany/modules.ts +4 -2
- package/src/sany/nodes.ts +3 -4
- package/src/sany/report.ts +3 -6
- package/src/sany/selectors.ts +46 -44
- package/src/sany/xml.ts +25 -58
- package/src/search.ts +513 -165
- package/src/simulate.ts +340 -251
- package/src/spec-description.ts +48 -55
- package/src/standard-definitions.ts +5 -0
- package/src/standard-modules.ts +72 -54
- package/src/state-graph.ts +0 -2
- package/src/subexpressions.ts +564 -138
- package/src/substitution-levels.ts +5 -4
- package/src/successors.ts +56 -28
- package/src/symmetry.ts +4 -3
- package/src/tableau.ts +2 -2
- package/src/tlc/fingerprint.ts +81 -9
- package/src/tlc/jar-data.ts +10 -0
- package/src/tlc/messages.ts +23 -18
- package/src/tlc/order.ts +14 -3
- package/src/tlc/random.ts +6 -5
- package/src/tlc/replay.ts +152 -58
- package/src/tlc/summary.ts +29 -14
- package/src/tlc/tlc-operators.ts +12 -11
- package/src/tlc/tlcext-operators.ts +87 -26
- package/src/tlc/trace-spec.ts +27 -60
- package/src/trace-liveness.ts +529 -0
- package/src/typed-tier.ts +6556 -0
- package/src/typescript/actions.ts +2 -4
- package/src/typescript/collections.ts +34 -20
- package/src/typescript/compile.ts +1 -3
- package/src/typescript/formula.ts +5 -3
- package/src/typescript/model.ts +4 -5
- package/src/typescript/steps.ts +20 -18
- package/src/typescript/types.ts +2 -2
- package/src/values.ts +208 -227
- package/src/prover/isabelle/isar/statement.ts +0 -52
- package/src/prover/smt/solver/z3-license.txt +0 -10
- package/src/prover/tlaps-module.ts +0 -510
- package/src/prover/zenon/LICENSE +0 -32
|
@@ -0,0 +1,1096 @@
|
|
|
1
|
+
import { SmtInvariantError } from "../../../errors";
|
|
2
|
+
import {
|
|
3
|
+
type AstManager,
|
|
4
|
+
FAMILY_ARITH,
|
|
5
|
+
OP_ADD,
|
|
6
|
+
OP_AND,
|
|
7
|
+
OP_DIV,
|
|
8
|
+
OP_EQ,
|
|
9
|
+
OP_GE,
|
|
10
|
+
OP_GT,
|
|
11
|
+
OP_LE,
|
|
12
|
+
OP_LT,
|
|
13
|
+
OP_MOD,
|
|
14
|
+
OP_MUL,
|
|
15
|
+
OP_NUM,
|
|
16
|
+
OP_SUB,
|
|
17
|
+
OP_UBV2INT,
|
|
18
|
+
OP_UMINUS,
|
|
19
|
+
SORT_BOOL,
|
|
20
|
+
SORT_INT,
|
|
21
|
+
SORT_REAL,
|
|
22
|
+
} from "./ast";
|
|
23
|
+
import { isAppOf } from "./ast-util";
|
|
24
|
+
import { ArithRewriter, TACTIC_ARITH_OPTIONS } from "./arith-rewriter";
|
|
25
|
+
import { mkBvApp } from "./bv-decl-plugin";
|
|
26
|
+
import { ExprSafeReplace } from "./expr-safe-replace";
|
|
27
|
+
import type { ContainsApp, QeSolverContext, QeSolverPlugin } from "./qe";
|
|
28
|
+
import { getEuclideanMod, getGcd, getLcm, Rational } from "./rational";
|
|
29
|
+
import { Rewriter, TACTIC_REWRITER_OPTIONS } from "./rewriter";
|
|
30
|
+
import type { Rewrite } from "./rewriter-tpl";
|
|
31
|
+
|
|
32
|
+
const getExpr = (result: number | Rewrite | undefined, fallback: () => number) =>
|
|
33
|
+
result === undefined ? fallback() : typeof result === "number" ? result : result.expr;
|
|
34
|
+
|
|
35
|
+
const isOne = (value: Rational) => value.equals(Rational.one);
|
|
36
|
+
|
|
37
|
+
const isArith = (manager: AstManager, expr: number) =>
|
|
38
|
+
manager.sorts[expr] === SORT_INT || manager.sorts[expr] === SORT_REAL;
|
|
39
|
+
|
|
40
|
+
// k*x + rest, where k is not zero.
|
|
41
|
+
interface Coeff {
|
|
42
|
+
k: Rational;
|
|
43
|
+
rest: number;
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
class ArithQeUtil {
|
|
47
|
+
readonly manager: AstManager;
|
|
48
|
+
private rewriter: Rewriter;
|
|
49
|
+
private arithRewriter: ArithRewriter;
|
|
50
|
+
varsAdded: number[] = [];
|
|
51
|
+
|
|
52
|
+
constructor(readonly context: QeSolverContext) {
|
|
53
|
+
this.manager = context.manager;
|
|
54
|
+
this.rewriter = new Rewriter(this.manager, TACTIC_REWRITER_OPTIONS);
|
|
55
|
+
this.arithRewriter = new ArithRewriter(this.manager, TACTIC_ARITH_OPTIONS);
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
release() {
|
|
59
|
+
this.rewriter.release();
|
|
60
|
+
}
|
|
61
|
+
|
|
62
|
+
pin(expr: number) {
|
|
63
|
+
return this.context.pin(expr);
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
simplify(expr: number) {
|
|
67
|
+
return this.context.pinOwned(this.rewriter.rewrite(expr));
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
replace(source: number, target: number, formula: number) {
|
|
71
|
+
const replace = new ExprSafeReplace(this.manager);
|
|
72
|
+
replace.insert(source, target);
|
|
73
|
+
const result = this.context.pinOwned(replace.apply(formula));
|
|
74
|
+
replace.release();
|
|
75
|
+
return result;
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
getNumeral(expr: number) {
|
|
79
|
+
const manager = this.manager;
|
|
80
|
+
return manager.isNumeral(expr) && isArith(manager, expr)
|
|
81
|
+
? manager.getRationalValue(expr)
|
|
82
|
+
: undefined;
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
mkNumeral(value: Rational, isInt = true) {
|
|
86
|
+
return this.pin(this.manager.mkNumeralOfSort(value, isInt ? SORT_INT : SORT_REAL));
|
|
87
|
+
}
|
|
88
|
+
|
|
89
|
+
mkApp(op: number, args: number[], sort: number) {
|
|
90
|
+
return this.pin(this.manager.mkApp(op, args, sort));
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
mkAddN(args: number[]) {
|
|
94
|
+
return args.length === 1 ? args[0] : this.mkApp(OP_ADD, args, this.manager.sorts[args[0]]);
|
|
95
|
+
}
|
|
96
|
+
|
|
97
|
+
mkAdd(first: number, second: number) {
|
|
98
|
+
return this.mkApp(OP_ADD, [first, second], this.manager.sorts[first]);
|
|
99
|
+
}
|
|
100
|
+
|
|
101
|
+
mkSub(first: number, second: number) {
|
|
102
|
+
return this.mkApp(OP_SUB, [first, second], this.manager.sorts[first]);
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
mkMulApp(first: number, second: number) {
|
|
106
|
+
return this.mkApp(OP_MUL, [first, second], this.manager.sorts[second]);
|
|
107
|
+
}
|
|
108
|
+
|
|
109
|
+
mkMul(value: Rational, expr: number) {
|
|
110
|
+
return isOne(value)
|
|
111
|
+
? expr
|
|
112
|
+
: this.mkMulApp(this.mkNumeral(value, this.manager.isInt(expr)), expr);
|
|
113
|
+
}
|
|
114
|
+
|
|
115
|
+
mkUminus(expr: number) {
|
|
116
|
+
return this.mkApp(OP_UMINUS, [expr], this.manager.sorts[expr]);
|
|
117
|
+
}
|
|
118
|
+
|
|
119
|
+
mkLeApp(first: number, second: number) {
|
|
120
|
+
return this.mkApp(OP_LE, [first, second], SORT_BOOL);
|
|
121
|
+
}
|
|
122
|
+
|
|
123
|
+
mkZero(sort: number) {
|
|
124
|
+
return this.mkNumeral(Rational.zero, sort === SORT_INT);
|
|
125
|
+
}
|
|
126
|
+
|
|
127
|
+
mkOne(sort: number) {
|
|
128
|
+
return this.mkNumeral(Rational.one, sort === SORT_INT);
|
|
129
|
+
}
|
|
130
|
+
|
|
131
|
+
mkAnd(args: number[]) {
|
|
132
|
+
return this.context.pinOwned(this.manager.withTemporaries(() => this.rewriter.mkAnd(args)));
|
|
133
|
+
}
|
|
134
|
+
|
|
135
|
+
mkOr(args: number[]) {
|
|
136
|
+
return this.context.pinOwned(this.manager.withTemporaries(() => this.rewriter.mkOr(args)));
|
|
137
|
+
}
|
|
138
|
+
|
|
139
|
+
mkNotRewrite(expr: number) {
|
|
140
|
+
return this.context.pinOwned(this.manager.withTemporaries(() => this.rewriter.mkNot(expr)));
|
|
141
|
+
}
|
|
142
|
+
|
|
143
|
+
mkEqRewrite(first: number, second: number) {
|
|
144
|
+
return this.context.pinOwned(
|
|
145
|
+
this.manager.withTemporaries(() => this.rewriter.mkEq(first, second)),
|
|
146
|
+
);
|
|
147
|
+
}
|
|
148
|
+
|
|
149
|
+
// arith_rewriter's mk_le, which keeps a rewrite without rewriting it further.
|
|
150
|
+
mkLeRewrite(first: number, second: number) {
|
|
151
|
+
return this.pin(
|
|
152
|
+
getExpr(this.arithRewriter.mkLe(first, second), () =>
|
|
153
|
+
this.manager.mkApp(OP_LE, [first, second], SORT_BOOL),
|
|
154
|
+
),
|
|
155
|
+
);
|
|
156
|
+
}
|
|
157
|
+
|
|
158
|
+
mkModRewrite(first: number, second: number) {
|
|
159
|
+
return this.pin(
|
|
160
|
+
getExpr(this.arithRewriter.mkMod(first, second), () =>
|
|
161
|
+
this.manager.mkApp(OP_MOD, [first, second], SORT_INT),
|
|
162
|
+
),
|
|
163
|
+
);
|
|
164
|
+
}
|
|
165
|
+
|
|
166
|
+
mkSubRewrite(first: number, second: number) {
|
|
167
|
+
return this.pin(
|
|
168
|
+
getExpr(this.arithRewriter.mkSub([first, second]), () => this.mkSub(first, second)),
|
|
169
|
+
);
|
|
170
|
+
}
|
|
171
|
+
|
|
172
|
+
getCoeff(contains: ContainsApp, p: number): Coeff | undefined {
|
|
173
|
+
const manager = this.manager;
|
|
174
|
+
const x = contains.x;
|
|
175
|
+
const restList: number[] = [];
|
|
176
|
+
const todo = [p];
|
|
177
|
+
let k: Rational | undefined;
|
|
178
|
+
for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
|
|
179
|
+
if (isAppOf(manager, expr, OP_ADD)) {
|
|
180
|
+
todo.push(...manager.getArgs(expr));
|
|
181
|
+
continue;
|
|
182
|
+
}
|
|
183
|
+
if (expr === x) {
|
|
184
|
+
k = Rational.one;
|
|
185
|
+
break;
|
|
186
|
+
}
|
|
187
|
+
if (isAppOf(manager, expr, OP_MUL) && manager.getNumArgs(expr) === 2) {
|
|
188
|
+
const [first, second] = manager.getArgs(expr);
|
|
189
|
+
const firstValue = this.getNumeral(first);
|
|
190
|
+
const secondValue = this.getNumeral(second);
|
|
191
|
+
if (first === x && secondValue !== undefined) {
|
|
192
|
+
k = secondValue;
|
|
193
|
+
break;
|
|
194
|
+
}
|
|
195
|
+
if (second === x && firstValue !== undefined) {
|
|
196
|
+
k = firstValue;
|
|
197
|
+
break;
|
|
198
|
+
}
|
|
199
|
+
}
|
|
200
|
+
restList.push(expr);
|
|
201
|
+
}
|
|
202
|
+
if (k === undefined) return undefined;
|
|
203
|
+
while (todo.length > 0) restList.push(todo.pop() as number);
|
|
204
|
+
const rest = restList.length === 0 ? this.mkZero(manager.sorts[x]) : this.mkAddN(restList);
|
|
205
|
+
return contains.has(rest) ? undefined : { k, rest };
|
|
206
|
+
}
|
|
207
|
+
|
|
208
|
+
// The p of an inequality written as p <= 0 for isLe, or as p >= 0 otherwise.
|
|
209
|
+
private getLeGe(expr: number, isLe: boolean) {
|
|
210
|
+
const manager = this.manager;
|
|
211
|
+
const first = isLe ? 0 : 1;
|
|
212
|
+
const second = 1 - first;
|
|
213
|
+
if (isAppOf(manager, expr, OP_LE))
|
|
214
|
+
return this.getSide(manager.getArg(expr, first), manager.getArg(expr, second));
|
|
215
|
+
if (isAppOf(manager, expr, OP_GE))
|
|
216
|
+
return this.getSide(manager.getArg(expr, second), manager.getArg(expr, first));
|
|
217
|
+
return undefined;
|
|
218
|
+
}
|
|
219
|
+
|
|
220
|
+
private getSide(p: number, other: number) {
|
|
221
|
+
return this.getNumeral(other)?.isZero() === true ? p : this.simplify(this.mkSub(p, other));
|
|
222
|
+
}
|
|
223
|
+
|
|
224
|
+
isLe(expr: number) {
|
|
225
|
+
return this.getLeGe(expr, true);
|
|
226
|
+
}
|
|
227
|
+
|
|
228
|
+
isGe(expr: number) {
|
|
229
|
+
return this.getLeGe(expr, false);
|
|
230
|
+
}
|
|
231
|
+
|
|
232
|
+
// The p of a strict inequality written as p < 0.
|
|
233
|
+
isLt(expr: number) {
|
|
234
|
+
const manager = this.manager;
|
|
235
|
+
if (isAppOf(manager, expr, OP_LT))
|
|
236
|
+
return this.getSide(manager.getArg(expr, 0), manager.getArg(expr, 1));
|
|
237
|
+
if (isAppOf(manager, expr, OP_GT))
|
|
238
|
+
return this.getSide(manager.getArg(expr, 1), manager.getArg(expr, 0));
|
|
239
|
+
return undefined;
|
|
240
|
+
}
|
|
241
|
+
|
|
242
|
+
// Matches 0 = p mod k and p mod k = 0.
|
|
243
|
+
isDivides(expr: number) {
|
|
244
|
+
const manager = this.manager;
|
|
245
|
+
if (!isAppOf(manager, expr, OP_EQ)) return undefined;
|
|
246
|
+
const [first, second] = manager.getArgs(expr);
|
|
247
|
+
return this.isDividesSides(first, second) ?? this.isDividesSides(second, first);
|
|
248
|
+
}
|
|
249
|
+
|
|
250
|
+
private isDividesSides(zero: number, mod: number) {
|
|
251
|
+
const manager = this.manager;
|
|
252
|
+
if (!isAppOf(manager, mod, OP_MOD) || this.getNumeral(zero)?.isZero() !== true)
|
|
253
|
+
return undefined;
|
|
254
|
+
const k = this.getNumeral(manager.getArg(mod, 1));
|
|
255
|
+
return k === undefined ? undefined : { k, p: manager.getArg(mod, 0) };
|
|
256
|
+
}
|
|
257
|
+
|
|
258
|
+
isNotDivides(expr: number) {
|
|
259
|
+
const manager = this.manager;
|
|
260
|
+
if (!manager.isNot(expr)) return undefined;
|
|
261
|
+
const atom = manager.getArg(expr, 0);
|
|
262
|
+
const divides = this.isDivides(atom);
|
|
263
|
+
return divides === undefined ? undefined : { ...divides, atom };
|
|
264
|
+
}
|
|
265
|
+
|
|
266
|
+
isReal(x: number) {
|
|
267
|
+
return this.manager.isReal(x);
|
|
268
|
+
}
|
|
269
|
+
|
|
270
|
+
// b*t <= a*s, or b*t < a*s when isStrict.
|
|
271
|
+
mkBoundAux(isStrict: boolean, a: Rational, t: number, b: Rational, s: number) {
|
|
272
|
+
const manager = this.manager;
|
|
273
|
+
const ss = this.mkMul(a.abs(), s);
|
|
274
|
+
const tt = this.mkMul(b.abs(), t);
|
|
275
|
+
const e = a.isNegative() ? this.mkSub(tt, ss) : this.mkSub(ss, tt);
|
|
276
|
+
if (!isStrict) return this.mkLe(e);
|
|
277
|
+
return manager.isInt(e) ? this.mkLe(this.mkAdd(e, this.mkOne(SORT_INT))) : this.mkLt(e);
|
|
278
|
+
}
|
|
279
|
+
|
|
280
|
+
mkDivides(n: Rational, expr: number) {
|
|
281
|
+
const simplified = this.simplify(expr);
|
|
282
|
+
const mod = this.mkModRewrite(simplified, this.mkNumeral(n));
|
|
283
|
+
return this.mkEqRewrite(this.mkZero(SORT_INT), mod);
|
|
284
|
+
}
|
|
285
|
+
|
|
286
|
+
mkDiv(expr: number, k: Rational) {
|
|
287
|
+
return this.simplify(this.mkApp(OP_DIV, [expr, this.mkNumeral(k, false)], SORT_REAL));
|
|
288
|
+
}
|
|
289
|
+
|
|
290
|
+
mkLe(expr: number) {
|
|
291
|
+
return this.mkLeRewrite(this.simplify(expr), this.mkZero(this.manager.sorts[expr]));
|
|
292
|
+
}
|
|
293
|
+
|
|
294
|
+
mkLt(expr: number) {
|
|
295
|
+
const manager = this.manager;
|
|
296
|
+
const value = this.getNumeral(expr);
|
|
297
|
+
if (value !== undefined) return value.isNegative() ? manager.trueExpr : manager.falseExpr;
|
|
298
|
+
const result = manager.isInt(expr)
|
|
299
|
+
? this.mkLeApp(expr, this.mkNumeral(Rational.minusOne))
|
|
300
|
+
: this.pin(manager.mkNot(this.mkLeApp(this.mkZero(manager.sorts[expr]), expr)));
|
|
301
|
+
return this.simplify(result);
|
|
302
|
+
}
|
|
303
|
+
|
|
304
|
+
// a*x + t = 0
|
|
305
|
+
mkEq(a: Rational, x: number, t: number) {
|
|
306
|
+
return this.pin(
|
|
307
|
+
this.manager.mkEq(this.mkAdd(this.mkMul(a, x), t), this.mkZero(this.manager.sorts[x])),
|
|
308
|
+
);
|
|
309
|
+
}
|
|
310
|
+
|
|
311
|
+
mkFlatAnd(first: number, second: number) {
|
|
312
|
+
const manager = this.manager;
|
|
313
|
+
return this.mkAnd(
|
|
314
|
+
[first, second].flatMap((expr) =>
|
|
315
|
+
isAppOf(manager, expr, OP_AND) ? manager.getArgs(expr) : [expr],
|
|
316
|
+
),
|
|
317
|
+
);
|
|
318
|
+
}
|
|
319
|
+
|
|
320
|
+
// b*t <= a*s, with the cases of integer resolution.
|
|
321
|
+
mkResolve(x: number, isStrict: boolean, a: Rational, t: number, b: Rational, s: number) {
|
|
322
|
+
const manager = this.manager;
|
|
323
|
+
const bt = this.mkMul(b.abs(), t);
|
|
324
|
+
const as = this.mkMul(a.abs(), s);
|
|
325
|
+
const asBt = this.mkAdd(as, bt);
|
|
326
|
+
const result = isStrict ? this.mkLt(asBt) : this.mkLe(asBt);
|
|
327
|
+
if (isOne(a.abs()) || isOne(b.abs())) return result;
|
|
328
|
+
// a*s + b*t + (a-1)(b-1) <= 0
|
|
329
|
+
const slack = this.mkNumeral(a.abs().sub(Rational.one).mul(b.abs().sub(Rational.one)));
|
|
330
|
+
const result1 = this.mkLe(this.mkApp(OP_ADD, [asBt, slack], manager.sorts[asBt]));
|
|
331
|
+
const isSwapped = a.abs().compare(b.abs()) < 0;
|
|
332
|
+
const a1 = isSwapped ? b : a;
|
|
333
|
+
const b1 = isSwapped ? a : b;
|
|
334
|
+
const s1 = isSwapped ? t : s;
|
|
335
|
+
const bt1 = isSwapped ? as : bt;
|
|
336
|
+
// exists z in [0 .. |b|-2] . |b| | (z + s) && a*n_sign(b)(s + z) + |b|t <= 0
|
|
337
|
+
const sum = this.mkAdd(s1, x);
|
|
338
|
+
const sz = b1.isPositive() ? this.mkUminus(sum) : sum;
|
|
339
|
+
const aszBtLe0 = this.mkLe(this.mkAdd(this.mkMul(a1, sz), bt1));
|
|
340
|
+
const isZBound =
|
|
341
|
+
manager.getNumArgs(aszBtLe0) === 2 &&
|
|
342
|
+
manager.getArg(aszBtLe0, 0) === x &&
|
|
343
|
+
this.getNumeral(manager.getArg(aszBtLe0, 1))?.isZero() === true;
|
|
344
|
+
const tmp2 = isZBound
|
|
345
|
+
? this.mkDivides(b1.abs(), s1)
|
|
346
|
+
: this.mkBigOr(
|
|
347
|
+
b1.abs().sub(Rational.of(2n)),
|
|
348
|
+
x,
|
|
349
|
+
this.mkAnd([this.mkDivides(b1.abs(), sz), aszBtLe0]),
|
|
350
|
+
);
|
|
351
|
+
return this.simplify(this.mkOr([result1, this.mkFlatAnd(result, tmp2)]));
|
|
352
|
+
}
|
|
353
|
+
|
|
354
|
+
normalizeSum(p: number) {
|
|
355
|
+
const manager = this.manager;
|
|
356
|
+
const simplified = this.simplify(p);
|
|
357
|
+
if (!isAppOf(manager, simplified, OP_ADD)) return simplified;
|
|
358
|
+
const strip = (expr: number) => {
|
|
359
|
+
if (!isAppOf(manager, expr, OP_MUL) || manager.getNumArgs(expr) !== 2) return expr;
|
|
360
|
+
return this.getNumeral(manager.getArg(expr, 0)) !== undefined
|
|
361
|
+
? manager.getArg(expr, 1)
|
|
362
|
+
: expr;
|
|
363
|
+
};
|
|
364
|
+
const ids = manager.ids;
|
|
365
|
+
const args = [...manager.getArgs(simplified)].sort(
|
|
366
|
+
(first, second) => ids[strip(first)] - ids[strip(second)],
|
|
367
|
+
);
|
|
368
|
+
return this.mkAddN(args);
|
|
369
|
+
}
|
|
370
|
+
|
|
371
|
+
mkAtom(expr: number, isPositive: boolean) {
|
|
372
|
+
const manager = this.manager;
|
|
373
|
+
if (this.isDivides(expr) !== undefined) return isPositive ? expr : this.mkNotRewrite(expr);
|
|
374
|
+
const [a0, a1] = manager.getArgs(expr);
|
|
375
|
+
if (isAppOf(manager, expr, OP_EQ) && isArith(manager, a0)) {
|
|
376
|
+
if (isPositive) {
|
|
377
|
+
const t1 = this.simplify(this.mkSub(a0, a1));
|
|
378
|
+
const t2 = this.simplify(this.mkSub(a1, a0));
|
|
379
|
+
return this.mkAnd([this.mkLe(t1), this.mkLe(t2)]);
|
|
380
|
+
}
|
|
381
|
+
if (manager.isInt(a0)) {
|
|
382
|
+
const difference = this.mkSub(a0, a1);
|
|
383
|
+
const t1 = this.simplify(this.mkAdd(this.mkOne(SORT_INT), difference));
|
|
384
|
+
const t2 = this.simplify(this.mkSub(this.mkOne(SORT_INT), difference));
|
|
385
|
+
return this.mkOr([this.mkLe(t1), this.mkLe(t2)]);
|
|
386
|
+
}
|
|
387
|
+
const t1 = this.simplify(this.mkSub(a0, a1));
|
|
388
|
+
const t2 = this.simplify(this.mkSub(a1, a0));
|
|
389
|
+
return this.mkOr([this.mkLt(t1), this.mkLt(t2)]);
|
|
390
|
+
}
|
|
391
|
+
const isLe = isAppOf(manager, expr, OP_LE);
|
|
392
|
+
const isGe = isAppOf(manager, expr, OP_GE);
|
|
393
|
+
if (isLe || isGe) {
|
|
394
|
+
if (isPositive) return expr;
|
|
395
|
+
const [low, high] = isLe ? [a0, a1] : [a1, a0];
|
|
396
|
+
return this.mkLt(this.mkSub(high, low));
|
|
397
|
+
}
|
|
398
|
+
const isLt = isAppOf(manager, expr, OP_LT);
|
|
399
|
+
if (isLt || isAppOf(manager, expr, OP_GT)) {
|
|
400
|
+
const [low, high] = isLt ? [a0, a1] : [a1, a0];
|
|
401
|
+
return isPositive ? this.mkLt(this.mkSub(low, high)) : this.mkLe(this.mkSub(high, low));
|
|
402
|
+
}
|
|
403
|
+
return undefined;
|
|
404
|
+
}
|
|
405
|
+
|
|
406
|
+
mkBoundedVar(n: Rational) {
|
|
407
|
+
const manager = this.manager;
|
|
408
|
+
let size = 0;
|
|
409
|
+
let b = n.num;
|
|
410
|
+
do {
|
|
411
|
+
size++;
|
|
412
|
+
b /= 2n;
|
|
413
|
+
} while (b > 0n);
|
|
414
|
+
const zBv = this.pin(manager.mkFreshConst("z", manager.mkBvSort(size)));
|
|
415
|
+
return { zBv, z: this.pin(mkBvApp(manager, OP_UBV2INT, [zBv])) };
|
|
416
|
+
}
|
|
417
|
+
|
|
418
|
+
solve(conjs: readonly number[], formula: number) {
|
|
419
|
+
return this.extractEqualities(conjs).some((eq) => this.reduceEquation(eq, formula));
|
|
420
|
+
}
|
|
421
|
+
|
|
422
|
+
private extractEqualities(conjs: readonly number[]) {
|
|
423
|
+
const manager = this.manager;
|
|
424
|
+
const leqs = new Set<number>();
|
|
425
|
+
const eqs: number[] = [];
|
|
426
|
+
for (const conj of conjs) {
|
|
427
|
+
if (isAppOf(manager, conj, OP_EQ) && isArith(manager, manager.getArg(conj, 0))) {
|
|
428
|
+
eqs.push(
|
|
429
|
+
this.simplify(this.mkSubRewrite(manager.getArg(conj, 0), manager.getArg(conj, 1))),
|
|
430
|
+
);
|
|
431
|
+
continue;
|
|
432
|
+
}
|
|
433
|
+
const isLe = isAppOf(manager, conj, OP_LE);
|
|
434
|
+
if (!isLe && !isAppOf(manager, conj, OP_GE)) continue;
|
|
435
|
+
const [first, second] = manager.getArgs(conj);
|
|
436
|
+
const difference = this.normalizeSum(
|
|
437
|
+
isLe ? this.mkSubRewrite(first, second) : this.mkSubRewrite(second, first),
|
|
438
|
+
);
|
|
439
|
+
const negated = this.normalizeSum(this.mkUminus(difference));
|
|
440
|
+
if (leqs.has(negated)) eqs.push(difference);
|
|
441
|
+
else leqs.add(difference);
|
|
442
|
+
}
|
|
443
|
+
return eqs;
|
|
444
|
+
}
|
|
445
|
+
|
|
446
|
+
addVar(x: number, isTracked = true) {
|
|
447
|
+
this.context.addVar(x);
|
|
448
|
+
if (isTracked) this.varsAdded.push(x);
|
|
449
|
+
}
|
|
450
|
+
|
|
451
|
+
private mkBigOr(up: Rational, x: number, body: number) {
|
|
452
|
+
return Rational.one.compare(up) >= 0
|
|
453
|
+
? this.mkBigOrBlast(up, x, body)
|
|
454
|
+
: this.mkBigOrSymbolicBlast(up, x, body);
|
|
455
|
+
}
|
|
456
|
+
|
|
457
|
+
private mkBigOrBlast(up: Rational, x: number, body: number) {
|
|
458
|
+
const ors: number[] = [];
|
|
459
|
+
for (let index = 0n; index <= up.num; index++)
|
|
460
|
+
ors.push(this.replace(x, this.mkNumeral(Rational.of(index)), body));
|
|
461
|
+
return this.mkOr(ors);
|
|
462
|
+
}
|
|
463
|
+
|
|
464
|
+
private mkBigOrSymbolicBlast(up: Rational, x: number, body: number) {
|
|
465
|
+
const bound = this.mkLeApp(x, this.mkNumeral(up));
|
|
466
|
+
const bounded = this.mkFlatAnd(bound, body);
|
|
467
|
+
const { zBv, z } = this.mkBoundedVar(up);
|
|
468
|
+
return this.context.blastOr(zBv, this.replace(x, z, bounded));
|
|
469
|
+
}
|
|
470
|
+
|
|
471
|
+
// The coefficient of x, when x occurs in exactly one summand of p.
|
|
472
|
+
private isolateX(p: number, x: number, contains: ContainsApp) {
|
|
473
|
+
const manager = this.manager;
|
|
474
|
+
let current = p;
|
|
475
|
+
while (isAppOf(manager, current, OP_ADD)) {
|
|
476
|
+
const withX = manager.getArgs(current).filter((arg) => contains.has(arg));
|
|
477
|
+
if (withX.length !== 1) return undefined;
|
|
478
|
+
current = withX[0];
|
|
479
|
+
}
|
|
480
|
+
if (current === x) return Rational.one;
|
|
481
|
+
if (!isAppOf(manager, current, OP_MUL) || manager.getNumArgs(current) !== 2) return undefined;
|
|
482
|
+
const [first, second] = manager.getArgs(current);
|
|
483
|
+
const firstValue = this.getNumeral(first);
|
|
484
|
+
if (firstValue !== undefined && second === x) return firstValue;
|
|
485
|
+
const secondValue = this.getNumeral(second);
|
|
486
|
+
return secondValue !== undefined && first === x ? secondValue : undefined;
|
|
487
|
+
}
|
|
488
|
+
|
|
489
|
+
private solveSingular(index: number, p: number, formula: number) {
|
|
490
|
+
const manager = this.manager;
|
|
491
|
+
const context = this.context;
|
|
492
|
+
const x = context.getVar(index);
|
|
493
|
+
const k = this.isolateX(p, x, context.contains(index));
|
|
494
|
+
if (k === undefined) return false;
|
|
495
|
+
if (manager.isInt(x) && !isOne(k.abs())) return false;
|
|
496
|
+
const sort = manager.sorts[x];
|
|
497
|
+
const e = isOne(k.abs())
|
|
498
|
+
? k.isNegative()
|
|
499
|
+
? this.mkApp(OP_ADD, [p, x], sort)
|
|
500
|
+
: this.mkApp(OP_SUB, [x, p], sort)
|
|
501
|
+
: (() => {
|
|
502
|
+
// p = p' + k*x = 0, so x = (p - k*x) / -k.
|
|
503
|
+
const ke = this.mkNumeral(k.neg(), false);
|
|
504
|
+
return this.mkApp(
|
|
505
|
+
OP_DIV,
|
|
506
|
+
[this.mkApp(OP_ADD, [p, this.mkMulApp(ke, x)], sort), ke],
|
|
507
|
+
sort,
|
|
508
|
+
);
|
|
509
|
+
})();
|
|
510
|
+
context.elimVar(index, this.simplify(this.replace(x, e, formula)));
|
|
511
|
+
return true;
|
|
512
|
+
}
|
|
513
|
+
|
|
514
|
+
private solveLinear(p: number, formula: number) {
|
|
515
|
+
const manager = this.manager;
|
|
516
|
+
const context = this.context;
|
|
517
|
+
const vars = context.getVars();
|
|
518
|
+
const values = this.getLinear(p, vars);
|
|
519
|
+
if (values === undefined || values.slice(1).every((value) => value.isZero())) return false;
|
|
520
|
+
const solved = solveIntegerEquation(values);
|
|
521
|
+
if (solved === undefined) return false;
|
|
522
|
+
const x = vars[solved.index - 1];
|
|
523
|
+
const sort = manager.sorts[p];
|
|
524
|
+
let p1: number;
|
|
525
|
+
if (solved.isAux) {
|
|
526
|
+
// A fresh variable stands for x, with the coefficient values[index].
|
|
527
|
+
const z = this.pin(manager.mkFreshConst("x", sort));
|
|
528
|
+
this.addVar(z);
|
|
529
|
+
p1 = this.mkMulApp(this.pin(manager.mkNumeralOfSort(values[solved.index], sort)), z);
|
|
530
|
+
} else p1 = this.pin(manager.mkNumeralOfSort(Rational.zero, sort));
|
|
531
|
+
for (let index = 1; index <= vars.length; index++) {
|
|
532
|
+
const k = values[index];
|
|
533
|
+
if (k.isZero() || index === solved.index) continue;
|
|
534
|
+
const term = this.mkMulApp(this.pin(manager.mkNumeralOfSort(k, sort)), vars[index - 1]);
|
|
535
|
+
p1 = this.mkApp(OP_ADD, [p1, term], sort);
|
|
536
|
+
}
|
|
537
|
+
p1 = this.mkApp(OP_ADD, [p1, this.pin(manager.mkNumeralOfSort(values[0], sort))], sort);
|
|
538
|
+
context.elimVar(solved.index - 1, this.simplify(this.replace(x, p1, formula)));
|
|
539
|
+
return true;
|
|
540
|
+
}
|
|
541
|
+
|
|
542
|
+
private reduceEquation(p: number, formula: number) {
|
|
543
|
+
if (this.getNumeral(p)?.isZero() === true) return false;
|
|
544
|
+
for (let index = 0; index < this.context.getNumVars(); index++)
|
|
545
|
+
if (this.solveSingular(index, p, formula)) return true;
|
|
546
|
+
return this.solveLinear(p, formula);
|
|
547
|
+
}
|
|
548
|
+
|
|
549
|
+
// The constant of p, then the coefficient of each variable, when p is linear in them.
|
|
550
|
+
private getLinear(p: number, vars: readonly number[]) {
|
|
551
|
+
const manager = this.manager;
|
|
552
|
+
if (vars.length === 0) return undefined;
|
|
553
|
+
const values = Array.from({ length: vars.length + 1 }, () => Rational.zero);
|
|
554
|
+
const addToVar = (expr: number, k: Rational) => {
|
|
555
|
+
if (manager.getNumArgs(expr) > 0) return false;
|
|
556
|
+
const index = vars.indexOf(expr);
|
|
557
|
+
if (index === -1) return false;
|
|
558
|
+
values[index + 1] = values[index + 1].add(k);
|
|
559
|
+
return true;
|
|
560
|
+
};
|
|
561
|
+
const todo = [p];
|
|
562
|
+
for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
|
|
563
|
+
if (isAppOf(manager, expr, OP_ADD)) {
|
|
564
|
+
todo.push(...manager.getArgs(expr));
|
|
565
|
+
continue;
|
|
566
|
+
}
|
|
567
|
+
if (isAppOf(manager, expr, OP_MUL) && manager.getNumArgs(expr) === 2) {
|
|
568
|
+
const [first, second] = manager.getArgs(expr);
|
|
569
|
+
const firstValue = this.getNumeral(first);
|
|
570
|
+
if (firstValue !== undefined && addToVar(second, firstValue)) continue;
|
|
571
|
+
const secondValue = this.getNumeral(second);
|
|
572
|
+
if (secondValue !== undefined && addToVar(first, secondValue)) continue;
|
|
573
|
+
}
|
|
574
|
+
// Z3 adds a stale coefficient here, zero or that of an earlier product, instead of one.
|
|
575
|
+
if (addToVar(expr, Rational.one)) continue;
|
|
576
|
+
const value = this.getNumeral(expr);
|
|
577
|
+
if (value === undefined) return undefined;
|
|
578
|
+
values[0] = values[0].add(value);
|
|
579
|
+
}
|
|
580
|
+
return values;
|
|
581
|
+
}
|
|
582
|
+
}
|
|
583
|
+
|
|
584
|
+
// One step of the omega test's equality elimination on a1*x1 + ... + an*xn + a0 = 0, where
|
|
585
|
+
// values[0] is a0: it picks the variable of least absolute coefficient, whose coefficient becomes
|
|
586
|
+
// -1, or a fresh one's coefficient when it is not a unit.
|
|
587
|
+
const solveIntegerEquation = (values: Rational[]) => {
|
|
588
|
+
if (!values.every((value) => value.isInt())) return undefined;
|
|
589
|
+
let gcd = 0n;
|
|
590
|
+
for (const value of values) {
|
|
591
|
+
gcd =
|
|
592
|
+
gcd === 0n
|
|
593
|
+
? value.num < 0n
|
|
594
|
+
? -value.num
|
|
595
|
+
: value.num
|
|
596
|
+
: getGcd(value.num < 0n ? -value.num : value.num, gcd);
|
|
597
|
+
if (gcd === 1n) break;
|
|
598
|
+
}
|
|
599
|
+
if (gcd !== 0n && gcd !== 1n)
|
|
600
|
+
values.forEach((value, index) => (values[index] = Rational.of(value.num / gcd)));
|
|
601
|
+
let testGcd = 0n;
|
|
602
|
+
for (let index = 1; testGcd !== 1n && index < values.length; index++) {
|
|
603
|
+
const value = values[index].num < 0n ? -values[index].num : values[index].num;
|
|
604
|
+
if (value !== 0n) testGcd = testGcd === 0n ? value : getGcd(value, testGcd);
|
|
605
|
+
}
|
|
606
|
+
if (testGcd === 0n ? !values[0].isZero() : testGcd !== 1n && values[0].num % testGcd !== 0n)
|
|
607
|
+
return undefined;
|
|
608
|
+
let index = 0;
|
|
609
|
+
let least = 0n;
|
|
610
|
+
for (let candidate = 1; candidate < values.length; candidate++) {
|
|
611
|
+
const value = values[candidate].num < 0n ? -values[candidate].num : values[candidate].num;
|
|
612
|
+
if (least === 0n || (value !== 0n && value < least)) {
|
|
613
|
+
index = candidate;
|
|
614
|
+
least = value;
|
|
615
|
+
}
|
|
616
|
+
}
|
|
617
|
+
if (least === 0n) return { index, isAux: false };
|
|
618
|
+
const negate = () => values.forEach((value, position) => (values[position] = value.neg()));
|
|
619
|
+
if (values[index].num === 1n) negate();
|
|
620
|
+
const isAux = least !== 1n;
|
|
621
|
+
if (isAux) {
|
|
622
|
+
const modulus = least + 1n;
|
|
623
|
+
values.forEach((value, position) => {
|
|
624
|
+
const remainder = getEuclideanMod(value.num, modulus);
|
|
625
|
+
values[position] = Rational.of(2n * remainder > modulus ? remainder - modulus : remainder);
|
|
626
|
+
});
|
|
627
|
+
if (values[index].num === 1n) negate();
|
|
628
|
+
values[index] = Rational.of(modulus);
|
|
629
|
+
}
|
|
630
|
+
return { index, isAux };
|
|
631
|
+
};
|
|
632
|
+
|
|
633
|
+
interface Bound {
|
|
634
|
+
term: number;
|
|
635
|
+
coeff: Rational;
|
|
636
|
+
atom: number;
|
|
637
|
+
}
|
|
638
|
+
|
|
639
|
+
interface Div {
|
|
640
|
+
term: number;
|
|
641
|
+
coeff: Rational;
|
|
642
|
+
divisor: Rational;
|
|
643
|
+
atom: number;
|
|
644
|
+
}
|
|
645
|
+
|
|
646
|
+
interface NestedDiv extends Div {
|
|
647
|
+
z: number;
|
|
648
|
+
zBv: number;
|
|
649
|
+
}
|
|
650
|
+
|
|
651
|
+
class BoundsProc {
|
|
652
|
+
private marked = new Set<number>();
|
|
653
|
+
readonly le: Bound[] = [];
|
|
654
|
+
readonly ge: Bound[] = [];
|
|
655
|
+
readonly lt: Bound[] = [];
|
|
656
|
+
readonly gt: Bound[] = [];
|
|
657
|
+
readonly divs: Div[] = [];
|
|
658
|
+
readonly nestedDivs: NestedDiv[] = [];
|
|
659
|
+
private divZ: { d: Rational; z: number; zBv: number } | undefined;
|
|
660
|
+
|
|
661
|
+
constructor(private util: ArithQeUtil) {}
|
|
662
|
+
|
|
663
|
+
getBound(contains: ContainsApp, atom: number) {
|
|
664
|
+
const hasBound =
|
|
665
|
+
this.marked.has(atom) ||
|
|
666
|
+
this.getLeBound(contains, atom) ||
|
|
667
|
+
this.getLtBound(contains, atom) ||
|
|
668
|
+
this.getDivides(contains, atom) ||
|
|
669
|
+
this.getNestedDivs(contains, atom);
|
|
670
|
+
if (hasBound) this.marked.add(atom);
|
|
671
|
+
return hasBound;
|
|
672
|
+
}
|
|
673
|
+
|
|
674
|
+
get(isStrict: boolean, isLower: boolean) {
|
|
675
|
+
return isStrict ? (isLower ? this.lt : this.gt) : isLower ? this.le : this.ge;
|
|
676
|
+
}
|
|
677
|
+
|
|
678
|
+
getDivZ() {
|
|
679
|
+
if (this.divZ !== undefined) return this.divZ;
|
|
680
|
+
if (this.divs.length === 0 && this.nestedDivs.length === 0) return undefined;
|
|
681
|
+
let d = 1n;
|
|
682
|
+
for (const div of [...this.divs, ...this.nestedDivs]) d = getLcm(div.divisor.num, d);
|
|
683
|
+
if (d === 1n || d === -1n) return undefined;
|
|
684
|
+
this.divZ = { d: Rational.of(d), ...this.util.mkBoundedVar(Rational.of(d)) };
|
|
685
|
+
return this.divZ;
|
|
686
|
+
}
|
|
687
|
+
|
|
688
|
+
private getNestedDivs(contains: ContainsApp, atom: number) {
|
|
689
|
+
const util = this.util;
|
|
690
|
+
const manager = util.manager;
|
|
691
|
+
const todo = [atom];
|
|
692
|
+
for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
|
|
693
|
+
if (this.marked.has(expr)) continue;
|
|
694
|
+
this.marked.add(expr);
|
|
695
|
+
if (!contains.has(expr)) continue;
|
|
696
|
+
if (contains.x === expr) return false;
|
|
697
|
+
if (isAppOf(manager, expr, OP_MOD)) {
|
|
698
|
+
const k1 = util.getNumeral(manager.getArg(expr, 1));
|
|
699
|
+
const coeff =
|
|
700
|
+
k1 === undefined ? undefined : util.getCoeff(contains, manager.getArg(expr, 0));
|
|
701
|
+
if (k1 !== undefined && coeff !== undefined) {
|
|
702
|
+
this.nestedDivs.push({
|
|
703
|
+
term: coeff.rest,
|
|
704
|
+
coeff: coeff.k,
|
|
705
|
+
divisor: k1,
|
|
706
|
+
atom: expr,
|
|
707
|
+
...util.mkBoundedVar(k1),
|
|
708
|
+
});
|
|
709
|
+
continue;
|
|
710
|
+
}
|
|
711
|
+
}
|
|
712
|
+
todo.push(...manager.getArgs(expr));
|
|
713
|
+
}
|
|
714
|
+
return true;
|
|
715
|
+
}
|
|
716
|
+
|
|
717
|
+
private getLeBound(contains: ContainsApp, atom: number) {
|
|
718
|
+
const util = this.util;
|
|
719
|
+
const p = util.isLe(atom);
|
|
720
|
+
const coeff = p === undefined ? undefined : util.getCoeff(contains, p);
|
|
721
|
+
if (coeff === undefined) return false;
|
|
722
|
+
// k*x + rest <= 0
|
|
723
|
+
let k = coeff.k;
|
|
724
|
+
let rest = coeff.rest;
|
|
725
|
+
if (util.isReal(contains.x)) {
|
|
726
|
+
rest = util.mkDiv(rest, k.abs());
|
|
727
|
+
k = k.isPositive() ? Rational.one : Rational.minusOne;
|
|
728
|
+
}
|
|
729
|
+
(k.isNegative() ? this.le : this.ge).push({ term: rest, coeff: k, atom });
|
|
730
|
+
return true;
|
|
731
|
+
}
|
|
732
|
+
|
|
733
|
+
private getLtBound(contains: ContainsApp, atom: number) {
|
|
734
|
+
const util = this.util;
|
|
735
|
+
const manager = util.manager;
|
|
736
|
+
const p = util.isLt(atom);
|
|
737
|
+
let coeff = p === undefined ? undefined : util.getCoeff(contains, p);
|
|
738
|
+
if (coeff === undefined && manager.isNot(atom)) {
|
|
739
|
+
// not (k*x + rest >= 0), that is k*x + rest < 0.
|
|
740
|
+
const negatedP = util.isGe(manager.getArg(atom, 0));
|
|
741
|
+
coeff = negatedP === undefined ? undefined : util.getCoeff(contains, negatedP);
|
|
742
|
+
}
|
|
743
|
+
if (coeff === undefined) return false;
|
|
744
|
+
const rest = util.mkDiv(coeff.rest, coeff.k.abs());
|
|
745
|
+
if (coeff.k.isNegative()) this.lt.push({ term: rest, coeff: Rational.minusOne, atom });
|
|
746
|
+
else this.gt.push({ term: rest, coeff: Rational.one, atom });
|
|
747
|
+
return true;
|
|
748
|
+
}
|
|
749
|
+
|
|
750
|
+
private getDivides(contains: ContainsApp, atom: number) {
|
|
751
|
+
const util = this.util;
|
|
752
|
+
const divides = util.isDivides(atom);
|
|
753
|
+
const coeff = divides === undefined ? undefined : util.getCoeff(contains, divides.p);
|
|
754
|
+
if (divides !== undefined && coeff !== undefined) {
|
|
755
|
+
this.divs.push({ term: coeff.rest, divisor: divides.k, coeff: coeff.k, atom });
|
|
756
|
+
return true;
|
|
757
|
+
}
|
|
758
|
+
const notDivides = util.isNotDivides(atom);
|
|
759
|
+
const notCoeff = notDivides === undefined ? undefined : util.getCoeff(contains, notDivides.p);
|
|
760
|
+
if (notDivides === undefined || notCoeff === undefined) return false;
|
|
761
|
+
this.divs.push({
|
|
762
|
+
term: notCoeff.rest,
|
|
763
|
+
divisor: notDivides.k,
|
|
764
|
+
coeff: notCoeff.k,
|
|
765
|
+
atom: notDivides.atom,
|
|
766
|
+
});
|
|
767
|
+
return true;
|
|
768
|
+
}
|
|
769
|
+
}
|
|
770
|
+
|
|
771
|
+
// x is coeff*x' + term after a substitution.
|
|
772
|
+
class XSubst {
|
|
773
|
+
term = -1;
|
|
774
|
+
coeff = Rational.one;
|
|
775
|
+
|
|
776
|
+
constructor(private util: ArithQeUtil) {}
|
|
777
|
+
|
|
778
|
+
mkTerm(c: Rational, t: number) {
|
|
779
|
+
return this.term === -1 ? t : this.util.mkAdd(this.util.mkMul(c, this.term), t);
|
|
780
|
+
}
|
|
781
|
+
|
|
782
|
+
mkCoeff(k: Rational) {
|
|
783
|
+
return k.mul(this.coeff);
|
|
784
|
+
}
|
|
785
|
+
}
|
|
786
|
+
|
|
787
|
+
interface BranchFormula {
|
|
788
|
+
result: number;
|
|
789
|
+
vars: number[];
|
|
790
|
+
}
|
|
791
|
+
|
|
792
|
+
export class ArithPlugin implements QeSolverPlugin {
|
|
793
|
+
readonly family = FAMILY_ARITH;
|
|
794
|
+
private util: ArithQeUtil;
|
|
795
|
+
private boundsCache = new Map<string, BoundsProc>();
|
|
796
|
+
private substCache = new Map<string, BranchFormula>();
|
|
797
|
+
|
|
798
|
+
constructor(private context: QeSolverContext) {
|
|
799
|
+
this.util = new ArithQeUtil(context);
|
|
800
|
+
}
|
|
801
|
+
|
|
802
|
+
release() {
|
|
803
|
+
this.util.release();
|
|
804
|
+
}
|
|
805
|
+
|
|
806
|
+
assign(contains: ContainsApp, formula: number, value: bigint) {
|
|
807
|
+
const util = this.util;
|
|
808
|
+
const x = contains.x;
|
|
809
|
+
if (this.getCache(x, formula, value) !== undefined) return;
|
|
810
|
+
util.varsAdded = [];
|
|
811
|
+
const bounds = this.getBounds(x, formula);
|
|
812
|
+
const sizes = this.getBoundSizes(bounds, x);
|
|
813
|
+
const isLower = sizes.isLower;
|
|
814
|
+
const xT = new XSubst(util);
|
|
815
|
+
let result = this.assignNestedDivs(bounds, formula);
|
|
816
|
+
result = this.assignDivs(contains, bounds, xT, result);
|
|
817
|
+
if (value === 0n) {
|
|
818
|
+
// The case where x is unbounded.
|
|
819
|
+
result = this.mkNonBounds(bounds, true, isLower, result);
|
|
820
|
+
result = this.mkNonBounds(bounds, false, isLower, result);
|
|
821
|
+
result = this.mkNonResolve(bounds, true, isLower, result);
|
|
822
|
+
result = this.mkNonResolve(bounds, false, isLower, result);
|
|
823
|
+
this.addCache(x, formula, value, util.simplify(result));
|
|
824
|
+
return;
|
|
825
|
+
}
|
|
826
|
+
// Strict bounds come after the others, and a non-strict bound of a real is two cases: x equals
|
|
827
|
+
// it, or x is below it.
|
|
828
|
+
const position = Number(value) - 1;
|
|
829
|
+
const isStrict = sizes.eSize <= position;
|
|
830
|
+
const isEq = !isStrict && util.isReal(x) && position % 2 === 0;
|
|
831
|
+
const index = isStrict
|
|
832
|
+
? position - sizes.eSize
|
|
833
|
+
: util.isReal(x)
|
|
834
|
+
? Math.floor(position / 2)
|
|
835
|
+
: position;
|
|
836
|
+
const bound = bounds.get(isStrict, isLower)[index];
|
|
837
|
+
let t = bound.term;
|
|
838
|
+
let a = bound.coeff;
|
|
839
|
+
const context = { bounds, x, isEq, isStrictCtx: isStrict, isLower, index };
|
|
840
|
+
result = this.mkBounds(context, true, a, t, result);
|
|
841
|
+
result = this.mkBounds(context, false, a, t, result);
|
|
842
|
+
t = xT.mkTerm(a, t);
|
|
843
|
+
a = xT.mkCoeff(a);
|
|
844
|
+
result = this.mkResolve(context, xT, true, a, t, result);
|
|
845
|
+
result = this.mkResolve(context, xT, false, a, t, result);
|
|
846
|
+
this.addCache(x, formula, value, util.simplify(result));
|
|
847
|
+
}
|
|
848
|
+
|
|
849
|
+
getNumBranches(contains: ContainsApp, formula: number) {
|
|
850
|
+
if (!this.updateBounds(contains, formula)) return undefined;
|
|
851
|
+
const sizes = this.getBoundSizes(this.getBounds(contains.x, formula), contains.x);
|
|
852
|
+
return BigInt(sizes.tSize + sizes.eSize + 1);
|
|
853
|
+
}
|
|
854
|
+
|
|
855
|
+
subst(contains: ContainsApp, value: bigint, formula: number) {
|
|
856
|
+
const result = this.getCache(contains.x, formula, value);
|
|
857
|
+
if (result === undefined) throw new SmtInvariantError("quantifier elimination lost a branch");
|
|
858
|
+
return result;
|
|
859
|
+
}
|
|
860
|
+
|
|
861
|
+
solve(conjs: readonly number[], formula: number) {
|
|
862
|
+
return this.util.solve(conjs, formula);
|
|
863
|
+
}
|
|
864
|
+
|
|
865
|
+
mkAtom(expr: number, isPositive: boolean) {
|
|
866
|
+
return this.util.mkAtom(expr, isPositive);
|
|
867
|
+
}
|
|
868
|
+
|
|
869
|
+
isUninterpreted(app: number) {
|
|
870
|
+
const manager = this.util.manager;
|
|
871
|
+
const op = manager.getOp(app);
|
|
872
|
+
if ([OP_NUM, OP_LE, OP_LT, OP_GE, OP_GT, OP_ADD, OP_SUB, OP_UMINUS].includes(op)) return false;
|
|
873
|
+
if (op === OP_MOD) return this.util.getNumeral(manager.getArg(app, 1)) === undefined;
|
|
874
|
+
if (op === OP_MUL && manager.getNumArgs(app) === 2)
|
|
875
|
+
return manager.getArgs(app).every((arg) => this.util.getNumeral(arg) === undefined);
|
|
876
|
+
return true;
|
|
877
|
+
}
|
|
878
|
+
|
|
879
|
+
private getBoundSizes(bounds: BoundsProc, x: number) {
|
|
880
|
+
const factor = this.util.isReal(x) ? 2 : 1;
|
|
881
|
+
const leSize = bounds.le.length * factor;
|
|
882
|
+
const geSize = bounds.ge.length * factor;
|
|
883
|
+
return leSize + bounds.lt.length < geSize + bounds.gt.length
|
|
884
|
+
? { eSize: leSize, tSize: bounds.lt.length, isLower: true }
|
|
885
|
+
: { eSize: geSize, tSize: bounds.gt.length, isLower: false };
|
|
886
|
+
}
|
|
887
|
+
|
|
888
|
+
private addCache(x: number, formula: number, value: bigint, result: number) {
|
|
889
|
+
this.context.pin(x);
|
|
890
|
+
this.context.pin(formula);
|
|
891
|
+
this.substCache.set(`${formula}:${x}:${value}`, {
|
|
892
|
+
result: this.context.pin(result),
|
|
893
|
+
vars: [...this.util.varsAdded],
|
|
894
|
+
});
|
|
895
|
+
}
|
|
896
|
+
|
|
897
|
+
private getCache(x: number, formula: number, value: bigint) {
|
|
898
|
+
const cached = this.substCache.get(`${formula}:${x}:${value}`);
|
|
899
|
+
if (cached === undefined) return undefined;
|
|
900
|
+
for (const variable of cached.vars) this.util.addVar(variable, false);
|
|
901
|
+
return cached.result;
|
|
902
|
+
}
|
|
903
|
+
|
|
904
|
+
private assignDivs(contains: ContainsApp, bounds: BoundsProc, xT: XSubst, formula: number) {
|
|
905
|
+
const util = this.util;
|
|
906
|
+
const x = contains.x;
|
|
907
|
+
const divZ = bounds.getDivZ();
|
|
908
|
+
if (divZ === undefined) return formula;
|
|
909
|
+
util.addVar(divZ.zBv);
|
|
910
|
+
// z < d, d | (x - z) and (c | ax + t <-> c | az + t) for each divisor.
|
|
911
|
+
const d1 = divZ.d.sub(Rational.one);
|
|
912
|
+
this.context.addConstraint(false, util.mkLeApp(divZ.z, util.mkNumeral(d1)));
|
|
913
|
+
const zLeD1 = util.mkLeRewrite(divZ.z, util.mkNumeral(d1));
|
|
914
|
+
let result = util.mkAnd([formula, zLeD1]);
|
|
915
|
+
this.context.addConstraint(false, util.mkDivides(divZ.d, util.mkSub(x, divZ.z)));
|
|
916
|
+
for (const div of bounds.divs) {
|
|
917
|
+
const newAtom = util.mkDivides(
|
|
918
|
+
div.divisor,
|
|
919
|
+
util.mkAdd(util.mkMul(div.coeff, divZ.z), div.term),
|
|
920
|
+
);
|
|
921
|
+
result = util.replace(div.atom, newAtom, result);
|
|
922
|
+
this.context.addConstraint(false, this.mkNot(div.atom), newAtom);
|
|
923
|
+
this.context.addConstraint(false, this.mkNot(newAtom), div.atom);
|
|
924
|
+
}
|
|
925
|
+
xT.term = divZ.z;
|
|
926
|
+
xT.coeff = divZ.d;
|
|
927
|
+
return result;
|
|
928
|
+
}
|
|
929
|
+
|
|
930
|
+
private assignNestedDivs(bounds: BoundsProc, formula: number) {
|
|
931
|
+
const util = this.util;
|
|
932
|
+
const manager = util.manager;
|
|
933
|
+
if (bounds.nestedDivs.length === 0) return formula;
|
|
934
|
+
const divZ = bounds.getDivZ();
|
|
935
|
+
if (divZ === undefined) throw new SmtInvariantError("quantifier elimination found no divisor");
|
|
936
|
+
let result = formula;
|
|
937
|
+
for (const nested of bounds.nestedDivs) {
|
|
938
|
+
// mod_term = arg_0 mod k, with z1 < k and (coeff*x + rest - z1) mod k = 0.
|
|
939
|
+
util.addVar(nested.zBv);
|
|
940
|
+
const k1 = nested.divisor.sub(Rational.one);
|
|
941
|
+
this.context.addConstraint(false, util.mkLeApp(nested.z, util.mkNumeral(k1)));
|
|
942
|
+
const [dividend, divisor] = manager.getArgs(nested.atom);
|
|
943
|
+
const modTerm = util.simplify(
|
|
944
|
+
util.mkApp(OP_MOD, [util.mkSub(dividend, nested.z), divisor], SORT_INT),
|
|
945
|
+
);
|
|
946
|
+
this.context.addConstraint(false, util.pin(manager.mkEq(modTerm, util.mkZero(SORT_INT))));
|
|
947
|
+
result = util.replace(nested.atom, nested.z, result);
|
|
948
|
+
// (coeff*z + rest - z1) mod k = 0
|
|
949
|
+
const scaled = util.mkMulApp(util.mkNumeral(nested.coeff), nested.z);
|
|
950
|
+
const sum = util.mkAdd(scaled, util.mkSub(nested.term, divZ.z));
|
|
951
|
+
const modEq = util.simplify(
|
|
952
|
+
util.pin(manager.mkEq(util.mkApp(OP_MOD, [sum, divisor], SORT_INT), util.mkZero(SORT_INT))),
|
|
953
|
+
);
|
|
954
|
+
result = util.pin(manager.mkAnd([result, modEq]));
|
|
955
|
+
}
|
|
956
|
+
return result;
|
|
957
|
+
}
|
|
958
|
+
|
|
959
|
+
private getBounds(x: number, formula: number) {
|
|
960
|
+
return this.boundsCache.get(`${x}:${formula}`) as BoundsProc;
|
|
961
|
+
}
|
|
962
|
+
|
|
963
|
+
private mkNot(expr: number) {
|
|
964
|
+
const manager = this.util.manager;
|
|
965
|
+
return manager.isNot(expr) ? manager.getArg(expr, 0) : this.util.pin(manager.mkNot(expr));
|
|
966
|
+
}
|
|
967
|
+
|
|
968
|
+
private mkNonBounds(bounds: BoundsProc, isStrict: boolean, isLower: boolean, formula: number) {
|
|
969
|
+
let result = formula;
|
|
970
|
+
for (const bound of bounds.get(isStrict, isLower)) {
|
|
971
|
+
this.context.addConstraint(true, this.mkNot(bound.atom));
|
|
972
|
+
result = this.util.replace(bound.atom, this.util.manager.falseExpr, result);
|
|
973
|
+
}
|
|
974
|
+
return result;
|
|
975
|
+
}
|
|
976
|
+
|
|
977
|
+
private mkNonResolve(bounds: BoundsProc, isStrict: boolean, isLower: boolean, formula: number) {
|
|
978
|
+
let result = formula;
|
|
979
|
+
for (const bound of bounds.get(isStrict, !isLower)) {
|
|
980
|
+
this.context.addConstraint(true, bound.atom);
|
|
981
|
+
result = this.util.replace(bound.atom, this.util.manager.trueExpr, result);
|
|
982
|
+
}
|
|
983
|
+
return result;
|
|
984
|
+
}
|
|
985
|
+
|
|
986
|
+
private mkBound(
|
|
987
|
+
isStrict: boolean,
|
|
988
|
+
isLower: boolean,
|
|
989
|
+
a: Rational,
|
|
990
|
+
t: number,
|
|
991
|
+
b: Rational,
|
|
992
|
+
s: number,
|
|
993
|
+
) {
|
|
994
|
+
const util = this.util;
|
|
995
|
+
const result = isLower
|
|
996
|
+
? util.mkBoundAux(isStrict, b, s, a, t)
|
|
997
|
+
: util.mkBoundAux(isStrict, a, t, b, s);
|
|
998
|
+
return util.simplify(result);
|
|
999
|
+
}
|
|
1000
|
+
|
|
1001
|
+
// The bounds of the same direction as the chosen one at index, which is a*x <= t.
|
|
1002
|
+
private mkBounds(
|
|
1003
|
+
context: BoundContext,
|
|
1004
|
+
isStrict: boolean,
|
|
1005
|
+
a: Rational,
|
|
1006
|
+
t: number,
|
|
1007
|
+
formula: number,
|
|
1008
|
+
) {
|
|
1009
|
+
const util = this.util;
|
|
1010
|
+
const manager = util.manager;
|
|
1011
|
+
const bounds = context.bounds.get(isStrict, context.isLower);
|
|
1012
|
+
const isSameStrict = isStrict === context.isStrictCtx;
|
|
1013
|
+
const isNonStrictReal = util.isReal(context.x) && !context.isStrictCtx;
|
|
1014
|
+
const atom = context.bounds.get(context.isStrictCtx, context.isLower)[context.index].atom;
|
|
1015
|
+
let result = formula;
|
|
1016
|
+
for (const [index, bound] of bounds.entries()) {
|
|
1017
|
+
if (isSameStrict && index === context.index) {
|
|
1018
|
+
if (isNonStrictReal) {
|
|
1019
|
+
const eq = util.mkEq(a, context.x, t);
|
|
1020
|
+
if (context.isEq) this.context.addConstraint(true, eq);
|
|
1021
|
+
else {
|
|
1022
|
+
this.context.addConstraint(true, this.mkNot(eq));
|
|
1023
|
+
this.context.addConstraint(true, bound.atom);
|
|
1024
|
+
}
|
|
1025
|
+
} else this.context.addConstraint(true, bound.atom);
|
|
1026
|
+
result = util.replace(atom, manager.trueExpr, result);
|
|
1027
|
+
continue;
|
|
1028
|
+
}
|
|
1029
|
+
// Substitutions keep the exact value of an atom, which may occur in both polarities.
|
|
1030
|
+
const isResultStrict = isNonStrictReal && context.isEq && isStrict;
|
|
1031
|
+
const tmp = this.mkBound(isResultStrict, context.isLower, a, t, bound.coeff, bound.term);
|
|
1032
|
+
result = util.replace(bound.atom, tmp, result);
|
|
1033
|
+
this.context.addConstraint(true, this.mkNot(bound.atom), tmp);
|
|
1034
|
+
}
|
|
1035
|
+
return result;
|
|
1036
|
+
}
|
|
1037
|
+
|
|
1038
|
+
// The bounds of the other direction, resolved against the chosen one.
|
|
1039
|
+
private mkResolve(
|
|
1040
|
+
context: BoundContext,
|
|
1041
|
+
xT: XSubst,
|
|
1042
|
+
isStrict: boolean,
|
|
1043
|
+
a: Rational,
|
|
1044
|
+
t: number,
|
|
1045
|
+
formula: number,
|
|
1046
|
+
) {
|
|
1047
|
+
const util = this.util;
|
|
1048
|
+
const isStrictReal = !context.isEq && util.isReal(context.x) && !context.isStrictCtx;
|
|
1049
|
+
const isStrictResolve = isStrict || context.isStrictCtx || isStrictReal;
|
|
1050
|
+
let result = formula;
|
|
1051
|
+
for (const bound of context.bounds.get(isStrict, !context.isLower)) {
|
|
1052
|
+
const s = xT.mkTerm(bound.coeff, bound.term);
|
|
1053
|
+
const b = xT.mkCoeff(bound.coeff);
|
|
1054
|
+
const tmp = util.mkResolve(context.x, isStrictResolve, a, t, b, s);
|
|
1055
|
+
result = util.replace(bound.atom, tmp, result);
|
|
1056
|
+
this.context.addConstraint(true, this.mkNot(bound.atom), tmp);
|
|
1057
|
+
}
|
|
1058
|
+
return result;
|
|
1059
|
+
}
|
|
1060
|
+
|
|
1061
|
+
private updateBoundsIn(
|
|
1062
|
+
bounds: BoundsProc,
|
|
1063
|
+
contains: ContainsApp,
|
|
1064
|
+
atoms: Iterable<number>,
|
|
1065
|
+
isPositive: boolean,
|
|
1066
|
+
) {
|
|
1067
|
+
const manager = this.util.manager;
|
|
1068
|
+
for (const atom of atoms) {
|
|
1069
|
+
if (!contains.has(atom)) continue;
|
|
1070
|
+
const literal = isPositive ? atom : this.util.pin(manager.mkNot(atom));
|
|
1071
|
+
if (!bounds.getBound(contains, literal)) return false;
|
|
1072
|
+
}
|
|
1073
|
+
return true;
|
|
1074
|
+
}
|
|
1075
|
+
|
|
1076
|
+
private updateBounds(contains: ContainsApp, formula: number) {
|
|
1077
|
+
const key = `${contains.x}:${formula}`;
|
|
1078
|
+
if (this.boundsCache.has(key)) return true;
|
|
1079
|
+
const bounds = new BoundsProc(this.util);
|
|
1080
|
+
if (!this.updateBoundsIn(bounds, contains, this.context.posAtoms(), true)) return false;
|
|
1081
|
+
if (!this.updateBoundsIn(bounds, contains, this.context.negAtoms(), false)) return false;
|
|
1082
|
+
this.context.pin(contains.x);
|
|
1083
|
+
this.context.pin(formula);
|
|
1084
|
+
this.boundsCache.set(key, bounds);
|
|
1085
|
+
return true;
|
|
1086
|
+
}
|
|
1087
|
+
}
|
|
1088
|
+
|
|
1089
|
+
interface BoundContext {
|
|
1090
|
+
bounds: BoundsProc;
|
|
1091
|
+
x: number;
|
|
1092
|
+
isEq: boolean;
|
|
1093
|
+
isStrictCtx: boolean;
|
|
1094
|
+
isLower: boolean;
|
|
1095
|
+
index: number;
|
|
1096
|
+
}
|