tla-ts 0.0.10-dev.63a6693bd → 0.0.10-dev.6b2a6741a
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 +45 -41
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +5 -1
- package/dist/index.d.ts +5 -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 +44 -43
- package/dist/tlapm.cjs +1 -1
- package/dist/tlapm.js +1 -1
- 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 +4 -3
- package/src/bags.ts +46 -28
- package/src/check-trace.ts +2 -16
- package/src/check.ts +349 -91
- 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/cli/xml-exporter.ts +1 -1
- package/src/codegen.ts +9 -5
- package/src/dependencies.ts +72 -11
- package/src/dfid.ts +9 -2
- package/src/environment.ts +65 -36
- package/src/errors.ts +38 -3
- package/src/evaluate.ts +92 -32
- package/src/exit-codes.ts +5 -2
- package/src/instances.ts +5 -5
- package/src/java-overrides.ts +2 -2
- package/src/levels.ts +138 -90
- 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 +37 -7
- package/src/obligations/levels.ts +24 -11
- package/src/obligations/module.ts +1 -3
- package/src/obligations/normalize.ts +25 -17
- 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 +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 +664 -287
- 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 +4 -11
- 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 +3 -5
- 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/md5.ts +26 -29
- 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 +1449 -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 +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 +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 +349 -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 +544 -0
- package/src/prover/smt/solver/smt2-printer.ts +765 -0
- package/src/prover/smt/solver/smtlib-parser.ts +3228 -327
- package/src/prover/smt/solver/smtlib-script.ts +1843 -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 +2012 -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 +37 -16
- 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 +625 -189
- package/src/runtime.ts +7 -1
- package/src/sany/builtins.ts +10 -10
- package/src/sany/generation.ts +2 -13
- package/src/sany/generator-definitions.ts +3 -1
- package/src/sany/generator-expressions.ts +36 -30
- package/src/sany/generator-proofs.ts +5 -3
- package/src/sany/generator.ts +2 -1
- package/src/sany/levels.ts +0 -2
- package/src/sany/lexer.ts +3 -3
- package/src/sany/linter.ts +0 -2
- package/src/sany/modules.ts +4 -2
- package/src/sany/nodes.ts +1 -1
- package/src/sany/selectors.ts +11 -6
- package/src/sany/xml.ts +2 -3
- package/src/search.ts +209 -56
- package/src/simulate.ts +3 -0
- package/src/spec-description.ts +2 -2
- package/src/standard-definitions.ts +4 -0
- package/src/state-graph.ts +0 -2
- package/src/subexpressions.ts +265 -94
- package/src/successors.ts +2 -1
- package/src/symmetry.ts +3 -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 +3 -3
- package/src/tlc/order.ts +14 -3
- package/src/tlc/summary.ts +29 -14
- package/src/tlc/tlc-operators.ts +3 -1
- package/src/tlc/tlcext-operators.ts +61 -16
- package/src/tlc/trace-spec.ts +5 -5
- package/src/typed-tier.ts +6541 -0
- package/src/typescript/types.ts +2 -2
- package/src/values.ts +46 -27
- 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,1204 @@
|
|
|
1
|
+
import { SmtInvariantError, SmtUnsupportedError } from "../../../../errors";
|
|
2
|
+
import {
|
|
3
|
+
type AstManager,
|
|
4
|
+
FAMILY_BASIC,
|
|
5
|
+
FAMILY_MODEL_VALUE,
|
|
6
|
+
FAMILY_USER,
|
|
7
|
+
KIND_QUANTIFIER,
|
|
8
|
+
OP_DISTINCT,
|
|
9
|
+
OP_EQ,
|
|
10
|
+
OP_ITE,
|
|
11
|
+
SORT_BOOL,
|
|
12
|
+
SORT_SIZE_INFINITE,
|
|
13
|
+
SORT_SIZE_VERY_BIG,
|
|
14
|
+
QUANTIFIER_LAMBDA,
|
|
15
|
+
} from "../ast";
|
|
16
|
+
import { ObjHashtable } from "../hashtable";
|
|
17
|
+
import { L_FALSE, L_TRUE, L_UNDEF } from "../lbool";
|
|
18
|
+
import type { ProtoModel } from "../proto-model";
|
|
19
|
+
import { FuncInterp } from "../proto-model";
|
|
20
|
+
import { Rewriter, TACTIC_REWRITER_OPTIONS } from "../rewriter";
|
|
21
|
+
import { NULL_LITERAL } from "../sat/clause";
|
|
22
|
+
import {
|
|
23
|
+
CR_CONTINUE,
|
|
24
|
+
CR_DONE,
|
|
25
|
+
CR_GIVEUP,
|
|
26
|
+
JUSTIFICATION_EXT,
|
|
27
|
+
type SatExtension,
|
|
28
|
+
type Solver,
|
|
29
|
+
} from "../sat/solver";
|
|
30
|
+
import { Egraph, type Enode, getClass, mkExternal, NULL_BOOL_VAR, type ThEq } from "./egraph";
|
|
31
|
+
import {
|
|
32
|
+
addDependency,
|
|
33
|
+
type Dependencies,
|
|
34
|
+
type ThExplain,
|
|
35
|
+
type ThSolver,
|
|
36
|
+
TrailStack,
|
|
37
|
+
} from "./th-solver";
|
|
38
|
+
|
|
39
|
+
export interface EufInternalizer {
|
|
40
|
+
internalize(expr: number): number;
|
|
41
|
+
isBoolOp(expr: number): boolean;
|
|
42
|
+
addBoolVar(expr: number): number;
|
|
43
|
+
toBoolVar(expr: number): number;
|
|
44
|
+
push(): void;
|
|
45
|
+
pop(numScopes: number): void;
|
|
46
|
+
uncache(lit: number): void;
|
|
47
|
+
cache(expr: number, lit: number): void;
|
|
48
|
+
isCached(expr: number, lit: number): boolean;
|
|
49
|
+
setExpr2VarReplay(replay: Map<number, number> | null): void;
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
// A theory solver for the family of a declaration, created on first use like euf::solver::get_solver.
|
|
53
|
+
export type ThSolverFactory = (ctx: EufSolver, family: number) => ThSolver | null;
|
|
54
|
+
|
|
55
|
+
const K_CONFLICT = 0;
|
|
56
|
+
const K_EQ = 1;
|
|
57
|
+
const K_LIT = 2;
|
|
58
|
+
|
|
59
|
+
interface Constraint {
|
|
60
|
+
readonly owner: ThSolver | null;
|
|
61
|
+
readonly kind: number;
|
|
62
|
+
readonly node: Enode | null;
|
|
63
|
+
readonly data: unknown;
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
// The external justification of an egraph merge: a literal, or the index of a theory constraint.
|
|
67
|
+
const literalPayload = (lit: number) => lit * 2;
|
|
68
|
+
const constraintPayload = (index: number) => index * 2 + 1;
|
|
69
|
+
const isLiteralPayload = (payload: number) => (payload & 1) === 0;
|
|
70
|
+
|
|
71
|
+
interface Reinit {
|
|
72
|
+
readonly expr: number;
|
|
73
|
+
readonly generation: number;
|
|
74
|
+
readonly boolVar: number;
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
export class EufSolver implements SatExtension {
|
|
78
|
+
readonly egraph: Egraph;
|
|
79
|
+
readonly solvers: ThSolver[] = [];
|
|
80
|
+
private id2solver = new Map<number, ThSolver>();
|
|
81
|
+
qsolver: ThSolver | null = null;
|
|
82
|
+
private boolVar2exprs: (number | undefined)[] = [];
|
|
83
|
+
private varTrail: number[] = [];
|
|
84
|
+
private scopes: number[] = [];
|
|
85
|
+
readonly trail = new TrailStack();
|
|
86
|
+
readonly unhandledFunctions: number[] = [];
|
|
87
|
+
generation = 0;
|
|
88
|
+
private constraints: Constraint[] = [
|
|
89
|
+
{ owner: null, kind: K_CONFLICT, node: null, data: null },
|
|
90
|
+
{ owner: null, kind: K_EQ, node: null, data: null },
|
|
91
|
+
];
|
|
92
|
+
private explanation: number[] = [];
|
|
93
|
+
private assertedVars: boolean[] = [];
|
|
94
|
+
private reinits: Reinit[] = [];
|
|
95
|
+
private stack: { expr: number; index: number }[] = [];
|
|
96
|
+
private rewriter: Rewriter;
|
|
97
|
+
reasonUnknown = "";
|
|
98
|
+
private values: (number | undefined)[] = [];
|
|
99
|
+
private values2rootMap: Map<number, Enode> | null = null;
|
|
100
|
+
qmodel: ProtoModel | null = null;
|
|
101
|
+
|
|
102
|
+
constructor(
|
|
103
|
+
readonly manager: AstManager,
|
|
104
|
+
readonly si: EufInternalizer,
|
|
105
|
+
readonly s: Solver,
|
|
106
|
+
readonly mkThSolver: ThSolverFactory,
|
|
107
|
+
) {
|
|
108
|
+
this.egraph = new Egraph(manager);
|
|
109
|
+
this.egraph.onPropagateLiteral = (node, ante) => this.propagateLiteral(node, ante);
|
|
110
|
+
this.rewriter = new Rewriter(manager, TACTIC_REWRITER_OPTIONS);
|
|
111
|
+
}
|
|
112
|
+
|
|
113
|
+
getEnode(expr: number) {
|
|
114
|
+
return this.egraph.find(expr);
|
|
115
|
+
}
|
|
116
|
+
|
|
117
|
+
boolVar2expr(boolVar: number) {
|
|
118
|
+
return this.boolVar2exprs[boolVar];
|
|
119
|
+
}
|
|
120
|
+
|
|
121
|
+
private setBoolVar2expr(boolVar: number, expr: number) {
|
|
122
|
+
this.varTrail.push(boolVar);
|
|
123
|
+
while (this.boolVar2exprs.length <= boolVar) this.boolVar2exprs.push(undefined);
|
|
124
|
+
this.boolVar2exprs[boolVar] = expr;
|
|
125
|
+
}
|
|
126
|
+
|
|
127
|
+
expr2literal(expr: number) {
|
|
128
|
+
return 2 * (this.egraph.find(expr) as Enode).boolVar;
|
|
129
|
+
}
|
|
130
|
+
|
|
131
|
+
rewrite(expr: number) {
|
|
132
|
+
return this.rewriter.rewrite(expr);
|
|
133
|
+
}
|
|
134
|
+
|
|
135
|
+
private boolVar2solver(boolVar: number) {
|
|
136
|
+
const expr = this.boolVar2exprs[boolVar];
|
|
137
|
+
return expr === undefined ? null : this.expr2solver(expr);
|
|
138
|
+
}
|
|
139
|
+
|
|
140
|
+
expr2solver(expr: number) {
|
|
141
|
+
const manager = this.manager;
|
|
142
|
+
if (manager.isApp(expr)) return this.decl2solver(manager.decls[expr]);
|
|
143
|
+
return manager.kinds[expr] === KIND_QUANTIFIER &&
|
|
144
|
+
manager.getQuantifier(expr).kind !== QUANTIFIER_LAMBDA
|
|
145
|
+
? this.quantifier2solver()
|
|
146
|
+
: null;
|
|
147
|
+
}
|
|
148
|
+
|
|
149
|
+
private quantifier2solver() {
|
|
150
|
+
if (this.qsolver !== null) return this.qsolver;
|
|
151
|
+
const solver = this.mkThSolver(this, -1);
|
|
152
|
+
if (solver === null) return null;
|
|
153
|
+
this.qsolver = solver;
|
|
154
|
+
this.addSolver(solver);
|
|
155
|
+
return solver;
|
|
156
|
+
}
|
|
157
|
+
|
|
158
|
+
decl2solver(decl: number) {
|
|
159
|
+
return this.getSolver(this.manager.funcDecls[decl].family, decl);
|
|
160
|
+
}
|
|
161
|
+
|
|
162
|
+
sort2solver(sort: number) {
|
|
163
|
+
return this.getSolver(this.manager.getSortFamily(sort), -1);
|
|
164
|
+
}
|
|
165
|
+
|
|
166
|
+
fid2solver(family: number) {
|
|
167
|
+
return this.id2solver.get(family);
|
|
168
|
+
}
|
|
169
|
+
|
|
170
|
+
private getSolver(family: number, decl: number) {
|
|
171
|
+
if (family < 0) return null;
|
|
172
|
+
const existing = this.id2solver.get(family);
|
|
173
|
+
if (existing !== undefined) return existing;
|
|
174
|
+
if (family === FAMILY_BASIC || family === FAMILY_USER) return null;
|
|
175
|
+
const solver = this.mkThSolver(this, family);
|
|
176
|
+
if (solver !== null) this.addSolver(solver);
|
|
177
|
+
else if (decl !== -1) this.unhandledFunction(decl);
|
|
178
|
+
return solver;
|
|
179
|
+
}
|
|
180
|
+
|
|
181
|
+
private addSolver(solver: ThSolver) {
|
|
182
|
+
const numScopes = this.s.scopeLvl + this.s.numUserScopes;
|
|
183
|
+
for (let index = 0; index < numScopes; index++) solver.push();
|
|
184
|
+
this.solvers.push(solver);
|
|
185
|
+
this.id2solver.set(solver.id, solver);
|
|
186
|
+
if (solver.useDiseqs()) this.egraph.setThPropagatesDiseqs(solver.id);
|
|
187
|
+
}
|
|
188
|
+
|
|
189
|
+
private unhandledFunction(decl: number) {
|
|
190
|
+
if (
|
|
191
|
+
this.unhandledFunctions.includes(decl) ||
|
|
192
|
+
this.manager.funcDecls[decl].family === FAMILY_MODEL_VALUE
|
|
193
|
+
)
|
|
194
|
+
return;
|
|
195
|
+
this.unhandledFunctions.push(decl);
|
|
196
|
+
this.trail.push(() => this.unhandledFunctions.pop());
|
|
197
|
+
}
|
|
198
|
+
|
|
199
|
+
hasUnhandled() {
|
|
200
|
+
return this.unhandledFunctions.length > 0;
|
|
201
|
+
}
|
|
202
|
+
|
|
203
|
+
internalizeTerm(expr: number) {
|
|
204
|
+
if (this.getEnode(expr) !== undefined) return;
|
|
205
|
+
if (this.si.isBoolOp(expr)) this.attachLit(this.si.internalize(expr), expr);
|
|
206
|
+
else {
|
|
207
|
+
const solver = this.expr2solver(expr);
|
|
208
|
+
if (solver !== null) solver.internalizeTerm(expr);
|
|
209
|
+
else this.visitRec(expr, false, false);
|
|
210
|
+
}
|
|
211
|
+
}
|
|
212
|
+
|
|
213
|
+
mkLiteral(expr: number) {
|
|
214
|
+
const manager = this.manager;
|
|
215
|
+
const isNot = manager.isNot(expr);
|
|
216
|
+
const lit = this.internalize(isNot ? manager.getArg(expr, 0) : expr, false, false);
|
|
217
|
+
return isNot ? lit ^ 1 : lit;
|
|
218
|
+
}
|
|
219
|
+
|
|
220
|
+
internalize(expr: number, isSign: boolean, isRoot: boolean): number {
|
|
221
|
+
const manager = this.manager;
|
|
222
|
+
const node = this.getEnode(expr);
|
|
223
|
+
if (node !== undefined)
|
|
224
|
+
return manager.isBool(expr) ? 2 * node.boolVar + (isSign ? 1 : 0) : NULL_LITERAL;
|
|
225
|
+
if (this.si.isBoolOp(expr)) {
|
|
226
|
+
const lit = this.attachLit(this.si.internalize(expr), expr);
|
|
227
|
+
return isSign ? lit ^ 1 : lit;
|
|
228
|
+
}
|
|
229
|
+
const solver = this.expr2solver(expr);
|
|
230
|
+
if (solver !== null) return solver.internalize(expr, isSign, isRoot);
|
|
231
|
+
if (!this.visitRec(expr, isSign, isRoot)) return NULL_LITERAL;
|
|
232
|
+
return manager.isBool(expr) ? 2 * this.si.toBoolVar(expr) + (isSign ? 1 : 0) : NULL_LITERAL;
|
|
233
|
+
}
|
|
234
|
+
|
|
235
|
+
private visitRec(expr: number, isSign: boolean, isRoot: boolean) {
|
|
236
|
+
const stack = this.stack;
|
|
237
|
+
const manager = this.manager;
|
|
238
|
+
const base = stack.length;
|
|
239
|
+
this.visit(expr);
|
|
240
|
+
loop: while (stack.length > base) {
|
|
241
|
+
const frame = stack[stack.length - 1];
|
|
242
|
+
const current = frame.expr;
|
|
243
|
+
if (this.egraph.find(current) !== undefined) {
|
|
244
|
+
stack.pop();
|
|
245
|
+
continue;
|
|
246
|
+
}
|
|
247
|
+
const numArgs = manager.getNumArgs(current);
|
|
248
|
+
while (frame.index < numArgs)
|
|
249
|
+
if (!this.visit(manager.getArg(current, frame.index++))) continue loop;
|
|
250
|
+
if (
|
|
251
|
+
this.egraph.find(current) === undefined &&
|
|
252
|
+
!this.postVisit(current, isSign, isRoot && current === expr)
|
|
253
|
+
) {
|
|
254
|
+
stack.length = base;
|
|
255
|
+
return false;
|
|
256
|
+
}
|
|
257
|
+
stack.pop();
|
|
258
|
+
}
|
|
259
|
+
return true;
|
|
260
|
+
}
|
|
261
|
+
|
|
262
|
+
private visit(expr: number) {
|
|
263
|
+
const manager = this.manager;
|
|
264
|
+
const node = this.egraph.find(expr);
|
|
265
|
+
if (node !== undefined) {
|
|
266
|
+
if (!this.si.isBoolOp(expr)) {
|
|
267
|
+
const solver = this.expr2solver(expr);
|
|
268
|
+
if (solver !== null && node.getThVar(solver.id) === -1) solver.internalizeTerm(expr);
|
|
269
|
+
}
|
|
270
|
+
return true;
|
|
271
|
+
}
|
|
272
|
+
if (this.si.isBoolOp(expr)) {
|
|
273
|
+
this.attachLit(this.si.internalize(expr), expr);
|
|
274
|
+
return true;
|
|
275
|
+
}
|
|
276
|
+
if (manager.isApp(expr) && manager.getNumArgs(expr) > 0) {
|
|
277
|
+
this.stack.push({ expr, index: 0 });
|
|
278
|
+
return false;
|
|
279
|
+
}
|
|
280
|
+
const solver = this.expr2solver(expr);
|
|
281
|
+
if (solver !== null) solver.internalizeTerm(expr);
|
|
282
|
+
else this.attachNode(this.mkEnode(expr, []));
|
|
283
|
+
return true;
|
|
284
|
+
}
|
|
285
|
+
|
|
286
|
+
private postVisit(expr: number, isSign: boolean, isRoot: boolean) {
|
|
287
|
+
const manager = this.manager;
|
|
288
|
+
const args = manager.isApp(expr)
|
|
289
|
+
? manager.getArgs(expr).map((arg) => this.egraph.find(arg) as Enode)
|
|
290
|
+
: [];
|
|
291
|
+
if (isRoot && this.internalizeRoot(expr, isSign, args)) return false;
|
|
292
|
+
const solver = this.expr2solver(expr);
|
|
293
|
+
if (solver !== null) solver.internalizeTerm(expr);
|
|
294
|
+
else this.attachNode(this.mkEnode(expr, args));
|
|
295
|
+
return true;
|
|
296
|
+
}
|
|
297
|
+
|
|
298
|
+
attachNode(node: Enode) {
|
|
299
|
+
const manager = this.manager;
|
|
300
|
+
const expr = node.owner;
|
|
301
|
+
const sort = manager.sorts[expr];
|
|
302
|
+
if (manager.isBool(expr)) this.attachLit(2 * this.si.addBoolVar(expr), expr);
|
|
303
|
+
if (!manager.isBool(expr) && !manager.isUninterpretedSort(sort)) {
|
|
304
|
+
const exprSolver = this.expr2solver(expr);
|
|
305
|
+
const sortSolver = this.sort2solver(sort);
|
|
306
|
+
if (sortSolver !== null && sortSolver !== exprSolver) sortSolver.applySortCnstr(node, sort);
|
|
307
|
+
else if (sortSolver === null && exprSolver === null && manager.isApp(expr))
|
|
308
|
+
this.unhandledFunction(manager.decls[expr]);
|
|
309
|
+
}
|
|
310
|
+
if (manager.getFamily(expr) === FAMILY_BASIC && manager.getOp(expr) === OP_EQ)
|
|
311
|
+
this.sort2solver(manager.sorts[manager.getArg(expr, 0)])?.eqInternalized(node);
|
|
312
|
+
this.axiomatizeBasic(node);
|
|
313
|
+
}
|
|
314
|
+
|
|
315
|
+
attachLit(lit: number, expr: number) {
|
|
316
|
+
const s = this.s;
|
|
317
|
+
let boolVar = lit >> 1;
|
|
318
|
+
s.setExternal(boolVar);
|
|
319
|
+
s.setEliminated(boolVar, false);
|
|
320
|
+
let result = lit;
|
|
321
|
+
if ((lit & 1) === 1) {
|
|
322
|
+
boolVar = this.si.addBoolVar(expr);
|
|
323
|
+
s.setExternal(boolVar);
|
|
324
|
+
s.setEliminated(boolVar, false);
|
|
325
|
+
this.setBoolVar2expr(boolVar, expr);
|
|
326
|
+
this.varTrail.push(boolVar);
|
|
327
|
+
const lit2 = 2 * boolVar;
|
|
328
|
+
s.mkClause([lit ^ 1, lit2]);
|
|
329
|
+
s.mkClause([lit, lit2 ^ 1]);
|
|
330
|
+
result = lit2;
|
|
331
|
+
}
|
|
332
|
+
if (this.boolVar2exprs[boolVar] !== undefined && this.egraph.find(expr) !== undefined)
|
|
333
|
+
return result;
|
|
334
|
+
this.setBoolVar2expr(boolVar, expr);
|
|
335
|
+
const node = this.egraph.find(expr) ?? this.mkEnode(expr, []);
|
|
336
|
+
node.boolVar = boolVar;
|
|
337
|
+
if (this.si.isBoolOp(expr)) this.egraph.setCgcEnabled(node, false);
|
|
338
|
+
const value = s.value(result);
|
|
339
|
+
if (value !== L_UNDEF)
|
|
340
|
+
this.egraph.setValue(
|
|
341
|
+
node,
|
|
342
|
+
value,
|
|
343
|
+
mkExternal(literalPayload(value === L_TRUE ? result : result ^ 1)),
|
|
344
|
+
);
|
|
345
|
+
return result;
|
|
346
|
+
}
|
|
347
|
+
|
|
348
|
+
private internalizeRoot(expr: number, isSign: boolean, args: readonly Enode[]) {
|
|
349
|
+
const manager = this.manager;
|
|
350
|
+
if (manager.getFamily(expr) !== FAMILY_BASIC || manager.getOp(expr) !== OP_DISTINCT)
|
|
351
|
+
return false;
|
|
352
|
+
if (isSign) this.addNotDistinctAxiom(expr, args);
|
|
353
|
+
else this.addDistinctAxiom(expr, args);
|
|
354
|
+
return true;
|
|
355
|
+
}
|
|
356
|
+
|
|
357
|
+
private addNotDistinctAxiom(expr: number, args: readonly Enode[]) {
|
|
358
|
+
const manager = this.manager;
|
|
359
|
+
const size = args.length;
|
|
360
|
+
if (size <= 1) {
|
|
361
|
+
this.s.mkClause([]);
|
|
362
|
+
return;
|
|
363
|
+
}
|
|
364
|
+
if (new Set(manager.getArgs(expr)).size < size) return;
|
|
365
|
+
if (size > 32) throw new SmtUnsupportedError("distinct over more than 32 arguments");
|
|
366
|
+
const lits: number[] = [];
|
|
367
|
+
for (let first = 0; first < size; first++)
|
|
368
|
+
for (let second = first + 1; second < size; second++)
|
|
369
|
+
lits.push(this.mkLiteral(this.mkEq(args[first].owner, args[second].owner)));
|
|
370
|
+
this.s.mkClause(lits);
|
|
371
|
+
}
|
|
372
|
+
|
|
373
|
+
private addDistinctAxiom(expr: number, args: readonly Enode[]) {
|
|
374
|
+
const manager = this.manager;
|
|
375
|
+
const size = args.length;
|
|
376
|
+
if (size <= 1) return;
|
|
377
|
+
const sortSize = manager.getSortSize(manager.sorts[manager.getArg(expr, 0)]);
|
|
378
|
+
if (sortSize !== SORT_SIZE_INFINITE && sortSize !== SORT_SIZE_VERY_BIG && sortSize < size) {
|
|
379
|
+
this.s.mkClause([]);
|
|
380
|
+
return;
|
|
381
|
+
}
|
|
382
|
+
if (size > 32) throw new SmtUnsupportedError("distinct over more than 32 arguments");
|
|
383
|
+
for (let first = 0; first < size; first++)
|
|
384
|
+
for (let second = first + 1; second < size; second++)
|
|
385
|
+
this.s.mkClause([this.mkLiteral(this.mkEq(args[first].owner, args[second].owner)) ^ 1]);
|
|
386
|
+
}
|
|
387
|
+
|
|
388
|
+
private axiomatizeBasic(node: Enode) {
|
|
389
|
+
const manager = this.manager;
|
|
390
|
+
const expr = node.owner;
|
|
391
|
+
if (manager.getFamily(expr) !== FAMILY_BASIC) return;
|
|
392
|
+
const op = manager.getOp(expr);
|
|
393
|
+
if (op === OP_ITE && !manager.isBool(expr)) {
|
|
394
|
+
const condition = manager.getArg(expr, 0);
|
|
395
|
+
const thenExpr = manager.getArg(expr, 1);
|
|
396
|
+
const elseExpr = manager.getArg(expr, 2);
|
|
397
|
+
const thenLit = this.mkLiteral(this.mkEq(expr, thenExpr));
|
|
398
|
+
if (thenExpr === elseExpr) {
|
|
399
|
+
this.s.mkClause([thenLit]);
|
|
400
|
+
return;
|
|
401
|
+
}
|
|
402
|
+
const conditionLit = this.mkLiteral(condition);
|
|
403
|
+
const elseLit = this.mkLiteral(this.mkEq(expr, elseExpr));
|
|
404
|
+
this.s.mkClause([conditionLit ^ 1, thenLit]);
|
|
405
|
+
this.s.mkClause([conditionLit, elseLit]);
|
|
406
|
+
} else if (op === OP_DISTINCT) {
|
|
407
|
+
const eqs: number[] = [];
|
|
408
|
+
for (let first = 0; first < node.numArgs; first++)
|
|
409
|
+
for (let second = first + 1; second < node.numArgs; second++)
|
|
410
|
+
eqs.push(this.mkEq(node.getArg(first).owner, node.getArg(second).owner));
|
|
411
|
+
const disjunction =
|
|
412
|
+
eqs.length === 0 ? manager.falseExpr : eqs.length === 1 ? eqs[0] : manager.mkOr(eqs);
|
|
413
|
+
manager.incRef(disjunction);
|
|
414
|
+
const distinctLit = 2 * this.si.toBoolVar(expr);
|
|
415
|
+
const someEq = this.si.internalize(disjunction);
|
|
416
|
+
this.s.mkClause([distinctLit ^ 1, someEq ^ 1]);
|
|
417
|
+
this.s.mkClause([distinctLit, someEq]);
|
|
418
|
+
} else if (op === OP_EQ && !manager.isBool(manager.getArg(expr, 0)))
|
|
419
|
+
this.s.setPhaseLiteral(this.expr2literal(expr));
|
|
420
|
+
}
|
|
421
|
+
|
|
422
|
+
isShared(node: Enode) {
|
|
423
|
+
const manager = this.manager;
|
|
424
|
+
const root = node.root;
|
|
425
|
+
if (root.isShared !== L_UNDEF) return root.isShared === L_TRUE;
|
|
426
|
+
const setShared = (isShared: boolean) => {
|
|
427
|
+
root.isShared = isShared ? L_TRUE : L_FALSE;
|
|
428
|
+
return isShared;
|
|
429
|
+
};
|
|
430
|
+
if (manager.getFamily(root.owner) === FAMILY_BASIC && manager.getOp(root.owner) === OP_ITE)
|
|
431
|
+
return setShared(true);
|
|
432
|
+
let thId = FAMILY_BASIC;
|
|
433
|
+
for (const thVar of root.thVars) {
|
|
434
|
+
if (thVar.id === FAMILY_BASIC) continue;
|
|
435
|
+
if (thId !== FAMILY_BASIC) return setShared(true);
|
|
436
|
+
thId = thVar.id;
|
|
437
|
+
}
|
|
438
|
+
if (manager.isBool(root.owner) && thId !== FAMILY_BASIC) return setShared(true);
|
|
439
|
+
for (const parent of root.parents) {
|
|
440
|
+
const family = manager.getFamily(parent.owner);
|
|
441
|
+
if (this.isBetaRedex(parent, root)) continue;
|
|
442
|
+
if (family !== thId && family !== FAMILY_BASIC) return setShared(true);
|
|
443
|
+
}
|
|
444
|
+
for (const thVar of root.thVars)
|
|
445
|
+
if (this.id2solver.get(thVar.id)?.isShared(thVar.thVar) === true) return setShared(true);
|
|
446
|
+
return setShared(false);
|
|
447
|
+
}
|
|
448
|
+
|
|
449
|
+
isBetaRedex(parent: Enode, node: Enode) {
|
|
450
|
+
for (const thVar of parent.thVars)
|
|
451
|
+
if (this.id2solver.get(thVar.id)?.isBetaRedex(parent, node) === true) return true;
|
|
452
|
+
return false;
|
|
453
|
+
}
|
|
454
|
+
|
|
455
|
+
mkEq(first: number, second: number) {
|
|
456
|
+
const manager = this.manager;
|
|
457
|
+
if (first === second) return manager.trueExpr;
|
|
458
|
+
if (manager.areDistinct(first, second)) return manager.falseExpr;
|
|
459
|
+
const swapped = manager.mkEq(second, first);
|
|
460
|
+
return this.egraph.find(swapped) !== undefined ? swapped : manager.mkEq(first, second);
|
|
461
|
+
}
|
|
462
|
+
|
|
463
|
+
getMaxGeneration(expr: number) {
|
|
464
|
+
const manager = this.manager;
|
|
465
|
+
let generation = 0;
|
|
466
|
+
const visited = new Set<number>();
|
|
467
|
+
const todo = [expr];
|
|
468
|
+
for (let current = todo.pop(); current !== undefined; current = todo.pop()) {
|
|
469
|
+
if (visited.has(current)) continue;
|
|
470
|
+
visited.add(current);
|
|
471
|
+
const node = this.egraph.find(current);
|
|
472
|
+
if (node !== undefined) generation = Math.max(generation, node.generation);
|
|
473
|
+
else if (manager.isApp(current)) todo.push(...manager.getArgs(current));
|
|
474
|
+
}
|
|
475
|
+
return generation;
|
|
476
|
+
}
|
|
477
|
+
|
|
478
|
+
eInternalize(expr: number) {
|
|
479
|
+
const existing = this.egraph.find(expr);
|
|
480
|
+
if (existing !== undefined) return existing;
|
|
481
|
+
this.internalizeTerm(expr);
|
|
482
|
+
return this.egraph.find(expr) as Enode;
|
|
483
|
+
}
|
|
484
|
+
|
|
485
|
+
mkEnode(expr: number, args: readonly Enode[]) {
|
|
486
|
+
const manager = this.manager;
|
|
487
|
+
const isBoolOp = this.si.isBoolOp(expr);
|
|
488
|
+
const isIte = manager.getFamily(expr) === FAMILY_BASIC && manager.getOp(expr) === OP_ITE;
|
|
489
|
+
const nodeArgs = isBoolOp || isIte ? [] : args;
|
|
490
|
+
const node = this.egraph.mk(expr, this.generation, nodeArgs);
|
|
491
|
+
if (isBoolOp) this.egraph.setCgcEnabled(node, false);
|
|
492
|
+
for (const arg of nodeArgs)
|
|
493
|
+
if (manager.isBool(arg.owner)) this.egraph.setMergeTfEnabled(arg, true);
|
|
494
|
+
return node;
|
|
495
|
+
}
|
|
496
|
+
|
|
497
|
+
addClause(lits: number[], isRedundant: boolean) {
|
|
498
|
+
this.s.mkClause(lits, isRedundant, true);
|
|
499
|
+
}
|
|
500
|
+
|
|
501
|
+
mkConstraint(owner: ThSolver, data: unknown) {
|
|
502
|
+
return this.pushConstraint({ owner, kind: K_LIT, node: null, data });
|
|
503
|
+
}
|
|
504
|
+
|
|
505
|
+
constraintData(index: number) {
|
|
506
|
+
return this.constraints[index].data;
|
|
507
|
+
}
|
|
508
|
+
|
|
509
|
+
addExplain(payload: number) {
|
|
510
|
+
this.explanation.push(payload);
|
|
511
|
+
}
|
|
512
|
+
|
|
513
|
+
private pushConstraint(constraint: Constraint) {
|
|
514
|
+
const index = this.constraints.length;
|
|
515
|
+
this.constraints.push(constraint);
|
|
516
|
+
this.trail.push(() => this.constraints.pop());
|
|
517
|
+
return index;
|
|
518
|
+
}
|
|
519
|
+
|
|
520
|
+
private litConstraint(node: Enode) {
|
|
521
|
+
return this.pushConstraint({ owner: null, kind: K_LIT, node, data: null });
|
|
522
|
+
}
|
|
523
|
+
|
|
524
|
+
propagated() {
|
|
525
|
+
return false;
|
|
526
|
+
}
|
|
527
|
+
|
|
528
|
+
setConflict(index: number) {
|
|
529
|
+
this.s.setConflict(this.s.scopeLvl, JUSTIFICATION_EXT, index);
|
|
530
|
+
}
|
|
531
|
+
|
|
532
|
+
propagate(lit: number, index: number) {
|
|
533
|
+
this.s.assign(lit, this.s.scopeLvl, JUSTIFICATION_EXT, index);
|
|
534
|
+
}
|
|
535
|
+
|
|
536
|
+
propagateEq(first: Enode, second: Enode, index: number) {
|
|
537
|
+
if (first.root === second.root) return false;
|
|
538
|
+
this.egraph.merge(first, second, constraintPayload(index));
|
|
539
|
+
return true;
|
|
540
|
+
}
|
|
541
|
+
|
|
542
|
+
resolveConflict() {
|
|
543
|
+
return L_UNDEF;
|
|
544
|
+
}
|
|
545
|
+
|
|
546
|
+
getAntecedents(lit: number, index: number, antecedents: number[]) {
|
|
547
|
+
const constraint = this.constraints[index];
|
|
548
|
+
const egraph = this.egraph;
|
|
549
|
+
egraph.beginExplain();
|
|
550
|
+
this.explanation = [];
|
|
551
|
+
if (constraint.owner === null) this.getEufAntecedents(lit, constraint);
|
|
552
|
+
else constraint.owner.getAntecedents(lit, constraint.data, antecedents);
|
|
553
|
+
this.explainQueue(antecedents);
|
|
554
|
+
egraph.endExplain();
|
|
555
|
+
let kept = 0;
|
|
556
|
+
for (const antecedent of antecedents)
|
|
557
|
+
if (this.s.lvl(antecedent) > 0) antecedents[kept++] = antecedent;
|
|
558
|
+
antecedents.length = kept;
|
|
559
|
+
}
|
|
560
|
+
|
|
561
|
+
private explainQueue(antecedents: number[]) {
|
|
562
|
+
const explanation = this.explanation;
|
|
563
|
+
for (let head = 0; head < explanation.length; head++) {
|
|
564
|
+
const payload = explanation[head];
|
|
565
|
+
if (isLiteralPayload(payload)) antecedents.push(payload >> 1);
|
|
566
|
+
else {
|
|
567
|
+
const constraint = this.constraints[payload >> 1];
|
|
568
|
+
(constraint.owner as ThSolver).getAntecedents(NULL_LITERAL, constraint.data, antecedents);
|
|
569
|
+
}
|
|
570
|
+
}
|
|
571
|
+
}
|
|
572
|
+
|
|
573
|
+
addEqAntecedent(first: Enode, second: Enode) {
|
|
574
|
+
this.egraph.explainEq(this.explanation, first, second);
|
|
575
|
+
}
|
|
576
|
+
|
|
577
|
+
getThAntecedents(explain: ThExplain, antecedents: number[]) {
|
|
578
|
+
for (const lit of explain.lits) antecedents.push(lit);
|
|
579
|
+
for (const eq of explain.eqs)
|
|
580
|
+
if (eq[0].owner > eq[1].owner) this.egraph.explainEq(this.explanation, eq[1], eq[0]);
|
|
581
|
+
else this.egraph.explainEq(this.explanation, eq[0], eq[1]);
|
|
582
|
+
}
|
|
583
|
+
|
|
584
|
+
explainDiseq(justifications: number[], first: Enode, second: Enode) {
|
|
585
|
+
const boolVar = this.egraph.explainDiseq(justifications, first, second);
|
|
586
|
+
if (boolVar !== NULL_BOOL_VAR) justifications.push(literalPayload(2 * boolVar + 1));
|
|
587
|
+
}
|
|
588
|
+
|
|
589
|
+
private getEufAntecedents(lit: number, constraint: Constraint) {
|
|
590
|
+
const egraph = this.egraph;
|
|
591
|
+
if (constraint.kind === K_CONFLICT) {
|
|
592
|
+
egraph.explain(this.explanation);
|
|
593
|
+
return;
|
|
594
|
+
}
|
|
595
|
+
const node = egraph.find(this.boolVar2exprs[lit >> 1] as number) as Enode;
|
|
596
|
+
if (constraint.kind === K_EQ) {
|
|
597
|
+
egraph.explainEq(this.explanation, node.getArg(0), node.getArg(1));
|
|
598
|
+
return;
|
|
599
|
+
}
|
|
600
|
+
const ante = constraint.node as Enode;
|
|
601
|
+
egraph.explainEq(this.explanation, node, ante);
|
|
602
|
+
const manager = this.manager;
|
|
603
|
+
if (!manager.isTrue(ante.owner) && !manager.isFalse(ante.owner))
|
|
604
|
+
this.explanation.push(literalPayload(2 * ante.boolVar + (ante.value === L_FALSE ? 1 : 0)));
|
|
605
|
+
}
|
|
606
|
+
|
|
607
|
+
setEliminated(boolVar: number) {
|
|
608
|
+
this.si.uncache(2 * boolVar);
|
|
609
|
+
this.si.uncache(2 * boolVar + 1);
|
|
610
|
+
}
|
|
611
|
+
|
|
612
|
+
asserted(lit: number) {
|
|
613
|
+
const expr = this.boolVar2exprs[lit >> 1];
|
|
614
|
+
if (expr === undefined) return;
|
|
615
|
+
const egraph = this.egraph;
|
|
616
|
+
const node = egraph.find(expr);
|
|
617
|
+
if (node === undefined) return;
|
|
618
|
+
const boolVar = lit >> 1;
|
|
619
|
+
if (this.assertedVars[boolVar] === true) return;
|
|
620
|
+
while (this.assertedVars.length <= boolVar) this.assertedVars.push(false);
|
|
621
|
+
this.assertedVars[boolVar] = true;
|
|
622
|
+
this.trail.push(() => {
|
|
623
|
+
this.assertedVars[boolVar] = false;
|
|
624
|
+
});
|
|
625
|
+
const isSign = (lit & 1) === 1;
|
|
626
|
+
const oldValue = node.value;
|
|
627
|
+
const newValue = isSign ? L_FALSE : L_TRUE;
|
|
628
|
+
egraph.setValue(node, newValue, mkExternal(literalPayload(lit)));
|
|
629
|
+
if (oldValue === L_UNDEF && node.isCgcEnabled)
|
|
630
|
+
for (const other of getClass(node)) {
|
|
631
|
+
if (other.boolVar === NULL_BOOL_VAR || other.value === newValue) continue;
|
|
632
|
+
const otherLit = 2 * other.boolVar + (isSign ? 1 : 0);
|
|
633
|
+
if (this.s.value(otherLit) === L_TRUE) continue;
|
|
634
|
+
this.propagate(otherLit, this.litConstraint(node));
|
|
635
|
+
if (this.s.value(otherLit) === L_FALSE) return;
|
|
636
|
+
}
|
|
637
|
+
for (const thVar of node.thVars) (this.id2solver.get(thVar.id) as ThSolver).asserted(lit);
|
|
638
|
+
if (node.mergeTf)
|
|
639
|
+
egraph.merge(node, isSign ? this.mkFalse() : this.mkTrue(), literalPayload(lit));
|
|
640
|
+
if (node.isEquality) {
|
|
641
|
+
if (isSign) egraph.newDiseq(node);
|
|
642
|
+
else egraph.merge(node.getArg(0), node.getArg(1), literalPayload(lit));
|
|
643
|
+
}
|
|
644
|
+
}
|
|
645
|
+
|
|
646
|
+
canPropagate() {
|
|
647
|
+
return this.egraph.canPropagate();
|
|
648
|
+
}
|
|
649
|
+
|
|
650
|
+
unitPropagate() {
|
|
651
|
+
let isPropagated = false;
|
|
652
|
+
const egraph = this.egraph;
|
|
653
|
+
while (!this.s.isInconsistent) {
|
|
654
|
+
if (egraph.isInconsistent) {
|
|
655
|
+
this.setConflict(K_CONFLICT);
|
|
656
|
+
return true;
|
|
657
|
+
}
|
|
658
|
+
let isPropagatedOnce = false;
|
|
659
|
+
if (egraph.propagate()) {
|
|
660
|
+
this.propagateThEqs();
|
|
661
|
+
isPropagatedOnce = true;
|
|
662
|
+
}
|
|
663
|
+
for (let index = 0; index < this.solvers.length; index++)
|
|
664
|
+
if (this.solvers[index].unitPropagate()) isPropagatedOnce = true;
|
|
665
|
+
if (!isPropagatedOnce) break;
|
|
666
|
+
isPropagated = true;
|
|
667
|
+
}
|
|
668
|
+
return isPropagated;
|
|
669
|
+
}
|
|
670
|
+
|
|
671
|
+
private propagateLiteral(node: Enode, ante: Enode | null) {
|
|
672
|
+
const manager = this.manager;
|
|
673
|
+
const boolVar = node.boolVar;
|
|
674
|
+
if (boolVar === NULL_BOOL_VAR) return;
|
|
675
|
+
const constraint = ante === null ? K_EQ : this.litConstraint(ante);
|
|
676
|
+
const lit =
|
|
677
|
+
ante === null
|
|
678
|
+
? 2 * boolVar
|
|
679
|
+
: 2 * boolVar +
|
|
680
|
+
((ante.value === L_UNDEF
|
|
681
|
+
? manager.isTrue(ante.owner)
|
|
682
|
+
? L_TRUE
|
|
683
|
+
: L_FALSE
|
|
684
|
+
: ante.value) === L_FALSE
|
|
685
|
+
? 1
|
|
686
|
+
: 0);
|
|
687
|
+
if (this.s.value(lit) !== L_TRUE) {
|
|
688
|
+
this.s.assign(lit, this.s.scopeLvl, JUSTIFICATION_EXT, constraint);
|
|
689
|
+
return;
|
|
690
|
+
}
|
|
691
|
+
if (!node.mergeTf || manager.isValue(node.root.owner)) return;
|
|
692
|
+
this.egraph.merge(node, ante ?? this.mkTrue(), literalPayload(lit));
|
|
693
|
+
}
|
|
694
|
+
|
|
695
|
+
private isSelfPropagated(eq: ThEq) {
|
|
696
|
+
if (eq.root === null) return false;
|
|
697
|
+
const egraph = this.egraph;
|
|
698
|
+
egraph.beginExplain();
|
|
699
|
+
const explanation: number[] = [];
|
|
700
|
+
egraph.explainEq(explanation, eq.child, eq.root);
|
|
701
|
+
egraph.endExplain();
|
|
702
|
+
if (egraph.usesCongruence) return false;
|
|
703
|
+
for (const payload of explanation) {
|
|
704
|
+
if (isLiteralPayload(payload)) return false;
|
|
705
|
+
const owner = this.constraints[payload >> 1].owner;
|
|
706
|
+
if (owner === null || owner.id !== eq.id || owner.isSelfPropagating()) return false;
|
|
707
|
+
}
|
|
708
|
+
return true;
|
|
709
|
+
}
|
|
710
|
+
|
|
711
|
+
private propagateThEqs() {
|
|
712
|
+
const egraph = this.egraph;
|
|
713
|
+
for (
|
|
714
|
+
;
|
|
715
|
+
egraph.hasThEq() && !this.s.isInconsistent && !egraph.isInconsistent;
|
|
716
|
+
egraph.nextThEq()
|
|
717
|
+
) {
|
|
718
|
+
const eq = egraph.getThEq();
|
|
719
|
+
const solver = this.id2solver.get(eq.id) as ThSolver;
|
|
720
|
+
if (eq.root === null) solver.newDiseqEh(eq);
|
|
721
|
+
else if (!this.isSelfPropagated(eq)) solver.newEqEh(eq);
|
|
722
|
+
}
|
|
723
|
+
}
|
|
724
|
+
|
|
725
|
+
mkTrue() {
|
|
726
|
+
this.visit(this.manager.trueExpr);
|
|
727
|
+
return this.egraph.find(this.manager.trueExpr) as Enode;
|
|
728
|
+
}
|
|
729
|
+
|
|
730
|
+
mkFalse() {
|
|
731
|
+
this.visit(this.manager.falseExpr);
|
|
732
|
+
return this.egraph.find(this.manager.falseExpr) as Enode;
|
|
733
|
+
}
|
|
734
|
+
|
|
735
|
+
check() {
|
|
736
|
+
if (this.unitPropagate()) return CR_CONTINUE;
|
|
737
|
+
const numNodes = this.egraph.numNodes;
|
|
738
|
+
let isGivenUp = false;
|
|
739
|
+
let isContinued = false;
|
|
740
|
+
const applySolver = (solver: ThSolver) => {
|
|
741
|
+
const result = solver.check();
|
|
742
|
+
if (result === CR_CONTINUE) isContinued = true;
|
|
743
|
+
else if (result === CR_GIVEUP) {
|
|
744
|
+
this.reasonUnknown = `incomplete theory ${solver.name}`;
|
|
745
|
+
isGivenUp = true;
|
|
746
|
+
}
|
|
747
|
+
};
|
|
748
|
+
if (this.mergeSharedBools()) isContinued = true;
|
|
749
|
+
for (let index = 0; index < this.solvers.length; index++) {
|
|
750
|
+
const solver = this.solvers[index];
|
|
751
|
+
if (!this.manager.limit.inc()) {
|
|
752
|
+
this.reasonUnknown = "canceled";
|
|
753
|
+
return CR_GIVEUP;
|
|
754
|
+
}
|
|
755
|
+
if (solver === this.qsolver) continue;
|
|
756
|
+
applySolver(solver);
|
|
757
|
+
if (this.s.isInconsistent) return CR_CONTINUE;
|
|
758
|
+
}
|
|
759
|
+
if (this.s.isInconsistent || isContinued) return CR_CONTINUE;
|
|
760
|
+
if (this.qsolver !== null) applySolver(this.qsolver);
|
|
761
|
+
if (numNodes < this.egraph.numNodes || isContinued) return CR_CONTINUE;
|
|
762
|
+
if (isGivenUp) return CR_GIVEUP;
|
|
763
|
+
for (const solver of this.solvers) solver.finalize();
|
|
764
|
+
return CR_DONE;
|
|
765
|
+
}
|
|
766
|
+
|
|
767
|
+
getReasonUnknown() {
|
|
768
|
+
return this.reasonUnknown;
|
|
769
|
+
}
|
|
770
|
+
|
|
771
|
+
private mergeSharedBools() {
|
|
772
|
+
const manager = this.manager;
|
|
773
|
+
let isMerged = false;
|
|
774
|
+
const nodes = this.egraph.nodes;
|
|
775
|
+
for (let index = nodes.length; index-- > 0;) {
|
|
776
|
+
const node = nodes[index];
|
|
777
|
+
if (!manager.isBool(node.owner) || !this.isShared(node)) continue;
|
|
778
|
+
if (node.value === L_TRUE && node.isCgcEnabled && !manager.isTrue(node.root.owner)) {
|
|
779
|
+
this.egraph.merge(node, this.mkTrue(), literalPayload(2 * node.boolVar));
|
|
780
|
+
isMerged = true;
|
|
781
|
+
}
|
|
782
|
+
if (node.value === L_FALSE && node.isCgcEnabled && !manager.isFalse(node.root.owner)) {
|
|
783
|
+
this.egraph.merge(node, this.mkFalse(), literalPayload(2 * node.boolVar + 1));
|
|
784
|
+
isMerged = true;
|
|
785
|
+
}
|
|
786
|
+
}
|
|
787
|
+
return isMerged;
|
|
788
|
+
}
|
|
789
|
+
|
|
790
|
+
push() {
|
|
791
|
+
this.si.push();
|
|
792
|
+
this.scopes.push(this.varTrail.length);
|
|
793
|
+
this.trail.pushScope();
|
|
794
|
+
for (const solver of this.solvers) solver.push();
|
|
795
|
+
this.egraph.pushScope();
|
|
796
|
+
}
|
|
797
|
+
|
|
798
|
+
pop(numScopes: number) {
|
|
799
|
+
this.startReinit();
|
|
800
|
+
this.trail.popScope(numScopes);
|
|
801
|
+
for (const solver of this.solvers) solver.pop(numScopes);
|
|
802
|
+
this.si.pop(numScopes);
|
|
803
|
+
this.egraph.popScopes(numScopes);
|
|
804
|
+
const varLim = this.scopes[this.scopes.length - numScopes];
|
|
805
|
+
for (let index = this.varTrail.length; index-- > varLim;) {
|
|
806
|
+
const boolVar = this.varTrail[index];
|
|
807
|
+
this.boolVar2exprs[boolVar] = undefined;
|
|
808
|
+
this.s.setNonExternal(boolVar);
|
|
809
|
+
}
|
|
810
|
+
this.varTrail.length = varLim;
|
|
811
|
+
this.scopes.length -= numScopes;
|
|
812
|
+
}
|
|
813
|
+
|
|
814
|
+
// user_push: the scope literal of the sat solver gets a fresh constant, out of the egraph.
|
|
815
|
+
userPush() {
|
|
816
|
+
this.push();
|
|
817
|
+
const manager = this.manager;
|
|
818
|
+
const guard = manager.mkFreshConst("sat.scope", SORT_BOOL);
|
|
819
|
+
manager.incRef(guard);
|
|
820
|
+
this.trail.push(() => manager.decRef(guard));
|
|
821
|
+
this.setBoolVar2expr(this.s.userScopeLiterals[this.scopes.length - 1] >> 1, guard);
|
|
822
|
+
}
|
|
823
|
+
|
|
824
|
+
userPop(numScopes: number) {
|
|
825
|
+
this.pop(numScopes);
|
|
826
|
+
}
|
|
827
|
+
|
|
828
|
+
private startReinit() {
|
|
829
|
+
this.reinits = [];
|
|
830
|
+
for (const boolVar of this.s.varsToReinit) {
|
|
831
|
+
const expr = this.boolVar2exprs[boolVar];
|
|
832
|
+
if (expr === undefined) continue;
|
|
833
|
+
this.manager.incRef(expr);
|
|
834
|
+
this.reinits.push({
|
|
835
|
+
expr,
|
|
836
|
+
generation: this.getEnode(expr)?.generation ?? 0,
|
|
837
|
+
boolVar,
|
|
838
|
+
});
|
|
839
|
+
}
|
|
840
|
+
}
|
|
841
|
+
|
|
842
|
+
popReinit() {
|
|
843
|
+
this.finishReinit();
|
|
844
|
+
for (const solver of this.solvers) solver.popReinit();
|
|
845
|
+
}
|
|
846
|
+
|
|
847
|
+
private finishReinit() {
|
|
848
|
+
if (this.reinits.length === 0) return;
|
|
849
|
+
const manager = this.manager;
|
|
850
|
+
const si = this.si;
|
|
851
|
+
const replay = new Map<number, number>();
|
|
852
|
+
for (const reinit of this.reinits) replay.set(reinit.expr, reinit.boolVar);
|
|
853
|
+
si.setExpr2VarReplay(replay);
|
|
854
|
+
// scoped_suspend_rlimit: the replay runs to its end even when the limit is spent.
|
|
855
|
+
const limit = manager.limit;
|
|
856
|
+
const wasSuspended = limit.isSuspended;
|
|
857
|
+
limit.isSuspended = true;
|
|
858
|
+
try {
|
|
859
|
+
for (const reinit of this.reinits) {
|
|
860
|
+
const expr = reinit.expr;
|
|
861
|
+
const oldGeneration = this.generation;
|
|
862
|
+
this.generation = reinit.generation;
|
|
863
|
+
const lit = si.isBoolOp(expr) ? 2 * (replay.get(expr) as number) : si.internalize(expr);
|
|
864
|
+
const isConnective =
|
|
865
|
+
manager.getFamily(expr) === FAMILY_BASIC &&
|
|
866
|
+
(si.isBoolOp(expr) ||
|
|
867
|
+
(manager.getOp(expr) === OP_EQ && manager.isBool(manager.getArg(expr, 0))));
|
|
868
|
+
if (this.egraph.find(expr) === undefined && !isConnective) {
|
|
869
|
+
const args = manager.isApp(expr)
|
|
870
|
+
? manager.getArgs(expr).map((arg) => this.eInternalize(arg))
|
|
871
|
+
: [];
|
|
872
|
+
this.internalizeTerm(expr);
|
|
873
|
+
if (this.egraph.find(expr) === undefined) this.mkEnode(expr, args);
|
|
874
|
+
} else this.attachLit(lit, expr);
|
|
875
|
+
this.generation = oldGeneration;
|
|
876
|
+
}
|
|
877
|
+
} finally {
|
|
878
|
+
limit.isSuspended = wasSuspended;
|
|
879
|
+
}
|
|
880
|
+
for (const entry of replay)
|
|
881
|
+
if (si.isBoolOp(entry[0]) && !si.isCached(entry[0], 2 * entry[1]))
|
|
882
|
+
si.cache(entry[0], 2 * entry[1]);
|
|
883
|
+
si.setExpr2VarReplay(null);
|
|
884
|
+
for (const reinit of this.reinits) manager.decRef(reinit.expr);
|
|
885
|
+
this.reinits = [];
|
|
886
|
+
}
|
|
887
|
+
|
|
888
|
+
isRelevant() {
|
|
889
|
+
return true;
|
|
890
|
+
}
|
|
891
|
+
|
|
892
|
+
getPhase(boolVar: number) {
|
|
893
|
+
return this.boolVar2solver(boolVar)?.getPhase(boolVar) ?? L_UNDEF;
|
|
894
|
+
}
|
|
895
|
+
|
|
896
|
+
isExternal(boolVar: number) {
|
|
897
|
+
if (this.s.isExternal(boolVar) || this.boolVar2exprs[boolVar] !== undefined) return true;
|
|
898
|
+
return this.solvers.some((solver) => solver.isExternal(boolVar));
|
|
899
|
+
}
|
|
900
|
+
|
|
901
|
+
initSearch() {
|
|
902
|
+
this.reasonUnknown = "";
|
|
903
|
+
for (const solver of this.solvers) solver.initSearch();
|
|
904
|
+
}
|
|
905
|
+
|
|
906
|
+
preSimplify() {
|
|
907
|
+
for (const solver of this.solvers) solver.preSimplify();
|
|
908
|
+
}
|
|
909
|
+
|
|
910
|
+
simplify() {
|
|
911
|
+
for (const solver of this.solvers) solver.simplify();
|
|
912
|
+
}
|
|
913
|
+
|
|
914
|
+
gc() {}
|
|
915
|
+
|
|
916
|
+
setRoot() {
|
|
917
|
+
return false;
|
|
918
|
+
}
|
|
919
|
+
|
|
920
|
+
flushRoots() {
|
|
921
|
+
for (const solver of this.solvers) solver.flushRoots();
|
|
922
|
+
}
|
|
923
|
+
|
|
924
|
+
initUseList() {}
|
|
925
|
+
|
|
926
|
+
findMutexes() {}
|
|
927
|
+
|
|
928
|
+
// Every theory solver but pb's returns false from to_formulas, which ends the walk.
|
|
929
|
+
toFormulas(_lit2expr: (lit: number) => number, formulas: number[]) {
|
|
930
|
+
if (this.solvers.length > 0) return;
|
|
931
|
+
for (const node of this.egraph.nodes)
|
|
932
|
+
if (node.root !== node) formulas.push(this.manager.mkEq(node.owner, node.root.owner));
|
|
933
|
+
}
|
|
934
|
+
|
|
935
|
+
saveModel(model: ProtoModel | null) {
|
|
936
|
+
model?.incRef();
|
|
937
|
+
this.qmodel?.decRef();
|
|
938
|
+
this.qmodel = model;
|
|
939
|
+
}
|
|
940
|
+
|
|
941
|
+
updateModel(model: ProtoModel) {
|
|
942
|
+
if (this.qmodel !== null) return this.qmodel;
|
|
943
|
+
model.resetEvalCache();
|
|
944
|
+
for (const solver of this.solvers) solver.initModel();
|
|
945
|
+
this.values = [];
|
|
946
|
+
this.values2rootMap = null;
|
|
947
|
+
const userSorts = new UserSortValues(this.manager);
|
|
948
|
+
const deps = new EnodeTopSort(this.manager);
|
|
949
|
+
this.collectDependencies(userSorts, deps);
|
|
950
|
+
deps.sort();
|
|
951
|
+
this.dependencies2values(userSorts, deps, model);
|
|
952
|
+
this.values2model(deps, model);
|
|
953
|
+
for (const solver of this.solvers) solver.finalizeModel(model);
|
|
954
|
+
userSorts.registerWith(model);
|
|
955
|
+
return model;
|
|
956
|
+
}
|
|
957
|
+
|
|
958
|
+
// validate_model, for its side effect: evaluating an application of a partial theory function,
|
|
959
|
+
// such as a division by zero, completes its interpretation with some value.
|
|
960
|
+
validateModel(model: ProtoModel) {
|
|
961
|
+
if (this.hasUnhandled() || this.solvers.some((solver) => solver.hasUnhandled())) return;
|
|
962
|
+
const manager = this.manager;
|
|
963
|
+
for (const node of this.egraph.nodes) {
|
|
964
|
+
const expr = node.owner;
|
|
965
|
+
if (!manager.isBool(expr) || manager.hasQuantifierFlags[expr] === 1) continue;
|
|
966
|
+
if (node.boolVar === NULL_BOOL_VAR) continue;
|
|
967
|
+
const value = model.eval(expr, false);
|
|
968
|
+
if (
|
|
969
|
+
this.s.value(2 * node.boolVar) === L_TRUE ? manager.isFalse(value) : manager.isTrue(value)
|
|
970
|
+
)
|
|
971
|
+
throw new SmtInvariantError("the euf model falsifies an assignment");
|
|
972
|
+
}
|
|
973
|
+
}
|
|
974
|
+
|
|
975
|
+
private includeFuncInterp(decl: number) {
|
|
976
|
+
const info = this.manager.funcDecls[decl];
|
|
977
|
+
if (info.family === FAMILY_USER) return true;
|
|
978
|
+
if (info.family === FAMILY_BASIC || info.isSkolem) return false;
|
|
979
|
+
return this.decl2solver(decl)?.includeFuncInterp(decl) === true;
|
|
980
|
+
}
|
|
981
|
+
|
|
982
|
+
private collectDependencies(userSorts: UserSortValues, deps: EnodeTopSort) {
|
|
983
|
+
const manager = this.manager;
|
|
984
|
+
const freshValues: Enode[] = [];
|
|
985
|
+
const nodes = this.egraph.nodes;
|
|
986
|
+
for (const node of nodes) {
|
|
987
|
+
const expr = node.owner;
|
|
988
|
+
const sort = manager.sorts[expr];
|
|
989
|
+
const solver = this.sort2solver(sort);
|
|
990
|
+
if (solver === null) deps.insert(node, null);
|
|
991
|
+
else if (!solver.addDep(node, deps.deps)) freshValues.push(node);
|
|
992
|
+
if (node.isRoot && manager.isUninterpretedSort(sort) && manager.isValue(expr))
|
|
993
|
+
userSorts.registerValue(expr);
|
|
994
|
+
}
|
|
995
|
+
for (const node of freshValues) deps.insert(node, null);
|
|
996
|
+
const freshSet = new Set(freshValues);
|
|
997
|
+
for (const node of freshValues)
|
|
998
|
+
for (const root of nodes)
|
|
999
|
+
if (
|
|
1000
|
+
root.isRoot &&
|
|
1001
|
+
manager.sorts[root.owner] === manager.sorts[node.owner] &&
|
|
1002
|
+
!freshSet.has(root)
|
|
1003
|
+
)
|
|
1004
|
+
addDependency(deps.deps, node, root);
|
|
1005
|
+
}
|
|
1006
|
+
|
|
1007
|
+
private dependencies2values(userSorts: UserSortValues, deps: EnodeTopSort, model: ProtoModel) {
|
|
1008
|
+
const manager = this.manager;
|
|
1009
|
+
const values = this.values;
|
|
1010
|
+
for (const node of deps.sorted) {
|
|
1011
|
+
const id = node.root.owner;
|
|
1012
|
+
if (values[id] !== undefined) continue;
|
|
1013
|
+
const expr = node.owner;
|
|
1014
|
+
if (manager.isBool(expr)) {
|
|
1015
|
+
if (manager.isUninterpretedConst(expr)) {
|
|
1016
|
+
const interp = model.constInterps.get(manager.decls[expr]);
|
|
1017
|
+
if (interp !== undefined) {
|
|
1018
|
+
values[id] = interp;
|
|
1019
|
+
continue;
|
|
1020
|
+
}
|
|
1021
|
+
}
|
|
1022
|
+
if (manager.isTrue(expr) || manager.isFalse(expr)) {
|
|
1023
|
+
values[id] = expr;
|
|
1024
|
+
continue;
|
|
1025
|
+
}
|
|
1026
|
+
const value =
|
|
1027
|
+
node.value !== L_UNDEF
|
|
1028
|
+
? node.value
|
|
1029
|
+
: node.boolVar === NULL_BOOL_VAR
|
|
1030
|
+
? L_UNDEF
|
|
1031
|
+
: this.s.value(2 * node.boolVar);
|
|
1032
|
+
if (value !== L_UNDEF) values[id] = value === L_TRUE ? manager.trueExpr : manager.falseExpr;
|
|
1033
|
+
continue;
|
|
1034
|
+
}
|
|
1035
|
+
const sort = manager.sorts[expr];
|
|
1036
|
+
if (manager.isUninterpretedSort(sort)) {
|
|
1037
|
+
userSorts.add(node.root, sort, values);
|
|
1038
|
+
continue;
|
|
1039
|
+
}
|
|
1040
|
+
const solver = this.sort2solver(sort) ?? this.expr2solver(expr);
|
|
1041
|
+
if (solver !== null) solver.addValue(node, model, values);
|
|
1042
|
+
else if (manager.isApp(expr) && manager.getFamily(expr) !== FAMILY_BASIC) values[id] = expr;
|
|
1043
|
+
}
|
|
1044
|
+
}
|
|
1045
|
+
|
|
1046
|
+
private values2model(deps: EnodeTopSort, model: ProtoModel) {
|
|
1047
|
+
const manager = this.manager;
|
|
1048
|
+
const values = this.values;
|
|
1049
|
+
for (const node of deps.sorted) {
|
|
1050
|
+
const expr = node.owner;
|
|
1051
|
+
if (!manager.isApp(expr)) continue;
|
|
1052
|
+
const decl = manager.decls[expr];
|
|
1053
|
+
if (!this.includeFuncInterp(decl)) continue;
|
|
1054
|
+
if (
|
|
1055
|
+
manager.isBool(expr) &&
|
|
1056
|
+
manager.isUninterpretedConst(expr) &&
|
|
1057
|
+
model.constInterps.has(decl)
|
|
1058
|
+
)
|
|
1059
|
+
continue;
|
|
1060
|
+
const value = values[node.root.owner];
|
|
1061
|
+
if (value === undefined) continue;
|
|
1062
|
+
const arity = node.numArgs;
|
|
1063
|
+
if (arity === 0) {
|
|
1064
|
+
model.registerConst(decl, value);
|
|
1065
|
+
continue;
|
|
1066
|
+
}
|
|
1067
|
+
let interp = model.funcInterps.get(decl);
|
|
1068
|
+
if (interp === undefined) {
|
|
1069
|
+
interp = new FuncInterp(manager, arity);
|
|
1070
|
+
model.registerFunc(decl, interp);
|
|
1071
|
+
}
|
|
1072
|
+
const args = manager
|
|
1073
|
+
.getArgs(expr)
|
|
1074
|
+
.map((arg) => values[(this.getEnode(arg) as Enode).root.owner] as number);
|
|
1075
|
+
if (interp.getEntry(args) === undefined) interp.insertNewEntry(args, value);
|
|
1076
|
+
}
|
|
1077
|
+
}
|
|
1078
|
+
|
|
1079
|
+
modelUpdated(model: ProtoModel) {
|
|
1080
|
+
this.values2rootMap = null;
|
|
1081
|
+
for (const node of this.egraph.nodes)
|
|
1082
|
+
if (node.isRoot && this.values[node.owner] !== undefined)
|
|
1083
|
+
this.values[node.owner] = model.eval(node.owner, false);
|
|
1084
|
+
}
|
|
1085
|
+
|
|
1086
|
+
values2root() {
|
|
1087
|
+
if (this.values2rootMap !== null) return this.values2rootMap;
|
|
1088
|
+
const map = new Map<number, Enode>();
|
|
1089
|
+
for (const node of this.egraph.nodes) {
|
|
1090
|
+
const value = this.values[node.owner];
|
|
1091
|
+
if (node.isRoot && value !== undefined) map.set(value, node);
|
|
1092
|
+
}
|
|
1093
|
+
this.values2rootMap = map;
|
|
1094
|
+
return map;
|
|
1095
|
+
}
|
|
1096
|
+
|
|
1097
|
+
node2value(node: Enode) {
|
|
1098
|
+
return this.values[node.root.owner];
|
|
1099
|
+
}
|
|
1100
|
+
}
|
|
1101
|
+
|
|
1102
|
+
// euf::solver::user_sort: the universe of each uninterpreted sort, with fresh values from a
|
|
1103
|
+
// user_sort_factory.
|
|
1104
|
+
class UserSortValues {
|
|
1105
|
+
private sort2values = new Map<number, number[]>();
|
|
1106
|
+
private registered = new Map<number, Set<number>>();
|
|
1107
|
+
private next = new Map<number, number>();
|
|
1108
|
+
|
|
1109
|
+
constructor(private manager: AstManager) {}
|
|
1110
|
+
|
|
1111
|
+
registerValue(value: number) {
|
|
1112
|
+
const sort = this.manager.sorts[value];
|
|
1113
|
+
const set = this.registered.get(sort) ?? new Set<number>();
|
|
1114
|
+
this.registered.set(sort, set);
|
|
1115
|
+
set.add(value);
|
|
1116
|
+
}
|
|
1117
|
+
|
|
1118
|
+
private getFreshValue(sort: number) {
|
|
1119
|
+
const set = this.registered.get(sort) ?? new Set<number>();
|
|
1120
|
+
this.registered.set(sort, set);
|
|
1121
|
+
for (let index = this.next.get(sort) ?? 0; ; index++) {
|
|
1122
|
+
const value = this.manager.mkModelValue(index, sort);
|
|
1123
|
+
if (set.has(value)) continue;
|
|
1124
|
+
set.add(value);
|
|
1125
|
+
this.next.set(sort, index + 1);
|
|
1126
|
+
return value;
|
|
1127
|
+
}
|
|
1128
|
+
}
|
|
1129
|
+
|
|
1130
|
+
add(root: Enode, sort: number, values: (number | undefined)[]) {
|
|
1131
|
+
const value = this.manager.isValue(root.owner) ? root.owner : this.getFreshValue(sort);
|
|
1132
|
+
values[root.owner] = value;
|
|
1133
|
+
const sortValues = this.sort2values.get(sort) ?? [];
|
|
1134
|
+
this.sort2values.set(sort, sortValues);
|
|
1135
|
+
sortValues.push(value);
|
|
1136
|
+
}
|
|
1137
|
+
|
|
1138
|
+
registerWith(model: ProtoModel) {
|
|
1139
|
+
for (const entry of this.sort2values) {
|
|
1140
|
+
for (const value of entry[1]) model.registerValue(value);
|
|
1141
|
+
model.registerUsort(entry[0], entry[1]);
|
|
1142
|
+
}
|
|
1143
|
+
}
|
|
1144
|
+
}
|
|
1145
|
+
|
|
1146
|
+
// top_sort<enode>: the nodes ordered so that each comes after the nodes it depends on.
|
|
1147
|
+
class EnodeTopSort {
|
|
1148
|
+
readonly deps: Dependencies = new Map();
|
|
1149
|
+
readonly sorted: Enode[] = [];
|
|
1150
|
+
private partitions = new Map<Enode, number>();
|
|
1151
|
+
private dfsNums = new Map<Enode, number>();
|
|
1152
|
+
private stackS: Enode[] = [];
|
|
1153
|
+
private stackP: Enode[] = [];
|
|
1154
|
+
|
|
1155
|
+
constructor(private manager: AstManager) {}
|
|
1156
|
+
|
|
1157
|
+
insert(node: Enode, deps: Enode[] | null) {
|
|
1158
|
+
this.deps.set(node, deps);
|
|
1159
|
+
}
|
|
1160
|
+
|
|
1161
|
+
sort() {
|
|
1162
|
+
for (const node of this.deps.keys()) this.traverse(node);
|
|
1163
|
+
}
|
|
1164
|
+
|
|
1165
|
+
private traverse(node: Enode) {
|
|
1166
|
+
const dfsNum = this.dfsNums.get(node);
|
|
1167
|
+
if (dfsNum !== undefined) {
|
|
1168
|
+
if (this.partitions.has(node)) return;
|
|
1169
|
+
for (
|
|
1170
|
+
let top = this.stackP.at(-1);
|
|
1171
|
+
top !== undefined && (this.partitions.get(top) ?? -1) > dfsNum;
|
|
1172
|
+
top = this.stackP.at(-1)
|
|
1173
|
+
)
|
|
1174
|
+
this.stackP.pop();
|
|
1175
|
+
return;
|
|
1176
|
+
}
|
|
1177
|
+
if (!this.deps.has(node)) return;
|
|
1178
|
+
this.dfsNums.set(node, this.dfsNums.size);
|
|
1179
|
+
this.stackS.push(node);
|
|
1180
|
+
this.stackP.push(node);
|
|
1181
|
+
const deps = this.deps.get(node);
|
|
1182
|
+
if (deps !== null && deps !== undefined)
|
|
1183
|
+
for (const dep of sortByExprId(this.manager, deps)) this.traverse(dep);
|
|
1184
|
+
if (node !== this.stackP.at(-1)) return;
|
|
1185
|
+
const partition = this.sorted.length;
|
|
1186
|
+
for (let top = this.stackS.pop(); top !== undefined; top = this.stackS.pop()) {
|
|
1187
|
+
this.sorted.push(top);
|
|
1188
|
+
this.partitions.set(top, partition);
|
|
1189
|
+
if (top === node) break;
|
|
1190
|
+
}
|
|
1191
|
+
this.stackP.pop();
|
|
1192
|
+
}
|
|
1193
|
+
}
|
|
1194
|
+
|
|
1195
|
+
// An obj_hashtable<enode> iterates its nodes by hash, which is the id of their expression.
|
|
1196
|
+
const sortByExprId = (manager: AstManager, nodes: readonly Enode[]) => {
|
|
1197
|
+
const table = new ObjHashtable((expr) => manager.ids[expr]);
|
|
1198
|
+
const byId = new Map<number, Enode>();
|
|
1199
|
+
for (const node of nodes) {
|
|
1200
|
+
table.add(node.owner);
|
|
1201
|
+
byId.set(node.owner, node);
|
|
1202
|
+
}
|
|
1203
|
+
return [...table].map((id) => byId.get(id) as Enode);
|
|
1204
|
+
};
|