tla-ts 0.0.10-dev.f16792fed → 0.0.10-dev.fdc173479
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +2 -1
- package/dist/compile.cjs +6 -6
- package/dist/compile.js +10 -10
- package/dist/deciders.cjs +41 -37
- package/dist/deciders.js +41 -37
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +21 -4
- package/dist/index.d.ts +21 -4
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +1 -1
- package/dist/prove-worker.cjs +1 -1
- package/dist/prove-worker.js +1 -1
- package/dist/prove.cjs +2681 -425
- package/dist/prove.js +2681 -425
- package/dist/run.cjs +41 -42
- package/dist/run.js +41 -42
- package/dist/tlapm.cjs +2 -2
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +97 -89
- package/dist/transfer.js +97 -89
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +1 -1
- package/src/ast.ts +72 -39
- package/src/bags.ts +50 -29
- package/src/builtins.ts +8 -16
- package/src/check-failure.ts +118 -0
- package/src/check-trace.ts +321 -0
- package/src/check.ts +828 -770
- package/src/cli/options.ts +6 -31
- package/src/cli/runtime-invariants.ts +20 -56
- package/src/cli/shared.ts +1 -1
- package/src/cli/tlapm.ts +433 -70
- package/src/cli/tlc-arguments.ts +224 -212
- package/src/cli/tlc-output.ts +701 -0
- package/src/cli/tlc-usage.ts +1 -2
- package/src/cli/tlc.ts +65 -712
- package/src/cli/xml-exporter.ts +23 -33
- package/src/codegen.ts +28 -20
- package/src/coverage.ts +255 -20
- package/src/dependencies.ts +96 -27
- package/src/dfid.ts +115 -50
- package/src/environment-config.ts +315 -0
- package/src/environment.ts +175 -373
- package/src/errors.ts +40 -5
- package/src/evaluate.ts +429 -139
- package/src/exit-codes.ts +28 -12
- package/src/fingerprints.ts +65 -1
- package/src/instances.ts +178 -17
- package/src/java-hash.ts +14 -0
- package/src/java-overrides.ts +2 -2
- package/src/json.ts +4 -7
- package/src/levels.ts +708 -272
- package/src/lexer.ts +17 -5
- package/src/liveness-checker.ts +707 -249
- package/src/liveness.ts +148 -95
- package/src/obligations/action.ts +14 -17
- package/src/obligations/anonymize.ts +37 -16
- package/src/obligations/enabled-axioms.ts +218 -0
- package/src/obligations/equality.ts +1 -3
- package/src/obligations/expression.ts +36 -8
- package/src/obligations/format.ts +0 -2
- package/src/obligations/generate.ts +66 -54
- package/src/obligations/index.ts +39 -9
- package/src/obligations/levels.ts +24 -11
- package/src/obligations/module.ts +28 -41
- package/src/obligations/normalize.ts +27 -18
- package/src/obligations/operators.ts +0 -2
- package/src/obligations/pragma.ts +53 -16
- package/src/obligations/printer.ts +48 -18
- package/src/obligations/proof.ts +3 -2
- package/src/obligations/regroup.ts +0 -2
- package/src/obligations/simplify.ts +55 -50
- package/src/obligations/source.ts +120 -74
- package/src/obligations/subexpression.ts +45 -18
- package/src/obligations/substitution.ts +1 -3
- package/src/obligations/temporal.ts +5 -7
- package/src/obligations/tuples.ts +0 -2
- package/src/parallel-worker.ts +17 -31
- package/src/parallel.ts +29 -47
- package/src/parser.ts +757 -326
- package/src/pretty-print.ts +1 -1
- package/src/prover/decide-pool.ts +3 -3
- package/src/prover/deciders.ts +12 -9
- package/src/prover/isabelle/decide.ts +3 -25
- package/src/prover/isabelle/encode.ts +72 -42
- package/src/prover/isabelle/isar/attrib.ts +250 -0
- package/src/prover/isabelle/isar/context.ts +335 -0
- package/src/prover/isabelle/isar/induct.ts +382 -0
- package/src/prover/isabelle/isar/inner-syntax.ts +158 -7
- package/src/prover/isabelle/isar/method.ts +509 -212
- package/src/prover/isabelle/isar/proof.ts +570 -14
- package/src/prover/isabelle/isar/rule-cases.ts +226 -0
- package/src/prover/isabelle/isar/theory.ts +487 -76
- package/src/prover/isabelle/isar/toplevel.ts +331 -0
- package/src/prover/isabelle/isar/type-check.ts +89 -14
- package/src/prover/isabelle/provers/blast/blast.ts +7 -65
- package/src/prover/isabelle/provers/blast/branch.ts +0 -2
- package/src/prover/isabelle/provers/blast/prove.ts +0 -2
- package/src/prover/isabelle/provers/blast/rules.ts +0 -2
- package/src/prover/isabelle/provers/blast/state.ts +0 -2
- package/src/prover/isabelle/provers/blast/term.ts +0 -2
- package/src/prover/isabelle/provers/clasimp.ts +1 -3
- package/src/prover/isabelle/provers/classical.ts +45 -20
- package/src/prover/isabelle/provers/hypsubst.ts +19 -30
- package/src/prover/isabelle/pure/bicompose.ts +9 -27
- package/src/prover/isabelle/pure/consts.ts +0 -2
- package/src/prover/isabelle/pure/conv.ts +2 -10
- package/src/prover/isabelle/pure/drule.ts +72 -6
- package/src/prover/isabelle/pure/envir.ts +0 -2
- package/src/prover/isabelle/pure/goal.ts +1 -3
- package/src/prover/isabelle/pure/logic.ts +1 -3
- package/src/prover/isabelle/pure/name.ts +0 -2
- package/src/prover/isabelle/pure/net.ts +0 -2
- package/src/prover/isabelle/pure/object-logic.ts +13 -7
- package/src/prover/isabelle/pure/pattern.ts +0 -2
- package/src/prover/isabelle/pure/raw-simplifier.ts +4 -15
- package/src/prover/isabelle/pure/rewriter.ts +9 -20
- package/src/prover/isabelle/pure/search.ts +0 -2
- package/src/prover/isabelle/pure/seq.ts +0 -2
- package/src/prover/isabelle/pure/simplifier.ts +26 -7
- package/src/prover/isabelle/pure/table.ts +2 -3
- package/src/prover/isabelle/pure/tactic.ts +0 -2
- package/src/prover/isabelle/pure/tactical.ts +42 -37
- package/src/prover/isabelle/pure/term-ord.ts +0 -2
- package/src/prover/isabelle/pure/term.ts +3 -5
- package/src/prover/isabelle/pure/thm.ts +14 -13
- package/src/prover/isabelle/pure/type.ts +0 -2
- package/src/prover/isabelle/pure/unify.ts +0 -2
- package/src/prover/isabelle/pure/variable.ts +0 -2
- package/src/prover/isabelle/tla/classical-setup.ts +18 -16
- package/src/prover/isabelle/tla/context.ts +58 -11
- package/src/prover/isabelle/tla/logic-data.ts +1 -1
- package/src/prover/isabelle/tla/logic.ts +49 -21
- package/src/prover/isabelle/tla/simpdata.ts +1 -12
- package/src/prover/isabelle/tools/intuitionistic.ts +28 -12
- package/src/prover/ocaml.ts +4 -1
- package/src/prover/prep/action.ts +30 -31
- package/src/prover/prep/enabled-axioms.ts +11 -2
- package/src/prover/prep/fingerprint.ts +2 -5
- package/src/prover/prep/md5.ts +26 -29
- package/src/prover/prep/methods.ts +181 -51
- package/src/prover/prep/normalize.ts +38 -9
- package/src/prover/prove.ts +395 -94
- package/src/prover/ptl/decide.ts +95 -50
- package/src/prover/ptl/encode.ts +2 -3
- package/src/prover/ptl/tableau.ts +28 -2
- package/src/prover/smt/arithmetic.ts +310 -0
- package/src/prover/smt/axioms.ts +12 -8
- package/src/prover/smt/context.ts +43 -8
- package/src/prover/smt/data.ts +498 -379
- package/src/prover/smt/encode.ts +148 -57
- package/src/prover/smt/extensionality.ts +5 -3
- package/src/prover/smt/flatten.ts +4 -6
- package/src/prover/smt/format.ts +28 -4
- package/src/prover/smt/instances.ts +7 -1
- package/src/prover/smt/layout.ts +91 -0
- package/src/prover/smt/rewrite.ts +1016 -618
- package/src/prover/smt/simplify.ts +441 -0
- package/src/prover/smt/solver/ackermannize-bv-tactic.ts +62 -0
- package/src/prover/smt/solver/ackr-helper.ts +179 -0
- package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
- package/src/prover/smt/solver/act-cache.ts +0 -1
- package/src/prover/smt/solver/add-bounds-tactic.ts +59 -0
- package/src/prover/smt/solver/aig-tactic.ts +52 -0
- package/src/prover/smt/solver/aig.ts +889 -0
- package/src/prover/smt/solver/arith-rewriter.ts +624 -9
- package/src/prover/smt/solver/arith-terms.ts +121 -0
- package/src/prover/smt/solver/array-decl-plugin.ts +175 -0
- package/src/prover/smt/solver/array-rewriter.ts +319 -0
- package/src/prover/smt/solver/asserted-formulas.ts +240 -56
- package/src/prover/smt/solver/ast-lt.ts +165 -11
- package/src/prover/smt/solver/ast-util.ts +160 -2
- package/src/prover/smt/solver/ast.ts +1483 -45
- package/src/prover/smt/solver/auf-solver.ts +25 -18
- package/src/prover/smt/solver/bit-blast-tactic.ts +608 -0
- package/src/prover/smt/solver/bit-blaster.ts +871 -0
- package/src/prover/smt/solver/blast-term-ite.ts +47 -0
- package/src/prover/smt/solver/bound-manager.ts +196 -0
- package/src/prover/smt/solver/bound-simplifier.ts +598 -0
- package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
- package/src/prover/smt/solver/bv-decl-plugin.ts +341 -0
- package/src/prover/smt/solver/bv-divrem-bounds.ts +95 -0
- package/src/prover/smt/solver/bv-rewriter.ts +1901 -0
- package/src/prover/smt/solver/bv1-blast.ts +214 -0
- package/src/prover/smt/solver/bv2fpa-converter.ts +174 -0
- package/src/prover/smt/solver/bv2int-rewriter.ts +544 -0
- package/src/prover/smt/solver/bv2real-rewriter.ts +533 -0
- package/src/prover/smt/solver/card2bv.ts +127 -0
- package/src/prover/smt/solver/case-split-queue.ts +0 -2
- package/src/prover/smt/solver/cg-table.ts +39 -25
- package/src/prover/smt/solver/check-logic.ts +330 -0
- package/src/prover/smt/solver/clause.ts +0 -1
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +293 -0
- package/src/prover/smt/solver/conflict-resolution.ts +78 -2
- package/src/prover/smt/solver/context.ts +598 -128
- package/src/prover/smt/solver/ctx-simplify.ts +29 -14
- package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
- package/src/prover/smt/solver/datatype-decl-plugin.ts +580 -0
- package/src/prover/smt/solver/datatype-rewriter.ts +82 -0
- package/src/prover/smt/solver/demodulator.ts +786 -0
- package/src/prover/smt/solver/dependent-expr-state.ts +93 -0
- package/src/prover/smt/solver/der.ts +38 -10
- package/src/prover/smt/solver/diff-neq.ts +207 -0
- package/src/prover/smt/solver/distribute-forall.ts +57 -0
- package/src/prover/smt/solver/dom-simplify.ts +511 -0
- package/src/prover/smt/solver/dt2bv-tactic.ts +298 -0
- package/src/prover/smt/solver/dyn-ack.ts +0 -1
- package/src/prover/smt/solver/e-matching.ts +7 -8
- package/src/prover/smt/solver/elim-bounds.ts +89 -0
- package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
- package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
- package/src/prover/smt/solver/elim-uncnstr.ts +548 -0
- package/src/prover/smt/solver/enode.ts +100 -3
- package/src/prover/smt/solver/eq2bv-tactic.ts +227 -0
- package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
- package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
- package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
- package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
- package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
- package/src/prover/smt/solver/euf/array-solver.ts +306 -0
- package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
- package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
- package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
- package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
- package/src/prover/smt/solver/euf/egraph.ts +901 -0
- package/src/prover/smt/solver/euf/euf-solver.ts +1204 -0
- package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
- package/src/prover/smt/solver/euf/mam.ts +1046 -0
- package/src/prover/smt/solver/euf/q-ematch.ts +829 -0
- package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
- package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
- package/src/prover/smt/solver/euf/q-solver.ts +361 -0
- package/src/prover/smt/solver/euf/th-solver.ts +328 -0
- package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
- package/src/prover/smt/solver/expr-ref.ts +0 -1
- package/src/prover/smt/solver/expr-safe-replace.ts +26 -2
- package/src/prover/smt/solver/expr2polynomial.ts +271 -0
- package/src/prover/smt/solver/factor.ts +163 -0
- package/src/prover/smt/solver/fd-solver.ts +734 -0
- package/src/prover/smt/solver/fingerprints.ts +15 -15
- package/src/prover/smt/solver/fix-dl-var.ts +147 -0
- package/src/prover/smt/solver/flat-literals.ts +0 -1
- package/src/prover/smt/solver/fm-tactic.ts +886 -0
- package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
- package/src/prover/smt/solver/fpa-rewriter.ts +639 -0
- package/src/prover/smt/solver/fpa2bv-converter.ts +2251 -0
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +349 -0
- package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
- package/src/prover/smt/solver/goal.ts +178 -15
- package/src/prover/smt/solver/goal2nlsat.ts +216 -0
- package/src/prover/smt/solver/guard-set.ts +219 -0
- package/src/prover/smt/solver/hash.ts +0 -1
- package/src/prover/smt/solver/hashtable.ts +34 -16
- package/src/prover/smt/solver/inf-eps.ts +63 -0
- package/src/prover/smt/solver/inj-axiom.ts +101 -0
- package/src/prover/smt/solver/internalizer.ts +111 -39
- package/src/prover/smt/solver/lackr.ts +381 -0
- package/src/prover/smt/solver/lbool.ts +0 -1
- package/src/prover/smt/solver/lia2card.ts +268 -0
- package/src/prover/smt/solver/lia2pb.ts +154 -0
- package/src/prover/smt/solver/literal.ts +0 -1
- package/src/prover/smt/solver/logic-tactics.ts +355 -0
- package/src/prover/smt/solver/lp/bound-propagator.ts +0 -1
- package/src/prover/smt/solver/lp/constraints.ts +0 -1
- package/src/prover/smt/solver/lp/containers.ts +7 -2
- package/src/prover/smt/solver/lp/core-solver.ts +30 -11
- package/src/prover/smt/solver/lp/cross-nested.ts +1 -4
- package/src/prover/smt/solver/lp/dep-intervals.ts +0 -3
- package/src/prover/smt/solver/lp/dependency.ts +0 -2
- package/src/prover/smt/solver/lp/dioph-eq.ts +1 -10
- package/src/prover/smt/solver/lp/explanation.ts +0 -1
- package/src/prover/smt/solver/lp/gomory.ts +0 -1
- package/src/prover/smt/solver/lp/hnf-cutter.ts +1 -2
- package/src/prover/smt/solver/lp/hnf.ts +0 -3
- package/src/prover/smt/solver/lp/int-cube.ts +3 -4
- package/src/prover/smt/solver/lp/int-solver.ts +0 -2
- package/src/prover/smt/solver/lp/lar-solver.ts +41 -5
- package/src/prover/smt/solver/lp/lar-term.ts +0 -1
- package/src/prover/smt/solver/lp/lp-settings.ts +6 -3
- package/src/prover/smt/solver/lp/maximize-term.ts +59 -10
- package/src/prover/smt/solver/lp/nex-creator.ts +3 -3
- package/src/prover/smt/solver/lp/nex.ts +2 -2
- package/src/prover/smt/solver/lp/nla-backoff.ts +0 -2
- package/src/prover/smt/solver/lp/nla-basics.ts +46 -3
- package/src/prover/smt/solver/lp/nla-core.ts +68 -17
- package/src/prover/smt/solver/lp/nla-divisions.ts +0 -2
- package/src/prover/smt/solver/lp/nla-emonics.ts +0 -1
- package/src/prover/smt/solver/lp/nla-factorization.ts +0 -1
- package/src/prover/smt/solver/lp/nla-grobner.ts +167 -85
- package/src/prover/smt/solver/lp/nla-horner.ts +0 -2
- package/src/prover/smt/solver/lp/nla-intervals.ts +0 -1
- package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +0 -2
- package/src/prover/smt/solver/lp/nla-monotone.ts +0 -1
- package/src/prover/smt/solver/lp/nla-order.ts +0 -2
- package/src/prover/smt/solver/lp/nla-patcher.ts +0 -1
- package/src/prover/smt/solver/lp/nla-powers.ts +220 -0
- package/src/prover/smt/solver/lp/nla-tangents.ts +0 -2
- package/src/prover/smt/solver/lp/nla-throttle.ts +0 -1
- package/src/prover/smt/solver/lp/nla-transcendentals.ts +324 -0
- package/src/prover/smt/solver/lp/nla-types.ts +0 -2
- package/src/prover/smt/solver/lp/nla-var-eqs.ts +0 -1
- package/src/prover/smt/solver/lp/nra-solver.ts +163 -99
- package/src/prover/smt/solver/lp/numeric-pair.ts +0 -1
- package/src/prover/smt/solver/lp/pdd-interval.ts +6 -3
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -21
- package/src/prover/smt/solver/lp/pdd-solver.ts +72 -41
- package/src/prover/smt/solver/lp/pdd.ts +725 -290
- package/src/prover/smt/solver/lp/random-updater.ts +0 -2
- package/src/prover/smt/solver/lp/static-matrix.ts +0 -1
- package/src/prover/smt/solver/lp/union-find.ts +7 -2
- package/src/prover/smt/solver/macro-finder.ts +530 -0
- package/src/prover/smt/solver/mam-compiler.ts +122 -90
- package/src/prover/smt/solver/mam-interpreter.ts +0 -1
- package/src/prover/smt/solver/max-bv-sharing-tactic.ts +17 -0
- package/src/prover/smt/solver/max-cliques.ts +105 -0
- package/src/prover/smt/solver/maxcore.ts +310 -0
- package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -6
- package/src/prover/smt/solver/maxlex.ts +115 -0
- package/src/prover/smt/solver/maxsmt-base.ts +106 -0
- package/src/prover/smt/solver/maxsmt.ts +92 -0
- package/src/prover/smt/solver/mbp/mbp-arith.ts +467 -0
- package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +101 -0
- package/src/prover/smt/solver/mbp/mbp-plugin.ts +287 -0
- package/src/prover/smt/solver/mbp/mbp-qel.ts +48 -0
- package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +271 -0
- package/src/prover/smt/solver/mbp/mbp-term-graph.ts +606 -0
- package/src/prover/smt/solver/model-based-opt.ts +844 -0
- package/src/prover/smt/solver/model-checker.ts +19 -28
- package/src/prover/smt/solver/model-evaluator.ts +190 -12
- package/src/prover/smt/solver/model-finder.ts +12 -18
- package/src/prover/smt/solver/model-generator.ts +104 -35
- package/src/prover/smt/solver/model-macro-solver.ts +49 -46
- package/src/prover/smt/solver/model-printer.ts +214 -0
- package/src/prover/smt/solver/mpf.ts +709 -0
- package/src/prover/smt/solver/mus.ts +50 -0
- package/src/prover/smt/solver/muz/dl-context.ts +382 -0
- package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +97 -0
- package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +167 -0
- package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +125 -0
- package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +299 -0
- package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +455 -0
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +340 -0
- package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +163 -0
- package/src/prover/smt/solver/muz/dl-rule-set.ts +273 -0
- package/src/prover/smt/solver/muz/dl-rule-transformer.ts +123 -0
- package/src/prover/smt/solver/muz/dl-rule.ts +495 -0
- package/src/prover/smt/solver/muz/hnf.ts +201 -0
- package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
- package/src/prover/smt/solver/muz/horn-tactic.ts +214 -0
- package/src/prover/smt/solver/muz/rule-properties.ts +359 -0
- package/src/prover/smt/solver/muz/spacer-context.ts +1404 -0
- package/src/prover/smt/solver/muz/spacer-dl-interface.ts +52 -0
- package/src/prover/smt/solver/muz/spacer-generalizers.ts +241 -0
- package/src/prover/smt/solver/muz/spacer-manager.ts +127 -0
- package/src/prover/smt/solver/muz/spacer-pdr.ts +219 -0
- package/src/prover/smt/solver/muz/spacer-prop-solver.ts +333 -0
- package/src/prover/smt/solver/muz/spacer-util.ts +282 -0
- package/src/prover/smt/solver/muz/substitution.ts +203 -0
- package/src/prover/smt/solver/nla2bv-tactic.ts +285 -0
- package/src/prover/smt/solver/nlqsat.ts +485 -0
- package/src/prover/smt/solver/nlsat/algebraic.ts +315 -98
- package/src/prover/smt/solver/nlsat/atoms.ts +71 -38
- package/src/prover/smt/solver/nlsat/evaluator.ts +0 -1
- package/src/prover/smt/solver/nlsat/explain.ts +427 -229
- package/src/prover/smt/solver/nlsat/interval-set.ts +1 -2
- package/src/prover/smt/solver/nlsat/levelwise.ts +460 -246
- package/src/prover/smt/solver/nlsat/mpbq.ts +45 -1
- package/src/prover/smt/solver/nlsat/polynomial.ts +2376 -684
- package/src/prover/smt/solver/nlsat/solver.ts +293 -92
- package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
- package/src/prover/smt/solver/nlsat/transcendentals.ts +391 -0
- package/src/prover/smt/solver/nlsat/types.ts +0 -2
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +9 -8
- package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -20
- package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
- package/src/prover/smt/solver/nnf.ts +110 -24
- package/src/prover/smt/solver/normalize-bounds.ts +53 -0
- package/src/prover/smt/solver/occf.ts +97 -0
- package/src/prover/smt/solver/opt-context.ts +801 -0
- package/src/prover/smt/solver/opt-nlsat.ts +386 -0
- package/src/prover/smt/solver/opt-pareto.ts +301 -0
- package/src/prover/smt/solver/opt-preprocess.ts +101 -0
- package/src/prover/smt/solver/opt-solver.ts +312 -0
- package/src/prover/smt/solver/opt-value.ts +55 -0
- package/src/prover/smt/solver/optsmt.ts +692 -0
- package/src/prover/smt/solver/parallel-tactic.ts +299 -0
- package/src/prover/smt/solver/pattern-inference.ts +19 -11
- package/src/prover/smt/solver/pb-rewriter.ts +281 -0
- package/src/prover/smt/solver/pb2bv-tactic.ts +546 -0
- package/src/prover/smt/solver/poly-rewriter.ts +259 -57
- package/src/prover/smt/solver/probes.ts +577 -0
- package/src/prover/smt/solver/propagate-values.ts +37 -21
- package/src/prover/smt/solver/proto-model.ts +648 -19
- package/src/prover/smt/solver/pull-quant.ts +28 -12
- package/src/prover/smt/solver/purify-arith.ts +634 -0
- package/src/prover/smt/solver/push-app-ite.ts +37 -0
- package/src/prover/smt/solver/qe-arith-plugin.ts +1096 -0
- package/src/prover/smt/solver/qe-lite-der.ts +2 -3
- package/src/prover/smt/solver/qe-lite-fm.ts +3 -4
- package/src/prover/smt/solver/qe-lite.ts +39 -19
- package/src/prover/smt/solver/qe-mbp.ts +270 -0
- package/src/prover/smt/solver/qe.ts +1499 -0
- package/src/prover/smt/solver/qel.ts +25 -0
- package/src/prover/smt/solver/qi-queue.ts +0 -1
- package/src/prover/smt/solver/qsat.ts +829 -0
- package/src/prover/smt/solver/quant-hoist.ts +196 -0
- package/src/prover/smt/solver/quant-tactics.ts +16 -56
- package/src/prover/smt/solver/quantifier-analyzer.ts +19 -20
- package/src/prover/smt/solver/quantifier-manager.ts +22 -25
- package/src/prover/smt/solver/quasi-macros.ts +243 -0
- package/src/prover/smt/solver/random-gen.ts +0 -1
- package/src/prover/smt/solver/rational.ts +45 -1
- package/src/prover/smt/solver/recfun-decl-plugin.ts +262 -0
- package/src/prover/smt/solver/recfun-rewriter.ts +107 -0
- package/src/prover/smt/solver/reduce-args.ts +225 -0
- package/src/prover/smt/solver/reduce-bv-size.ts +119 -0
- package/src/prover/smt/solver/ref-vector.ts +0 -1
- package/src/prover/smt/solver/relevancy.ts +1 -2
- package/src/prover/smt/solver/rewriter-tpl.ts +82 -14
- package/src/prover/smt/solver/rewriter.ts +505 -60
- package/src/prover/smt/solver/rlimit.ts +45 -5
- package/src/prover/smt/solver/sat/asymm-branch.ts +325 -0
- package/src/prover/smt/solver/sat/big.ts +177 -0
- package/src/prover/smt/solver/sat/clause-use-list.ts +71 -0
- package/src/prover/smt/solver/sat/clause.ts +203 -0
- package/src/prover/smt/solver/sat/cleaner.ts +94 -0
- package/src/prover/smt/solver/sat/config.ts +122 -0
- package/src/prover/smt/solver/sat/consequences.ts +203 -0
- package/src/prover/smt/solver/sat/elim-eqs.ts +142 -0
- package/src/prover/smt/solver/sat/goal2sat.ts +589 -0
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +480 -0
- package/src/prover/smt/solver/sat/model-converter.ts +136 -0
- package/src/prover/smt/solver/sat/pb-constraint.ts +268 -0
- package/src/prover/smt/solver/sat/pb-solver.ts +1596 -0
- package/src/prover/smt/solver/sat/probing.ts +170 -0
- package/src/prover/smt/solver/sat/sat-tactic.ts +72 -0
- package/src/prover/smt/solver/sat/sat2goal.ts +190 -0
- package/src/prover/smt/solver/sat/scc.ts +142 -0
- package/src/prover/smt/solver/sat/simplifier.ts +1618 -0
- package/src/prover/smt/solver/sat/solver.ts +2107 -0
- package/src/prover/smt/solver/sat/var-queue.ts +117 -0
- package/src/prover/smt/solver/sat/watch-list.ts +140 -0
- package/src/prover/smt/solver/search-tree.ts +284 -0
- package/src/prover/smt/solver/seq-axioms.ts +995 -0
- package/src/prover/smt/solver/seq-decl-plugin.ts +819 -0
- package/src/prover/smt/solver/seq-derive.ts +1298 -0
- package/src/prover/smt/solver/seq-eq-approx.ts +236 -0
- package/src/prover/smt/solver/seq-eq-solver.ts +439 -0
- package/src/prover/smt/solver/seq-factory.ts +89 -0
- package/src/prover/smt/solver/seq-monadic.ts +730 -0
- package/src/prover/smt/solver/seq-range-predicate.ts +235 -0
- package/src/prover/smt/solver/seq-re-rewriter.ts +1171 -0
- package/src/prover/smt/solver/seq-re-util.ts +758 -0
- package/src/prover/smt/solver/seq-regex-bisim.ts +144 -0
- package/src/prover/smt/solver/seq-regex-live.ts +200 -0
- package/src/prover/smt/solver/seq-rewriter.ts +2404 -0
- package/src/prover/smt/solver/seq-skolem.ts +294 -0
- package/src/prover/smt/solver/seq-subset.ts +165 -0
- package/src/prover/smt/solver/seq-view-witness.ts +353 -0
- package/src/prover/smt/solver/smt-consequences.ts +297 -0
- package/src/prover/smt/solver/smt-kernel.ts +124 -0
- package/src/prover/smt/solver/smt-logics.ts +66 -0
- package/src/prover/smt/solver/smt-setup.ts +589 -0
- package/src/prover/smt/solver/smt2-printer.ts +765 -0
- package/src/prover/smt/solver/smtlib-parser.ts +3535 -360
- package/src/prover/smt/solver/smtlib-script.ts +2136 -0
- package/src/prover/smt/solver/solve-eqs.ts +928 -0
- package/src/prover/smt/solver/solver.ts +128 -23
- package/src/prover/smt/solver/static-features.ts +314 -0
- package/src/prover/smt/solver/sticky-generations.ts +0 -1
- package/src/prover/smt/solver/tactic.ts +2176 -0
- package/src/prover/smt/solver/term-enumeration.ts +205 -0
- package/src/prover/smt/solver/theory-array.ts +1240 -0
- package/src/prover/smt/solver/theory-bv.ts +1210 -0
- package/src/prover/smt/solver/theory-char.ts +355 -0
- package/src/prover/smt/solver/theory-datatype.ts +598 -0
- package/src/prover/smt/solver/theory-finite-set.ts +30 -0
- package/src/prover/smt/solver/theory-fpa.ts +389 -0
- package/src/prover/smt/solver/theory-lra-axioms.ts +53 -2
- package/src/prover/smt/solver/theory-lra-bounds.ts +31 -6
- package/src/prover/smt/solver/theory-lra-final-check.ts +57 -70
- package/src/prover/smt/solver/theory-lra-internalize.ts +96 -27
- package/src/prover/smt/solver/theory-lra-model.ts +20 -35
- package/src/prover/smt/solver/theory-lra-propagate.ts +35 -28
- package/src/prover/smt/solver/theory-lra-state.ts +7 -23
- package/src/prover/smt/solver/theory-lra.ts +189 -2
- package/src/prover/smt/solver/theory-pb.ts +951 -0
- package/src/prover/smt/solver/theory-polymorphism.ts +58 -0
- package/src/prover/smt/solver/theory-recfun.ts +307 -0
- package/src/prover/smt/solver/theory-seq-regex.ts +867 -0
- package/src/prover/smt/solver/theory-seq-solve.ts +1373 -0
- package/src/prover/smt/solver/theory-seq-state.ts +852 -0
- package/src/prover/smt/solver/theory-seq.ts +961 -0
- package/src/prover/smt/solver/theory-without-terms.ts +24 -0
- package/src/prover/smt/solver/theory.ts +189 -0
- package/src/prover/smt/solver/tseitin-cnf.ts +495 -0
- package/src/prover/smt/solver/var-subst.ts +36 -14
- package/src/prover/smt/table.ts +3 -2
- package/src/prover/smt/types.ts +146 -0
- package/src/prover/tlapm/cache.ts +57 -26
- package/src/prover/tlapm/tlapm.ts +15 -9
- package/src/prover/tlapm-library.ts +3208 -0
- package/src/prover/verdict.ts +9 -0
- package/src/prover/zenon/check/check.ts +1 -2
- package/src/prover/zenon/check/records.ts +1 -1
- package/src/prover/zenon/check/relations.ts +2 -1
- package/src/prover/zenon/check/rewrites.ts +2 -15
- package/src/prover/zenon/check/sets.ts +40 -58
- package/src/prover/zenon/check/terms.ts +1 -2
- package/src/prover/zenon/decide.ts +10 -7
- package/src/prover/zenon/encode.ts +0 -2
- package/src/prover/zenon/eqrel.ts +2 -2
- package/src/prover/zenon/equality-rules.ts +24 -2
- package/src/prover/zenon/expr.ts +28 -2
- package/src/prover/zenon/index-table.ts +16 -23
- package/src/prover/zenon/isar-case.ts +1 -3
- package/src/prover/zenon/isar.ts +37 -39
- package/src/prover/zenon/llproof.ts +2 -13
- package/src/prover/zenon/mltoll.ts +12 -30
- package/src/prover/zenon/node.ts +20 -5
- package/src/prover/zenon/parse.ts +9 -8
- package/src/prover/zenon/phrase.ts +1 -3
- package/src/prover/zenon/proof.ts +0 -2
- package/src/prover/zenon/propositional-rules.ts +0 -2
- package/src/prover/zenon/rules.ts +2 -3
- package/src/prover/zenon/search.ts +11 -19
- package/src/prover/zenon/tla/functions.ts +2 -4
- package/src/prover/zenon/tla/llproof.ts +9 -13
- package/src/prover/zenon/tla/records.ts +1 -8
- package/src/prover/zenon/tla/rewrites.ts +0 -2
- package/src/prover/zenon/tla/sets.ts +22 -22
- package/src/prover/zenon/tla/terms.ts +0 -2
- package/src/prover/zenon/tla/tla.ts +7 -8
- package/src/resolve.ts +1327 -328
- package/src/runtime.ts +25 -2
- package/src/sany/builtins.ts +10 -10
- package/src/sany/generation.ts +384 -0
- package/src/sany/generator-def-entries.ts +297 -0
- package/src/sany/generator-definitions.ts +688 -0
- package/src/sany/generator-expressions.ts +1123 -0
- package/src/sany/generator-proofs.ts +668 -0
- package/src/sany/generator.ts +161 -2625
- package/src/sany/levels.ts +0 -2
- package/src/sany/lexer.ts +32 -23
- package/src/sany/linter.ts +0 -2
- package/src/sany/modules.ts +4 -2
- package/src/sany/nodes.ts +3 -4
- package/src/sany/report.ts +3 -6
- package/src/sany/selectors.ts +46 -44
- package/src/sany/xml.ts +25 -58
- package/src/search.ts +513 -165
- package/src/simulate.ts +340 -251
- package/src/spec-description.ts +48 -55
- package/src/standard-definitions.ts +5 -0
- package/src/standard-modules.ts +72 -54
- package/src/state-graph.ts +0 -2
- package/src/subexpressions.ts +564 -138
- package/src/substitution-levels.ts +5 -4
- package/src/successors.ts +56 -28
- package/src/symmetry.ts +4 -3
- package/src/tableau.ts +2 -2
- package/src/tlc/fingerprint.ts +81 -9
- package/src/tlc/jar-data.ts +10 -0
- package/src/tlc/messages.ts +23 -18
- package/src/tlc/order.ts +14 -3
- package/src/tlc/random.ts +6 -5
- package/src/tlc/replay.ts +152 -58
- package/src/tlc/summary.ts +29 -14
- package/src/tlc/tlc-operators.ts +12 -11
- package/src/tlc/tlcext-operators.ts +87 -26
- package/src/tlc/trace-spec.ts +27 -60
- package/src/trace-liveness.ts +529 -0
- package/src/typed-tier.ts +6556 -0
- package/src/typescript/actions.ts +2 -4
- package/src/typescript/collections.ts +34 -20
- package/src/typescript/compile.ts +1 -3
- package/src/typescript/formula.ts +5 -3
- package/src/typescript/model.ts +4 -5
- package/src/typescript/steps.ts +20 -18
- package/src/typescript/types.ts +2 -2
- package/src/values.ts +208 -227
- package/src/prover/isabelle/isar/statement.ts +0 -52
- package/src/prover/smt/solver/z3-license.txt +0 -10
- package/src/prover/tlaps-module.ts +0 -510
- package/src/prover/zenon/LICENSE +0 -32
|
@@ -0,0 +1,2136 @@
|
|
|
1
|
+
import { ENCODINGS, UNICODE_ENCODING } from "./seq-decl-plugin";
|
|
2
|
+
import {
|
|
3
|
+
isStackOverflow,
|
|
4
|
+
SmtCanceledError,
|
|
5
|
+
SmtParseError,
|
|
6
|
+
SmtDefaultError,
|
|
7
|
+
SmtTacticError,
|
|
8
|
+
SmtUnsupportedError,
|
|
9
|
+
} from "../../../errors";
|
|
10
|
+
import type { DecideOptions } from "../../verdict";
|
|
11
|
+
import {
|
|
12
|
+
AstManager,
|
|
13
|
+
FAMILY_BASIC,
|
|
14
|
+
FAMILY_MODEL_VALUE,
|
|
15
|
+
FAMILY_USER,
|
|
16
|
+
KIND_APP,
|
|
17
|
+
KIND_QUANTIFIER,
|
|
18
|
+
OP_IMPLIES,
|
|
19
|
+
SORT_BOOL,
|
|
20
|
+
SORT_INT,
|
|
21
|
+
SORT_REAL,
|
|
22
|
+
} from "./ast";
|
|
23
|
+
import { Goal, getDependencyValues, mkDependencyLeaf, PRECISION_NAMES } from "./goal";
|
|
24
|
+
import { Rational } from "./rational";
|
|
25
|
+
import { Rewriter } from "./rewriter";
|
|
26
|
+
import { ResourceLimit } from "./rlimit";
|
|
27
|
+
import {
|
|
28
|
+
DEFAULT_PRINT_OPTIONS,
|
|
29
|
+
formatSort,
|
|
30
|
+
getQuotedName,
|
|
31
|
+
mkSeq1,
|
|
32
|
+
mkSeq5,
|
|
33
|
+
mkText,
|
|
34
|
+
type PrintOptions,
|
|
35
|
+
printExpr,
|
|
36
|
+
renderFormat,
|
|
37
|
+
} from "./smt2-printer";
|
|
38
|
+
import {
|
|
39
|
+
createCommandReader,
|
|
40
|
+
createSmtlibReader,
|
|
41
|
+
DECLARATIONS,
|
|
42
|
+
expectClosed,
|
|
43
|
+
isSymbol,
|
|
44
|
+
isUnsigned,
|
|
45
|
+
type SExpr,
|
|
46
|
+
type SmtList,
|
|
47
|
+
type SmtlibReader,
|
|
48
|
+
type SmtToken,
|
|
49
|
+
} from "./smtlib-parser";
|
|
50
|
+
import { O_MAXIMIZE, O_MAXSMT, O_MINIMIZE, OptContext, type OptObjective } from "./opt-context";
|
|
51
|
+
import { getLogicStrategy } from "./logic-tactics";
|
|
52
|
+
import { isMbqiByFeatures, isMbqiByLogic } from "./smt-setup";
|
|
53
|
+
import { isSupportedLogic, logicHasSeq } from "./smt-logics";
|
|
54
|
+
import { getVerdict, solveAssertions, solveAssuming } from "./solver";
|
|
55
|
+
import { getConsequences } from "./smt-consequences";
|
|
56
|
+
import { FdSolver } from "./fd-solver";
|
|
57
|
+
import { SmtKernel } from "./smt-kernel";
|
|
58
|
+
import { RefVector } from "./ref-vector";
|
|
59
|
+
import { IncSatSolver } from "./sat/inc-sat-solver";
|
|
60
|
+
import { mkThSolver } from "./euf/th-solvers";
|
|
61
|
+
import { isAstLess } from "./ast-lt";
|
|
62
|
+
import { InvVarShifter } from "./rewriter-tpl";
|
|
63
|
+
import { elimUnusedVars, getFreeVarSorts, VarSubst } from "./var-subst";
|
|
64
|
+
import { type Context, MBQI_MAX_ITERATIONS } from "./context";
|
|
65
|
+
import { L_FALSE, L_TRUE, L_UNDEF } from "./lbool";
|
|
66
|
+
import type { DatalogContext } from "./muz/dl-context";
|
|
67
|
+
import { createDatalogContext } from "./muz/horn-tactic";
|
|
68
|
+
import { printModel } from "./model-printer";
|
|
69
|
+
import { ModelEvaluator } from "./model-evaluator";
|
|
70
|
+
import { FuncInterp, getManagerSomeValue, ProtoModel } from "./proto-model";
|
|
71
|
+
import {
|
|
72
|
+
applyTactic,
|
|
73
|
+
checkSatUsing,
|
|
74
|
+
compileInternalTactic,
|
|
75
|
+
compileTactic,
|
|
76
|
+
getRewriterOptions,
|
|
77
|
+
getSatParams,
|
|
78
|
+
getSmtTacticFailure,
|
|
79
|
+
type TacticParam,
|
|
80
|
+
} from "./tactic";
|
|
81
|
+
|
|
82
|
+
const UNPORTED_COMMANDS = new Set([
|
|
83
|
+
"assert-not",
|
|
84
|
+
"assume",
|
|
85
|
+
"dbg-bool-rewriter",
|
|
86
|
+
"dbg-elim-and",
|
|
87
|
+
"dbg-get-qbody",
|
|
88
|
+
"dbg-params",
|
|
89
|
+
"dbg-pp-var",
|
|
90
|
+
"dbg-set",
|
|
91
|
+
"dbg-set-next-id",
|
|
92
|
+
"dbg-sexpr",
|
|
93
|
+
"dbg-shift-vars",
|
|
94
|
+
"dbg-size",
|
|
95
|
+
"dbg-subst",
|
|
96
|
+
"dbg-th-rewriter",
|
|
97
|
+
"dbg-translator",
|
|
98
|
+
"declare-map",
|
|
99
|
+
"declare-tactic",
|
|
100
|
+
"declare-type-var",
|
|
101
|
+
"del",
|
|
102
|
+
"display-dimacs",
|
|
103
|
+
"euf-project",
|
|
104
|
+
"eufi",
|
|
105
|
+
"ff-boolean-certify",
|
|
106
|
+
"ff-certify",
|
|
107
|
+
"ff-check-native-proof",
|
|
108
|
+
"ff-integrated-certify",
|
|
109
|
+
"get-interpolant",
|
|
110
|
+
"get-proof",
|
|
111
|
+
"get-proof-graph",
|
|
112
|
+
"get-user-tactics",
|
|
113
|
+
"help",
|
|
114
|
+
"help-simplifier",
|
|
115
|
+
"help-tactic",
|
|
116
|
+
"include",
|
|
117
|
+
"infer",
|
|
118
|
+
"labels",
|
|
119
|
+
"mbi",
|
|
120
|
+
"mbp",
|
|
121
|
+
"mbp-qel",
|
|
122
|
+
"model-add",
|
|
123
|
+
"model-del",
|
|
124
|
+
"prefer",
|
|
125
|
+
"qe-lite",
|
|
126
|
+
"qel",
|
|
127
|
+
"reset-preferences",
|
|
128
|
+
"set-initial-value",
|
|
129
|
+
"set-simplifier",
|
|
130
|
+
]);
|
|
131
|
+
|
|
132
|
+
const SILENT_COMMANDS = new Set([
|
|
133
|
+
...DECLARATIONS,
|
|
134
|
+
"assert",
|
|
135
|
+
"push",
|
|
136
|
+
"pop",
|
|
137
|
+
"reset",
|
|
138
|
+
"reset-assertions",
|
|
139
|
+
"set-option",
|
|
140
|
+
"set-info",
|
|
141
|
+
"assert-soft",
|
|
142
|
+
"declare-rel",
|
|
143
|
+
"declare-var",
|
|
144
|
+
"rule",
|
|
145
|
+
]);
|
|
146
|
+
|
|
147
|
+
type PrintOptionOf<Value> = {
|
|
148
|
+
[Key in keyof PrintOptions]: PrintOptions[Key] extends Value ? Key : never;
|
|
149
|
+
}[keyof PrintOptions];
|
|
150
|
+
|
|
151
|
+
const NUMERIC_PRINT_OPTIONS = new Map<string, PrintOptionOf<number>>([
|
|
152
|
+
[":pp.max_indent", "maxIndent"],
|
|
153
|
+
[":pp.max_num_lines", "maxNumLines"],
|
|
154
|
+
[":pp.max_width", "maxWidth"],
|
|
155
|
+
[":pp.max_ribbon", "maxRibbon"],
|
|
156
|
+
[":pp.max_depth", "maxDepth"],
|
|
157
|
+
[":pp.min_alias_size", "minAliasSize"],
|
|
158
|
+
[":pp.decimal_precision", "decimalPrecision"],
|
|
159
|
+
]);
|
|
160
|
+
|
|
161
|
+
const BOOLEAN_PRINT_OPTIONS = new Map<string, PrintOptionOf<boolean>>([
|
|
162
|
+
[":pp.flat_assoc", "isFlatAssoc"],
|
|
163
|
+
[":pp.single_line", "isSingleLine"],
|
|
164
|
+
[":pp.bounded", "isBounded"],
|
|
165
|
+
[":pp.decimal", "isDecimal"],
|
|
166
|
+
[":pp.bv_literals", "isBvLiterals"],
|
|
167
|
+
[":pp.bv_neg", "isBvNeg"],
|
|
168
|
+
[":pp.fp_real_literals", "isFpRealLiterals"],
|
|
169
|
+
]);
|
|
170
|
+
|
|
171
|
+
const SIMPLIFY_PARAMETERS = new Set([
|
|
172
|
+
"elim_and",
|
|
173
|
+
"local_ctx",
|
|
174
|
+
"pull_cheap_ite",
|
|
175
|
+
"blast_distinct",
|
|
176
|
+
"som",
|
|
177
|
+
"sort_sums",
|
|
178
|
+
"arith_lhs",
|
|
179
|
+
"arith_ineq_lhs",
|
|
180
|
+
"gcd_rounding",
|
|
181
|
+
"hi_div0",
|
|
182
|
+
"mul2concat",
|
|
183
|
+
"split_concat_eq",
|
|
184
|
+
"algebraic_number_evaluator",
|
|
185
|
+
"expand_power",
|
|
186
|
+
"expand_tan",
|
|
187
|
+
"sort_store",
|
|
188
|
+
"elim_rem",
|
|
189
|
+
]);
|
|
190
|
+
|
|
191
|
+
const SIMPLIFY_UINT_PARAMETERS = new Set([
|
|
192
|
+
"max_degree",
|
|
193
|
+
"local_ctx_limit",
|
|
194
|
+
"blast_distinct_threshold",
|
|
195
|
+
]);
|
|
196
|
+
|
|
197
|
+
const PARAMETER_DEFAULTS = new Map([
|
|
198
|
+
["auto_config", "true"],
|
|
199
|
+
["smt.relevancy", "2"],
|
|
200
|
+
["smt.mbqi", "true"],
|
|
201
|
+
["rlimit", "0"],
|
|
202
|
+
["rewriter.hi_div0", "true"],
|
|
203
|
+
]);
|
|
204
|
+
|
|
205
|
+
const BUILTIN_OPTIONS = new Set([
|
|
206
|
+
":print-success",
|
|
207
|
+
":print-warning",
|
|
208
|
+
":expand-definitions",
|
|
209
|
+
":interactive-mode",
|
|
210
|
+
":produce-proofs",
|
|
211
|
+
":produce-unsat-cores",
|
|
212
|
+
":produce-unsat-assumptions",
|
|
213
|
+
":produce-models",
|
|
214
|
+
":produce-assignments",
|
|
215
|
+
":produce-assertions",
|
|
216
|
+
":regular-output-channel",
|
|
217
|
+
":diagnostic-output-channel",
|
|
218
|
+
":random-seed",
|
|
219
|
+
":verbosity",
|
|
220
|
+
":global-decls",
|
|
221
|
+
":global-declarations",
|
|
222
|
+
":numeral-as-real",
|
|
223
|
+
":error-behavior",
|
|
224
|
+
":int-real-coercions",
|
|
225
|
+
":reproducible-resource-limit",
|
|
226
|
+
]);
|
|
227
|
+
|
|
228
|
+
const getParameterName = (keyword: string) => keyword.slice(1).toLowerCase().replaceAll("-", "_");
|
|
229
|
+
|
|
230
|
+
const getSoftParameters = (items: SExpr[]) => {
|
|
231
|
+
const parameters = { weight: Rational.one, id: null as string | null };
|
|
232
|
+
for (let index = 0; index < items.length; index += 2) {
|
|
233
|
+
const keyword = items[index];
|
|
234
|
+
if (keyword.kind !== "keyword")
|
|
235
|
+
throw new SmtParseError("invalid command argument, keyword expected", keyword);
|
|
236
|
+
const name = getParameterName(keyword.text);
|
|
237
|
+
const value = items[index + 1];
|
|
238
|
+
if (name === "weight" && (value?.kind === "numeral" || value?.kind === "decimal")) {
|
|
239
|
+
const [whole, fraction = ""] = value.text.split(".");
|
|
240
|
+
parameters.weight = Rational.of(BigInt(whole + fraction), 10n ** BigInt(fraction.length));
|
|
241
|
+
continue;
|
|
242
|
+
}
|
|
243
|
+
if (name !== "id" || !isSymbol(value))
|
|
244
|
+
throw new SmtUnsupportedError(`the parameter :${name} of assert-soft`);
|
|
245
|
+
parameters.id = value.text;
|
|
246
|
+
}
|
|
247
|
+
return parameters;
|
|
248
|
+
};
|
|
249
|
+
|
|
250
|
+
const getSimplifyParams = (items: SExpr[]) => {
|
|
251
|
+
const params = new Map<string, TacticParam>();
|
|
252
|
+
for (let index = 0; index < items.length; index += 2) {
|
|
253
|
+
const keyword = items[index];
|
|
254
|
+
if (keyword.kind !== "keyword")
|
|
255
|
+
throw new SmtParseError("invalid command argument, keyword expected", keyword);
|
|
256
|
+
const name = getParameterName(keyword.text);
|
|
257
|
+
const value = items[index + 1];
|
|
258
|
+
if (SIMPLIFY_UINT_PARAMETERS.has(name) && value?.kind === "numeral") {
|
|
259
|
+
params.set(name, Number(value.text));
|
|
260
|
+
continue;
|
|
261
|
+
}
|
|
262
|
+
if (!SIMPLIFY_PARAMETERS.has(name) || !isSymbol(value))
|
|
263
|
+
throw new SmtUnsupportedError(`the parameter :${name} of the simplifier`);
|
|
264
|
+
params.set(name, isSymbol(value, "true"));
|
|
265
|
+
}
|
|
266
|
+
return params;
|
|
267
|
+
};
|
|
268
|
+
|
|
269
|
+
const GET_INFO_KEYWORDS = [
|
|
270
|
+
":reason-unknown",
|
|
271
|
+
":status",
|
|
272
|
+
":version",
|
|
273
|
+
":authors",
|
|
274
|
+
":error-behavior",
|
|
275
|
+
":parameters",
|
|
276
|
+
":rlimit",
|
|
277
|
+
":assertion-stack-levels",
|
|
278
|
+
];
|
|
279
|
+
|
|
280
|
+
const APPLY_PARAMETERS = new Map([
|
|
281
|
+
["print", true],
|
|
282
|
+
["print_model_converter", true],
|
|
283
|
+
["print_benchmark", true],
|
|
284
|
+
["print_dependencies", true],
|
|
285
|
+
["timeout", false],
|
|
286
|
+
["max_memory", false],
|
|
287
|
+
["print_statistics", true],
|
|
288
|
+
]);
|
|
289
|
+
|
|
290
|
+
const CHECK_SAT_USING_PARAMETERS = new Map([
|
|
291
|
+
["timeout", false],
|
|
292
|
+
["max_memory", false],
|
|
293
|
+
["print_statistics", true],
|
|
294
|
+
["print_unsat_core", true],
|
|
295
|
+
["print_proof", true],
|
|
296
|
+
["print_model", true],
|
|
297
|
+
]);
|
|
298
|
+
|
|
299
|
+
const getCommandParams = (items: SExpr[], isBooleans: ReadonlyMap<string, boolean>) => {
|
|
300
|
+
const params = new Map<string, TacticParam>();
|
|
301
|
+
for (let index = 2; index < items.length; index += 2) {
|
|
302
|
+
const keyword = items[index];
|
|
303
|
+
if (keyword.kind !== "keyword")
|
|
304
|
+
throw new SmtParseError("invalid command argument, keyword expected", keyword);
|
|
305
|
+
const name = getParameterName(keyword.text);
|
|
306
|
+
const isBoolean = isBooleans.get(name);
|
|
307
|
+
if (isBoolean === undefined) throw new SmtParseError("invalid keyword argument", keyword);
|
|
308
|
+
const value = items[index + 1];
|
|
309
|
+
if (isBoolean) {
|
|
310
|
+
if (!isSymbol(value, "true") && !isSymbol(value, "false"))
|
|
311
|
+
throw new SmtParseError("invalid command argument, true/false expected", value ?? keyword);
|
|
312
|
+
params.set(name, isSymbol(value, "true"));
|
|
313
|
+
} else {
|
|
314
|
+
if (value?.kind !== "numeral")
|
|
315
|
+
throw new SmtParseError(
|
|
316
|
+
"invalid command argument, unsigned integer expected",
|
|
317
|
+
value ?? keyword,
|
|
318
|
+
);
|
|
319
|
+
if (!isUnsigned(value.text))
|
|
320
|
+
throw new SmtParseError(
|
|
321
|
+
"invalid indexed identifier, index is too big to fit in an unsigned machine integer",
|
|
322
|
+
value,
|
|
323
|
+
);
|
|
324
|
+
params.set(name, Number(value.text));
|
|
325
|
+
}
|
|
326
|
+
}
|
|
327
|
+
return params;
|
|
328
|
+
};
|
|
329
|
+
|
|
330
|
+
const getFirstArgument = (list: SmtList) => {
|
|
331
|
+
const argument = list.items[1];
|
|
332
|
+
if (argument === undefined)
|
|
333
|
+
throw new SmtParseError("invalid command, argument(s) missing", list.end);
|
|
334
|
+
return argument;
|
|
335
|
+
};
|
|
336
|
+
|
|
337
|
+
const checkArgumentCount = (list: SmtList, count: number) => {
|
|
338
|
+
const extra = list.items[count + 1];
|
|
339
|
+
if (extra !== undefined) throw new SmtParseError("invalid command, too many arguments", extra);
|
|
340
|
+
};
|
|
341
|
+
|
|
342
|
+
// Z3's parse_opt_unsigned names the push command for pop as well.
|
|
343
|
+
const getScopeCount = (list: SmtList) => {
|
|
344
|
+
const argument = list.items[1];
|
|
345
|
+
if (argument === undefined) return 1;
|
|
346
|
+
if (argument.kind !== "numeral")
|
|
347
|
+
throw new SmtParseError("invalid push command, integer expected", argument);
|
|
348
|
+
if (argument.text.startsWith("-"))
|
|
349
|
+
throw new SmtParseError("invalid push command, value is negative.", argument);
|
|
350
|
+
return Number(argument.text);
|
|
351
|
+
};
|
|
352
|
+
|
|
353
|
+
interface Scope {
|
|
354
|
+
assertions: number;
|
|
355
|
+
objectives: number;
|
|
356
|
+
softTrail: number;
|
|
357
|
+
rlimit: number;
|
|
358
|
+
}
|
|
359
|
+
|
|
360
|
+
interface CheckResult {
|
|
361
|
+
status: number;
|
|
362
|
+
context: Context | undefined;
|
|
363
|
+
isOptimizing: boolean;
|
|
364
|
+
isFromTactic: boolean;
|
|
365
|
+
model: ProtoModel | undefined;
|
|
366
|
+
fdSolver: FdSolver | undefined;
|
|
367
|
+
core: number[] | undefined;
|
|
368
|
+
// check_sat_result::reason_unknown, where the port tracks it.
|
|
369
|
+
reasonUnknown?: string;
|
|
370
|
+
}
|
|
371
|
+
|
|
372
|
+
interface SolverAnswer {
|
|
373
|
+
result: number;
|
|
374
|
+
context: Context | undefined;
|
|
375
|
+
reasonUnknown: string | undefined;
|
|
376
|
+
}
|
|
377
|
+
|
|
378
|
+
interface ScriptState {
|
|
379
|
+
manager: AstManager;
|
|
380
|
+
logic: string | undefined;
|
|
381
|
+
reader: SmtlibReader;
|
|
382
|
+
assertions: number[];
|
|
383
|
+
names: number[];
|
|
384
|
+
assertionTexts: string[];
|
|
385
|
+
objectives: OptObjective[];
|
|
386
|
+
// The objective of each soft constraint, in the order they were asserted.
|
|
387
|
+
softTrail: number[];
|
|
388
|
+
optimizer: OptContext | undefined;
|
|
389
|
+
scopes: Scope[];
|
|
390
|
+
check: CheckResult | undefined;
|
|
391
|
+
isProofsEnabled: boolean | undefined;
|
|
392
|
+
isIncremental: boolean;
|
|
393
|
+
hasChecked: boolean;
|
|
394
|
+
// The datalog context of the declare-rel, declare-var, rule and query commands.
|
|
395
|
+
datalog: DatalogContext | undefined;
|
|
396
|
+
// combined_solver's incremental smt kernel, which keeps one context across the checks, or
|
|
397
|
+
// undefined while Z3 has made no such kernel.
|
|
398
|
+
kernel: SmtKernel | undefined;
|
|
399
|
+
satSolver: IncSatSolver | undefined;
|
|
400
|
+
fdSolver: FdSolver | undefined;
|
|
401
|
+
}
|
|
402
|
+
|
|
403
|
+
// Z3 fixes the proof mode at the first command that needs terms.
|
|
404
|
+
const MANAGERLESS_COMMANDS = new Set([
|
|
405
|
+
"set-option",
|
|
406
|
+
"set-info",
|
|
407
|
+
"set-logic",
|
|
408
|
+
"get-option",
|
|
409
|
+
"get-info",
|
|
410
|
+
"get-assertions",
|
|
411
|
+
"echo",
|
|
412
|
+
]);
|
|
413
|
+
|
|
414
|
+
export const runSmtlibScript = (
|
|
415
|
+
text: string,
|
|
416
|
+
options: DecideOptions,
|
|
417
|
+
printLine: (line: string, isDiagnostic?: boolean) => void,
|
|
418
|
+
) => {
|
|
419
|
+
const commands = createCommandReader(text);
|
|
420
|
+
// Z3 writes to a stream: text left without a newline starts the next line.
|
|
421
|
+
let pendingText = "";
|
|
422
|
+
const print = (line: string, isDiagnostic?: boolean) => {
|
|
423
|
+
printLine(pendingText + line, isDiagnostic);
|
|
424
|
+
pendingText = "";
|
|
425
|
+
};
|
|
426
|
+
const settings = {
|
|
427
|
+
isPrintingSuccess: false,
|
|
428
|
+
isProducingModels: true,
|
|
429
|
+
isProducingUnsatCores: false,
|
|
430
|
+
isProducingUnsatAssumptions: false,
|
|
431
|
+
isProducingProofs: false,
|
|
432
|
+
isExitingOnError: false,
|
|
433
|
+
isInteractive: false,
|
|
434
|
+
isDiagnosticOnStdout: false,
|
|
435
|
+
parameters: new Map<string, string>(),
|
|
436
|
+
isMbqi: true,
|
|
437
|
+
mbqiMaxIterations: MBQI_MAX_ITERATIONS,
|
|
438
|
+
isFindingMacros: false,
|
|
439
|
+
isHiDiv0: true,
|
|
440
|
+
encoding: UNICODE_ENCODING,
|
|
441
|
+
rlimit: 0,
|
|
442
|
+
printOptions: { ...DEFAULT_PRINT_OPTIONS },
|
|
443
|
+
parserOptions: { isIgnoringBadPatterns: true },
|
|
444
|
+
// Z3 keeps set-info's :status across reset.
|
|
445
|
+
status: L_UNDEF,
|
|
446
|
+
};
|
|
447
|
+
const createState = (): ScriptState => {
|
|
448
|
+
const manager = new AstManager(new ResourceLimit(Infinity, options.signal));
|
|
449
|
+
manager.isHiDiv0 = settings.isHiDiv0;
|
|
450
|
+
manager.maxChar = settings.encoding.maxChar;
|
|
451
|
+
manager.charBits = settings.encoding.charBits;
|
|
452
|
+
return {
|
|
453
|
+
manager,
|
|
454
|
+
logic: undefined,
|
|
455
|
+
reader: createSmtlibReader(manager, undefined, settings.parserOptions),
|
|
456
|
+
assertions: [],
|
|
457
|
+
names: [],
|
|
458
|
+
assertionTexts: [],
|
|
459
|
+
objectives: [],
|
|
460
|
+
softTrail: [],
|
|
461
|
+
optimizer: undefined,
|
|
462
|
+
scopes: [],
|
|
463
|
+
check: undefined,
|
|
464
|
+
isProofsEnabled: undefined,
|
|
465
|
+
isIncremental: false,
|
|
466
|
+
hasChecked: false,
|
|
467
|
+
datalog: undefined,
|
|
468
|
+
kernel: undefined,
|
|
469
|
+
satSolver: undefined,
|
|
470
|
+
fdSolver: undefined,
|
|
471
|
+
};
|
|
472
|
+
};
|
|
473
|
+
let state = createState();
|
|
474
|
+
const getPrintEnvironment = () => ({
|
|
475
|
+
options: settings.printOptions,
|
|
476
|
+
isUsed: state.reader.isUsed,
|
|
477
|
+
isClashing: state.reader.isClashing,
|
|
478
|
+
});
|
|
479
|
+
const format = (expr: number) => printExpr(state.manager, getPrintEnvironment(), expr);
|
|
480
|
+
const display = (expr: number) => print(format(expr));
|
|
481
|
+
const report = (error: SmtParseError) =>
|
|
482
|
+
print(`(error "line ${error.line} column ${error.column}: ${error.message}")`);
|
|
483
|
+
const getNamedAssertions = () => {
|
|
484
|
+
const manager = state.manager;
|
|
485
|
+
const isNamed = hasNames();
|
|
486
|
+
return state.assertions.map((assertion, index) =>
|
|
487
|
+
isNamed && state.names[index] !== -1
|
|
488
|
+
? manager.mkApp(OP_IMPLIES, [state.names[index], assertion], SORT_BOOL)
|
|
489
|
+
: assertion,
|
|
490
|
+
);
|
|
491
|
+
};
|
|
492
|
+
const getOptOptions = () => {
|
|
493
|
+
const parameters = settings.parameters;
|
|
494
|
+
// symba and farkas run on the infinitesimal arithmetic solver, which is not ported.
|
|
495
|
+
if ((parameters.get("opt.optsmt_engine") ?? "basic") !== "basic")
|
|
496
|
+
throw new SmtUnsupportedError("the option :opt.optsmt_engine");
|
|
497
|
+
return {
|
|
498
|
+
priority: parameters.get("opt.priority") ?? "lex",
|
|
499
|
+
optsmt: {
|
|
500
|
+
bisectRounds: Number(parameters.get("opt.optsmt_bisect_rounds") ?? 64),
|
|
501
|
+
isNlsat: parameters.get("opt.optsmt_nlsat") !== "false",
|
|
502
|
+
isDualBounds: parameters.get("opt.optsmt_dual_bounds") !== "false",
|
|
503
|
+
supremumRlimit: Number(parameters.get("opt.optsmt_nlsat_supremum_rlimit") ?? 100000),
|
|
504
|
+
isLexAfterUnbounded: parameters.get("opt.optsmt_lex_after_unbounded") !== "false",
|
|
505
|
+
},
|
|
506
|
+
isParetoNlsat: parameters.get("opt.pareto_nlsat") !== "false",
|
|
507
|
+
isParetoNlsatReused: parameters.get("opt.pareto_nlsat_reuse") !== "false",
|
|
508
|
+
paretoMaxLemmas: Number(parameters.get("opt.pareto_nlsat_max_lemmas") ?? 128),
|
|
509
|
+
};
|
|
510
|
+
};
|
|
511
|
+
const optimize = (extra: number[], end: SmtToken) => {
|
|
512
|
+
const manager = state.manager;
|
|
513
|
+
const objectives = state.objectives;
|
|
514
|
+
const hard = [...getNamedAssertions(), ...state.names.filter((name) => name !== -1), ...extra];
|
|
515
|
+
const pinned = hard.map((form) => {
|
|
516
|
+
manager.incRef(form);
|
|
517
|
+
return form;
|
|
518
|
+
});
|
|
519
|
+
state.optimizer ??= new OptContext(
|
|
520
|
+
manager,
|
|
521
|
+
{
|
|
522
|
+
manager,
|
|
523
|
+
isMbqi: settings.isMbqi,
|
|
524
|
+
mbqiMaxIterations: settings.mbqiMaxIterations,
|
|
525
|
+
isFindingMacros: settings.isFindingMacros,
|
|
526
|
+
setup: getSetup(),
|
|
527
|
+
write: () => {},
|
|
528
|
+
parameters: settings.parameters,
|
|
529
|
+
hasDefinitions: () => state.reader.hasDefinitions(),
|
|
530
|
+
},
|
|
531
|
+
objectives,
|
|
532
|
+
);
|
|
533
|
+
const optimizer = state.optimizer;
|
|
534
|
+
clearCheck();
|
|
535
|
+
state.manager.limit.push(settings.rlimit);
|
|
536
|
+
try {
|
|
537
|
+
const hasAssumptions = extra.length > 0 || hasNames();
|
|
538
|
+
const status = optimizer.optimize(hard, {
|
|
539
|
+
...getOptOptions(),
|
|
540
|
+
hasAssumptions,
|
|
541
|
+
isSatEnabled: settings.parameters.get("opt.enable_sat") !== "false",
|
|
542
|
+
maxsat: {
|
|
543
|
+
maxsatEngine: settings.parameters.get("opt.maxsat_engine") ?? "maxres",
|
|
544
|
+
isMaxlexEnabled: settings.parameters.get("opt.maxlex.enable") !== "false",
|
|
545
|
+
isHillClimbing: settings.parameters.get("opt.maxres.hill_climb") !== "false",
|
|
546
|
+
maxCoreSize: Number(settings.parameters.get("opt.maxres.max_core_size") ?? 3),
|
|
547
|
+
},
|
|
548
|
+
isEliminatingZeroOne:
|
|
549
|
+
settings.parameters.get("opt.elim_01") !== "false" &&
|
|
550
|
+
state.logic === undefined &&
|
|
551
|
+
!hasAssumptions &&
|
|
552
|
+
settings.parameters.get("opt.incremental") !== "true",
|
|
553
|
+
});
|
|
554
|
+
setCheck(status, {
|
|
555
|
+
isOptimizing: true,
|
|
556
|
+
model: optimizer.model ?? undefined,
|
|
557
|
+
reasonUnknown: optimizer.getReasonUnknown(),
|
|
558
|
+
});
|
|
559
|
+
print(getVerdict(status));
|
|
560
|
+
return true;
|
|
561
|
+
} catch (error) {
|
|
562
|
+
// The unported parts of optimization keep the answer of the hard constraints.
|
|
563
|
+
if (error instanceof SmtUnsupportedError) {
|
|
564
|
+
resetOptimizer();
|
|
565
|
+
return false;
|
|
566
|
+
}
|
|
567
|
+
if (error instanceof SmtDefaultError) {
|
|
568
|
+
setCheck(L_UNDEF, { isFromTactic: true, reasonUnknown: optimizer.getReasonUnknown() });
|
|
569
|
+
throw new SmtParseError(error.message, end);
|
|
570
|
+
}
|
|
571
|
+
if (!(error instanceof SmtCanceledError || isStackOverflow(error))) throw error;
|
|
572
|
+
const reasonUnknown = optimizer.getReasonUnknown();
|
|
573
|
+
optimizer.release();
|
|
574
|
+
setCheck(L_UNDEF, { isOptimizing: true, reasonUnknown });
|
|
575
|
+
if (error instanceof SmtCanceledError)
|
|
576
|
+
throw new SmtParseError(manager.limit.getCancelMessage(), end);
|
|
577
|
+
print("unknown");
|
|
578
|
+
return true;
|
|
579
|
+
} finally {
|
|
580
|
+
state.manager.limit.pop();
|
|
581
|
+
for (const form of pinned) manager.decRef(form);
|
|
582
|
+
}
|
|
583
|
+
};
|
|
584
|
+
const resetOptimizer = () => {
|
|
585
|
+
state.optimizer?.release();
|
|
586
|
+
state.optimizer = undefined;
|
|
587
|
+
};
|
|
588
|
+
// The port keeps answering with the smt kernel where it lacks a piece of the logic's strategy.
|
|
589
|
+
const solveWithStrategy = () => {
|
|
590
|
+
try {
|
|
591
|
+
const goal = getGoal();
|
|
592
|
+
const strategy =
|
|
593
|
+
settings.parameters.get("tactic.default_tactic") ??
|
|
594
|
+
getLogicStrategy(state.logic, goal.isProofsEnabled);
|
|
595
|
+
const checked = checkSatUsing(compileInternalTactic(getTacticEnvironment(), strategy), goal);
|
|
596
|
+
return {
|
|
597
|
+
result: checked.status,
|
|
598
|
+
context: undefined,
|
|
599
|
+
model: checked.model,
|
|
600
|
+
reasonUnknown: checked.reasonUnknown,
|
|
601
|
+
};
|
|
602
|
+
} catch (error) {
|
|
603
|
+
if (!(error instanceof SmtUnsupportedError)) throw error;
|
|
604
|
+
const hasQuantifiers = state.assertions.some(
|
|
605
|
+
(assertion) => state.manager.hasQuantifierFlags[assertion],
|
|
606
|
+
);
|
|
607
|
+
const solved = solveAssertions(state.manager, state.assertions, {
|
|
608
|
+
isMbqi: settings.isMbqi || isMbqiByFeatures(getSetup(), hasQuantifiers),
|
|
609
|
+
mbqiMaxIterations: settings.mbqiMaxIterations,
|
|
610
|
+
isFindingMacros: settings.isFindingMacros,
|
|
611
|
+
setup: getSetup(),
|
|
612
|
+
});
|
|
613
|
+
return {
|
|
614
|
+
...solved,
|
|
615
|
+
model: undefined,
|
|
616
|
+
reasonUnknown:
|
|
617
|
+
solved.result === L_UNDEF && solved.context !== undefined
|
|
618
|
+
? getSmtTacticFailure(solved.context)
|
|
619
|
+
: "",
|
|
620
|
+
};
|
|
621
|
+
}
|
|
622
|
+
};
|
|
623
|
+
// Deviation from Z3: the heap guard and a stack overflow, which Z3 lacks, read as an exhausted rlimit.
|
|
624
|
+
const getCancelMessage = (deadline: number) =>
|
|
625
|
+
Date.now() > deadline || options.signal?.aborted === true
|
|
626
|
+
? "canceled"
|
|
627
|
+
: "max. resource limit exceeded";
|
|
628
|
+
// As in Z3, a timeout leaves "timeout" in the kernel, which reports it while its last search hasn't failed.
|
|
629
|
+
const getReasonUnknown = (solved: SolverAnswer, deadline: number) => {
|
|
630
|
+
const isTimedOut = solved.result === L_UNDEF && Date.now() > deadline;
|
|
631
|
+
const context = state.kernel?.context;
|
|
632
|
+
if (isTimedOut && context !== undefined) context.reasonUnknown = "timeout";
|
|
633
|
+
if (context !== undefined && solved.context === context) return context.getLastFailureMessage();
|
|
634
|
+
return isTimedOut ? "timeout" : (solved.reasonUnknown ?? getCancelMessage(deadline));
|
|
635
|
+
};
|
|
636
|
+
// As in Z3, a kernel loses the mbqi its logic turned on once it reads the parameters again.
|
|
637
|
+
const getKernelParams = (isSetUp = false) => ({
|
|
638
|
+
isMbqi: settings.isMbqi || (!isSetUp && isMbqiByLogic(getSetup())),
|
|
639
|
+
mbqiMaxIterations: settings.mbqiMaxIterations,
|
|
640
|
+
isFindingMacros: settings.isFindingMacros,
|
|
641
|
+
isCoreMinimizing: settings.parameters.get("smt.core.minimize") === "true",
|
|
642
|
+
setup: getSetup(),
|
|
643
|
+
});
|
|
644
|
+
const checkFdSolver = (fdSolver: FdSolver, extra: number[]) => {
|
|
645
|
+
const result = fdSolver.check(extra);
|
|
646
|
+
// cmd_context::check_sat counts a step to see whether the limit stopped a search that gave up.
|
|
647
|
+
if (result === L_UNDEF) state.manager.limit.inc();
|
|
648
|
+
return {
|
|
649
|
+
result,
|
|
650
|
+
context: undefined,
|
|
651
|
+
model: undefined,
|
|
652
|
+
core: result === L_FALSE ? [...fdSolver.getUnsatCore()] : undefined,
|
|
653
|
+
reasonUnknown: fdSolver.reasonUnknown,
|
|
654
|
+
};
|
|
655
|
+
};
|
|
656
|
+
const checkSat = (extra: number[], end: SmtToken) => {
|
|
657
|
+
const deadline = Date.now() + options.timeLimitMs;
|
|
658
|
+
state.manager.limit.restart(deadline);
|
|
659
|
+
// opt::context::optimize answers as the search of the hard constraints does: once they are
|
|
660
|
+
// satisfiable, optsmt and maxsmt only improve the model. The unported parts of optimization
|
|
661
|
+
// only get that answer.
|
|
662
|
+
if (state.objectives.length > 0 && optimize(extra, end)) return;
|
|
663
|
+
state.manager.limit.push(settings.rlimit);
|
|
664
|
+
const isOptimizing = state.objectives.length > 0;
|
|
665
|
+
const manager = state.manager;
|
|
666
|
+
const names = state.names.filter((name) => name !== -1);
|
|
667
|
+
const isNamed = names.length > 0;
|
|
668
|
+
const isAssuming = isNamed || extra.length > 0;
|
|
669
|
+
if (isAssuming) state.isIncremental = true;
|
|
670
|
+
if (!isOptimizing) state.hasChecked = true;
|
|
671
|
+
const fdSolver = state.fdSolver;
|
|
672
|
+
const isKernelChecking =
|
|
673
|
+
fdSolver === undefined && (isAssuming || (state.isIncremental && !isOptimizing));
|
|
674
|
+
try {
|
|
675
|
+
const kernel = isKernelChecking ? checkKernel(names, extra) : undefined;
|
|
676
|
+
// Z3 retries a quantifier-free problem with its tactic when the incremental kernel gives up.
|
|
677
|
+
const isFromTactic =
|
|
678
|
+
kernel === undefined ||
|
|
679
|
+
(!isAssuming &&
|
|
680
|
+
kernel.result === L_UNDEF &&
|
|
681
|
+
!state.assertions.some((assertion) => manager.hasQuantifierFlags[assertion]) &&
|
|
682
|
+
manager.limit.inc());
|
|
683
|
+
const solved =
|
|
684
|
+
fdSolver !== undefined
|
|
685
|
+
? checkFdSolver(fdSolver, extra)
|
|
686
|
+
: isFromTactic
|
|
687
|
+
? { ...solveWithStrategy(), core: undefined }
|
|
688
|
+
: kernel;
|
|
689
|
+
setCheck(solved.result, {
|
|
690
|
+
context: solved.context,
|
|
691
|
+
isOptimizing,
|
|
692
|
+
isFromTactic,
|
|
693
|
+
model: solved.model,
|
|
694
|
+
fdSolver,
|
|
695
|
+
core: solved.core ?? solved.context?.unsatCore ?? [],
|
|
696
|
+
reasonUnknown: getReasonUnknown(solved, deadline),
|
|
697
|
+
});
|
|
698
|
+
print(getVerdict(solved.result));
|
|
699
|
+
} catch (error) {
|
|
700
|
+
if (
|
|
701
|
+
!(
|
|
702
|
+
error instanceof SmtCanceledError ||
|
|
703
|
+
error instanceof SmtDefaultError ||
|
|
704
|
+
isStackOverflow(error)
|
|
705
|
+
)
|
|
706
|
+
)
|
|
707
|
+
throw error;
|
|
708
|
+
const context = isKernelChecking ? state.kernel?.context : undefined;
|
|
709
|
+
const reasonUnknown = isKernelChecking
|
|
710
|
+
? state.satSolver?.reasonUnknown
|
|
711
|
+
: state.fdSolver?.reasonUnknown;
|
|
712
|
+
setCheck(L_UNDEF, {
|
|
713
|
+
isOptimizing,
|
|
714
|
+
isFromTactic: !isKernelChecking,
|
|
715
|
+
reasonUnknown:
|
|
716
|
+
error instanceof SmtDefaultError
|
|
717
|
+
? ((isKernelChecking ? undefined : reasonUnknown) ?? error.message)
|
|
718
|
+
: getReasonUnknown({ result: L_UNDEF, context, reasonUnknown }, deadline),
|
|
719
|
+
});
|
|
720
|
+
print("unknown");
|
|
721
|
+
} finally {
|
|
722
|
+
state.manager.limit.release();
|
|
723
|
+
state.manager.limit.pop();
|
|
724
|
+
}
|
|
725
|
+
};
|
|
726
|
+
const getModel = (list: SmtList) => {
|
|
727
|
+
const check = state.check;
|
|
728
|
+
if (!settings.isProducingModels || check === undefined || check.status === L_FALSE)
|
|
729
|
+
throw new SmtParseError("model is not available", list.end);
|
|
730
|
+
if (check.model !== undefined) return check.model;
|
|
731
|
+
if (check.isOptimizing) throw new SmtUnsupportedError("the models of optimization");
|
|
732
|
+
if (check.context === undefined && check.status !== L_TRUE)
|
|
733
|
+
throw check.isFromTactic
|
|
734
|
+
? new SmtParseError("model is not available", list.end)
|
|
735
|
+
: new SmtUnsupportedError("the model of a canceled search");
|
|
736
|
+
const context = check.context;
|
|
737
|
+
const model =
|
|
738
|
+
check.fdSolver !== undefined
|
|
739
|
+
? check.fdSolver.getModel()
|
|
740
|
+
: context === undefined
|
|
741
|
+
? new ProtoModel(state.manager)
|
|
742
|
+
: context.getModel();
|
|
743
|
+
if (model === undefined) throw new SmtParseError("model is not available", list.end);
|
|
744
|
+
if (check.fdSolver !== undefined) return model;
|
|
745
|
+
model.incRef();
|
|
746
|
+
check.model = model;
|
|
747
|
+
return model;
|
|
748
|
+
};
|
|
749
|
+
const clearCheck = () => {
|
|
750
|
+
state.check?.model?.decRef();
|
|
751
|
+
state.check = undefined;
|
|
752
|
+
};
|
|
753
|
+
// cmd_context::validate_check_sat_result runs after the answer is printed.
|
|
754
|
+
const validateCheck = (end: SmtToken) => {
|
|
755
|
+
const status = state.check?.status ?? L_UNDEF;
|
|
756
|
+
if (status !== L_UNDEF && settings.status !== L_UNDEF && status !== settings.status)
|
|
757
|
+
throw new SmtParseError(`check annotation that says ${getVerdict(settings.status)}`, end);
|
|
758
|
+
};
|
|
759
|
+
// The check holds a reference to its model until clearCheck.
|
|
760
|
+
const setCheck = (status: number, result: Partial<Omit<CheckResult, "status">> = {}) => {
|
|
761
|
+
result.model?.incRef();
|
|
762
|
+
state.check = {
|
|
763
|
+
status,
|
|
764
|
+
context: undefined,
|
|
765
|
+
isOptimizing: false,
|
|
766
|
+
isFromTactic: false,
|
|
767
|
+
model: undefined,
|
|
768
|
+
fdSolver: undefined,
|
|
769
|
+
core: undefined,
|
|
770
|
+
...result,
|
|
771
|
+
};
|
|
772
|
+
};
|
|
773
|
+
const resetKernel = () => {
|
|
774
|
+
const logic = state.logic;
|
|
775
|
+
const parameters = settings.parameters;
|
|
776
|
+
const isProofsEnabled = settings.isProducingProofs || state.isProofsEnabled === true;
|
|
777
|
+
const isFdSolver =
|
|
778
|
+
((logic === "QF_FD" || logic === "SAT") && !isProofsEnabled) || logic === "SMTFD";
|
|
779
|
+
const isEuf = parameters.get("sat.euf") === "true";
|
|
780
|
+
const isSatSolver =
|
|
781
|
+
isFdSolver ||
|
|
782
|
+
(logic === "QF_BV" && settings.isHiDiv0) ||
|
|
783
|
+
parameters.get("tactic.default_tactic") === "sat" ||
|
|
784
|
+
parameters.get("sat.smt") === "true" ||
|
|
785
|
+
isEuf;
|
|
786
|
+
state.satSolver?.release();
|
|
787
|
+
state.kernel = isSatSolver ? undefined : new SmtKernel(state.manager, getKernelParams());
|
|
788
|
+
state.satSolver =
|
|
789
|
+
isSatSolver && !isFdSolver && parameters.get("sat.smt") !== "true"
|
|
790
|
+
? new IncSatSolver(state.manager, getSatParams(parameters), true, isEuf ? mkThSolver : null)
|
|
791
|
+
: undefined;
|
|
792
|
+
state.fdSolver?.release();
|
|
793
|
+
state.fdSolver =
|
|
794
|
+
(logic === "QF_FD" || logic === "SAT") &&
|
|
795
|
+
!isProofsEnabled &&
|
|
796
|
+
!parameters.has("tactic.default_tactic")
|
|
797
|
+
? new FdSolver(state.manager, getSatParams(parameters))
|
|
798
|
+
: undefined;
|
|
799
|
+
for (let index = 0; index < state.scopes.length; index++) {
|
|
800
|
+
state.kernel?.push();
|
|
801
|
+
useSatSolver((solver) => solver.push());
|
|
802
|
+
state.fdSolver?.push();
|
|
803
|
+
}
|
|
804
|
+
};
|
|
805
|
+
const initManager = () => {
|
|
806
|
+
if (state.isProofsEnabled !== undefined) return;
|
|
807
|
+
state.isProofsEnabled = settings.parameters.get("proof") === "true";
|
|
808
|
+
if (state.logic === undefined || logicHasSeq(state.logic)) state.manager.initSeqPlugin();
|
|
809
|
+
if (state.logic === undefined) state.reader.registerList();
|
|
810
|
+
resetKernel();
|
|
811
|
+
};
|
|
812
|
+
// The parts of inc_sat_solver that are not ported leave its answers to the smt kernel.
|
|
813
|
+
const useSatSolver = <Result>(action: (solver: IncSatSolver) => Result) => {
|
|
814
|
+
const solver = state.satSolver;
|
|
815
|
+
if (solver === undefined) return undefined;
|
|
816
|
+
try {
|
|
817
|
+
return action(solver);
|
|
818
|
+
} catch (error) {
|
|
819
|
+
if (!(error instanceof SmtUnsupportedError)) throw error;
|
|
820
|
+
solver.release();
|
|
821
|
+
state.satSolver = undefined;
|
|
822
|
+
return undefined;
|
|
823
|
+
}
|
|
824
|
+
};
|
|
825
|
+
// solver_na2as asserts a named assertion as an implication from its name.
|
|
826
|
+
const assertInKernel = (formula: number, name: number) => {
|
|
827
|
+
const manager = state.manager;
|
|
828
|
+
useSatSolver((solver) =>
|
|
829
|
+
name === -1 ? solver.assertExpr(formula) : solver.assertNamed(formula, name),
|
|
830
|
+
);
|
|
831
|
+
state.fdSolver?.assertExpr(formula, name);
|
|
832
|
+
const kernel = state.kernel;
|
|
833
|
+
if (kernel === undefined) return;
|
|
834
|
+
const asserted = name === -1 ? formula : manager.mkApp(OP_IMPLIES, [name, formula], SORT_BOOL);
|
|
835
|
+
manager.incRef(asserted);
|
|
836
|
+
kernel.assertExpr(asserted);
|
|
837
|
+
manager.decRef(asserted);
|
|
838
|
+
};
|
|
839
|
+
const checkKernel = (names: number[], extra: number[]) => {
|
|
840
|
+
const kernel = state.kernel;
|
|
841
|
+
const assumptions = [...names, ...extra];
|
|
842
|
+
const found = useSatSolver((solver) => {
|
|
843
|
+
const result = solver.check(extra);
|
|
844
|
+
return {
|
|
845
|
+
result,
|
|
846
|
+
context: undefined,
|
|
847
|
+
model: result === L_TRUE ? (solver.getModel() ?? undefined) : undefined,
|
|
848
|
+
core: result === L_FALSE ? [...solver.getUnsatCore()] : undefined,
|
|
849
|
+
reasonUnknown: solver.reasonUnknown,
|
|
850
|
+
};
|
|
851
|
+
});
|
|
852
|
+
if (found !== undefined) return found;
|
|
853
|
+
if (kernel !== undefined)
|
|
854
|
+
return {
|
|
855
|
+
result: kernel.check(assumptions),
|
|
856
|
+
context: kernel.context,
|
|
857
|
+
model: undefined,
|
|
858
|
+
core: undefined,
|
|
859
|
+
reasonUnknown: undefined,
|
|
860
|
+
};
|
|
861
|
+
const solved = solveAssuming(
|
|
862
|
+
state.manager,
|
|
863
|
+
getNamedAssertions(),
|
|
864
|
+
assumptions,
|
|
865
|
+
getKernelParams(),
|
|
866
|
+
);
|
|
867
|
+
return {
|
|
868
|
+
...solved,
|
|
869
|
+
model: undefined,
|
|
870
|
+
core: undefined,
|
|
871
|
+
// inc_sat_solver, which these logics use, keeps "no reason given" after an answer.
|
|
872
|
+
reasonUnknown:
|
|
873
|
+
solved.result === L_UNDEF ? solved.context.getLastFailureMessage() : "no reason given",
|
|
874
|
+
};
|
|
875
|
+
};
|
|
876
|
+
const printDiagnostic = (line: string) => print(line, !settings.isDiagnosticOnStdout);
|
|
877
|
+
const write = (text: string, isDiagnostic: boolean) => {
|
|
878
|
+
const lines = text.split("\n");
|
|
879
|
+
const rest = lines.pop() ?? "";
|
|
880
|
+
for (const line of lines) (isDiagnostic ? printDiagnostic : print)(line);
|
|
881
|
+
pendingText += rest;
|
|
882
|
+
};
|
|
883
|
+
const getSetup = () => ({
|
|
884
|
+
logic: state.logic,
|
|
885
|
+
isAutoConfig:
|
|
886
|
+
settings.parameters.get("auto_config") !== "false" &&
|
|
887
|
+
settings.parameters.get("smt.auto_config") !== "false",
|
|
888
|
+
});
|
|
889
|
+
const getTacticEnvironment = () => ({
|
|
890
|
+
manager: state.manager,
|
|
891
|
+
isMbqi: settings.isMbqi,
|
|
892
|
+
mbqiMaxIterations: settings.mbqiMaxIterations,
|
|
893
|
+
isFindingMacros: settings.isFindingMacros,
|
|
894
|
+
setup: getSetup(),
|
|
895
|
+
write,
|
|
896
|
+
parameters: settings.parameters,
|
|
897
|
+
hasDefinitions: () => state.reader.hasDefinitions(),
|
|
898
|
+
});
|
|
899
|
+
const getDatalog = () => {
|
|
900
|
+
state.datalog ??= createDatalogContext(
|
|
901
|
+
state.manager,
|
|
902
|
+
settings.parameters,
|
|
903
|
+
getRewriterOptions(state.manager, new Map()),
|
|
904
|
+
);
|
|
905
|
+
return state.datalog;
|
|
906
|
+
};
|
|
907
|
+
const getGoal = (isTrackingDependencies = false) => {
|
|
908
|
+
const goal = new Goal(state.manager);
|
|
909
|
+
goal.isProofsEnabled = settings.isProducingProofs || state.isProofsEnabled === true;
|
|
910
|
+
goal.isModelsEnabled = settings.isProducingModels;
|
|
911
|
+
goal.isCoresEnabled = settings.isProducingUnsatCores;
|
|
912
|
+
for (const [index, assertion] of state.assertions.entries())
|
|
913
|
+
goal.assert(
|
|
914
|
+
assertion,
|
|
915
|
+
isTrackingDependencies && state.names[index] !== -1
|
|
916
|
+
? mkDependencyLeaf(state.names[index])
|
|
917
|
+
: undefined,
|
|
918
|
+
);
|
|
919
|
+
return goal;
|
|
920
|
+
};
|
|
921
|
+
const getCommandGoal = (isTrackingDependencies: boolean, end: SmtToken) => {
|
|
922
|
+
if (
|
|
923
|
+
settings.isProducingUnsatCores &&
|
|
924
|
+
(settings.isProducingProofs || state.isProofsEnabled === true)
|
|
925
|
+
)
|
|
926
|
+
throw new SmtParseError(
|
|
927
|
+
"Frontend does not support simultaneous generation of proofs and unsat cores",
|
|
928
|
+
end,
|
|
929
|
+
);
|
|
930
|
+
return getGoal(isTrackingDependencies);
|
|
931
|
+
};
|
|
932
|
+
const hasNames = () => state.names.some((name) => name !== -1);
|
|
933
|
+
// parse_check_sat shrinks the expression stack once the check has run.
|
|
934
|
+
const checkSatAssuming = (items: SmtList["items"], itemsEnd: SmtToken, end: SmtToken) => {
|
|
935
|
+
const literals: number[] = [];
|
|
936
|
+
try {
|
|
937
|
+
for (const [index, item] of items.entries())
|
|
938
|
+
literals.push(
|
|
939
|
+
state.reader.parseFormula(
|
|
940
|
+
item,
|
|
941
|
+
items[index + 1] ?? itemsEnd,
|
|
942
|
+
"invalid check-sat command, argument must be a Boolean literal",
|
|
943
|
+
),
|
|
944
|
+
);
|
|
945
|
+
checkSat(literals, end);
|
|
946
|
+
} finally {
|
|
947
|
+
for (const literal of literals) state.manager.decRef(literal);
|
|
948
|
+
}
|
|
949
|
+
};
|
|
950
|
+
const addObjective = (list: SmtList, isMax: boolean) => {
|
|
951
|
+
const term = state.reader.parseTerm(getFirstArgument(list));
|
|
952
|
+
const sort = state.manager.sorts[term];
|
|
953
|
+
if (sort !== SORT_INT && sort !== SORT_REAL && !state.manager.isBvSort(sort))
|
|
954
|
+
throw new SmtParseError(
|
|
955
|
+
"Objective must be bit-vector, integer or real",
|
|
956
|
+
list.items[2] ?? list.end,
|
|
957
|
+
);
|
|
958
|
+
resetOptimizer();
|
|
959
|
+
state.manager.incRef(term);
|
|
960
|
+
state.objectives.push({
|
|
961
|
+
type: isMax ? O_MAXIMIZE : O_MINIMIZE,
|
|
962
|
+
term,
|
|
963
|
+
terms: [],
|
|
964
|
+
weights: [],
|
|
965
|
+
id: null,
|
|
966
|
+
});
|
|
967
|
+
if (settings.isPrintingSuccess) print("success");
|
|
968
|
+
checkArgumentCount(list, 1);
|
|
969
|
+
};
|
|
970
|
+
const releaseObjectives = (size: number, softSize: number) => {
|
|
971
|
+
for (const index of state.softTrail.splice(softSize).reverse()) {
|
|
972
|
+
const objective = state.objectives[index];
|
|
973
|
+
state.manager.decRef(objective.terms.pop() as number);
|
|
974
|
+
objective.weights.pop();
|
|
975
|
+
}
|
|
976
|
+
for (const objective of state.objectives.splice(size))
|
|
977
|
+
if (objective.type !== O_MAXSMT) state.manager.decRef(objective.term);
|
|
978
|
+
};
|
|
979
|
+
const restoreAssertions = (size: number) => {
|
|
980
|
+
for (const assertion of state.assertions.splice(size)) state.manager.decRef(assertion);
|
|
981
|
+
for (const name of state.names.splice(size)) if (name !== -1) state.manager.decRef(name);
|
|
982
|
+
state.assertionTexts.length = size;
|
|
983
|
+
};
|
|
984
|
+
const instantiate = (list: SmtList, isNested: boolean) => {
|
|
985
|
+
const manager = state.manager;
|
|
986
|
+
const outer = state.reader.parseTerm(list.items[1] ?? list.end);
|
|
987
|
+
if (manager.kinds[outer] !== KIND_QUANTIFIER)
|
|
988
|
+
throw new SmtParseError("invalid command, quantifier expected.", list.end);
|
|
989
|
+
const quantifier = isNested ? manager.getQuantifier(outer).body : outer;
|
|
990
|
+
if (manager.kinds[quantifier] !== KIND_QUANTIFIER)
|
|
991
|
+
throw new SmtParseError("invalid command, nested quantifier expected", list.end);
|
|
992
|
+
const terms = list.items[2];
|
|
993
|
+
if (terms?.kind !== "list")
|
|
994
|
+
throw new SmtParseError("invalid command, '(' expected", terms ?? list.end);
|
|
995
|
+
const args = terms.items.map((item) => state.reader.parseTerm(item));
|
|
996
|
+
const sorts = manager.getQuantifier(quantifier).sorts;
|
|
997
|
+
if (args.length !== sorts.length)
|
|
998
|
+
throw new SmtParseError(
|
|
999
|
+
"invalid command, mismatch between the number of quantified variables and the number of arguments.",
|
|
1000
|
+
list.end,
|
|
1001
|
+
);
|
|
1002
|
+
for (let index = args.length - 1; index >= 0; index--)
|
|
1003
|
+
if (manager.sorts[args[index]] !== sorts[index])
|
|
1004
|
+
throw new SmtParseError(`invalid command, sort mismatch at position ${index}`, list.end);
|
|
1005
|
+
const subst = new VarSubst(manager, true);
|
|
1006
|
+
const substituted = subst.apply(manager.getQuantifier(quantifier).body, args);
|
|
1007
|
+
subst.release();
|
|
1008
|
+
const shifter = new InvVarShifter(manager);
|
|
1009
|
+
const result = shifter.shift(substituted, args.length);
|
|
1010
|
+
shifter.release();
|
|
1011
|
+
display(result);
|
|
1012
|
+
manager.decRef(result);
|
|
1013
|
+
manager.decRef(substituted);
|
|
1014
|
+
};
|
|
1015
|
+
// parser::parse_func_decl_ref: a name, or a name with its signature. Z3 ends the message of an
|
|
1016
|
+
// unexpected token with the last identifier it read.
|
|
1017
|
+
const getFuncDeclRef = (reference: SExpr) => {
|
|
1018
|
+
if (isSymbol(reference)) {
|
|
1019
|
+
const decls = state.reader.getFuncs(reference.text);
|
|
1020
|
+
if (decls.length > 1)
|
|
1021
|
+
throw new SmtParseError(
|
|
1022
|
+
`ambiguous function declaration reference, provide full signature to disambiguate (<symbol> (<sort>*) <sort>) ${reference.text}`,
|
|
1023
|
+
reference,
|
|
1024
|
+
);
|
|
1025
|
+
if (decls.length === 0)
|
|
1026
|
+
throw new SmtParseError(
|
|
1027
|
+
`invalid function declaration reference, unknown function ${reference.text}`,
|
|
1028
|
+
reference,
|
|
1029
|
+
);
|
|
1030
|
+
return decls[0];
|
|
1031
|
+
}
|
|
1032
|
+
const name = reference.kind === "list" ? (reference.items[0] ?? reference.end) : reference;
|
|
1033
|
+
if (reference.kind !== "list" || name.kind !== "symbol") {
|
|
1034
|
+
if (name.kind === "list")
|
|
1035
|
+
throw new SmtUnsupportedError("an indexed function declaration reference");
|
|
1036
|
+
throw new SmtParseError(
|
|
1037
|
+
`invalid function declaration reference, symbol or '(' expected got ${name.lastId}`,
|
|
1038
|
+
name,
|
|
1039
|
+
);
|
|
1040
|
+
}
|
|
1041
|
+
const domain = reference.items[1] ?? reference.end;
|
|
1042
|
+
if (domain.kind !== "list")
|
|
1043
|
+
throw new SmtParseError(
|
|
1044
|
+
`Invalid function name. Expecting sort list starting with '(' to disambiguate function name got ${domain.lastId}`,
|
|
1045
|
+
domain,
|
|
1046
|
+
);
|
|
1047
|
+
const sorts = domain.items.map((sort) =>
|
|
1048
|
+
state.reader.parseSort(
|
|
1049
|
+
sort,
|
|
1050
|
+
"Invalid function name. Expecting sort list starting with '(' to disambiguate function name",
|
|
1051
|
+
),
|
|
1052
|
+
);
|
|
1053
|
+
if (reference.items[2] === undefined)
|
|
1054
|
+
throw new SmtParseError("Invalid function name invalid sort, unexpected ')'", reference.end);
|
|
1055
|
+
const range = state.reader.parseSort(reference.items[2], "Invalid function name");
|
|
1056
|
+
const follower = reference.items[3] ?? reference.end;
|
|
1057
|
+
const found = state.reader.getFuncs(name.text).find((decl) => {
|
|
1058
|
+
const funcDecl = state.manager.funcDecls[decl];
|
|
1059
|
+
return (
|
|
1060
|
+
funcDecl.range === range &&
|
|
1061
|
+
funcDecl.domain.length === sorts.length &&
|
|
1062
|
+
funcDecl.domain.every((sort, index) => sort === sorts[index])
|
|
1063
|
+
);
|
|
1064
|
+
});
|
|
1065
|
+
if (found === undefined)
|
|
1066
|
+
throw new SmtParseError(
|
|
1067
|
+
`invalid function declaration reference, unknown indexed function ${name.text}`,
|
|
1068
|
+
follower,
|
|
1069
|
+
);
|
|
1070
|
+
if (follower !== reference.end)
|
|
1071
|
+
throw new SmtUnsupportedError("a function declaration reference with trailing terms");
|
|
1072
|
+
return found;
|
|
1073
|
+
};
|
|
1074
|
+
// get_info_cmd prints in set_next_arg, before the parser checks the rest of the command.
|
|
1075
|
+
const printInfo = (list: SmtList, keyword: string) => {
|
|
1076
|
+
if (keyword === ":reason-unknown") {
|
|
1077
|
+
const check = state.check;
|
|
1078
|
+
const reasonUnknown =
|
|
1079
|
+
check === undefined
|
|
1080
|
+
? "state of the most recent check-sat command is not known"
|
|
1081
|
+
: check.reasonUnknown;
|
|
1082
|
+
if (reasonUnknown === undefined)
|
|
1083
|
+
throw new SmtUnsupportedError("the information :reason-unknown");
|
|
1084
|
+
print(`(:reason-unknown "${reasonUnknown.replaceAll('"', '\\"')}")`);
|
|
1085
|
+
return;
|
|
1086
|
+
}
|
|
1087
|
+
if (keyword === ":rlimit") {
|
|
1088
|
+
initManager();
|
|
1089
|
+
print(`(:rlimit ${state.manager.limit.count})`);
|
|
1090
|
+
return;
|
|
1091
|
+
}
|
|
1092
|
+
if (keyword === ":error-behavior") {
|
|
1093
|
+
print(
|
|
1094
|
+
`(:error-behavior ${settings.isExitingOnError ? "immediate-exit" : "continued-execution"})`,
|
|
1095
|
+
);
|
|
1096
|
+
return;
|
|
1097
|
+
}
|
|
1098
|
+
if (keyword === ":name") {
|
|
1099
|
+
print('(:name "Z3")');
|
|
1100
|
+
return;
|
|
1101
|
+
}
|
|
1102
|
+
if (keyword === ":authors") {
|
|
1103
|
+
print(
|
|
1104
|
+
'(:authors "Leonardo de Moura, Nikolaj Bjorner, Lev Nachmanson and Christoph Wintersteiger")',
|
|
1105
|
+
);
|
|
1106
|
+
return;
|
|
1107
|
+
}
|
|
1108
|
+
if (keyword === ":version") {
|
|
1109
|
+
print('(:version "5.3.2")');
|
|
1110
|
+
return;
|
|
1111
|
+
}
|
|
1112
|
+
if (keyword === ":status") {
|
|
1113
|
+
print(`(:status ${getVerdict(settings.status)})`);
|
|
1114
|
+
return;
|
|
1115
|
+
}
|
|
1116
|
+
if (keyword === ":assertion-stack-levels") {
|
|
1117
|
+
print(`(:assertion-stack-levels ${state.scopes.length})`);
|
|
1118
|
+
return;
|
|
1119
|
+
}
|
|
1120
|
+
if (keyword === ":all-statistics" || keyword === ":parameters")
|
|
1121
|
+
throw new SmtUnsupportedError(`the information ${keyword}`);
|
|
1122
|
+
if (keyword !== ":?") {
|
|
1123
|
+
print("unsupported");
|
|
1124
|
+
printDiagnostic(`; ${keyword} line: ${list.line} position: ${list.column}`);
|
|
1125
|
+
}
|
|
1126
|
+
print("; Suppported get-info parameters:");
|
|
1127
|
+
for (const supported of GET_INFO_KEYWORDS) print(`; (get-info ${supported})`);
|
|
1128
|
+
};
|
|
1129
|
+
const printCore = () => {
|
|
1130
|
+
const check = state.check;
|
|
1131
|
+
if (check?.core === undefined)
|
|
1132
|
+
throw new SmtUnsupportedError("the unsat core of a tactic that drops dependencies");
|
|
1133
|
+
const kernel = state.kernel;
|
|
1134
|
+
if (kernel === undefined || check.context !== kernel.context) {
|
|
1135
|
+
print(`(${check.core.map(format).join(" ")})`);
|
|
1136
|
+
return;
|
|
1137
|
+
}
|
|
1138
|
+
state.manager.limit.restart(Date.now() + options.timeLimitMs);
|
|
1139
|
+
const core = new RefVector(state.manager);
|
|
1140
|
+
kernel.getUnsatCore(core);
|
|
1141
|
+
print(`(${core.items.map(format).join(" ")})`);
|
|
1142
|
+
core.reset();
|
|
1143
|
+
};
|
|
1144
|
+
const runCommand = new Map<string, (list: SmtList) => void>([
|
|
1145
|
+
[
|
|
1146
|
+
"assert",
|
|
1147
|
+
(list) => {
|
|
1148
|
+
const term = list.items[1] ?? list.end;
|
|
1149
|
+
const follower = list.items[2] ?? list.end;
|
|
1150
|
+
const assertion = state.reader.parseAssertion(term, follower);
|
|
1151
|
+
const logicError = state.reader.getLogicError(assertion.formula);
|
|
1152
|
+
if (logicError !== undefined) {
|
|
1153
|
+
state.manager.decRef(assertion.formula);
|
|
1154
|
+
throw new SmtParseError(logicError, follower);
|
|
1155
|
+
}
|
|
1156
|
+
state.assertions.push(assertion.formula);
|
|
1157
|
+
state.assertionTexts.push(
|
|
1158
|
+
text.slice(term.offset, (term.kind === "list" ? term.end : term).endOffset).trim(),
|
|
1159
|
+
);
|
|
1160
|
+
if (state.hasChecked) state.isIncremental = true;
|
|
1161
|
+
resetOptimizer();
|
|
1162
|
+
if (!settings.isProducingUnsatCores || assertion.name === undefined) state.names.push(-1);
|
|
1163
|
+
else {
|
|
1164
|
+
const manager = state.manager;
|
|
1165
|
+
const answer = manager.mkApp(
|
|
1166
|
+
manager.mkFuncDecl(assertion.name, [], SORT_BOOL, true),
|
|
1167
|
+
[],
|
|
1168
|
+
SORT_BOOL,
|
|
1169
|
+
);
|
|
1170
|
+
manager.incRef(answer);
|
|
1171
|
+
state.names.push(answer);
|
|
1172
|
+
}
|
|
1173
|
+
assertInKernel(assertion.formula, state.names[state.names.length - 1]);
|
|
1174
|
+
clearCheck();
|
|
1175
|
+
if (follower !== list.end)
|
|
1176
|
+
throw new SmtParseError("invalid assert command, ')' expected", follower);
|
|
1177
|
+
},
|
|
1178
|
+
],
|
|
1179
|
+
[
|
|
1180
|
+
"check-sat",
|
|
1181
|
+
(list) => {
|
|
1182
|
+
checkSatAssuming(list.items.slice(1), list.end, list.end);
|
|
1183
|
+
validateCheck(list.end);
|
|
1184
|
+
},
|
|
1185
|
+
],
|
|
1186
|
+
[
|
|
1187
|
+
"declare-rel",
|
|
1188
|
+
(list) => {
|
|
1189
|
+
const name = list.items[1];
|
|
1190
|
+
const domain = list.items[2];
|
|
1191
|
+
if (!isSymbol(name) || domain?.kind !== "list")
|
|
1192
|
+
throw new SmtParseError("at least 2 arguments expected", list.end);
|
|
1193
|
+
const decl = state.manager.mkFuncDecl(
|
|
1194
|
+
name.text,
|
|
1195
|
+
domain.items.map((sort) =>
|
|
1196
|
+
state.reader.parseSort(sort, "expecting sort list starting with '('"),
|
|
1197
|
+
),
|
|
1198
|
+
SORT_BOOL,
|
|
1199
|
+
);
|
|
1200
|
+
state.reader.insertFunc(decl, list.end);
|
|
1201
|
+
getDatalog().registerPredicate(decl);
|
|
1202
|
+
},
|
|
1203
|
+
],
|
|
1204
|
+
[
|
|
1205
|
+
"declare-var",
|
|
1206
|
+
(list) => {
|
|
1207
|
+
const name = list.items[1];
|
|
1208
|
+
const sort = list.items[2];
|
|
1209
|
+
if (!isSymbol(name) || sort === undefined)
|
|
1210
|
+
throw new SmtParseError(
|
|
1211
|
+
"invalid declare-var command, symbol and sort expected",
|
|
1212
|
+
list.end,
|
|
1213
|
+
);
|
|
1214
|
+
const manager = state.manager;
|
|
1215
|
+
const range = state.reader.parseSort(sort, "invalid command argument, sort expected");
|
|
1216
|
+
const decl = manager.mkFuncDecl(name.text, [], range);
|
|
1217
|
+
state.reader.insertFunc(decl, list.end);
|
|
1218
|
+
getDatalog().registerVariable(manager.mkApp(decl, [], range));
|
|
1219
|
+
},
|
|
1220
|
+
],
|
|
1221
|
+
[
|
|
1222
|
+
"rule",
|
|
1223
|
+
(list) => {
|
|
1224
|
+
const rule = list.items[1];
|
|
1225
|
+
if (rule === undefined) throw new SmtParseError("invalid rule, expected formula", list.end);
|
|
1226
|
+
const name = list.items[2];
|
|
1227
|
+
getDatalog().addRule(
|
|
1228
|
+
state.reader.parseFormula(rule, rule),
|
|
1229
|
+
isSymbol(name) ? name.text : undefined,
|
|
1230
|
+
);
|
|
1231
|
+
},
|
|
1232
|
+
],
|
|
1233
|
+
[
|
|
1234
|
+
"query",
|
|
1235
|
+
(list) => {
|
|
1236
|
+
if (list.items[1] === undefined)
|
|
1237
|
+
throw new SmtParseError("invalid query command, argument expected", list.end);
|
|
1238
|
+
const relation = getFuncDeclRef(list.items[1]);
|
|
1239
|
+
const datalog = getDatalog();
|
|
1240
|
+
// dl_query_cmd::set_next_arg runs once the parser is past the reference.
|
|
1241
|
+
const follower = list.items[2] ?? list.end;
|
|
1242
|
+
if (!datalog.isPredicateDecl(relation))
|
|
1243
|
+
throw new SmtParseError(
|
|
1244
|
+
"Invalid query argument, expected a predicate registered as a relation",
|
|
1245
|
+
follower,
|
|
1246
|
+
);
|
|
1247
|
+
if (follower.kind !== "keyword" && follower !== list.end)
|
|
1248
|
+
throw new SmtParseError("invalid command argument, keyword expected", follower);
|
|
1249
|
+
for (const assertion of state.assertions) datalog.assertExpr(assertion);
|
|
1250
|
+
state.manager.limit.restart(Date.now() + options.timeLimitMs);
|
|
1251
|
+
state.manager.limit.push(settings.rlimit);
|
|
1252
|
+
let status = L_UNDEF;
|
|
1253
|
+
try {
|
|
1254
|
+
status = datalog.relQuery(relation);
|
|
1255
|
+
} catch (error) {
|
|
1256
|
+
if (!(error instanceof SmtTacticError)) throw error;
|
|
1257
|
+
print(`(error "query failed: ${error.message}")`);
|
|
1258
|
+
} finally {
|
|
1259
|
+
state.manager.limit.pop();
|
|
1260
|
+
}
|
|
1261
|
+
print(status === L_UNDEF && datalog.isBounded ? "bounded" : getVerdict(status));
|
|
1262
|
+
datalog.isBounded = false;
|
|
1263
|
+
},
|
|
1264
|
+
],
|
|
1265
|
+
[
|
|
1266
|
+
"check-sat-using",
|
|
1267
|
+
(list) => {
|
|
1268
|
+
const params = getCommandParams(list.items, CHECK_SAT_USING_PARAMETERS);
|
|
1269
|
+
if (list.items[1] === undefined)
|
|
1270
|
+
throw new SmtParseError("check-sat-using needs a tactic argument", list.end);
|
|
1271
|
+
expectClosed(list.items[1]);
|
|
1272
|
+
const builder = compileTactic(getTacticEnvironment(), list.items[1]);
|
|
1273
|
+
const tactic = builder.build(params);
|
|
1274
|
+
const goal = getCommandGoal(builder.isTrackingDependencies, list.end);
|
|
1275
|
+
clearCheck();
|
|
1276
|
+
const deadline = Date.now() + options.timeLimitMs;
|
|
1277
|
+
state.manager.limit.restart(deadline);
|
|
1278
|
+
state.manager.limit.push(settings.rlimit);
|
|
1279
|
+
try {
|
|
1280
|
+
const checked = checkSatUsing(tactic, goal);
|
|
1281
|
+
const reasonUnknown = checked.reasonUnknown ?? getCancelMessage(deadline);
|
|
1282
|
+
setCheck(checked.status, {
|
|
1283
|
+
isFromTactic: true,
|
|
1284
|
+
model: checked.model,
|
|
1285
|
+
core:
|
|
1286
|
+
builder.isTrackingDependencies || !hasNames()
|
|
1287
|
+
? getDependencyValues(checked.core)
|
|
1288
|
+
: undefined,
|
|
1289
|
+
reasonUnknown,
|
|
1290
|
+
});
|
|
1291
|
+
print(
|
|
1292
|
+
checked.isConversionCanceled
|
|
1293
|
+
? `(error "tactic failed: ${reasonUnknown}")`
|
|
1294
|
+
: getVerdict(checked.status),
|
|
1295
|
+
);
|
|
1296
|
+
} finally {
|
|
1297
|
+
state.manager.limit.pop();
|
|
1298
|
+
}
|
|
1299
|
+
validateCheck(list.end);
|
|
1300
|
+
},
|
|
1301
|
+
],
|
|
1302
|
+
[
|
|
1303
|
+
"check-sat-assuming",
|
|
1304
|
+
(list) => {
|
|
1305
|
+
const literals = list.items[1] ?? list.end;
|
|
1306
|
+
if (literals.kind !== "list")
|
|
1307
|
+
throw new SmtParseError(
|
|
1308
|
+
`invalid check-sat-assuming command, '(', expected got ${literals.lastId}`,
|
|
1309
|
+
literals,
|
|
1310
|
+
);
|
|
1311
|
+
checkSatAssuming(literals.items, literals.end, list.end);
|
|
1312
|
+
validateCheck(list.end);
|
|
1313
|
+
},
|
|
1314
|
+
],
|
|
1315
|
+
[
|
|
1316
|
+
"get-consequences",
|
|
1317
|
+
(list) => {
|
|
1318
|
+
const manager = state.manager;
|
|
1319
|
+
const [assumptions, vars] = [list.items[1], list.items[2]].map((terms) => {
|
|
1320
|
+
if (terms === undefined)
|
|
1321
|
+
throw new SmtParseError("invalid command, argument(s) missing", list.end);
|
|
1322
|
+
if (terms.kind !== "list")
|
|
1323
|
+
throw new SmtParseError(
|
|
1324
|
+
`invalid list of terms, '(' expected got ${terms.lastId}`,
|
|
1325
|
+
terms,
|
|
1326
|
+
);
|
|
1327
|
+
return terms.items.map((item) => state.reader.parseTerm(item));
|
|
1328
|
+
});
|
|
1329
|
+
if (list.items.length > 3)
|
|
1330
|
+
throw new SmtParseError("invalid command, too many arguments", list.items[3]);
|
|
1331
|
+
clearCheck();
|
|
1332
|
+
const deadline = Date.now() + options.timeLimitMs;
|
|
1333
|
+
manager.limit.restart(deadline);
|
|
1334
|
+
manager.limit.push(settings.rlimit);
|
|
1335
|
+
const names = state.names.filter((name) => name !== -1);
|
|
1336
|
+
try {
|
|
1337
|
+
const fdSolver = state.fdSolver;
|
|
1338
|
+
if (fdSolver !== undefined) {
|
|
1339
|
+
const found = fdSolver.getConsequences(assumptions, vars);
|
|
1340
|
+
setCheck(found.result, {
|
|
1341
|
+
isFromTactic: true,
|
|
1342
|
+
fdSolver,
|
|
1343
|
+
core: [...fdSolver.getUnsatCore()],
|
|
1344
|
+
reasonUnknown: fdSolver.reasonUnknown,
|
|
1345
|
+
});
|
|
1346
|
+
print(getVerdict(found.result));
|
|
1347
|
+
print("");
|
|
1348
|
+
for (const consequence of found.consequences.items) display(consequence);
|
|
1349
|
+
found.consequences.reset();
|
|
1350
|
+
return;
|
|
1351
|
+
}
|
|
1352
|
+
const kernel = state.kernel ?? new SmtKernel(manager, getKernelParams());
|
|
1353
|
+
if (state.kernel === undefined)
|
|
1354
|
+
for (const assertion of getNamedAssertions()) kernel.assertExpr(assertion);
|
|
1355
|
+
const found = getConsequences(kernel, [...names, ...assumptions], vars);
|
|
1356
|
+
setCheck(found.result, {
|
|
1357
|
+
context: kernel.context,
|
|
1358
|
+
core: kernel.context.unsatCore,
|
|
1359
|
+
reasonUnknown: kernel.context.getLastFailureMessage(),
|
|
1360
|
+
});
|
|
1361
|
+
print(getVerdict(found.result));
|
|
1362
|
+
print("");
|
|
1363
|
+
for (const consequence of found.consequences.items) display(consequence);
|
|
1364
|
+
found.consequences.reset();
|
|
1365
|
+
} catch (error) {
|
|
1366
|
+
if (!(error instanceof SmtCanceledError || isStackOverflow(error))) throw error;
|
|
1367
|
+
const reasonUnknown = getCancelMessage(deadline);
|
|
1368
|
+
if (state.kernel !== undefined) state.kernel.context.reasonUnknown = reasonUnknown;
|
|
1369
|
+
setCheck(L_UNDEF, { reasonUnknown });
|
|
1370
|
+
print("unknown");
|
|
1371
|
+
print("");
|
|
1372
|
+
} finally {
|
|
1373
|
+
manager.limit.pop();
|
|
1374
|
+
}
|
|
1375
|
+
},
|
|
1376
|
+
],
|
|
1377
|
+
["minimize", (list) => addObjective(list, false)],
|
|
1378
|
+
["maximize", (list) => addObjective(list, true)],
|
|
1379
|
+
[
|
|
1380
|
+
"assert-soft",
|
|
1381
|
+
(list) => {
|
|
1382
|
+
const formula = state.reader.parseTerm(list.items[1] ?? list.end);
|
|
1383
|
+
if (state.manager.sorts[formula] !== SORT_BOOL)
|
|
1384
|
+
throw new SmtParseError("Invalid type for expression. Expected Boolean type.", list.end);
|
|
1385
|
+
const parameters = getSoftParameters(list.items.slice(2));
|
|
1386
|
+
resetOptimizer();
|
|
1387
|
+
const existing = state.objectives.findIndex(
|
|
1388
|
+
(objective) => objective.type === O_MAXSMT && objective.id === parameters.id,
|
|
1389
|
+
);
|
|
1390
|
+
const index = existing === -1 ? state.objectives.length : existing;
|
|
1391
|
+
if (existing === -1)
|
|
1392
|
+
state.objectives.push({
|
|
1393
|
+
type: O_MAXSMT,
|
|
1394
|
+
term: -1,
|
|
1395
|
+
terms: [],
|
|
1396
|
+
weights: [],
|
|
1397
|
+
id: parameters.id,
|
|
1398
|
+
});
|
|
1399
|
+
if (parameters.weight.isZero()) return;
|
|
1400
|
+
state.manager.incRef(formula);
|
|
1401
|
+
state.objectives[index].terms.push(formula);
|
|
1402
|
+
state.objectives[index].weights.push(parameters.weight);
|
|
1403
|
+
state.softTrail.push(index);
|
|
1404
|
+
},
|
|
1405
|
+
],
|
|
1406
|
+
[
|
|
1407
|
+
"push",
|
|
1408
|
+
(list) => {
|
|
1409
|
+
clearCheck();
|
|
1410
|
+
for (let index = getScopeCount(list); index > 0; index--) {
|
|
1411
|
+
state.scopes.push({
|
|
1412
|
+
assertions: state.assertions.length,
|
|
1413
|
+
objectives: state.objectives.length,
|
|
1414
|
+
softTrail: state.softTrail.length,
|
|
1415
|
+
rlimit: settings.rlimit,
|
|
1416
|
+
});
|
|
1417
|
+
state.reader.push();
|
|
1418
|
+
state.isIncremental = true;
|
|
1419
|
+
const limit = state.manager.limit;
|
|
1420
|
+
limit.push(settings.rlimit);
|
|
1421
|
+
try {
|
|
1422
|
+
state.kernel?.push();
|
|
1423
|
+
useSatSolver((solver) => solver.push());
|
|
1424
|
+
state.fdSolver?.push();
|
|
1425
|
+
} catch (error) {
|
|
1426
|
+
if (!(error instanceof SmtCanceledError)) throw error;
|
|
1427
|
+
throw new SmtParseError(limit.getCancelMessage(), list.end);
|
|
1428
|
+
} finally {
|
|
1429
|
+
limit.pop();
|
|
1430
|
+
}
|
|
1431
|
+
}
|
|
1432
|
+
if (list.items[2] !== undefined)
|
|
1433
|
+
throw new SmtParseError("invalid push command, ')' expected", list.items[2]);
|
|
1434
|
+
},
|
|
1435
|
+
],
|
|
1436
|
+
[
|
|
1437
|
+
"pop",
|
|
1438
|
+
(list) => {
|
|
1439
|
+
const count = getScopeCount(list);
|
|
1440
|
+
const follower = list.items[2] ?? list.end;
|
|
1441
|
+
clearCheck();
|
|
1442
|
+
if (count > state.scopes.length)
|
|
1443
|
+
throw new SmtParseError(
|
|
1444
|
+
"invalid pop command, argument is greater than the current stack depth",
|
|
1445
|
+
follower,
|
|
1446
|
+
);
|
|
1447
|
+
if (count > 0) {
|
|
1448
|
+
state.isIncremental = true;
|
|
1449
|
+
const scope = state.scopes[state.scopes.length - count];
|
|
1450
|
+
state.kernel?.pop(count);
|
|
1451
|
+
useSatSolver((solver) => solver.pop(count));
|
|
1452
|
+
state.fdSolver?.pop(count);
|
|
1453
|
+
state.reader.pop(count);
|
|
1454
|
+
restoreAssertions(scope.assertions);
|
|
1455
|
+
settings.rlimit = scope.rlimit;
|
|
1456
|
+
resetOptimizer();
|
|
1457
|
+
releaseObjectives(scope.objectives, scope.softTrail);
|
|
1458
|
+
state.scopes.length -= count;
|
|
1459
|
+
}
|
|
1460
|
+
if (follower !== list.end)
|
|
1461
|
+
throw new SmtParseError("invalid pop command, ')' expected", follower);
|
|
1462
|
+
},
|
|
1463
|
+
],
|
|
1464
|
+
[
|
|
1465
|
+
"reset",
|
|
1466
|
+
(list) => {
|
|
1467
|
+
if (list.items[1] !== undefined)
|
|
1468
|
+
throw new SmtParseError("invalid reset command, ')' expected", list.items[1]);
|
|
1469
|
+
clearCheck();
|
|
1470
|
+
resetOptimizer();
|
|
1471
|
+
state = createState();
|
|
1472
|
+
},
|
|
1473
|
+
],
|
|
1474
|
+
[
|
|
1475
|
+
"reset-assertions",
|
|
1476
|
+
(list) => {
|
|
1477
|
+
checkArgumentCount(list, 0);
|
|
1478
|
+
restoreAssertions(0);
|
|
1479
|
+
resetOptimizer();
|
|
1480
|
+
releaseObjectives(0, 0);
|
|
1481
|
+
state.scopes = state.scopes.map((scope) => ({
|
|
1482
|
+
...scope,
|
|
1483
|
+
assertions: 0,
|
|
1484
|
+
objectives: 0,
|
|
1485
|
+
softTrail: 0,
|
|
1486
|
+
}));
|
|
1487
|
+
if (state.isProofsEnabled !== undefined) resetKernel();
|
|
1488
|
+
state.isIncremental = state.scopes.length > 0;
|
|
1489
|
+
state.hasChecked = false;
|
|
1490
|
+
},
|
|
1491
|
+
],
|
|
1492
|
+
[
|
|
1493
|
+
"simplify",
|
|
1494
|
+
(list) => {
|
|
1495
|
+
const manager = state.manager;
|
|
1496
|
+
if (list.items.length < 2)
|
|
1497
|
+
throw new SmtParseError("invalid simplify command, argument expected", list.end);
|
|
1498
|
+
const term = state.reader.parseTerm(list.items[1]);
|
|
1499
|
+
manager.incRef(term);
|
|
1500
|
+
const rewriter = new Rewriter(
|
|
1501
|
+
manager,
|
|
1502
|
+
getRewriterOptions(manager, getSimplifyParams(list.items.slice(2))),
|
|
1503
|
+
);
|
|
1504
|
+
// simplify_cmd prints a failure of the rewriter and then the term as it was.
|
|
1505
|
+
const simplified = (() => {
|
|
1506
|
+
try {
|
|
1507
|
+
return rewriter.rewrite(term);
|
|
1508
|
+
} catch (error) {
|
|
1509
|
+
if (!(error instanceof SmtDefaultError)) throw error;
|
|
1510
|
+
print(`(error "simplifier failed: ${error.message}")`);
|
|
1511
|
+
manager.incRef(term);
|
|
1512
|
+
return term;
|
|
1513
|
+
}
|
|
1514
|
+
})();
|
|
1515
|
+
rewriter.cleanup();
|
|
1516
|
+
display(simplified);
|
|
1517
|
+
rewriter.release();
|
|
1518
|
+
manager.decRef(simplified);
|
|
1519
|
+
manager.decRef(term);
|
|
1520
|
+
},
|
|
1521
|
+
],
|
|
1522
|
+
// The Boolean rewriter alone matches the simplifier only on Boolean structure over constants.
|
|
1523
|
+
[
|
|
1524
|
+
"dbg-bool-flat-rewriter",
|
|
1525
|
+
(list) => {
|
|
1526
|
+
const manager = state.manager;
|
|
1527
|
+
if (list.items.length !== 2)
|
|
1528
|
+
throw new SmtParseError("invalid command, one argument expected", list.end);
|
|
1529
|
+
const term = state.reader.parseTerm(list.items[1]);
|
|
1530
|
+
manager.incRef(term);
|
|
1531
|
+
const visited = new Set<number>();
|
|
1532
|
+
const todo = [term];
|
|
1533
|
+
for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
|
|
1534
|
+
if (visited.has(expr)) continue;
|
|
1535
|
+
visited.add(expr);
|
|
1536
|
+
const family = manager.kinds[expr] === KIND_APP ? manager.getFamily(expr) : -1;
|
|
1537
|
+
if (family !== FAMILY_BASIC && family !== FAMILY_USER && !manager.isNumeral(expr))
|
|
1538
|
+
throw new SmtUnsupportedError(
|
|
1539
|
+
"the command dbg-bool-flat-rewriter beyond Boolean terms",
|
|
1540
|
+
);
|
|
1541
|
+
manager.pushArgs(expr, todo);
|
|
1542
|
+
}
|
|
1543
|
+
const rewriter = new Rewriter(manager, getRewriterOptions(manager, new Map()));
|
|
1544
|
+
const rewritten = rewriter.rewrite(term);
|
|
1545
|
+
display(rewritten);
|
|
1546
|
+
rewriter.release();
|
|
1547
|
+
manager.decRef(rewritten);
|
|
1548
|
+
manager.decRef(term);
|
|
1549
|
+
},
|
|
1550
|
+
],
|
|
1551
|
+
[
|
|
1552
|
+
"apply",
|
|
1553
|
+
(list) => {
|
|
1554
|
+
const params = getCommandParams(list.items, APPLY_PARAMETERS);
|
|
1555
|
+
if (list.items[1] === undefined)
|
|
1556
|
+
throw new SmtParseError("apply needs a tactic argument", list.end);
|
|
1557
|
+
expectClosed(list.items[1]);
|
|
1558
|
+
// apply_tactic_cmd, unlike check-sat-using, gives the tactic no logic.
|
|
1559
|
+
const builder = compileTactic(
|
|
1560
|
+
{ ...getTacticEnvironment(), setup: { ...getSetup(), logic: undefined } },
|
|
1561
|
+
list.items[1],
|
|
1562
|
+
);
|
|
1563
|
+
const tactic = builder.build(params);
|
|
1564
|
+
const input = getCommandGoal(builder.isTrackingDependencies, list.end);
|
|
1565
|
+
const isPrintingDependencies = params.get("print_dependencies") === true;
|
|
1566
|
+
if (isPrintingDependencies && !builder.isTrackingDependencies && hasNames())
|
|
1567
|
+
throw new SmtUnsupportedError("the dependencies of a tactic that drops dependencies");
|
|
1568
|
+
state.manager.limit.restart(Date.now() + options.timeLimitMs);
|
|
1569
|
+
state.manager.limit.push(settings.rlimit);
|
|
1570
|
+
const goals = (() => {
|
|
1571
|
+
try {
|
|
1572
|
+
return applyTactic(tactic, input);
|
|
1573
|
+
} catch (error) {
|
|
1574
|
+
if (!(error instanceof SmtTacticError)) throw error;
|
|
1575
|
+
print(`(error "tactic failed: ${error.message}")`);
|
|
1576
|
+
return undefined;
|
|
1577
|
+
} finally {
|
|
1578
|
+
state.manager.limit.pop();
|
|
1579
|
+
}
|
|
1580
|
+
})();
|
|
1581
|
+
// apply_tactic_cmd releases the result goals and then the input goal.
|
|
1582
|
+
if (goals === undefined) {
|
|
1583
|
+
input.reset();
|
|
1584
|
+
return;
|
|
1585
|
+
}
|
|
1586
|
+
try {
|
|
1587
|
+
const manager = state.manager;
|
|
1588
|
+
const environment = getPrintEnvironment();
|
|
1589
|
+
if (params.get("print") !== false)
|
|
1590
|
+
print(
|
|
1591
|
+
[
|
|
1592
|
+
"(goals",
|
|
1593
|
+
...goals.map((goal) =>
|
|
1594
|
+
[
|
|
1595
|
+
"(goal",
|
|
1596
|
+
...goal.forms.items.flatMap((form, index) => [
|
|
1597
|
+
...(isPrintingDependencies
|
|
1598
|
+
? [
|
|
1599
|
+
[
|
|
1600
|
+
" |-",
|
|
1601
|
+
...getDependencyValues(goal.getDependency(index)).map(format),
|
|
1602
|
+
].join(" "),
|
|
1603
|
+
]
|
|
1604
|
+
: []),
|
|
1605
|
+
` ${printExpr(state.manager, environment, form, 2)}`,
|
|
1606
|
+
]),
|
|
1607
|
+
` :precision ${PRECISION_NAMES[goal.precision]} :depth ${goal.depth})`,
|
|
1608
|
+
].join("\n"),
|
|
1609
|
+
),
|
|
1610
|
+
")",
|
|
1611
|
+
].join("\n"),
|
|
1612
|
+
);
|
|
1613
|
+
if (
|
|
1614
|
+
params.get("print_model_converter") === true &&
|
|
1615
|
+
input.converters.some(
|
|
1616
|
+
(entry) => !("definitions" in entry) || entry.definitions.length > 0,
|
|
1617
|
+
)
|
|
1618
|
+
)
|
|
1619
|
+
throw new SmtUnsupportedError("printing a model converter");
|
|
1620
|
+
if (params.get("print_benchmark") !== true) return;
|
|
1621
|
+
const assertions =
|
|
1622
|
+
goals.length === 1
|
|
1623
|
+
? goals[0].forms.items
|
|
1624
|
+
: [
|
|
1625
|
+
manager.mkOr(
|
|
1626
|
+
goals.map((goal) =>
|
|
1627
|
+
goal.forms.size === 1 ? goal.forms.items[0] : manager.mkAnd(goal.forms.items),
|
|
1628
|
+
),
|
|
1629
|
+
),
|
|
1630
|
+
];
|
|
1631
|
+
for (const assertion of assertions) manager.incRef(assertion);
|
|
1632
|
+
const visited = new Set<number>();
|
|
1633
|
+
const decls = new Set<number>();
|
|
1634
|
+
for (const assertion of assertions) {
|
|
1635
|
+
const todo = [assertion];
|
|
1636
|
+
for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
|
|
1637
|
+
if (visited.has(expr)) continue;
|
|
1638
|
+
visited.add(expr);
|
|
1639
|
+
if (manager.kinds[expr] === KIND_QUANTIFIER) {
|
|
1640
|
+
const data = manager.getQuantifier(expr);
|
|
1641
|
+
todo.push(data.body, ...data.patterns, ...data.noPatterns);
|
|
1642
|
+
} else if (manager.kinds[expr] === KIND_APP) {
|
|
1643
|
+
manager.pushArgs(expr, todo);
|
|
1644
|
+
const decl = manager.decls[expr];
|
|
1645
|
+
const family = manager.funcDecls[decl].family;
|
|
1646
|
+
if (family === FAMILY_USER || family === FAMILY_MODEL_VALUE) decls.add(decl);
|
|
1647
|
+
}
|
|
1648
|
+
}
|
|
1649
|
+
}
|
|
1650
|
+
const lines = [...decls].map((decl) => {
|
|
1651
|
+
const funcDecl = manager.funcDecls[decl];
|
|
1652
|
+
return renderFormat(
|
|
1653
|
+
mkSeq1(
|
|
1654
|
+
[
|
|
1655
|
+
mkText(getQuotedName(funcDecl.name)),
|
|
1656
|
+
mkSeq5(funcDecl.domain.map((sort) => formatSort(manager, sort))),
|
|
1657
|
+
formatSort(manager, funcDecl.range),
|
|
1658
|
+
],
|
|
1659
|
+
"declare-fun",
|
|
1660
|
+
),
|
|
1661
|
+
environment.options,
|
|
1662
|
+
);
|
|
1663
|
+
});
|
|
1664
|
+
for (const assertion of assertions)
|
|
1665
|
+
lines.push(`(assert ${printExpr(manager, environment, assertion, 8)})`);
|
|
1666
|
+
print([...lines, "(check-sat)"].join("\n"));
|
|
1667
|
+
for (const assertion of assertions) manager.decRef(assertion);
|
|
1668
|
+
} finally {
|
|
1669
|
+
for (const goal of goals) if (goal !== input) goal.reset();
|
|
1670
|
+
input.reset();
|
|
1671
|
+
}
|
|
1672
|
+
},
|
|
1673
|
+
],
|
|
1674
|
+
[
|
|
1675
|
+
"get-assertions",
|
|
1676
|
+
(list) => {
|
|
1677
|
+
checkArgumentCount(list, 0);
|
|
1678
|
+
if (!settings.isInteractive)
|
|
1679
|
+
throw new SmtParseError(
|
|
1680
|
+
"command is only available in interactive mode, use command (set-option :interactive-mode true)",
|
|
1681
|
+
list.end,
|
|
1682
|
+
);
|
|
1683
|
+
print(`(${state.assertionTexts.join("\n ")})`);
|
|
1684
|
+
},
|
|
1685
|
+
],
|
|
1686
|
+
[
|
|
1687
|
+
"get-unsat-core",
|
|
1688
|
+
(list) => {
|
|
1689
|
+
checkArgumentCount(list, 0);
|
|
1690
|
+
if (!settings.isProducingUnsatCores)
|
|
1691
|
+
throw new SmtParseError(
|
|
1692
|
+
"unsat core construction is not enabled, use command (set-option :produce-unsat-cores true)",
|
|
1693
|
+
list.end,
|
|
1694
|
+
);
|
|
1695
|
+
if (state.check?.status !== L_FALSE)
|
|
1696
|
+
throw new SmtParseError("unsat core is not available", list.end);
|
|
1697
|
+
printCore();
|
|
1698
|
+
},
|
|
1699
|
+
],
|
|
1700
|
+
[
|
|
1701
|
+
"get-unsat-assumptions",
|
|
1702
|
+
(list) => {
|
|
1703
|
+
checkArgumentCount(list, 0);
|
|
1704
|
+
if (!settings.isProducingUnsatAssumptions)
|
|
1705
|
+
throw new SmtParseError(
|
|
1706
|
+
"unsat assumptions construction is not enabled, use command (set-option :produce-unsat-assumptions true)",
|
|
1707
|
+
list.end,
|
|
1708
|
+
);
|
|
1709
|
+
if (state.check?.status !== L_FALSE)
|
|
1710
|
+
throw new SmtParseError("unsat assumptions is not available", list.end);
|
|
1711
|
+
printCore();
|
|
1712
|
+
},
|
|
1713
|
+
],
|
|
1714
|
+
[
|
|
1715
|
+
"eval",
|
|
1716
|
+
(list) => {
|
|
1717
|
+
const target = list.items[1];
|
|
1718
|
+
const term = target === undefined ? -1 : state.reader.parseTerm(target);
|
|
1719
|
+
const parameter = list.items[2];
|
|
1720
|
+
if (parameter !== undefined && parameter.kind !== "keyword")
|
|
1721
|
+
throw new SmtParseError("invalid command argument, keyword expected", parameter);
|
|
1722
|
+
if (parameter !== undefined) throw new SmtUnsupportedError("the parameters of eval");
|
|
1723
|
+
const model = getModel(list);
|
|
1724
|
+
if (term === -1) throw new SmtParseError("no arguments passed to eval", list.end);
|
|
1725
|
+
const manager = state.manager;
|
|
1726
|
+
manager.incRef(term);
|
|
1727
|
+
const evaluator = new ModelEvaluator(manager, model);
|
|
1728
|
+
const value = evaluator.rewrite(term);
|
|
1729
|
+
display(value);
|
|
1730
|
+
// eval_cmd frees its model_evaluator before the value, and the parser frees the term last.
|
|
1731
|
+
evaluator.release();
|
|
1732
|
+
manager.decRef(value);
|
|
1733
|
+
manager.decRef(term);
|
|
1734
|
+
},
|
|
1735
|
+
],
|
|
1736
|
+
[
|
|
1737
|
+
"get-value",
|
|
1738
|
+
(list) => {
|
|
1739
|
+
const terms = list.items[1] ?? list.end;
|
|
1740
|
+
if (terms.kind !== "list")
|
|
1741
|
+
throw new SmtParseError(
|
|
1742
|
+
`invalid get-value command, '(' expected got ${terms.lastId}`,
|
|
1743
|
+
terms,
|
|
1744
|
+
);
|
|
1745
|
+
const manager = state.manager;
|
|
1746
|
+
const exprs = terms.items.map((item) => state.reader.parseTerm(item));
|
|
1747
|
+
if (exprs.length === 0)
|
|
1748
|
+
throw new SmtParseError("invalid get-value command, empty list of terms", terms.end);
|
|
1749
|
+
const extra = list.items[2];
|
|
1750
|
+
if (
|
|
1751
|
+
extra?.kind === "keyword" &&
|
|
1752
|
+
(extra.text === ":model-index" || extra.text === ":model_index")
|
|
1753
|
+
)
|
|
1754
|
+
throw new SmtUnsupportedError("the model index of get-value");
|
|
1755
|
+
if (extra !== undefined)
|
|
1756
|
+
throw new SmtParseError("invalid get-value command, ')' expected", extra);
|
|
1757
|
+
const model = getModel(list);
|
|
1758
|
+
pendingText += "(";
|
|
1759
|
+
model.compact();
|
|
1760
|
+
// Z3 prints each term as the script spells it, from the end of the term before.
|
|
1761
|
+
const offsets = [
|
|
1762
|
+
terms.offset + 1,
|
|
1763
|
+
...terms.items.map((item) => (item.kind === "list" ? item.end : item).endOffset),
|
|
1764
|
+
];
|
|
1765
|
+
exprs.forEach((expr, index) => {
|
|
1766
|
+
manager.incRef(expr);
|
|
1767
|
+
const value = model.eval(expr, true);
|
|
1768
|
+
pendingText += `${index > 0 ? "\n " : ""}(${text.slice(offsets[index], offsets[index + 1]).trim()} ${format(value)})`;
|
|
1769
|
+
manager.decRef(value);
|
|
1770
|
+
manager.decRef(expr);
|
|
1771
|
+
});
|
|
1772
|
+
print(")");
|
|
1773
|
+
},
|
|
1774
|
+
],
|
|
1775
|
+
[
|
|
1776
|
+
"get-assignment",
|
|
1777
|
+
(list) => {
|
|
1778
|
+
checkArgumentCount(list, 0);
|
|
1779
|
+
const manager = state.manager;
|
|
1780
|
+
const model = getModel(list);
|
|
1781
|
+
const assignments = state.reader.getConstantMacros().flatMap((macro) => {
|
|
1782
|
+
if (manager.sorts[macro.body] !== SORT_BOOL) return [];
|
|
1783
|
+
const value = model.eval(macro.body, true);
|
|
1784
|
+
const assignment = `(${getQuotedName(macro.name)} ${manager.isTrue(value)})`;
|
|
1785
|
+
const isDecided = manager.isTrue(value) || manager.isFalse(value);
|
|
1786
|
+
manager.decRef(value);
|
|
1787
|
+
return isDecided ? [assignment] : [];
|
|
1788
|
+
});
|
|
1789
|
+
print(`(${assignments.join(" ")})`);
|
|
1790
|
+
},
|
|
1791
|
+
],
|
|
1792
|
+
[
|
|
1793
|
+
"get-objectives",
|
|
1794
|
+
() => {
|
|
1795
|
+
const optimizer = state.optimizer;
|
|
1796
|
+
if (optimizer === undefined || state.check === undefined)
|
|
1797
|
+
throw new SmtUnsupportedError("the command get-objectives");
|
|
1798
|
+
print(optimizer.getObjectives(format));
|
|
1799
|
+
},
|
|
1800
|
+
],
|
|
1801
|
+
[
|
|
1802
|
+
"get-model",
|
|
1803
|
+
(list) => {
|
|
1804
|
+
for (const index of list.items.slice(1)) {
|
|
1805
|
+
if (index.kind !== "numeral")
|
|
1806
|
+
throw new SmtParseError("invalid command argument, unsigned integer expected", index);
|
|
1807
|
+
if (!isUnsigned(index.text))
|
|
1808
|
+
throw new SmtParseError(
|
|
1809
|
+
"invalid indexed identifier, index is too big to fit in an unsigned machine integer",
|
|
1810
|
+
index,
|
|
1811
|
+
);
|
|
1812
|
+
}
|
|
1813
|
+
const manager = state.manager;
|
|
1814
|
+
const model = getModel(list);
|
|
1815
|
+
const last = list.items[list.items.length - 1];
|
|
1816
|
+
// get_model_cmd takes any number of indices and keeps the last.
|
|
1817
|
+
if (last.kind === "numeral" && BigInt(last.text) > 0n)
|
|
1818
|
+
throw new SmtUnsupportedError("the index of get-model");
|
|
1819
|
+
model.compact();
|
|
1820
|
+
for (const decl of state.reader.getDeclaredFuncs()) {
|
|
1821
|
+
const funcDecl = manager.funcDecls[decl];
|
|
1822
|
+
if (
|
|
1823
|
+
funcDecl.family !== FAMILY_USER ||
|
|
1824
|
+
manager.macros.has(decl) ||
|
|
1825
|
+
model.constInterps.has(decl) ||
|
|
1826
|
+
model.funcInterps.has(decl)
|
|
1827
|
+
)
|
|
1828
|
+
continue;
|
|
1829
|
+
const value = model.getSomeValue(funcDecl.range);
|
|
1830
|
+
if (funcDecl.domain.length === 0) {
|
|
1831
|
+
model.registerConst(decl, value);
|
|
1832
|
+
continue;
|
|
1833
|
+
}
|
|
1834
|
+
const interp = new FuncInterp(manager, funcDecl.domain.length);
|
|
1835
|
+
interp.setElse(value);
|
|
1836
|
+
model.registerFunc(decl, interp);
|
|
1837
|
+
}
|
|
1838
|
+
model.addRecFuns();
|
|
1839
|
+
print(`(\n${printModel(manager, getPrintEnvironment(), model, 2)})`);
|
|
1840
|
+
},
|
|
1841
|
+
],
|
|
1842
|
+
[
|
|
1843
|
+
"display",
|
|
1844
|
+
(list) => {
|
|
1845
|
+
display(state.reader.parseTerm(getFirstArgument(list)));
|
|
1846
|
+
checkArgumentCount(list, 1);
|
|
1847
|
+
},
|
|
1848
|
+
],
|
|
1849
|
+
[
|
|
1850
|
+
"dbg-lt",
|
|
1851
|
+
(list) => {
|
|
1852
|
+
const first = state.reader.parseTerm(list.items[1] ?? list.end);
|
|
1853
|
+
const second = state.reader.parseTerm(list.items[2] ?? list.end);
|
|
1854
|
+
print(String(isAstLess(state.manager, first, second)));
|
|
1855
|
+
},
|
|
1856
|
+
],
|
|
1857
|
+
[
|
|
1858
|
+
"dbg-some-value",
|
|
1859
|
+
(list) => {
|
|
1860
|
+
display(
|
|
1861
|
+
getManagerSomeValue(
|
|
1862
|
+
state.manager,
|
|
1863
|
+
state.reader.parseSort(
|
|
1864
|
+
list.items[1] ?? list.end,
|
|
1865
|
+
"invalid command argument, sort expected",
|
|
1866
|
+
),
|
|
1867
|
+
),
|
|
1868
|
+
);
|
|
1869
|
+
},
|
|
1870
|
+
],
|
|
1871
|
+
[
|
|
1872
|
+
"dbg-used-vars",
|
|
1873
|
+
(list) => {
|
|
1874
|
+
const manager = state.manager;
|
|
1875
|
+
const term = state.reader.parseTerm(list.items[1] ?? list.end);
|
|
1876
|
+
const body =
|
|
1877
|
+
manager.kinds[term] === KIND_QUANTIFIER ? manager.getQuantifier(term).body : term;
|
|
1878
|
+
const sorts = getFreeVarSorts(manager, body, manager.freeVarBounds[body]);
|
|
1879
|
+
const lines = sorts.map(
|
|
1880
|
+
(sort, index) =>
|
|
1881
|
+
`\n (${String(index).padEnd(6)} ${sort === undefined ? "<not-used>" : renderFormat(formatSort(manager, sort), settings.printOptions)})`,
|
|
1882
|
+
);
|
|
1883
|
+
print(`(vars${lines.join("")})`);
|
|
1884
|
+
},
|
|
1885
|
+
],
|
|
1886
|
+
[
|
|
1887
|
+
"dbg-elim-unused-vars",
|
|
1888
|
+
(list) => {
|
|
1889
|
+
const manager = state.manager;
|
|
1890
|
+
const term = state.reader.parseTerm(list.items[1] ?? list.end);
|
|
1891
|
+
if (manager.kinds[term] !== KIND_QUANTIFIER) {
|
|
1892
|
+
write(format(term), false);
|
|
1893
|
+
return;
|
|
1894
|
+
}
|
|
1895
|
+
display(elimUnusedVars(manager, term));
|
|
1896
|
+
},
|
|
1897
|
+
],
|
|
1898
|
+
["dbg-instantiate", (list) => instantiate(list, false)],
|
|
1899
|
+
["dbg-instantiate-nested", (list) => instantiate(list, true)],
|
|
1900
|
+
[
|
|
1901
|
+
"echo",
|
|
1902
|
+
(list) => {
|
|
1903
|
+
const message = getFirstArgument(list);
|
|
1904
|
+
if (message.kind !== "string")
|
|
1905
|
+
throw new SmtParseError("invalid command argument, string expected", message);
|
|
1906
|
+
print(message.text);
|
|
1907
|
+
checkArgumentCount(list, 1);
|
|
1908
|
+
},
|
|
1909
|
+
],
|
|
1910
|
+
[
|
|
1911
|
+
"set-option",
|
|
1912
|
+
(list) => {
|
|
1913
|
+
const option = list.items[1];
|
|
1914
|
+
const keyword = option?.kind === "keyword" ? option.text : "";
|
|
1915
|
+
const optionName = `:${getParameterName(keyword)}`;
|
|
1916
|
+
const value = list.items[2];
|
|
1917
|
+
const isTrue = isSymbol(value, "true");
|
|
1918
|
+
if (
|
|
1919
|
+
(keyword === ":produce-proofs" ||
|
|
1920
|
+
keyword === ":produce-unsat-cores" ||
|
|
1921
|
+
keyword === ":produce-unsat-assumptions") &&
|
|
1922
|
+
state.assertions.length > 0
|
|
1923
|
+
)
|
|
1924
|
+
throw new SmtParseError(
|
|
1925
|
+
`error setting '${keyword}', option value cannot be modified after assertions have been added`,
|
|
1926
|
+
value ?? list.end,
|
|
1927
|
+
);
|
|
1928
|
+
if (keyword === ":produce-models") settings.isProducingModels = isTrue;
|
|
1929
|
+
if (keyword === ":produce-unsat-cores") settings.isProducingUnsatCores = isTrue;
|
|
1930
|
+
if (keyword === ":produce-unsat-assumptions") settings.isProducingUnsatAssumptions = isTrue;
|
|
1931
|
+
if (keyword === ":produce-proofs") settings.isProducingProofs = isTrue;
|
|
1932
|
+
if (keyword === ":interactive-mode" || keyword === ":produce-assertions") {
|
|
1933
|
+
if (state.isProofsEnabled !== undefined)
|
|
1934
|
+
throw new SmtParseError(
|
|
1935
|
+
"error setting ':produce-assertions', option value cannot be modified after initialization",
|
|
1936
|
+
value ?? list.end,
|
|
1937
|
+
);
|
|
1938
|
+
settings.isInteractive = isTrue;
|
|
1939
|
+
}
|
|
1940
|
+
if (keyword === ":diagnostic-output-channel")
|
|
1941
|
+
settings.isDiagnosticOnStdout = value?.kind === "string" && value.text === "stdout";
|
|
1942
|
+
if (keyword === ":int-real-coercions" && !isTrue)
|
|
1943
|
+
throw new SmtUnsupportedError("the option :int-real-coercions false");
|
|
1944
|
+
if (keyword === ":error-behavior") {
|
|
1945
|
+
if (!isSymbol(value, "immediate-exit") && !isSymbol(value, "continued-execution"))
|
|
1946
|
+
throw new SmtParseError(
|
|
1947
|
+
"error setting :error-behavior, 'immediate-execution' or 'continued-execution' expected",
|
|
1948
|
+
list.end,
|
|
1949
|
+
);
|
|
1950
|
+
settings.isExitingOnError = isSymbol(value, "immediate-exit");
|
|
1951
|
+
}
|
|
1952
|
+
const isParameter =
|
|
1953
|
+
keyword !== "" &&
|
|
1954
|
+
!BUILTIN_OPTIONS.has(keyword) &&
|
|
1955
|
+
value !== undefined &&
|
|
1956
|
+
value.kind !== "list";
|
|
1957
|
+
if (isParameter) settings.parameters.set(getParameterName(keyword), value.text);
|
|
1958
|
+
if (optionName === ":print_success") settings.isPrintingSuccess = isTrue;
|
|
1959
|
+
if (
|
|
1960
|
+
!BUILTIN_OPTIONS.has(keyword) &&
|
|
1961
|
+
settings.parameters.get("smtlib2_compliant") === "true"
|
|
1962
|
+
)
|
|
1963
|
+
settings.isPrintingSuccess = true;
|
|
1964
|
+
if (optionName === ":smt.mbqi") settings.isMbqi = isTrue;
|
|
1965
|
+
if (optionName === ":smt.macro_finder") settings.isFindingMacros = isTrue;
|
|
1966
|
+
if (optionName === ":smt.mbqi.max_iterations" && value?.kind === "numeral")
|
|
1967
|
+
settings.mbqiMaxIterations = Number(value.text);
|
|
1968
|
+
if (optionName === ":rlimit" && value?.kind === "numeral")
|
|
1969
|
+
settings.rlimit = Number(value.text);
|
|
1970
|
+
const kernel = state.kernel;
|
|
1971
|
+
if (isParameter && kernel !== undefined)
|
|
1972
|
+
kernel.updateParams(getKernelParams(kernel.isSetUp));
|
|
1973
|
+
if (optionName === ":rewriter.hi_div0") {
|
|
1974
|
+
settings.isHiDiv0 = isTrue;
|
|
1975
|
+
state.manager.isHiDiv0 = isTrue;
|
|
1976
|
+
}
|
|
1977
|
+
if (optionName === ":encoding" && value !== undefined && value.kind !== "list") {
|
|
1978
|
+
settings.encoding = ENCODINGS.get(value.text) ?? UNICODE_ENCODING;
|
|
1979
|
+
state.manager.maxChar = settings.encoding.maxChar;
|
|
1980
|
+
state.manager.charBits = settings.encoding.charBits;
|
|
1981
|
+
}
|
|
1982
|
+
if (optionName === ":parser.ignore_bad_patterns")
|
|
1983
|
+
settings.parserOptions.isIgnoringBadPatterns = isTrue;
|
|
1984
|
+
const numericOption = NUMERIC_PRINT_OPTIONS.get(optionName);
|
|
1985
|
+
if (numericOption !== undefined && value?.kind === "numeral")
|
|
1986
|
+
settings.printOptions[numericOption] = Number(value.text);
|
|
1987
|
+
const booleanOption = BOOLEAN_PRINT_OPTIONS.get(optionName);
|
|
1988
|
+
if (booleanOption !== undefined) settings.printOptions[booleanOption] = isTrue;
|
|
1989
|
+
if (
|
|
1990
|
+
(optionName.startsWith(":pp.") &&
|
|
1991
|
+
numericOption === undefined &&
|
|
1992
|
+
booleanOption === undefined) ||
|
|
1993
|
+
optionName.startsWith(":lp.")
|
|
1994
|
+
)
|
|
1995
|
+
throw new SmtUnsupportedError(`the option ${optionName}`);
|
|
1996
|
+
},
|
|
1997
|
+
],
|
|
1998
|
+
[
|
|
1999
|
+
"get-option",
|
|
2000
|
+
(list) => {
|
|
2001
|
+
const option = list.items[1];
|
|
2002
|
+
if (option?.kind !== "keyword")
|
|
2003
|
+
throw new SmtParseError("invalid command argument, keyword expected", option ?? list.end);
|
|
2004
|
+
const builtinValues = new Map<string, boolean | string>([
|
|
2005
|
+
[":print-success", settings.isPrintingSuccess],
|
|
2006
|
+
[":produce-models", settings.isProducingModels],
|
|
2007
|
+
[":produce-unsat-cores", settings.isProducingUnsatCores],
|
|
2008
|
+
[":produce-unsat-assumptions", settings.isProducingUnsatAssumptions],
|
|
2009
|
+
[":interactive-mode", settings.isInteractive],
|
|
2010
|
+
[":produce-assertions", settings.isInteractive],
|
|
2011
|
+
[":int-real-coercions", true],
|
|
2012
|
+
[":error-behavior", settings.isExitingOnError ? "immediate-exit" : "continued-execution"],
|
|
2013
|
+
]);
|
|
2014
|
+
const name = getParameterName(option.text);
|
|
2015
|
+
const value =
|
|
2016
|
+
builtinValues.get(option.text) ??
|
|
2017
|
+
(BUILTIN_OPTIONS.has(option.text)
|
|
2018
|
+
? undefined
|
|
2019
|
+
: (settings.parameters.get(name) ?? PARAMETER_DEFAULTS.get(name)));
|
|
2020
|
+
if (value === undefined) throw new SmtUnsupportedError(`the option ${option.text}`);
|
|
2021
|
+
print(String(value));
|
|
2022
|
+
},
|
|
2023
|
+
],
|
|
2024
|
+
[
|
|
2025
|
+
"get-info",
|
|
2026
|
+
(list) => {
|
|
2027
|
+
const info = list.items[1];
|
|
2028
|
+
if (info === undefined)
|
|
2029
|
+
throw new SmtParseError("invalid command, argument(s) missing", list.end);
|
|
2030
|
+
if (info.kind !== "keyword")
|
|
2031
|
+
throw new SmtParseError("invalid command argument, keyword expected", info);
|
|
2032
|
+
printInfo(list, info.text);
|
|
2033
|
+
checkArgumentCount(list, 1);
|
|
2034
|
+
},
|
|
2035
|
+
],
|
|
2036
|
+
[
|
|
2037
|
+
"set-logic",
|
|
2038
|
+
(list) => {
|
|
2039
|
+
const logic = getFirstArgument(list);
|
|
2040
|
+
if (!isSymbol(logic))
|
|
2041
|
+
throw new SmtParseError("invalid command argument, symbol expected", logic);
|
|
2042
|
+
if (state.logic !== undefined)
|
|
2043
|
+
throw new SmtParseError("the logic has already been set", logic);
|
|
2044
|
+
if (state.assertions.length > 0)
|
|
2045
|
+
throw new SmtParseError("logic must be set before initialization", logic);
|
|
2046
|
+
if (!isSupportedLogic(logic.text)) {
|
|
2047
|
+
print("unsupported");
|
|
2048
|
+
printDiagnostic(
|
|
2049
|
+
`; ignoring unsupported logic ${logic.text} line: ${list.line} position: ${list.column}`,
|
|
2050
|
+
);
|
|
2051
|
+
checkArgumentCount(list, 1);
|
|
2052
|
+
return;
|
|
2053
|
+
}
|
|
2054
|
+
state.logic = logic.text;
|
|
2055
|
+
if (state.isProofsEnabled === undefined)
|
|
2056
|
+
state.reader = createSmtlibReader(state.manager, logic.text, settings.parserOptions);
|
|
2057
|
+
else {
|
|
2058
|
+
state.reader.restrictSorts(logic.text);
|
|
2059
|
+
// Deviation from Z3: its new solver starts without the open scopes, so it ignores their pop and keeps what they asserted.
|
|
2060
|
+
resetKernel();
|
|
2061
|
+
}
|
|
2062
|
+
if (settings.isPrintingSuccess) print("success");
|
|
2063
|
+
checkArgumentCount(list, 1);
|
|
2064
|
+
},
|
|
2065
|
+
],
|
|
2066
|
+
[
|
|
2067
|
+
"set-info",
|
|
2068
|
+
(list) => {
|
|
2069
|
+
const info = list.items[1];
|
|
2070
|
+
if (info === undefined)
|
|
2071
|
+
throw new SmtParseError("invalid command, argument(s) missing", list.end);
|
|
2072
|
+
if (info.kind !== "keyword")
|
|
2073
|
+
throw new SmtParseError("invalid command argument, keyword expected", info);
|
|
2074
|
+
const value = list.items[2];
|
|
2075
|
+
if (value === undefined)
|
|
2076
|
+
throw new SmtParseError("invalid command, argument(s) missing", list.end);
|
|
2077
|
+
if (value.kind === "list" || value.kind === "keyword" || value.kind === "eof")
|
|
2078
|
+
throw new SmtParseError("invalid option value", value);
|
|
2079
|
+
if (info.text === ":status" && value.kind === "symbol") {
|
|
2080
|
+
const status = [L_TRUE, L_FALSE, L_UNDEF].find(
|
|
2081
|
+
(innerStatus) => getVerdict(innerStatus) === value.text,
|
|
2082
|
+
);
|
|
2083
|
+
if (status === undefined) throw new SmtParseError("invalid ':status' attribute", value);
|
|
2084
|
+
settings.status = status;
|
|
2085
|
+
}
|
|
2086
|
+
if (list.items[3] !== undefined)
|
|
2087
|
+
throw new SmtParseError("invalid command, too many arguments", list.items[3]);
|
|
2088
|
+
},
|
|
2089
|
+
],
|
|
2090
|
+
]);
|
|
2091
|
+
const run = (list: SmtList) => {
|
|
2092
|
+
const head = list.items[0];
|
|
2093
|
+
if (!isSymbol(head))
|
|
2094
|
+
throw new SmtParseError("invalid command, symbol expected", head ?? list.end);
|
|
2095
|
+
const command = DECLARATIONS.has(head.text)
|
|
2096
|
+
? (declaration: SmtList) => state.reader.declareCommand(declaration)
|
|
2097
|
+
: runCommand.get(head.text);
|
|
2098
|
+
if (command === undefined && UNPORTED_COMMANDS.has(head.text))
|
|
2099
|
+
throw new SmtUnsupportedError(`the command ${head.text}`);
|
|
2100
|
+
if (command === undefined) {
|
|
2101
|
+
expectClosed(list);
|
|
2102
|
+
print("unsupported");
|
|
2103
|
+
printDiagnostic(`; ${head.text} line: ${list.end.line} position: ${list.end.column}`);
|
|
2104
|
+
return;
|
|
2105
|
+
}
|
|
2106
|
+
// Z3's scoped_timer ends with the command that set it, so a command starts without one.
|
|
2107
|
+
state.manager.limit.restart(Infinity);
|
|
2108
|
+
if (!MANAGERLESS_COMMANDS.has(head.text)) initManager();
|
|
2109
|
+
try {
|
|
2110
|
+
command(list);
|
|
2111
|
+
} catch (error) {
|
|
2112
|
+
if (!(error instanceof SmtDefaultError)) throw error;
|
|
2113
|
+
throw new SmtParseError(error.message, list.end);
|
|
2114
|
+
}
|
|
2115
|
+
if (settings.isPrintingSuccess && SILENT_COMMANDS.has(head.text)) print("success");
|
|
2116
|
+
};
|
|
2117
|
+
for (;;) {
|
|
2118
|
+
try {
|
|
2119
|
+
const list = commands.readCommand();
|
|
2120
|
+
if (list === undefined) break;
|
|
2121
|
+
if (isSymbol(list.items[0], "exit")) {
|
|
2122
|
+
checkArgumentCount(list, 0);
|
|
2123
|
+
if (settings.isPrintingSuccess) print("success");
|
|
2124
|
+
break;
|
|
2125
|
+
}
|
|
2126
|
+
run(list);
|
|
2127
|
+
} catch (error) {
|
|
2128
|
+
if (!(error instanceof SmtParseError)) throw error;
|
|
2129
|
+
report(error);
|
|
2130
|
+
if (settings.isExitingOnError) break;
|
|
2131
|
+
state.reader.reset();
|
|
2132
|
+
commands.skip(report);
|
|
2133
|
+
}
|
|
2134
|
+
}
|
|
2135
|
+
if (pendingText !== "") printLine(pendingText);
|
|
2136
|
+
};
|