tla-ts 0.0.10-dev.63a6693bd → 0.0.10-dev.7a3bb1545
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 +3 -3
- package/dist/compile.js +1 -1
- package/dist/deciders.cjs +41 -37
- package/dist/deciders.js +58 -54
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +4 -1
- package/dist/index.d.ts +4 -1
- 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 +2682 -426
- package/dist/prove.js +2679 -423
- package/dist/run.cjs +43 -42
- package/dist/run.js +45 -44
- package/dist/tlapm.cjs +1 -1
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +43 -40
- package/dist/transfer.js +43 -40
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +1 -1
- package/src/ast.ts +3 -3
- package/src/bags.ts +46 -28
- package/src/check-trace.ts +2 -16
- package/src/check.ts +336 -88
- package/src/cli/runtime-invariants.ts +20 -56
- package/src/cli/tlapm.ts +424 -62
- package/src/cli/tlc-arguments.ts +2 -2
- package/src/cli/tlc-output.ts +4 -5
- package/src/cli/tlc-usage.ts +0 -1
- package/src/cli/tlc.ts +26 -7
- package/src/dependencies.ts +23 -2
- package/src/dfid.ts +9 -2
- package/src/environment.ts +27 -5
- package/src/errors.ts +30 -3
- package/src/evaluate.ts +9 -3
- package/src/exit-codes.ts +5 -2
- package/src/instances.ts +1 -1
- package/src/levels.ts +3 -2
- package/src/lexer.ts +5 -3
- package/src/liveness-checker.ts +572 -204
- package/src/liveness.ts +47 -32
- package/src/obligations/action.ts +10 -6
- package/src/obligations/anonymize.ts +33 -14
- package/src/obligations/enabled-axioms.ts +218 -0
- package/src/obligations/equality.ts +1 -3
- package/src/obligations/expression.ts +18 -6
- package/src/obligations/format.ts +0 -2
- package/src/obligations/generate.ts +22 -17
- package/src/obligations/index.ts +36 -6
- package/src/obligations/levels.ts +24 -11
- package/src/obligations/module.ts +1 -3
- package/src/obligations/normalize.ts +24 -13
- package/src/obligations/operators.ts +0 -2
- package/src/obligations/pragma.ts +53 -16
- package/src/obligations/printer.ts +43 -13
- package/src/obligations/proof.ts +3 -2
- package/src/obligations/regroup.ts +0 -2
- package/src/obligations/simplify.ts +17 -7
- package/src/obligations/source.ts +71 -17
- package/src/obligations/subexpression.ts +45 -18
- package/src/obligations/substitution.ts +1 -3
- package/src/obligations/temporal.ts +0 -2
- package/src/obligations/tuples.ts +0 -2
- package/src/parallel-worker.ts +8 -2
- package/src/parallel.ts +7 -2
- package/src/parser.ts +633 -186
- package/src/pretty-print.ts +1 -1
- package/src/prover/deciders.ts +11 -8
- package/src/prover/isabelle/decide.ts +3 -25
- package/src/prover/isabelle/encode.ts +71 -41
- 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 +149 -3
- package/src/prover/isabelle/isar/method.ts +506 -198
- 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 +479 -69
- package/src/prover/isabelle/isar/toplevel.ts +331 -0
- package/src/prover/isabelle/isar/type-check.ts +83 -8
- package/src/prover/isabelle/provers/blast/blast.ts +0 -2
- 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 +2 -4
- package/src/prover/isabelle/pure/bicompose.ts +0 -2
- package/src/prover/isabelle/pure/consts.ts +0 -2
- package/src/prover/isabelle/pure/conv.ts +0 -2
- package/src/prover/isabelle/pure/drule.ts +63 -4
- 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 +0 -2
- 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 +0 -2
- package/src/prover/isabelle/pure/rewriter.ts +1 -8
- 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 +0 -2
- package/src/prover/isabelle/pure/tactic.ts +0 -2
- package/src/prover/isabelle/pure/tactical.ts +0 -2
- package/src/prover/isabelle/pure/term-ord.ts +0 -2
- package/src/prover/isabelle/pure/term.ts +0 -2
- package/src/prover/isabelle/pure/thm.ts +0 -2
- 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 +1 -2
- package/src/prover/isabelle/tla/context.ts +51 -9
- package/src/prover/isabelle/tla/logic-data.ts +1 -1
- package/src/prover/isabelle/tla/logic.ts +40 -1
- package/src/prover/isabelle/tla/simpdata.ts +0 -2
- package/src/prover/isabelle/tools/intuitionistic.ts +28 -12
- package/src/prover/ocaml.ts +4 -1
- package/src/prover/prep/action.ts +19 -12
- package/src/prover/prep/enabled-axioms.ts +11 -2
- package/src/prover/prep/methods.ts +159 -50
- package/src/prover/prep/normalize.ts +38 -9
- package/src/prover/prove.ts +343 -65
- 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 +42 -6
- package/src/prover/smt/data.ts +191 -84
- package/src/prover/smt/encode.ts +122 -43
- 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 +483 -116
- package/src/prover/smt/simplify.ts +441 -0
- package/src/prover/smt/solver/ackermannize-bv-tactic.ts +61 -0
- package/src/prover/smt/solver/ackr-helper.ts +179 -0
- package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
- package/src/prover/smt/solver/act-cache.ts +0 -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 +613 -6
- 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 +309 -0
- package/src/prover/smt/solver/asserted-formulas.ts +93 -15
- 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 +1448 -41
- package/src/prover/smt/solver/auf-solver.ts +0 -1
- package/src/prover/smt/solver/bit-blast-tactic.ts +582 -0
- package/src/prover/smt/solver/bit-blaster.ts +871 -0
- package/src/prover/smt/solver/bound-manager.ts +196 -0
- package/src/prover/smt/solver/bound-simplifier.ts +600 -0
- package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
- package/src/prover/smt/solver/bv-decl-plugin.ts +338 -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 +109 -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 +278 -0
- package/src/prover/smt/solver/conflict-resolution.ts +78 -2
- package/src/prover/smt/solver/context.ts +533 -114
- package/src/prover/smt/solver/ctx-simplify.ts +21 -12
- package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
- package/src/prover/smt/solver/datatype-decl-plugin.ts +572 -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 +81 -0
- package/src/prover/smt/solver/der.ts +38 -10
- package/src/prover/smt/solver/diff-neq.ts +205 -0
- package/src/prover/smt/solver/distribute-forall.ts +57 -0
- package/src/prover/smt/solver/dom-simplify.ts +511 -0
- package/src/prover/smt/solver/dt2bv-tactic.ts +260 -0
- package/src/prover/smt/solver/dyn-ack.ts +0 -1
- package/src/prover/smt/solver/e-matching.ts +6 -7
- package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
- package/src/prover/smt/solver/elim-uncnstr.ts +542 -0
- package/src/prover/smt/solver/enode.ts +100 -3
- package/src/prover/smt/solver/eq2bv-tactic.ts +218 -0
- package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
- package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
- package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
- package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
- package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
- package/src/prover/smt/solver/euf/array-solver.ts +306 -0
- package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
- package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
- package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
- package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
- package/src/prover/smt/solver/euf/egraph.ts +901 -0
- package/src/prover/smt/solver/euf/euf-solver.ts +1204 -0
- package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
- package/src/prover/smt/solver/euf/mam.ts +1046 -0
- package/src/prover/smt/solver/euf/q-ematch.ts +829 -0
- package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
- package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
- package/src/prover/smt/solver/euf/q-solver.ts +361 -0
- package/src/prover/smt/solver/euf/th-solver.ts +328 -0
- package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
- package/src/prover/smt/solver/expr-ref.ts +0 -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 +267 -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 +884 -0
- package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
- package/src/prover/smt/solver/fpa-rewriter.ts +639 -0
- package/src/prover/smt/solver/fpa2bv-converter.ts +2251 -0
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +348 -0
- package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
- package/src/prover/smt/solver/goal.ts +177 -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 +30 -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 +109 -36
- 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 +345 -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 +18 -3
- 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 +0 -2
- 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 +0 -1
- 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 +40 -4
- package/src/prover/smt/solver/lp/lar-term.ts +0 -1
- package/src/prover/smt/solver/lp/lp-settings.ts +0 -1
- 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 +66 -11
- 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 +118 -88
- 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 +309 -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 +105 -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 +17 -26
- package/src/prover/smt/solver/model-evaluator.ts +188 -12
- package/src/prover/smt/solver/model-finder.ts +0 -1
- package/src/prover/smt/solver/model-generator.ts +59 -30
- package/src/prover/smt/solver/model-macro-solver.ts +38 -27
- 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 +410 -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 +496 -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 +201 -0
- package/src/prover/smt/solver/muz/rule-properties.ts +337 -0
- package/src/prover/smt/solver/muz/spacer-context.ts +1404 -0
- package/src/prover/smt/solver/muz/spacer-dl-interface.ts +52 -0
- package/src/prover/smt/solver/muz/spacer-generalizers.ts +241 -0
- package/src/prover/smt/solver/muz/spacer-manager.ts +127 -0
- package/src/prover/smt/solver/muz/spacer-pdr.ts +219 -0
- package/src/prover/smt/solver/muz/spacer-prop-solver.ts +333 -0
- package/src/prover/smt/solver/muz/spacer-util.ts +282 -0
- package/src/prover/smt/solver/muz/substitution.ts +203 -0
- package/src/prover/smt/solver/nla2bv-tactic.ts +285 -0
- package/src/prover/smt/solver/nlqsat.ts +484 -0
- package/src/prover/smt/solver/nlsat/algebraic.ts +305 -88
- package/src/prover/smt/solver/nlsat/atoms.ts +52 -35
- package/src/prover/smt/solver/nlsat/evaluator.ts +0 -1
- package/src/prover/smt/solver/nlsat/explain.ts +424 -211
- package/src/prover/smt/solver/nlsat/interval-set.ts +1 -2
- package/src/prover/smt/solver/nlsat/levelwise.ts +460 -241
- package/src/prover/smt/solver/nlsat/mpbq.ts +45 -1
- package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -683
- package/src/prover/smt/solver/nlsat/solver.ts +282 -69
- 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 +8 -7
- 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 +105 -23
- 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 +792 -0
- package/src/prover/smt/solver/opt-nlsat.ts +386 -0
- package/src/prover/smt/solver/opt-pareto.ts +282 -0
- package/src/prover/smt/solver/opt-preprocess.ts +101 -0
- package/src/prover/smt/solver/opt-solver.ts +311 -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 +540 -0
- package/src/prover/smt/solver/poly-rewriter.ts +202 -57
- package/src/prover/smt/solver/probes.ts +511 -0
- package/src/prover/smt/solver/propagate-values.ts +37 -21
- package/src/prover/smt/solver/proto-model.ts +650 -17
- package/src/prover/smt/solver/pull-quant.ts +28 -12
- package/src/prover/smt/solver/purify-arith.ts +632 -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 +37 -17
- 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 +814 -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 +9 -10
- package/src/prover/smt/solver/quantifier-manager.ts +25 -24
- 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 +77 -10
- package/src/prover/smt/solver/rewriter.ts +475 -36
- package/src/prover/smt/solver/rlimit.ts +38 -2
- 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 +526 -0
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +378 -0
- package/src/prover/smt/solver/sat/model-converter.ts +136 -0
- package/src/prover/smt/solver/sat/pb-constraint.ts +261 -0
- package/src/prover/smt/solver/sat/pb-solver.ts +1577 -0
- package/src/prover/smt/solver/sat/probing.ts +170 -0
- package/src/prover/smt/solver/sat/sat-tactic.ts +44 -0
- package/src/prover/smt/solver/sat/sat2goal.ts +165 -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 +2105 -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 +90 -0
- package/src/prover/smt/solver/smt-logics.ts +66 -0
- package/src/prover/smt/solver/smt-setup.ts +496 -0
- package/src/prover/smt/solver/smt2-printer.ts +765 -0
- package/src/prover/smt/solver/smtlib-parser.ts +3154 -326
- package/src/prover/smt/solver/smtlib-script.ts +1702 -0
- package/src/prover/smt/solver/solve-eqs.ts +923 -0
- package/src/prover/smt/solver/solver.ts +113 -22
- 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 +1995 -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 +1200 -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 -5
- package/src/prover/smt/solver/theory-lra-final-check.ts +56 -71
- package/src/prover/smt/solver/theory-lra-internalize.ts +89 -11
- package/src/prover/smt/solver/theory-lra-model.ts +20 -35
- package/src/prover/smt/solver/theory-lra-propagate.ts +24 -28
- package/src/prover/smt/solver/theory-lra-state.ts +6 -22
- package/src/prover/smt/solver/theory-lra.ts +188 -2
- package/src/prover/smt/solver/theory-pb.ts +933 -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.ts +189 -0
- package/src/prover/smt/solver/tseitin-cnf.ts +485 -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 +29 -8
- package/src/prover/tlapm-library.ts +3208 -0
- package/src/prover/verdict.ts +2 -0
- package/src/prover/zenon/decide.ts +10 -7
- package/src/prover/zenon/encode.ts +0 -2
- package/src/prover/zenon/eqrel.ts +0 -2
- package/src/prover/zenon/equality-rules.ts +24 -2
- package/src/prover/zenon/expr.ts +21 -2
- package/src/prover/zenon/index-table.ts +7 -4
- package/src/prover/zenon/isar-case.ts +1 -3
- package/src/prover/zenon/isar.ts +2 -4
- package/src/prover/zenon/llproof.ts +0 -2
- package/src/prover/zenon/mltoll.ts +0 -2
- package/src/prover/zenon/node.ts +20 -5
- package/src/prover/zenon/parse.ts +6 -2
- 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 +7 -5
- package/src/prover/zenon/tla/functions.ts +0 -2
- package/src/prover/zenon/tla/llproof.ts +0 -2
- package/src/prover/zenon/tla/records.ts +0 -2
- package/src/prover/zenon/tla/rewrites.ts +0 -2
- package/src/prover/zenon/tla/sets.ts +7 -8
- package/src/prover/zenon/tla/terms.ts +0 -2
- package/src/prover/zenon/tla/tla.ts +0 -2
- package/src/resolve.ts +72 -36
- package/src/runtime.ts +6 -0
- package/src/sany/generation.ts +1 -13
- package/src/sany/generator-definitions.ts +1 -1
- package/src/sany/generator-expressions.ts +9 -17
- package/src/sany/generator-proofs.ts +1 -1
- package/src/sany/generator.ts +1 -1
- package/src/sany/levels.ts +0 -2
- package/src/sany/linter.ts +0 -2
- package/src/search.ts +198 -45
- package/src/simulate.ts +3 -0
- package/src/standard-definitions.ts +4 -0
- package/src/state-graph.ts +0 -2
- package/src/subexpressions.ts +4 -2
- package/src/successors.ts +1 -1
- package/src/symmetry.ts +2 -2
- package/src/tableau.ts +2 -2
- package/src/tlc/fingerprint.ts +81 -9
- package/src/tlc/jar-data.ts +12 -0
- package/src/tlc/order.ts +14 -3
- package/src/tlc/summary.ts +29 -14
- package/src/tlc/tlcext-operators.ts +61 -16
- package/src/tlc/trace-spec.ts +2 -3
- package/src/typed-tier.ts +6541 -0
- package/src/typescript/types.ts +2 -2
- package/src/values.ts +1 -1
- 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,1499 @@
|
|
|
1
|
+
import { SmtInvariantError, SmtUnsupportedError } from "../../../errors";
|
|
2
|
+
import {
|
|
3
|
+
type AstManager,
|
|
4
|
+
FAMILY_ARRAY,
|
|
5
|
+
FAMILY_BASIC,
|
|
6
|
+
FAMILY_BV,
|
|
7
|
+
FAMILY_DATATYPE,
|
|
8
|
+
KIND_APP,
|
|
9
|
+
KIND_QUANTIFIER,
|
|
10
|
+
OP_AND,
|
|
11
|
+
OP_BSDIV0,
|
|
12
|
+
OP_BSMOD_I,
|
|
13
|
+
OP_EQ,
|
|
14
|
+
OP_IMPLIES,
|
|
15
|
+
OP_ITE,
|
|
16
|
+
OP_OR,
|
|
17
|
+
OP_ULEQ,
|
|
18
|
+
OP_XOR,
|
|
19
|
+
SORT_BOOL,
|
|
20
|
+
QUANTIFIER_EXISTS,
|
|
21
|
+
QUANTIFIER_FORALL,
|
|
22
|
+
} from "./ast";
|
|
23
|
+
import { flattenAndVector, hasUninterpreted, isAppOf, mkNot } from "./ast-util";
|
|
24
|
+
import { mkBvApp } from "./bv-decl-plugin";
|
|
25
|
+
import { MBQI_MAX_ITERATIONS } from "./context";
|
|
26
|
+
import { ExprSafeReplace } from "./expr-safe-replace";
|
|
27
|
+
import type { Goal } from "./goal";
|
|
28
|
+
import { ObjHashtable } from "./hashtable";
|
|
29
|
+
import { L_TRUE, L_UNDEF } from "./lbool";
|
|
30
|
+
import type { ProtoModel } from "./proto-model";
|
|
31
|
+
import { ArithPlugin } from "./qe-arith-plugin";
|
|
32
|
+
import { hasSubterm } from "./recfun-decl-plugin";
|
|
33
|
+
import { RefVector } from "./ref-vector";
|
|
34
|
+
import { Rewriter, TACTIC_REWRITER_OPTIONS } from "./rewriter";
|
|
35
|
+
import { InvVarShifter, RewriterTpl, VarShifter } from "./rewriter-tpl";
|
|
36
|
+
import { SmtKernel } from "./smt-kernel";
|
|
37
|
+
import { VarSubst } from "./var-subst";
|
|
38
|
+
|
|
39
|
+
// Whether an expression contains x, with the answers kept for the subterms.
|
|
40
|
+
export class ContainsApp {
|
|
41
|
+
private visited = new Set<number>();
|
|
42
|
+
private holds = new Set<number>();
|
|
43
|
+
|
|
44
|
+
constructor(
|
|
45
|
+
private manager: AstManager,
|
|
46
|
+
readonly x: number,
|
|
47
|
+
) {}
|
|
48
|
+
|
|
49
|
+
has(expr: number) {
|
|
50
|
+
const manager = this.manager;
|
|
51
|
+
const todo = [expr];
|
|
52
|
+
while (todo.length > 0) {
|
|
53
|
+
const current = todo[todo.length - 1];
|
|
54
|
+
if (current === this.x) this.holds.add(current);
|
|
55
|
+
if (this.visited.has(current)) {
|
|
56
|
+
todo.pop();
|
|
57
|
+
continue;
|
|
58
|
+
}
|
|
59
|
+
const kind = manager.kinds[current];
|
|
60
|
+
if (kind === KIND_APP) {
|
|
61
|
+
let isAllVisited = true;
|
|
62
|
+
for (const arg of manager.getArgs(current)) {
|
|
63
|
+
if (!this.visited.has(arg)) {
|
|
64
|
+
todo.push(arg);
|
|
65
|
+
isAllVisited = false;
|
|
66
|
+
} else if (this.holds.has(arg)) this.holds.add(current);
|
|
67
|
+
}
|
|
68
|
+
if (isAllVisited) {
|
|
69
|
+
this.visited.add(current);
|
|
70
|
+
todo.pop();
|
|
71
|
+
}
|
|
72
|
+
} else if (kind === KIND_QUANTIFIER) {
|
|
73
|
+
const body = manager.getQuantifier(current).body;
|
|
74
|
+
if (this.visited.has(body)) {
|
|
75
|
+
todo.pop();
|
|
76
|
+
if (this.holds.has(body)) this.holds.add(current);
|
|
77
|
+
this.visited.add(current);
|
|
78
|
+
} else todo.push(body);
|
|
79
|
+
} else {
|
|
80
|
+
todo.pop();
|
|
81
|
+
this.visited.add(current);
|
|
82
|
+
}
|
|
83
|
+
}
|
|
84
|
+
return this.holds.has(expr);
|
|
85
|
+
}
|
|
86
|
+
}
|
|
87
|
+
|
|
88
|
+
export interface QeSolverPlugin {
|
|
89
|
+
readonly family: number;
|
|
90
|
+
getNumBranches(x: ContainsApp, formula: number): bigint | undefined;
|
|
91
|
+
assign(x: ContainsApp, formula: number, value: bigint): void;
|
|
92
|
+
subst(x: ContainsApp, value: bigint, formula: number): number;
|
|
93
|
+
solve(conjs: readonly number[], formula: number): boolean;
|
|
94
|
+
mkAtom(expr: number, isPositive: boolean): number | undefined;
|
|
95
|
+
isUninterpreted(app: number): boolean;
|
|
96
|
+
}
|
|
97
|
+
|
|
98
|
+
export interface QeSolverContext {
|
|
99
|
+
readonly manager: AstManager;
|
|
100
|
+
pin(expr: number): number;
|
|
101
|
+
pinOwned(expr: number): number;
|
|
102
|
+
posAtoms(): ObjHashtable;
|
|
103
|
+
negAtoms(): ObjHashtable;
|
|
104
|
+
getNumVars(): number;
|
|
105
|
+
getVar(index: number): number;
|
|
106
|
+
getVars(): readonly number[];
|
|
107
|
+
getVarIndex(expr: number): number;
|
|
108
|
+
contains(index: number): ContainsApp;
|
|
109
|
+
elimVar(index: number, formula: number): void;
|
|
110
|
+
addVar(x: number): void;
|
|
111
|
+
addConstraint(isUsingCurrent: boolean, ...literals: number[]): void;
|
|
112
|
+
blastOr(variable: number, formula: number): number;
|
|
113
|
+
}
|
|
114
|
+
|
|
115
|
+
const getFlatConjuncts = (manager: AstManager, formula: number) => {
|
|
116
|
+
const conjs = new RefVector(manager);
|
|
117
|
+
conjs.push(formula);
|
|
118
|
+
flattenAndVector(manager, conjs);
|
|
119
|
+
const result = [...conjs.items];
|
|
120
|
+
conjs.reset();
|
|
121
|
+
return result;
|
|
122
|
+
};
|
|
123
|
+
|
|
124
|
+
const applySubstitution = (
|
|
125
|
+
context: QeSolverContext,
|
|
126
|
+
source: number,
|
|
127
|
+
target: number,
|
|
128
|
+
formula: number,
|
|
129
|
+
) => {
|
|
130
|
+
const replace = new ExprSafeReplace(context.manager);
|
|
131
|
+
replace.insert(source, target);
|
|
132
|
+
const result = context.pinOwned(replace.apply(formula));
|
|
133
|
+
replace.release();
|
|
134
|
+
return result;
|
|
135
|
+
};
|
|
136
|
+
|
|
137
|
+
class BoolPlugin implements QeSolverPlugin {
|
|
138
|
+
readonly family = FAMILY_BASIC;
|
|
139
|
+
|
|
140
|
+
constructor(private context: QeSolverContext) {}
|
|
141
|
+
|
|
142
|
+
assign() {}
|
|
143
|
+
|
|
144
|
+
getNumBranches() {
|
|
145
|
+
return 2n;
|
|
146
|
+
}
|
|
147
|
+
|
|
148
|
+
subst(x: ContainsApp, value: bigint, formula: number) {
|
|
149
|
+
const manager = this.context.manager;
|
|
150
|
+
return applySubstitution(
|
|
151
|
+
this.context,
|
|
152
|
+
x.x,
|
|
153
|
+
value === 1n ? manager.trueExpr : manager.falseExpr,
|
|
154
|
+
formula,
|
|
155
|
+
);
|
|
156
|
+
}
|
|
157
|
+
|
|
158
|
+
solve(conjs: readonly number[], formula: number) {
|
|
159
|
+
return this.solveUnits(conjs, formula) || this.solvePolarized(formula);
|
|
160
|
+
}
|
|
161
|
+
|
|
162
|
+
mkAtom() {
|
|
163
|
+
return undefined;
|
|
164
|
+
}
|
|
165
|
+
|
|
166
|
+
isUninterpreted() {
|
|
167
|
+
return false;
|
|
168
|
+
}
|
|
169
|
+
|
|
170
|
+
private solveUnits(conjs: readonly number[], formula: number) {
|
|
171
|
+
const context = this.context;
|
|
172
|
+
const manager = context.manager;
|
|
173
|
+
for (const conj of conjs) {
|
|
174
|
+
if (manager.kinds[conj] !== KIND_APP) continue;
|
|
175
|
+
const index = context.getVarIndex(conj);
|
|
176
|
+
if (index !== -1) {
|
|
177
|
+
context.elimVar(index, applySubstitution(context, conj, manager.trueExpr, formula));
|
|
178
|
+
return true;
|
|
179
|
+
}
|
|
180
|
+
const negatedIndex = manager.isNot(conj) ? context.getVarIndex(manager.getArg(conj, 0)) : -1;
|
|
181
|
+
if (negatedIndex !== -1) {
|
|
182
|
+
const replaced = applySubstitution(
|
|
183
|
+
context,
|
|
184
|
+
manager.getArg(conj, 0),
|
|
185
|
+
manager.falseExpr,
|
|
186
|
+
formula,
|
|
187
|
+
);
|
|
188
|
+
context.elimVar(negatedIndex, replaced);
|
|
189
|
+
return true;
|
|
190
|
+
}
|
|
191
|
+
}
|
|
192
|
+
return false;
|
|
193
|
+
}
|
|
194
|
+
|
|
195
|
+
private solvePolarized(formula: number) {
|
|
196
|
+
const context = this.context;
|
|
197
|
+
const manager = context.manager;
|
|
198
|
+
for (let index = 0; index < context.getNumVars(); index++) {
|
|
199
|
+
if (manager.sorts[context.getVar(index)] !== SORT_BOOL) continue;
|
|
200
|
+
const solved = this.solvePolarizedVar(context.contains(index), formula);
|
|
201
|
+
if (solved !== undefined) {
|
|
202
|
+
context.elimVar(index, solved);
|
|
203
|
+
return true;
|
|
204
|
+
}
|
|
205
|
+
}
|
|
206
|
+
return false;
|
|
207
|
+
}
|
|
208
|
+
|
|
209
|
+
private solvePolarizedVar(contains: ContainsApp, formula: number) {
|
|
210
|
+
const context = this.context;
|
|
211
|
+
const manager = context.manager;
|
|
212
|
+
const x = contains.x;
|
|
213
|
+
const isPositive = context.posAtoms().has(x);
|
|
214
|
+
const isNegative = context.negAtoms().has(x);
|
|
215
|
+
if (isPositive && isNegative) return undefined;
|
|
216
|
+
if (isPositive || isNegative) {
|
|
217
|
+
for (const atom of context.posAtoms())
|
|
218
|
+
if ((isNegative || atom !== x) && contains.has(atom)) return undefined;
|
|
219
|
+
for (const atom of context.negAtoms())
|
|
220
|
+
if ((isPositive || atom !== x) && contains.has(atom)) return undefined;
|
|
221
|
+
// Each occurrence of x is in atoms of one polarity.
|
|
222
|
+
return applySubstitution(
|
|
223
|
+
context,
|
|
224
|
+
x,
|
|
225
|
+
isPositive ? manager.trueExpr : manager.falseExpr,
|
|
226
|
+
formula,
|
|
227
|
+
);
|
|
228
|
+
}
|
|
229
|
+
return contains.has(formula) ? undefined : formula;
|
|
230
|
+
}
|
|
231
|
+
}
|
|
232
|
+
|
|
233
|
+
class BvPlugin implements QeSolverPlugin {
|
|
234
|
+
readonly family = FAMILY_BV;
|
|
235
|
+
|
|
236
|
+
constructor(private context: QeSolverContext) {}
|
|
237
|
+
|
|
238
|
+
assign() {}
|
|
239
|
+
|
|
240
|
+
getNumBranches(x: ContainsApp) {
|
|
241
|
+
const manager = this.context.manager;
|
|
242
|
+
return 1n << BigInt(manager.getBvSize(manager.sorts[x.x]));
|
|
243
|
+
}
|
|
244
|
+
|
|
245
|
+
subst(x: ContainsApp, value: bigint, formula: number) {
|
|
246
|
+
const manager = this.context.manager;
|
|
247
|
+
const numeral = this.context.pin(
|
|
248
|
+
manager.mkBvNumeral(value, manager.getBvSize(manager.sorts[x.x])),
|
|
249
|
+
);
|
|
250
|
+
return applySubstitution(this.context, x.x, numeral, formula);
|
|
251
|
+
}
|
|
252
|
+
|
|
253
|
+
solve() {
|
|
254
|
+
return false;
|
|
255
|
+
}
|
|
256
|
+
|
|
257
|
+
mkAtom() {
|
|
258
|
+
return undefined;
|
|
259
|
+
}
|
|
260
|
+
|
|
261
|
+
isUninterpreted(app: number) {
|
|
262
|
+
const op = this.context.manager.getOp(app);
|
|
263
|
+
return op >= OP_BSDIV0 && op <= OP_BSMOD_I;
|
|
264
|
+
}
|
|
265
|
+
}
|
|
266
|
+
|
|
267
|
+
class SearchTree {
|
|
268
|
+
vars: number[] = [];
|
|
269
|
+
variable = -1;
|
|
270
|
+
formula = -1;
|
|
271
|
+
numBranches = 0n;
|
|
272
|
+
children: SearchTree[] = [];
|
|
273
|
+
branchIndex = new Map<bigint, number>();
|
|
274
|
+
pos: ObjHashtable;
|
|
275
|
+
neg: ObjHashtable;
|
|
276
|
+
|
|
277
|
+
constructor(
|
|
278
|
+
private manager: AstManager,
|
|
279
|
+
readonly parent: SearchTree | undefined,
|
|
280
|
+
readonly assignment: number,
|
|
281
|
+
) {
|
|
282
|
+
this.pos = new ObjHashtable((expr) => manager.hashes[expr]);
|
|
283
|
+
this.neg = new ObjHashtable((expr) => manager.hashes[expr]);
|
|
284
|
+
}
|
|
285
|
+
|
|
286
|
+
getLeaves() {
|
|
287
|
+
const result: number[] = [];
|
|
288
|
+
const todo: SearchTree[] = [this];
|
|
289
|
+
for (let node = todo.pop(); node !== undefined; node = todo.pop()) {
|
|
290
|
+
if (
|
|
291
|
+
node.children.length === 0 &&
|
|
292
|
+
node.formula !== -1 &&
|
|
293
|
+
node.vars.length === 0 &&
|
|
294
|
+
node.variable === -1
|
|
295
|
+
)
|
|
296
|
+
result.push(node.formula);
|
|
297
|
+
for (const child of node.children) todo.push(child);
|
|
298
|
+
}
|
|
299
|
+
return result;
|
|
300
|
+
}
|
|
301
|
+
|
|
302
|
+
reset() {
|
|
303
|
+
this.pos = new ObjHashtable((expr) => this.manager.hashes[expr]);
|
|
304
|
+
this.neg = new ObjHashtable((expr) => this.manager.hashes[expr]);
|
|
305
|
+
this.children = [];
|
|
306
|
+
this.vars = [];
|
|
307
|
+
this.branchIndex.clear();
|
|
308
|
+
this.variable = -1;
|
|
309
|
+
this.numBranches = 0n;
|
|
310
|
+
}
|
|
311
|
+
|
|
312
|
+
setVar(x: number, numBranches: bigint) {
|
|
313
|
+
this.variable = x;
|
|
314
|
+
this.vars.splice(this.vars.indexOf(x), 1);
|
|
315
|
+
this.numBranches = numBranches;
|
|
316
|
+
}
|
|
317
|
+
|
|
318
|
+
consumeVars(vars: number[]) {
|
|
319
|
+
for (let variable = vars.pop(); variable !== undefined; variable = vars.pop())
|
|
320
|
+
this.vars.push(variable);
|
|
321
|
+
}
|
|
322
|
+
|
|
323
|
+
isUnit() {
|
|
324
|
+
return this.children.length === 1 && this.branchIndex.size === 0;
|
|
325
|
+
}
|
|
326
|
+
|
|
327
|
+
delVar(x: number) {
|
|
328
|
+
this.vars.splice(this.vars.indexOf(x), 1);
|
|
329
|
+
}
|
|
330
|
+
|
|
331
|
+
addChild(formula: number) {
|
|
332
|
+
this.numBranches = 1n;
|
|
333
|
+
const child = new SearchTree(this.manager, this, this.manager.trueExpr);
|
|
334
|
+
this.children.push(child);
|
|
335
|
+
child.formula = formula;
|
|
336
|
+
child.vars.push(...this.vars);
|
|
337
|
+
return child;
|
|
338
|
+
}
|
|
339
|
+
|
|
340
|
+
addBranch(branch: bigint, assignment: number) {
|
|
341
|
+
const child = new SearchTree(this.manager, this, assignment);
|
|
342
|
+
this.branchIndex.set(branch, this.children.length);
|
|
343
|
+
this.children.push(child);
|
|
344
|
+
child.vars.push(...this.vars);
|
|
345
|
+
return child;
|
|
346
|
+
}
|
|
347
|
+
|
|
348
|
+
getChild(branch: bigint) {
|
|
349
|
+
return this.children[this.branchIndex.get(branch) as number];
|
|
350
|
+
}
|
|
351
|
+
}
|
|
352
|
+
|
|
353
|
+
// Splits the conjuncts into those without the variables, those with both the variables and
|
|
354
|
+
// uninterpreted terms, and those with the variables.
|
|
355
|
+
const getPartition = (
|
|
356
|
+
plugins: readonly QeSolverPlugin[],
|
|
357
|
+
manager: AstManager,
|
|
358
|
+
rewriter: Rewriter,
|
|
359
|
+
formula: number,
|
|
360
|
+
vars: readonly number[],
|
|
361
|
+
) => {
|
|
362
|
+
const conjs = getFlatConjuncts(manager, formula);
|
|
363
|
+
const visited = new Set<number>();
|
|
364
|
+
const containsVar = new Set<number>();
|
|
365
|
+
const containsUf = new Set<number>();
|
|
366
|
+
const isUninterpretedApp = (app: number) => {
|
|
367
|
+
const family = manager.getFamily(app);
|
|
368
|
+
const plugin = plugins.find((candidate) => candidate.family === family);
|
|
369
|
+
return manager.isUninterpreted(app) || plugin === undefined || plugin.isUninterpreted(app);
|
|
370
|
+
};
|
|
371
|
+
const todo = [...conjs];
|
|
372
|
+
while (todo.length > 0) {
|
|
373
|
+
const expr = todo[todo.length - 1];
|
|
374
|
+
if (visited.has(expr)) {
|
|
375
|
+
todo.pop();
|
|
376
|
+
continue;
|
|
377
|
+
}
|
|
378
|
+
if (vars.includes(expr)) {
|
|
379
|
+
containsVar.add(expr);
|
|
380
|
+
visited.add(expr);
|
|
381
|
+
todo.pop();
|
|
382
|
+
continue;
|
|
383
|
+
}
|
|
384
|
+
if (manager.kinds[expr] !== KIND_APP) {
|
|
385
|
+
visited.add(expr);
|
|
386
|
+
todo.pop();
|
|
387
|
+
continue;
|
|
388
|
+
}
|
|
389
|
+
let isAllVisited = true;
|
|
390
|
+
if (isUninterpretedApp(expr)) containsUf.add(expr);
|
|
391
|
+
for (const arg of manager.getArgs(expr)) {
|
|
392
|
+
if (!visited.has(arg)) {
|
|
393
|
+
isAllVisited = false;
|
|
394
|
+
todo.push(arg);
|
|
395
|
+
continue;
|
|
396
|
+
}
|
|
397
|
+
if (containsVar.has(arg)) containsVar.add(expr);
|
|
398
|
+
if (containsUf.has(arg)) containsUf.add(expr);
|
|
399
|
+
}
|
|
400
|
+
if (isAllVisited) {
|
|
401
|
+
todo.pop();
|
|
402
|
+
visited.add(expr);
|
|
403
|
+
}
|
|
404
|
+
}
|
|
405
|
+
const closed: number[] = [];
|
|
406
|
+
const mixed: number[] = [];
|
|
407
|
+
const open: number[] = [];
|
|
408
|
+
for (const conj of conjs) {
|
|
409
|
+
if (containsVar.has(conj) && containsUf.has(conj)) {
|
|
410
|
+
mixed.push(conj);
|
|
411
|
+
open.push(conj);
|
|
412
|
+
} else if (containsVar.has(conj)) open.push(conj);
|
|
413
|
+
else closed.push(conj);
|
|
414
|
+
}
|
|
415
|
+
const mkAnd = (args: number[]) => manager.withTemporaries(() => rewriter.mkAnd(args));
|
|
416
|
+
return { closed: mkAnd(closed), mixed: mkAnd(mixed), open: mkAnd(open) };
|
|
417
|
+
};
|
|
418
|
+
|
|
419
|
+
// Partitions the variables into buckets that cover disjoint sets of conjuncts. A variable in more
|
|
420
|
+
// than half of the conjuncts is shared.
|
|
421
|
+
const partitionVars = (contains: readonly ContainsApp[], args: readonly number[]) => {
|
|
422
|
+
const partition: number[][] = [];
|
|
423
|
+
const parents: number[] = [];
|
|
424
|
+
const find = (index: number): number => (parents[index] === index ? index : find(parents[index]));
|
|
425
|
+
const nonShared: number[] = [];
|
|
426
|
+
const nonSharedVars: number[] = [];
|
|
427
|
+
for (const [variable, containsX] of contains.entries()) {
|
|
428
|
+
const indices = args.flatMap((arg, index) => (containsX.has(arg) ? [index] : []));
|
|
429
|
+
if (2 * indices.length > args.length) {
|
|
430
|
+
if (partition.length === 0) partition.push([]);
|
|
431
|
+
partition[partition.length - 1].push(variable);
|
|
432
|
+
continue;
|
|
433
|
+
}
|
|
434
|
+
const varX = parents.length;
|
|
435
|
+
parents.push(varX);
|
|
436
|
+
nonSharedVars.push(variable);
|
|
437
|
+
for (const index of indices) {
|
|
438
|
+
const varY = nonShared[index];
|
|
439
|
+
if (varY === undefined) nonShared[index] = varX;
|
|
440
|
+
else {
|
|
441
|
+
const rootX = find(varX);
|
|
442
|
+
const rootY = find(varY);
|
|
443
|
+
if (rootX !== rootY) parents[rootX] = rootY;
|
|
444
|
+
}
|
|
445
|
+
}
|
|
446
|
+
}
|
|
447
|
+
if (nonSharedVars.length === 0) return undefined;
|
|
448
|
+
const root0 = find(0);
|
|
449
|
+
if (!nonSharedVars.some((_value, index) => index > 0 && find(index) !== root0)) return undefined;
|
|
450
|
+
const roots: number[] = partition.length > 0 ? [-1] : [];
|
|
451
|
+
for (const [index, x] of nonSharedVars.entries()) {
|
|
452
|
+
const root = nonSharedVars[find(index)];
|
|
453
|
+
const found = roots.indexOf(root);
|
|
454
|
+
if (found !== -1) partition[found].push(x);
|
|
455
|
+
else {
|
|
456
|
+
roots.push(root);
|
|
457
|
+
partition.push([x]);
|
|
458
|
+
}
|
|
459
|
+
}
|
|
460
|
+
return partition;
|
|
461
|
+
};
|
|
462
|
+
|
|
463
|
+
// Converts a formula to negation normal form over the relevant atoms, lifting the if-then-else
|
|
464
|
+
// terms of atoms to formulas.
|
|
465
|
+
class Nnf {
|
|
466
|
+
private pos = new Map<number, number>();
|
|
467
|
+
private neg = new Map<number, number>();
|
|
468
|
+
private todo: number[] = [];
|
|
469
|
+
private pols: boolean[] = [];
|
|
470
|
+
|
|
471
|
+
constructor(
|
|
472
|
+
private context: QeSolverContext,
|
|
473
|
+
private rewriter: Rewriter,
|
|
474
|
+
private isRelevant: (expr: number) => boolean,
|
|
475
|
+
) {}
|
|
476
|
+
|
|
477
|
+
apply(formula: number) {
|
|
478
|
+
this.reset();
|
|
479
|
+
return this.getNnf(formula, true) as number;
|
|
480
|
+
}
|
|
481
|
+
|
|
482
|
+
reset() {
|
|
483
|
+
this.todo = [];
|
|
484
|
+
this.pols = [];
|
|
485
|
+
this.pos.clear();
|
|
486
|
+
this.neg.clear();
|
|
487
|
+
}
|
|
488
|
+
|
|
489
|
+
private lookup(expr: number, isPositive: boolean) {
|
|
490
|
+
const result = (isPositive ? this.pos : this.neg).get(expr);
|
|
491
|
+
if (result !== undefined) return result;
|
|
492
|
+
this.todo.push(expr);
|
|
493
|
+
this.pols.push(isPositive);
|
|
494
|
+
return undefined;
|
|
495
|
+
}
|
|
496
|
+
|
|
497
|
+
private insert(expr: number, isPositive: boolean, result: number) {
|
|
498
|
+
(isPositive ? this.pos : this.neg).set(expr, this.context.pin(result));
|
|
499
|
+
}
|
|
500
|
+
|
|
501
|
+
private pop() {
|
|
502
|
+
this.todo.pop();
|
|
503
|
+
this.pols.pop();
|
|
504
|
+
}
|
|
505
|
+
|
|
506
|
+
private mkAnd(args: number[]) {
|
|
507
|
+
const manager = this.context.manager;
|
|
508
|
+
return this.context.pinOwned(manager.withTemporaries(() => this.rewriter.mkAnd(args)));
|
|
509
|
+
}
|
|
510
|
+
|
|
511
|
+
private mkOr(args: number[]) {
|
|
512
|
+
const manager = this.context.manager;
|
|
513
|
+
return this.context.pinOwned(manager.withTemporaries(() => this.rewriter.mkOr(args)));
|
|
514
|
+
}
|
|
515
|
+
|
|
516
|
+
private nnfIff(app: number, isPositive: boolean) {
|
|
517
|
+
const manager = this.context.manager;
|
|
518
|
+
const [first, second] = manager.getArgs(app);
|
|
519
|
+
const r1 = this.lookup(first, true);
|
|
520
|
+
const r2 = this.lookup(first, false);
|
|
521
|
+
const p1 = this.lookup(second, true);
|
|
522
|
+
const p2 = this.lookup(second, false);
|
|
523
|
+
if (r1 === undefined || r2 === undefined || p1 === undefined || p2 === undefined) return;
|
|
524
|
+
this.pop();
|
|
525
|
+
this.insert(
|
|
526
|
+
app,
|
|
527
|
+
isPositive,
|
|
528
|
+
isPositive
|
|
529
|
+
? this.mkOr([this.mkAnd([r1, p1]), this.mkAnd([r2, p2])])
|
|
530
|
+
: this.mkAnd([this.mkOr([r1, p1]), this.mkOr([r2, p2])]),
|
|
531
|
+
);
|
|
532
|
+
}
|
|
533
|
+
|
|
534
|
+
private nnfIte(app: number, isPositive: boolean) {
|
|
535
|
+
const manager = this.context.manager;
|
|
536
|
+
const [condition, thenExpr, elseExpr] = manager.getArgs(app);
|
|
537
|
+
const r1 = this.lookup(condition, true);
|
|
538
|
+
const r2 = this.lookup(condition, false);
|
|
539
|
+
const th = this.lookup(thenExpr, isPositive);
|
|
540
|
+
const el = this.lookup(elseExpr, isPositive);
|
|
541
|
+
if (r1 === undefined || r2 === undefined || th === undefined || el === undefined) return;
|
|
542
|
+
this.pop();
|
|
543
|
+
this.insert(app, isPositive, this.mkOr([this.mkAnd([r1, th]), this.mkAnd([r2, el])]));
|
|
544
|
+
}
|
|
545
|
+
|
|
546
|
+
private nnfImplies(app: number, isPositive: boolean) {
|
|
547
|
+
const manager = this.context.manager;
|
|
548
|
+
const r1 = this.lookup(manager.getArg(app, 0), !isPositive);
|
|
549
|
+
const r2 = this.lookup(manager.getArg(app, 1), isPositive);
|
|
550
|
+
if (r1 === undefined || r2 === undefined) return;
|
|
551
|
+
this.insert(app, isPositive, isPositive ? this.mkOr([r1, r2]) : this.mkAnd([r1, r2]));
|
|
552
|
+
}
|
|
553
|
+
|
|
554
|
+
private nnfNot(app: number, isPositive: boolean) {
|
|
555
|
+
const result = this.lookup(this.context.manager.getArg(app, 0), !isPositive);
|
|
556
|
+
if (result !== undefined) this.insert(app, isPositive, result);
|
|
557
|
+
}
|
|
558
|
+
|
|
559
|
+
private nnfAndOr(isAnd: boolean, app: number, isPositive: boolean) {
|
|
560
|
+
const manager = this.context.manager;
|
|
561
|
+
const args: number[] = [];
|
|
562
|
+
let isVisited = true;
|
|
563
|
+
for (const arg of manager.getArgs(app)) {
|
|
564
|
+
const result = this.lookup(arg, isPositive);
|
|
565
|
+
if (result !== undefined) args.push(result);
|
|
566
|
+
else isVisited = false;
|
|
567
|
+
}
|
|
568
|
+
if (!isVisited) return;
|
|
569
|
+
this.pop();
|
|
570
|
+
this.insert(app, isPositive, isPositive === isAnd ? manager.mkAnd(args) : manager.mkOr(args));
|
|
571
|
+
}
|
|
572
|
+
|
|
573
|
+
private getNnf(formula: number, isPositive0: boolean): number | undefined {
|
|
574
|
+
const manager = this.context.manager;
|
|
575
|
+
const size = this.todo.length;
|
|
576
|
+
const found = this.lookup(formula, isPositive0);
|
|
577
|
+
if (found !== undefined) return found;
|
|
578
|
+
while (size < this.todo.length) {
|
|
579
|
+
const expr = this.todo[this.todo.length - 1];
|
|
580
|
+
const isPositive = this.pols[this.pols.length - 1];
|
|
581
|
+
if (!this.isRelevant(expr)) {
|
|
582
|
+
this.pop();
|
|
583
|
+
this.insert(expr, isPositive, isPositive ? expr : mkNot(manager, expr));
|
|
584
|
+
continue;
|
|
585
|
+
}
|
|
586
|
+
if (manager.kinds[expr] !== KIND_APP) return undefined;
|
|
587
|
+
if ((isPositive ? this.pos : this.neg).has(expr)) {
|
|
588
|
+
this.pop();
|
|
589
|
+
continue;
|
|
590
|
+
}
|
|
591
|
+
if (isAppOf(manager, expr, OP_AND) || isAppOf(manager, expr, OP_OR))
|
|
592
|
+
this.nnfAndOr(isAppOf(manager, expr, OP_AND), expr, isPositive);
|
|
593
|
+
else if (manager.isNot(expr)) this.nnfNot(expr, isPositive);
|
|
594
|
+
else if (isAppOf(manager, expr, OP_ITE)) this.nnfIte(expr, isPositive);
|
|
595
|
+
else if (
|
|
596
|
+
isAppOf(manager, expr, OP_EQ) &&
|
|
597
|
+
manager.sorts[manager.getArg(expr, 0)] === SORT_BOOL
|
|
598
|
+
)
|
|
599
|
+
this.nnfIff(expr, isPositive);
|
|
600
|
+
else if (isAppOf(manager, expr, OP_XOR)) this.nnfIff(expr, !isPositive);
|
|
601
|
+
else if (isAppOf(manager, expr, OP_IMPLIES)) this.nnfImplies(expr, isPositive);
|
|
602
|
+
else {
|
|
603
|
+
const lifted = this.liftIte(expr);
|
|
604
|
+
if (lifted !== undefined) {
|
|
605
|
+
const result = this.getNnf(lifted, isPositive);
|
|
606
|
+
if (result === undefined) return undefined;
|
|
607
|
+
this.pop();
|
|
608
|
+
this.insert(expr, isPositive, result);
|
|
609
|
+
} else {
|
|
610
|
+
this.pop();
|
|
611
|
+
this.insert(expr, isPositive, isPositive ? expr : mkNot(manager, expr));
|
|
612
|
+
}
|
|
613
|
+
}
|
|
614
|
+
}
|
|
615
|
+
return this.lookup(formula, isPositive0);
|
|
616
|
+
}
|
|
617
|
+
|
|
618
|
+
// Replaces a relevant if-then-else term t of the atom by its branches.
|
|
619
|
+
private liftIte(formula: number) {
|
|
620
|
+
const manager = this.context.manager;
|
|
621
|
+
if (isAppOf(manager, formula, OP_ITE)) return formula;
|
|
622
|
+
const ite = this.findIte(formula);
|
|
623
|
+
if (ite === undefined) return undefined;
|
|
624
|
+
const [condition, thenExpr, elseExpr] = manager.getArgs(ite);
|
|
625
|
+
const thenFormula = applySubstitution(this.context, ite, thenExpr, formula);
|
|
626
|
+
const elseFormula = applySubstitution(this.context, ite, elseExpr, formula);
|
|
627
|
+
const result = this.context.pin(
|
|
628
|
+
manager.mkApp(OP_ITE, [condition, thenFormula, elseFormula], SORT_BOOL),
|
|
629
|
+
);
|
|
630
|
+
const rewritten = this.context.pinOwned(this.rewriter.rewrite(result));
|
|
631
|
+
return rewritten !== formula ? rewritten : undefined;
|
|
632
|
+
}
|
|
633
|
+
|
|
634
|
+
private findIte(root: number) {
|
|
635
|
+
const manager = this.context.manager;
|
|
636
|
+
const visited = new Set<number>();
|
|
637
|
+
const todo = [root];
|
|
638
|
+
for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
|
|
639
|
+
if (visited.has(expr)) continue;
|
|
640
|
+
visited.add(expr);
|
|
641
|
+
if (!this.isRelevant(expr)) continue;
|
|
642
|
+
if (isAppOf(manager, expr, OP_ITE)) return expr;
|
|
643
|
+
if (manager.kinds[expr] === KIND_APP) for (const arg of manager.getArgs(expr)) todo.push(arg);
|
|
644
|
+
}
|
|
645
|
+
return undefined;
|
|
646
|
+
}
|
|
647
|
+
}
|
|
648
|
+
|
|
649
|
+
class QuantElimPlugin implements QeSolverContext {
|
|
650
|
+
readonly manager: AstManager;
|
|
651
|
+
private rewriter: Rewriter;
|
|
652
|
+
private solver: SmtKernel;
|
|
653
|
+
private freeVars: number[] = [];
|
|
654
|
+
private formula = -1;
|
|
655
|
+
private subFormula = -1;
|
|
656
|
+
private var2Branch = new Map<number, number>();
|
|
657
|
+
private var2Contains = new Map<number, ContainsApp>();
|
|
658
|
+
private root: SearchTree;
|
|
659
|
+
private current: SearchTree;
|
|
660
|
+
private partition: number[][] = [];
|
|
661
|
+
private newVars: number[] = [];
|
|
662
|
+
private isGetFirst = false;
|
|
663
|
+
private nnf: Nnf;
|
|
664
|
+
private arith: ArithPlugin;
|
|
665
|
+
readonly plugins: QeSolverPlugin[];
|
|
666
|
+
private model: ProtoModel | undefined;
|
|
667
|
+
|
|
668
|
+
constructor(private quantElim: QuantElim) {
|
|
669
|
+
const manager = quantElim.manager;
|
|
670
|
+
this.manager = manager;
|
|
671
|
+
this.rewriter = new Rewriter(manager, {
|
|
672
|
+
...TACTIC_REWRITER_OPTIONS,
|
|
673
|
+
arith: { ...TACTIC_REWRITER_OPTIONS.arith, isGcdRounding: true },
|
|
674
|
+
});
|
|
675
|
+
this.solver = new SmtKernel(manager, {
|
|
676
|
+
isMbqi: true,
|
|
677
|
+
mbqiMaxIterations: MBQI_MAX_ITERATIONS,
|
|
678
|
+
isFindingMacros: false,
|
|
679
|
+
relevancyLevel: 0,
|
|
680
|
+
});
|
|
681
|
+
this.root = new SearchTree(manager, undefined, manager.trueExpr);
|
|
682
|
+
this.current = this.root;
|
|
683
|
+
this.nnf = new Nnf(this, quantElim.rewriter, (expr) => this.isRelevant(expr));
|
|
684
|
+
this.arith = new ArithPlugin(this);
|
|
685
|
+
this.plugins = [new BoolPlugin(this), this.arith, new BvPlugin(this)];
|
|
686
|
+
}
|
|
687
|
+
|
|
688
|
+
pin(expr: number) {
|
|
689
|
+
return this.quantElim.pin(expr);
|
|
690
|
+
}
|
|
691
|
+
|
|
692
|
+
pinOwned(expr: number) {
|
|
693
|
+
return this.quantElim.pinOwned(expr);
|
|
694
|
+
}
|
|
695
|
+
|
|
696
|
+
reset() {
|
|
697
|
+
this.freeVars = [];
|
|
698
|
+
this.var2Contains.clear();
|
|
699
|
+
this.var2Branch.clear();
|
|
700
|
+
this.root.reset();
|
|
701
|
+
this.newVars = [];
|
|
702
|
+
this.formula = -1;
|
|
703
|
+
this.nnf.reset();
|
|
704
|
+
this.setModel(undefined);
|
|
705
|
+
}
|
|
706
|
+
|
|
707
|
+
release() {
|
|
708
|
+
this.reset();
|
|
709
|
+
this.rewriter.release();
|
|
710
|
+
this.arith.release();
|
|
711
|
+
}
|
|
712
|
+
|
|
713
|
+
private setModel(model: ProtoModel | undefined) {
|
|
714
|
+
model?.incRef();
|
|
715
|
+
this.model?.decRef();
|
|
716
|
+
this.model = model;
|
|
717
|
+
}
|
|
718
|
+
|
|
719
|
+
private getPlugin(x: number) {
|
|
720
|
+
const family = this.manager.getSortFamily(this.manager.sorts[x]);
|
|
721
|
+
return this.plugins.find((plugin) => plugin.family === family);
|
|
722
|
+
}
|
|
723
|
+
|
|
724
|
+
private isRelevant(expr: number) {
|
|
725
|
+
for (let index = 0; index < this.getNumVars(); index++)
|
|
726
|
+
if (this.contains(index).has(expr)) return true;
|
|
727
|
+
return false;
|
|
728
|
+
}
|
|
729
|
+
|
|
730
|
+
// Eliminates the variables from the formula, which is returned, and adds those it could not
|
|
731
|
+
// eliminate to freeVars.
|
|
732
|
+
check(
|
|
733
|
+
vars: readonly number[],
|
|
734
|
+
assumption: number,
|
|
735
|
+
inputFormula: number,
|
|
736
|
+
isGetFirst: boolean,
|
|
737
|
+
freeVars: number[],
|
|
738
|
+
) {
|
|
739
|
+
const manager = this.manager;
|
|
740
|
+
this.reset();
|
|
741
|
+
this.solver.push();
|
|
742
|
+
this.isGetFirst = isGetFirst;
|
|
743
|
+
for (const x of vars) {
|
|
744
|
+
if (this.getPlugin(x) !== undefined) this.addVar(x);
|
|
745
|
+
else this.freeVars.push(x);
|
|
746
|
+
}
|
|
747
|
+
this.root.consumeVars(this.newVars);
|
|
748
|
+
this.current = this.root;
|
|
749
|
+
this.formula = this.normalize(inputFormula, this.root.pos, this.root.neg);
|
|
750
|
+
let formula = this.formula;
|
|
751
|
+
const relevant = this.getMaxRelevant(formula);
|
|
752
|
+
this.subFormula = relevant.subFormula;
|
|
753
|
+
formula = relevant.formula;
|
|
754
|
+
if (formula !== this.subFormula) {
|
|
755
|
+
this.formula = formula;
|
|
756
|
+
formula = this.subFormula;
|
|
757
|
+
this.solver.assertExpr(formula);
|
|
758
|
+
}
|
|
759
|
+
this.root.formula = formula;
|
|
760
|
+
this.solver.assertExpr(this.formula);
|
|
761
|
+
this.solver.assertExpr(assumption);
|
|
762
|
+
let isSat = false;
|
|
763
|
+
let result = L_TRUE;
|
|
764
|
+
while (result === L_TRUE) {
|
|
765
|
+
result = this.solver.check();
|
|
766
|
+
if (result === L_TRUE && hasUninterpreted(manager, this.formula)) result = L_UNDEF;
|
|
767
|
+
if (result === L_TRUE) result = this.finalCheck();
|
|
768
|
+
if (result !== L_TRUE) break;
|
|
769
|
+
isSat = true;
|
|
770
|
+
}
|
|
771
|
+
const finish = (output: number) => {
|
|
772
|
+
const result =
|
|
773
|
+
this.formula !== this.subFormula
|
|
774
|
+
? applySubstitution(this, this.subFormula, output, this.formula)
|
|
775
|
+
: output;
|
|
776
|
+
this.reset();
|
|
777
|
+
this.solver.pop(1);
|
|
778
|
+
return result;
|
|
779
|
+
};
|
|
780
|
+
if (result === L_UNDEF) {
|
|
781
|
+
freeVars.push(...vars);
|
|
782
|
+
this.reset();
|
|
783
|
+
this.solver.pop(1);
|
|
784
|
+
return inputFormula;
|
|
785
|
+
}
|
|
786
|
+
if (!isSat) return finish(manager.falseExpr);
|
|
787
|
+
const leaves = this.root.getLeaves();
|
|
788
|
+
const output = isGetFirst
|
|
789
|
+
? inputFormula
|
|
790
|
+
: this.pinOwned(manager.withTemporaries(() => this.quantElim.rewriter.mkOr(leaves)));
|
|
791
|
+
freeVars.push(...this.freeVars);
|
|
792
|
+
return finish(output);
|
|
793
|
+
}
|
|
794
|
+
|
|
795
|
+
private finalCheck() {
|
|
796
|
+
const manager = this.manager;
|
|
797
|
+
const model = this.solver.context.getModel();
|
|
798
|
+
this.setModel(model);
|
|
799
|
+
for (;;) {
|
|
800
|
+
manager.limit.checkpoint();
|
|
801
|
+
while (this.formula !== -1 && this.updateCurrent(false) === NEED_PROPAGATION)
|
|
802
|
+
this.updateCurrent(true);
|
|
803
|
+
this.updateCurrent(true);
|
|
804
|
+
if (this.solver.check() !== L_TRUE) return L_TRUE;
|
|
805
|
+
this.setModel(this.solver.context.getModel());
|
|
806
|
+
const node = this.current;
|
|
807
|
+
this.updateCurrent(false);
|
|
808
|
+
if (node === this.current) break;
|
|
809
|
+
}
|
|
810
|
+
this.pop();
|
|
811
|
+
return L_TRUE;
|
|
812
|
+
}
|
|
813
|
+
|
|
814
|
+
posAtoms() {
|
|
815
|
+
return this.current.pos;
|
|
816
|
+
}
|
|
817
|
+
|
|
818
|
+
negAtoms() {
|
|
819
|
+
return this.current.neg;
|
|
820
|
+
}
|
|
821
|
+
|
|
822
|
+
getNumVars() {
|
|
823
|
+
return this.current.vars.length;
|
|
824
|
+
}
|
|
825
|
+
|
|
826
|
+
getVar(index: number) {
|
|
827
|
+
return this.current.vars[index];
|
|
828
|
+
}
|
|
829
|
+
|
|
830
|
+
getVars() {
|
|
831
|
+
return this.current.vars;
|
|
832
|
+
}
|
|
833
|
+
|
|
834
|
+
getVarIndex(expr: number) {
|
|
835
|
+
return this.current.vars.indexOf(expr);
|
|
836
|
+
}
|
|
837
|
+
|
|
838
|
+
contains(index: number) {
|
|
839
|
+
return this.var2Contains.get(this.getVar(index)) as ContainsApp;
|
|
840
|
+
}
|
|
841
|
+
|
|
842
|
+
private containsOf(x: number) {
|
|
843
|
+
return this.var2Contains.get(x) as ContainsApp;
|
|
844
|
+
}
|
|
845
|
+
|
|
846
|
+
elimVar(index: number, formula: number) {
|
|
847
|
+
const x = this.getVar(index);
|
|
848
|
+
this.current.setVar(x, 1n);
|
|
849
|
+
this.current = this.current.addChild(formula);
|
|
850
|
+
this.current.consumeVars(this.newVars);
|
|
851
|
+
this.normalizeNode(this.current);
|
|
852
|
+
}
|
|
853
|
+
|
|
854
|
+
addVar(x: number) {
|
|
855
|
+
const manager = this.manager;
|
|
856
|
+
this.newVars.push(x);
|
|
857
|
+
if (this.var2Branch.has(x)) return;
|
|
858
|
+
this.var2Contains.set(x, new ContainsApp(manager, x));
|
|
859
|
+
const isBranchSelf = manager.sorts[x] === SORT_BOOL || manager.isBvSort(manager.sorts[x]);
|
|
860
|
+
this.var2Branch.set(
|
|
861
|
+
x,
|
|
862
|
+
isBranchSelf ? x : this.pin(manager.mkFreshConst("b", manager.mkBvSort(20))),
|
|
863
|
+
);
|
|
864
|
+
}
|
|
865
|
+
|
|
866
|
+
addConstraint(isUsingCurrent: boolean, ...literals: number[]) {
|
|
867
|
+
const manager = this.manager;
|
|
868
|
+
const all: number[] = [];
|
|
869
|
+
for (
|
|
870
|
+
let node = isUsingCurrent ? this.current : this.current.parent;
|
|
871
|
+
node !== undefined;
|
|
872
|
+
node = node.parent
|
|
873
|
+
)
|
|
874
|
+
all.push(this.pin(mkNot(manager, node.assignment)));
|
|
875
|
+
all.push(...literals);
|
|
876
|
+
this.solver.assertExpr(this.pin(manager.mkOr(all)));
|
|
877
|
+
}
|
|
878
|
+
|
|
879
|
+
blastOr(variable: number, formula: number) {
|
|
880
|
+
return this.quantElim.eliminateExists([variable], formula, this.freeVars, false);
|
|
881
|
+
}
|
|
882
|
+
|
|
883
|
+
private getMaxRelevant(formula: number): { formula: number; subFormula: number } {
|
|
884
|
+
const manager = this.manager;
|
|
885
|
+
if (!isAppOf(manager, formula, OP_AND) && !isAppOf(manager, formula, OP_OR))
|
|
886
|
+
return { formula, subFormula: formula };
|
|
887
|
+
const relevant: number[] = [];
|
|
888
|
+
const irrelevant: number[] = [];
|
|
889
|
+
for (const arg of manager.getArgs(formula))
|
|
890
|
+
(this.isRelevant(arg) ? relevant : irrelevant).push(arg);
|
|
891
|
+
if (relevant.length === 0 || irrelevant.length === 0) return { formula, subFormula: formula };
|
|
892
|
+
const decl = manager.decls[formula];
|
|
893
|
+
if (relevant.length === 1) {
|
|
894
|
+
const inner = this.getMaxRelevant(relevant[0]);
|
|
895
|
+
irrelevant.push(inner.formula);
|
|
896
|
+
return {
|
|
897
|
+
formula: this.pin(manager.mkApp(decl, irrelevant, SORT_BOOL)),
|
|
898
|
+
subFormula: inner.subFormula,
|
|
899
|
+
};
|
|
900
|
+
}
|
|
901
|
+
const subFormula = this.pin(manager.mkApp(decl, relevant, SORT_BOOL));
|
|
902
|
+
irrelevant.push(subFormula);
|
|
903
|
+
return { formula: this.pin(manager.mkApp(decl, irrelevant, SORT_BOOL)), subFormula };
|
|
904
|
+
}
|
|
905
|
+
|
|
906
|
+
private updateCurrent(isApplying: boolean) {
|
|
907
|
+
this.current = this.root;
|
|
908
|
+
for (;;) {
|
|
909
|
+
if (this.current.isUnit()) {
|
|
910
|
+
this.current = this.current.children[0];
|
|
911
|
+
continue;
|
|
912
|
+
}
|
|
913
|
+
if (this.current.variable === -1) return CHOOSE_VAR;
|
|
914
|
+
const x = this.current.variable;
|
|
915
|
+
const branchVar = this.var2Branch.get(x) as number;
|
|
916
|
+
const numBranches = this.current.numBranches;
|
|
917
|
+
const formula = this.current.formula;
|
|
918
|
+
const evaluated = this.eval(branchVar);
|
|
919
|
+
const branch = evaluated === undefined || evaluated >= numBranches ? 0n : evaluated;
|
|
920
|
+
if (!this.current.branchIndex.has(branch)) {
|
|
921
|
+
if (isApplying) {
|
|
922
|
+
this.current = this.current.addBranch(branch, this.mkEqValue(branchVar, branch));
|
|
923
|
+
(this.getPlugin(x) as QeSolverPlugin).assign(this.containsOf(x), formula, branch);
|
|
924
|
+
this.current.consumeVars(this.newVars);
|
|
925
|
+
}
|
|
926
|
+
return NEED_PROPAGATION;
|
|
927
|
+
}
|
|
928
|
+
this.current = this.current.getChild(branch);
|
|
929
|
+
if (this.current.formula === -1) {
|
|
930
|
+
if (isApplying) {
|
|
931
|
+
const substituted = (this.getPlugin(x) as QeSolverPlugin).subst(
|
|
932
|
+
this.containsOf(x),
|
|
933
|
+
branch,
|
|
934
|
+
formula,
|
|
935
|
+
);
|
|
936
|
+
this.current.consumeVars(this.newVars);
|
|
937
|
+
this.current.formula = substituted;
|
|
938
|
+
this.normalizeNode(this.current);
|
|
939
|
+
}
|
|
940
|
+
return CHOOSE_VAR;
|
|
941
|
+
}
|
|
942
|
+
}
|
|
943
|
+
}
|
|
944
|
+
|
|
945
|
+
private pop() {
|
|
946
|
+
const manager = this.manager;
|
|
947
|
+
this.solveVars();
|
|
948
|
+
const formula = this.current.formula;
|
|
949
|
+
if (this.current.vars.length === 0) {
|
|
950
|
+
this.addConstraint(true);
|
|
951
|
+
return;
|
|
952
|
+
}
|
|
953
|
+
const vars = [...this.current.vars];
|
|
954
|
+
const contains = vars.map((x) => this.containsOf(x));
|
|
955
|
+
const parts = getPartition(this.plugins, manager, this.quantElim.rewriter, formula, vars);
|
|
956
|
+
this.pinOwned(parts.closed);
|
|
957
|
+
this.pinOwned(parts.mixed);
|
|
958
|
+
this.pinOwned(parts.open);
|
|
959
|
+
if (isAppOf(manager, parts.open, OP_AND)) {
|
|
960
|
+
const partition = partitionVars(contains, manager.getArgs(parts.open));
|
|
961
|
+
if (partition !== undefined) {
|
|
962
|
+
this.partition = partition;
|
|
963
|
+
this.processPartition();
|
|
964
|
+
return;
|
|
965
|
+
}
|
|
966
|
+
}
|
|
967
|
+
// The closed part is the quantifier-free part, unless the current state is unsatisfiable.
|
|
968
|
+
if (manager.isTrue(parts.mixed)) {
|
|
969
|
+
this.current = this.current.addChild(parts.closed);
|
|
970
|
+
this.current.vars = [];
|
|
971
|
+
this.addConstraint(true);
|
|
972
|
+
return;
|
|
973
|
+
}
|
|
974
|
+
this.constrainAssignment();
|
|
975
|
+
}
|
|
976
|
+
|
|
977
|
+
private normalizeNode(node: SearchTree) {
|
|
978
|
+
node.formula = this.normalize(node.formula, node.pos, node.neg);
|
|
979
|
+
}
|
|
980
|
+
|
|
981
|
+
private normalize(formula: number, pos: ObjHashtable, neg: ObjHashtable) {
|
|
982
|
+
const manager = this.manager;
|
|
983
|
+
const rewritten = this.pinOwned(this.rewriter.rewrite(formula));
|
|
984
|
+
const nnf = this.nnf.apply(rewritten);
|
|
985
|
+
const normalized = this.normalizeLiterals(nnf);
|
|
986
|
+
collectAtoms(manager, normalized, (expr) => this.isRelevant(expr), pos, neg);
|
|
987
|
+
return normalized;
|
|
988
|
+
}
|
|
989
|
+
|
|
990
|
+
private mkAtom(expr: number, isPositive: boolean) {
|
|
991
|
+
for (const plugin of this.plugins) {
|
|
992
|
+
const result = plugin.mkAtom(expr, isPositive);
|
|
993
|
+
if (result !== undefined) return result;
|
|
994
|
+
}
|
|
995
|
+
return isPositive ? expr : this.pin(mkNot(this.manager, expr));
|
|
996
|
+
}
|
|
997
|
+
|
|
998
|
+
private normalizeLiterals(formula: number) {
|
|
999
|
+
const manager = this.manager;
|
|
1000
|
+
const cache = new Map<number, number>();
|
|
1001
|
+
const todo = [formula];
|
|
1002
|
+
while (todo.length > 0) {
|
|
1003
|
+
const expr = todo[todo.length - 1];
|
|
1004
|
+
if (cache.has(expr)) {
|
|
1005
|
+
todo.pop();
|
|
1006
|
+
continue;
|
|
1007
|
+
}
|
|
1008
|
+
if (manager.kinds[expr] !== KIND_APP || !this.isRelevant(expr)) {
|
|
1009
|
+
todo.pop();
|
|
1010
|
+
cache.set(expr, expr);
|
|
1011
|
+
continue;
|
|
1012
|
+
}
|
|
1013
|
+
if (isAppOf(manager, expr, OP_AND) || isAppOf(manager, expr, OP_OR)) {
|
|
1014
|
+
const args: number[] = [];
|
|
1015
|
+
let isAllVisited = true;
|
|
1016
|
+
for (const arg of manager.getArgs(expr)) {
|
|
1017
|
+
const cached = cache.get(arg);
|
|
1018
|
+
if (cached !== undefined) args.push(cached);
|
|
1019
|
+
else {
|
|
1020
|
+
isAllVisited = false;
|
|
1021
|
+
todo.push(arg);
|
|
1022
|
+
}
|
|
1023
|
+
}
|
|
1024
|
+
if (isAllVisited) {
|
|
1025
|
+
todo.pop();
|
|
1026
|
+
cache.set(expr, this.pin(manager.mkApp(manager.decls[expr], args, SORT_BOOL)));
|
|
1027
|
+
}
|
|
1028
|
+
continue;
|
|
1029
|
+
}
|
|
1030
|
+
todo.pop();
|
|
1031
|
+
cache.set(
|
|
1032
|
+
expr,
|
|
1033
|
+
manager.isNot(expr) ? this.mkAtom(manager.getArg(expr, 0), false) : this.mkAtom(expr, true),
|
|
1034
|
+
);
|
|
1035
|
+
}
|
|
1036
|
+
return cache.get(formula) as number;
|
|
1037
|
+
}
|
|
1038
|
+
|
|
1039
|
+
private eval(branchVar: number) {
|
|
1040
|
+
const manager = this.manager;
|
|
1041
|
+
const model = this.model as ProtoModel;
|
|
1042
|
+
const value = model.eval(branchVar, false);
|
|
1043
|
+
const result = manager.isTrue(value)
|
|
1044
|
+
? 1n
|
|
1045
|
+
: manager.isFalse(value)
|
|
1046
|
+
? 0n
|
|
1047
|
+
: manager.isBvNumeral(value)
|
|
1048
|
+
? manager.getBvNumeralValue(value)
|
|
1049
|
+
: undefined;
|
|
1050
|
+
manager.decRef(value);
|
|
1051
|
+
return result;
|
|
1052
|
+
}
|
|
1053
|
+
|
|
1054
|
+
private mkEqValue(branchVar: number, value: bigint) {
|
|
1055
|
+
const manager = this.manager;
|
|
1056
|
+
if (manager.sorts[branchVar] === SORT_BOOL)
|
|
1057
|
+
return value === 0n ? this.pin(mkNot(manager, branchVar)) : branchVar;
|
|
1058
|
+
const numeral = manager.mkBvNumeral(value, manager.getBvSize(manager.sorts[branchVar]));
|
|
1059
|
+
return this.pin(manager.mkEq(branchVar, numeral));
|
|
1060
|
+
}
|
|
1061
|
+
|
|
1062
|
+
private constrainAssignment() {
|
|
1063
|
+
const manager = this.manager;
|
|
1064
|
+
const chosen = this.findMinWeight();
|
|
1065
|
+
if (chosen === undefined) return;
|
|
1066
|
+
this.current.setVar(chosen.x, chosen.numBranches);
|
|
1067
|
+
if (manager.isBvSort(manager.sorts[chosen.x])) return;
|
|
1068
|
+
const branchVar = this.var2Branch.get(chosen.x) as number;
|
|
1069
|
+
if (manager.sorts[branchVar] === SORT_BOOL) return;
|
|
1070
|
+
// The branch of the variable is below its number of cases.
|
|
1071
|
+
const maxValue = manager.mkBvNumeral(
|
|
1072
|
+
chosen.numBranches - 1n,
|
|
1073
|
+
manager.getBvSize(manager.sorts[branchVar]),
|
|
1074
|
+
);
|
|
1075
|
+
this.addConstraint(true, this.pin(mkBvApp(manager, OP_ULEQ, [branchVar, maxValue])));
|
|
1076
|
+
}
|
|
1077
|
+
|
|
1078
|
+
private processPartition() {
|
|
1079
|
+
let formula = this.current.formula;
|
|
1080
|
+
for (let vars = this.partition.pop(); vars !== undefined; vars = this.partition.pop())
|
|
1081
|
+
formula = this.quantElim.eliminateExists(
|
|
1082
|
+
vars.map((index) => this.current.vars[index]),
|
|
1083
|
+
formula,
|
|
1084
|
+
this.freeVars,
|
|
1085
|
+
this.isGetFirst,
|
|
1086
|
+
);
|
|
1087
|
+
this.current.addChild(formula).vars = [];
|
|
1088
|
+
this.addConstraint(true);
|
|
1089
|
+
}
|
|
1090
|
+
|
|
1091
|
+
private findMinWeight() {
|
|
1092
|
+
while (this.current.vars.length > 0) {
|
|
1093
|
+
const formula = this.current.formula;
|
|
1094
|
+
// Z3 compares each weight with UINT_MAX, which it never lowers, so it picks the last
|
|
1095
|
+
// variable before the first one without a plugin.
|
|
1096
|
+
const firstWithout = this.current.vars.findIndex((x) => this.getPlugin(x) === undefined);
|
|
1097
|
+
const index =
|
|
1098
|
+
firstWithout === -1 ? this.current.vars.length - 1 : Math.max(firstWithout - 1, 0);
|
|
1099
|
+
const x = this.getVar(index);
|
|
1100
|
+
const numBranches = this.getPlugin(x)?.getNumBranches(this.containsOf(x), formula);
|
|
1101
|
+
if (numBranches !== undefined) return { x, numBranches };
|
|
1102
|
+
this.freeVars.push(x);
|
|
1103
|
+
this.current.delVar(x);
|
|
1104
|
+
}
|
|
1105
|
+
return undefined;
|
|
1106
|
+
}
|
|
1107
|
+
|
|
1108
|
+
private solveVars() {
|
|
1109
|
+
for (let isSolved = true; isSolved;) {
|
|
1110
|
+
const formula = this.current.formula;
|
|
1111
|
+
const conjs = getFlatConjuncts(this.manager, formula);
|
|
1112
|
+
isSolved = this.plugins.some((plugin) => plugin.solve(conjs, formula));
|
|
1113
|
+
}
|
|
1114
|
+
}
|
|
1115
|
+
}
|
|
1116
|
+
|
|
1117
|
+
const CHOOSE_VAR = 0;
|
|
1118
|
+
const NEED_PROPAGATION = 1;
|
|
1119
|
+
|
|
1120
|
+
const collectAtoms = (
|
|
1121
|
+
manager: AstManager,
|
|
1122
|
+
formula: number,
|
|
1123
|
+
isRelevant: (expr: number) => boolean,
|
|
1124
|
+
pos: ObjHashtable,
|
|
1125
|
+
neg: ObjHashtable,
|
|
1126
|
+
) => {
|
|
1127
|
+
const visited = new Set<number>();
|
|
1128
|
+
const todo = [formula];
|
|
1129
|
+
for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
|
|
1130
|
+
if (visited.has(expr)) continue;
|
|
1131
|
+
visited.add(expr);
|
|
1132
|
+
if (manager.kinds[expr] !== KIND_APP || !isRelevant(expr)) continue;
|
|
1133
|
+
if (isAppOf(manager, expr, OP_AND) || isAppOf(manager, expr, OP_OR))
|
|
1134
|
+
for (const arg of manager.getArgs(expr)) todo.push(arg);
|
|
1135
|
+
else if (manager.isNot(expr) && manager.kinds[manager.getArg(expr, 0)] === KIND_APP)
|
|
1136
|
+
neg.add(manager.getArg(expr, 0));
|
|
1137
|
+
else pos.add(expr);
|
|
1138
|
+
}
|
|
1139
|
+
};
|
|
1140
|
+
|
|
1141
|
+
// quant_elim_new: eliminates blocks of variables with a pool of solver contexts.
|
|
1142
|
+
class QuantElim {
|
|
1143
|
+
readonly rewriter: Rewriter;
|
|
1144
|
+
private trail: RefVector;
|
|
1145
|
+
private pool: QuantElimPlugin[] = [];
|
|
1146
|
+
private all: QuantElimPlugin[] = [];
|
|
1147
|
+
assumption: number;
|
|
1148
|
+
|
|
1149
|
+
constructor(readonly manager: AstManager) {
|
|
1150
|
+
this.rewriter = new Rewriter(manager, TACTIC_REWRITER_OPTIONS);
|
|
1151
|
+
this.trail = new RefVector(manager);
|
|
1152
|
+
this.assumption = manager.trueExpr;
|
|
1153
|
+
}
|
|
1154
|
+
|
|
1155
|
+
pin(expr: number) {
|
|
1156
|
+
this.trail.push(expr);
|
|
1157
|
+
return expr;
|
|
1158
|
+
}
|
|
1159
|
+
|
|
1160
|
+
pinOwned(expr: number) {
|
|
1161
|
+
this.trail.pushOwned(expr);
|
|
1162
|
+
return expr;
|
|
1163
|
+
}
|
|
1164
|
+
|
|
1165
|
+
release() {
|
|
1166
|
+
for (const plugin of this.all) plugin.release();
|
|
1167
|
+
this.rewriter.release();
|
|
1168
|
+
this.trail.reset();
|
|
1169
|
+
}
|
|
1170
|
+
|
|
1171
|
+
eliminate(isForall: boolean, vars: readonly number[], formula: number) {
|
|
1172
|
+
const manager = this.manager;
|
|
1173
|
+
if (!isForall) return this.eliminateExistsBind(vars, formula);
|
|
1174
|
+
const negated = this.pin(mkNot(manager, formula));
|
|
1175
|
+
return this.pin(mkNot(manager, this.eliminateExistsBind(vars, negated)));
|
|
1176
|
+
}
|
|
1177
|
+
|
|
1178
|
+
eliminateExists(
|
|
1179
|
+
vars: readonly number[],
|
|
1180
|
+
formula: number,
|
|
1181
|
+
freeVars: number[],
|
|
1182
|
+
isGetFirst: boolean,
|
|
1183
|
+
) {
|
|
1184
|
+
const manager = this.manager;
|
|
1185
|
+
manager.limit.checkpoint();
|
|
1186
|
+
if (manager.hasQuantifierFlags[formula]) {
|
|
1187
|
+
freeVars.push(...vars);
|
|
1188
|
+
return formula;
|
|
1189
|
+
}
|
|
1190
|
+
const plugin = this.pool.pop() ?? this.mkPlugin();
|
|
1191
|
+
const result = plugin.check(vars, this.assumption, formula, isGetFirst, freeVars);
|
|
1192
|
+
this.pool.push(plugin);
|
|
1193
|
+
plugin.reset();
|
|
1194
|
+
return result;
|
|
1195
|
+
}
|
|
1196
|
+
|
|
1197
|
+
private mkPlugin() {
|
|
1198
|
+
const plugin = new QuantElimPlugin(this);
|
|
1199
|
+
this.all.push(plugin);
|
|
1200
|
+
return plugin;
|
|
1201
|
+
}
|
|
1202
|
+
|
|
1203
|
+
private eliminateExistsBind(vars: readonly number[], formula: number) {
|
|
1204
|
+
const manager = this.manager;
|
|
1205
|
+
const freeVars: number[] = [];
|
|
1206
|
+
const result = this.eliminateExists(vars, formula, freeVars, false);
|
|
1207
|
+
const bound = freeVars.filter((x) => new ContainsApp(manager, x).has(result));
|
|
1208
|
+
if (bound.length === 0) return result;
|
|
1209
|
+
return this.pin(mkQuantifierOver(manager, QUANTIFIER_EXISTS, bound, result, this));
|
|
1210
|
+
}
|
|
1211
|
+
}
|
|
1212
|
+
|
|
1213
|
+
// mk_exists and mk_forall over the constants an abstracted body had.
|
|
1214
|
+
export const mkQuantifierOfConsts = (
|
|
1215
|
+
manager: AstManager,
|
|
1216
|
+
kind: number,
|
|
1217
|
+
vars: readonly number[],
|
|
1218
|
+
body: number,
|
|
1219
|
+
weight: number,
|
|
1220
|
+
) =>
|
|
1221
|
+
manager.mkQuantifier({
|
|
1222
|
+
kind,
|
|
1223
|
+
sorts: vars.map((x) => manager.sorts[x]),
|
|
1224
|
+
names: vars.map((x) => manager.getDeclName(x)),
|
|
1225
|
+
body,
|
|
1226
|
+
patterns: [],
|
|
1227
|
+
noPatterns: [],
|
|
1228
|
+
weight,
|
|
1229
|
+
qid: "",
|
|
1230
|
+
});
|
|
1231
|
+
|
|
1232
|
+
interface Pins {
|
|
1233
|
+
pin(expr: number): number;
|
|
1234
|
+
pinOwned(expr: number): number;
|
|
1235
|
+
}
|
|
1236
|
+
|
|
1237
|
+
// expr_abstract and mk_quantifier: binds the constants, the last one to (:var 0).
|
|
1238
|
+
const mkQuantifierOver = (
|
|
1239
|
+
manager: AstManager,
|
|
1240
|
+
kind: number,
|
|
1241
|
+
vars: readonly number[],
|
|
1242
|
+
formula: number,
|
|
1243
|
+
pins: Pins,
|
|
1244
|
+
) => {
|
|
1245
|
+
const replace = new ExprSafeReplace(manager);
|
|
1246
|
+
vars.forEach((x, index) =>
|
|
1247
|
+
replace.insert(x, pins.pin(manager.mkVar(vars.length - 1 - index, manager.sorts[x]))),
|
|
1248
|
+
);
|
|
1249
|
+
const body = pins.pinOwned(replace.apply(formula));
|
|
1250
|
+
replace.release();
|
|
1251
|
+
return mkQuantifierOfConsts(manager, kind, vars, body, 1);
|
|
1252
|
+
};
|
|
1253
|
+
|
|
1254
|
+
// The body of the quantifier over fresh constants for its variables, with a reference.
|
|
1255
|
+
export const extractVars = (manager: AstManager, quantifier: number, vars: RefVector) => {
|
|
1256
|
+
const data = manager.getQuantifier(quantifier);
|
|
1257
|
+
const fresh = data.sorts.map((sort) => manager.mkFreshConst("x", sort));
|
|
1258
|
+
for (const expr of fresh) vars.push(expr);
|
|
1259
|
+
const subst = new VarSubst(manager, true);
|
|
1260
|
+
const substituted = subst.apply(data.body, fresh);
|
|
1261
|
+
subst.release();
|
|
1262
|
+
const shifter = new InvVarShifter(manager);
|
|
1263
|
+
const result = shifter.shift(substituted, fresh.length);
|
|
1264
|
+
shifter.release();
|
|
1265
|
+
manager.decRef(substituted);
|
|
1266
|
+
return result;
|
|
1267
|
+
};
|
|
1268
|
+
|
|
1269
|
+
// expr_quant_elim: eliminates the quantifiers of a closed formula, innermost first.
|
|
1270
|
+
const eliminateQuantifiers = (quantElim: QuantElim, formula: number) => {
|
|
1271
|
+
const manager = quantElim.manager;
|
|
1272
|
+
const visited = new Map<number, number>();
|
|
1273
|
+
const elim = (root: number): number => {
|
|
1274
|
+
const todo = [root];
|
|
1275
|
+
while (todo.length > 0) {
|
|
1276
|
+
const expr = todo[todo.length - 1];
|
|
1277
|
+
if (visited.has(expr)) {
|
|
1278
|
+
todo.pop();
|
|
1279
|
+
continue;
|
|
1280
|
+
}
|
|
1281
|
+
if (manager.kinds[expr] === KIND_APP) {
|
|
1282
|
+
const args: number[] = [];
|
|
1283
|
+
let isAllVisited = true;
|
|
1284
|
+
for (const arg of manager.getArgs(expr)) {
|
|
1285
|
+
const result = visited.get(arg);
|
|
1286
|
+
if (result !== undefined) args.push(result);
|
|
1287
|
+
else {
|
|
1288
|
+
todo.push(arg);
|
|
1289
|
+
isAllVisited = false;
|
|
1290
|
+
}
|
|
1291
|
+
}
|
|
1292
|
+
if (isAllVisited) {
|
|
1293
|
+
const isChanged = args.some((arg, index) => arg !== manager.getArg(expr, index));
|
|
1294
|
+
visited.set(
|
|
1295
|
+
expr,
|
|
1296
|
+
isChanged
|
|
1297
|
+
? quantElim.pin(manager.mkApp(manager.decls[expr], args, manager.sorts[expr]))
|
|
1298
|
+
: expr,
|
|
1299
|
+
);
|
|
1300
|
+
todo.pop();
|
|
1301
|
+
}
|
|
1302
|
+
continue;
|
|
1303
|
+
}
|
|
1304
|
+
const data = manager.getQuantifier(expr);
|
|
1305
|
+
const vars = new RefVector(manager);
|
|
1306
|
+
const body = elim(quantElim.pinOwned(extractVars(manager, expr, vars)));
|
|
1307
|
+
for (const x of vars.items) quantElim.pin(x);
|
|
1308
|
+
visited.set(expr, quantElim.eliminate(data.kind === QUANTIFIER_FORALL, vars.items, body));
|
|
1309
|
+
vars.reset();
|
|
1310
|
+
todo.pop();
|
|
1311
|
+
}
|
|
1312
|
+
return visited.get(root) as number;
|
|
1313
|
+
};
|
|
1314
|
+
return elim(formula);
|
|
1315
|
+
};
|
|
1316
|
+
|
|
1317
|
+
// simplify_solver_context: only the solve step of the Boolean and arithmetic plugins.
|
|
1318
|
+
class SimplifySolverContext implements QeSolverContext {
|
|
1319
|
+
private trail: RefVector;
|
|
1320
|
+
private pos: ObjHashtable;
|
|
1321
|
+
private neg: ObjHashtable;
|
|
1322
|
+
private vars: number[] = [];
|
|
1323
|
+
private containsApps: ContainsApp[] = [];
|
|
1324
|
+
private formula = -1;
|
|
1325
|
+
private arith: ArithPlugin;
|
|
1326
|
+
private plugins: QeSolverPlugin[];
|
|
1327
|
+
|
|
1328
|
+
constructor(readonly manager: AstManager) {
|
|
1329
|
+
this.trail = new RefVector(manager);
|
|
1330
|
+
this.pos = new ObjHashtable((expr) => manager.hashes[expr]);
|
|
1331
|
+
this.neg = new ObjHashtable((expr) => manager.hashes[expr]);
|
|
1332
|
+
this.arith = new ArithPlugin(this);
|
|
1333
|
+
this.plugins = [new BoolPlugin(this), this.arith];
|
|
1334
|
+
}
|
|
1335
|
+
|
|
1336
|
+
release() {
|
|
1337
|
+
this.arith.release();
|
|
1338
|
+
this.trail.reset();
|
|
1339
|
+
}
|
|
1340
|
+
|
|
1341
|
+
pin(expr: number) {
|
|
1342
|
+
this.trail.push(expr);
|
|
1343
|
+
return expr;
|
|
1344
|
+
}
|
|
1345
|
+
|
|
1346
|
+
pinOwned(expr: number) {
|
|
1347
|
+
this.trail.pushOwned(expr);
|
|
1348
|
+
return expr;
|
|
1349
|
+
}
|
|
1350
|
+
|
|
1351
|
+
posAtoms() {
|
|
1352
|
+
return this.pos;
|
|
1353
|
+
}
|
|
1354
|
+
|
|
1355
|
+
negAtoms() {
|
|
1356
|
+
return this.neg;
|
|
1357
|
+
}
|
|
1358
|
+
|
|
1359
|
+
getNumVars() {
|
|
1360
|
+
return this.vars.length;
|
|
1361
|
+
}
|
|
1362
|
+
|
|
1363
|
+
getVar(index: number) {
|
|
1364
|
+
return this.vars[index];
|
|
1365
|
+
}
|
|
1366
|
+
|
|
1367
|
+
getVars() {
|
|
1368
|
+
return this.vars;
|
|
1369
|
+
}
|
|
1370
|
+
|
|
1371
|
+
getVarIndex(expr: number) {
|
|
1372
|
+
return this.vars.indexOf(expr);
|
|
1373
|
+
}
|
|
1374
|
+
|
|
1375
|
+
contains(index: number) {
|
|
1376
|
+
return this.containsApps[index];
|
|
1377
|
+
}
|
|
1378
|
+
|
|
1379
|
+
elimVar(index: number, formula: number) {
|
|
1380
|
+
this.formula = this.pin(formula);
|
|
1381
|
+
this.vars[index] = this.vars[this.vars.length - 1];
|
|
1382
|
+
this.vars.pop();
|
|
1383
|
+
this.containsApps[index] = this.containsApps[this.containsApps.length - 1];
|
|
1384
|
+
this.containsApps.pop();
|
|
1385
|
+
}
|
|
1386
|
+
|
|
1387
|
+
addVar(x: number) {
|
|
1388
|
+
this.vars.push(this.pin(x));
|
|
1389
|
+
this.containsApps.push(new ContainsApp(this.manager, x));
|
|
1390
|
+
}
|
|
1391
|
+
|
|
1392
|
+
addConstraint(): void {
|
|
1393
|
+
throw new SmtInvariantError("simplify_solver_context adds no constraints");
|
|
1394
|
+
}
|
|
1395
|
+
|
|
1396
|
+
blastOr(): number {
|
|
1397
|
+
throw new SmtInvariantError("simplify_solver_context blasts no variables");
|
|
1398
|
+
}
|
|
1399
|
+
|
|
1400
|
+
// The variables that remain and the formula over them.
|
|
1401
|
+
solve(formula: number, vars: readonly number[]) {
|
|
1402
|
+
const manager = this.manager;
|
|
1403
|
+
this.vars = [...vars];
|
|
1404
|
+
this.containsApps = vars.map((x) => new ContainsApp(manager, x));
|
|
1405
|
+
this.formula = formula;
|
|
1406
|
+
let isSolved = true;
|
|
1407
|
+
while (isSolved) {
|
|
1408
|
+
const conjs = getFlatConjuncts(manager, this.formula);
|
|
1409
|
+
isSolved = this.plugins.some((plugin) => plugin.solve(conjs, this.formula));
|
|
1410
|
+
}
|
|
1411
|
+
return { formula: this.formula, vars: this.vars };
|
|
1412
|
+
}
|
|
1413
|
+
}
|
|
1414
|
+
|
|
1415
|
+
class SimplifyRewriter extends RewriterTpl {
|
|
1416
|
+
private context: SimplifySolverContext;
|
|
1417
|
+
|
|
1418
|
+
constructor(manager: AstManager) {
|
|
1419
|
+
super(manager);
|
|
1420
|
+
this.context = new SimplifySolverContext(manager);
|
|
1421
|
+
}
|
|
1422
|
+
|
|
1423
|
+
reduceQuantifier(expr: number, body: number) {
|
|
1424
|
+
const manager = this.manager;
|
|
1425
|
+
const context = this.context;
|
|
1426
|
+
const data = manager.getQuantifier(expr);
|
|
1427
|
+
const fresh = data.sorts.map((sort) => context.pin(manager.mkFreshConst("x", sort)));
|
|
1428
|
+
const subst = new VarSubst(manager, true);
|
|
1429
|
+
const substituted = context.pinOwned(subst.apply(body, fresh));
|
|
1430
|
+
subst.release();
|
|
1431
|
+
const invShifter = new InvVarShifter(manager);
|
|
1432
|
+
let result = context.pinOwned(invShifter.shift(substituted, fresh.length));
|
|
1433
|
+
invShifter.release();
|
|
1434
|
+
if (data.kind === QUANTIFIER_FORALL) result = context.pin(mkNot(manager, result));
|
|
1435
|
+
const solved = context.solve(result, fresh);
|
|
1436
|
+
result = solved.formula;
|
|
1437
|
+
if (data.kind === QUANTIFIER_FORALL)
|
|
1438
|
+
result = context.pin(
|
|
1439
|
+
manager.isNot(result) ? manager.getArg(result, 0) : mkNot(manager, result),
|
|
1440
|
+
);
|
|
1441
|
+
const vars = solved.vars;
|
|
1442
|
+
const shifter = new VarShifter(manager);
|
|
1443
|
+
result = context.pinOwned(shifter.shift(result, 0, vars.length, 0));
|
|
1444
|
+
shifter.release();
|
|
1445
|
+
if (vars.length === 0) {
|
|
1446
|
+
manager.incRef(result);
|
|
1447
|
+
return result;
|
|
1448
|
+
}
|
|
1449
|
+
const quantifier = mkQuantifierOver(manager, data.kind, vars, result, context);
|
|
1450
|
+
manager.incRef(quantifier);
|
|
1451
|
+
return quantifier;
|
|
1452
|
+
}
|
|
1453
|
+
|
|
1454
|
+
release() {
|
|
1455
|
+
super.release();
|
|
1456
|
+
this.context.release();
|
|
1457
|
+
}
|
|
1458
|
+
}
|
|
1459
|
+
|
|
1460
|
+
// qe::simplify_rewriter_star: the result comes with a reference.
|
|
1461
|
+
export const simplifyQuantifiers = (manager: AstManager, formula: number) => {
|
|
1462
|
+
const rewriter = new SimplifyRewriter(manager);
|
|
1463
|
+
const result = rewriter.rewrite(formula);
|
|
1464
|
+
rewriter.release();
|
|
1465
|
+
return result;
|
|
1466
|
+
};
|
|
1467
|
+
|
|
1468
|
+
export const runQe = (manager: AstManager) => (goal: Goal) => {
|
|
1469
|
+
const quantElim = new QuantElim(manager);
|
|
1470
|
+
try {
|
|
1471
|
+
for (let index = 0; index < goal.forms.size; index++) {
|
|
1472
|
+
manager.limit.checkpoint();
|
|
1473
|
+
if (goal.isInconsistent) break;
|
|
1474
|
+
const formula = goal.forms.items[index];
|
|
1475
|
+
if (!manager.hasQuantifierFlags[formula]) continue;
|
|
1476
|
+
if (hasUnsupportedSort(manager, formula))
|
|
1477
|
+
throw new SmtUnsupportedError("quantifier elimination over arrays or datatypes");
|
|
1478
|
+
goal.update(index, eliminateQuantifiers(quantElim, formula));
|
|
1479
|
+
}
|
|
1480
|
+
goal.depth++;
|
|
1481
|
+
goal.elimTrue();
|
|
1482
|
+
return [goal];
|
|
1483
|
+
} finally {
|
|
1484
|
+
quantElim.release();
|
|
1485
|
+
}
|
|
1486
|
+
};
|
|
1487
|
+
|
|
1488
|
+
const isArrayOrDatatype = (manager: AstManager, sort: number) =>
|
|
1489
|
+
manager.getSortFamily(sort) === FAMILY_ARRAY || manager.getSortFamily(sort) === FAMILY_DATATYPE;
|
|
1490
|
+
|
|
1491
|
+
const hasUnsupportedSort = (manager: AstManager, formula: number) =>
|
|
1492
|
+
hasSubterm(
|
|
1493
|
+
manager,
|
|
1494
|
+
[formula],
|
|
1495
|
+
(expr) =>
|
|
1496
|
+
isArrayOrDatatype(manager, manager.sorts[expr]) ||
|
|
1497
|
+
(manager.kinds[expr] === KIND_QUANTIFIER &&
|
|
1498
|
+
manager.getQuantifier(expr).sorts.some((sort) => isArrayOrDatatype(manager, sort))),
|
|
1499
|
+
);
|