tla-ts 0.0.3 → 0.0.4-dev.1a3acf6
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 +46 -115
- package/dist/cli.cjs +1 -1
- package/dist/cli.js +1 -1
- package/dist/deciders.cjs +366 -0
- package/dist/deciders.js +366 -0
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +194 -8
- package/dist/index.d.ts +194 -8
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -4
- package/dist/parallel-worker.js +1 -4
- package/dist/prove-worker.cjs +9 -0
- package/dist/prove-worker.d.cts +9 -0
- package/dist/prove-worker.d.ts +9 -0
- package/dist/prove-worker.js +9 -0
- package/dist/prove.cjs +1006 -0
- package/dist/prove.js +1006 -0
- package/dist/run.cjs +45 -0
- package/dist/run.js +45 -0
- package/dist/tlapm.cjs +10 -0
- package/dist/tlapm.js +10 -0
- package/dist/transfer.cjs +1377 -18
- package/dist/transfer.js +1377 -18
- package/dist/worker.cjs +21 -0
- package/dist/worker.js +21 -0
- package/package.json +24 -11
- package/src/ast.ts +149 -8
- package/src/bags.ts +26 -30
- package/src/builtins.ts +45 -19
- package/src/bundled-modules.ts +3 -3
- package/src/check.ts +1182 -900
- package/src/cli/options.ts +109 -0
- package/src/cli/run.ts +63 -0
- package/src/cli/shared.ts +106 -0
- package/src/cli/tlapm.ts +374 -0
- package/src/cli/tlc.ts +941 -0
- package/src/cli/xml-exporter.ts +221 -0
- package/src/cli.ts +9 -2
- package/src/codegen.ts +112 -51
- package/src/config.ts +254 -181
- package/src/dependencies.ts +5 -7
- package/src/environment.ts +579 -184
- package/src/errors.ts +287 -4
- package/src/evaluate.ts +1095 -365
- package/src/exit-codes.ts +22 -43
- package/src/fingerprints.ts +49 -14
- package/src/index.ts +11 -0
- package/src/instances.ts +73 -60
- package/src/java-overrides.ts +183 -66
- package/src/json.ts +31 -36
- package/src/levels.ts +197 -54
- package/src/lexer.ts +127 -30
- package/src/liveness-checker.ts +894 -0
- package/src/liveness.ts +246 -596
- package/src/{obligation-action.ts → obligations/action.ts} +248 -74
- package/src/{obligation-anon.ts → obligations/anonymize.ts} +55 -57
- package/src/obligations/equality.ts +260 -0
- package/src/obligations/expression.ts +618 -0
- package/src/{obligation-format.ts → obligations/format.ts} +7 -8
- package/src/obligations/generate.ts +457 -0
- package/src/{obligations.ts → obligations/index.ts} +46 -32
- package/src/{obligation-levels.ts → obligations/levels.ts} +44 -40
- package/src/obligations/module.ts +445 -0
- package/src/obligations/normalize.ts +554 -0
- package/src/obligations/operators.ts +176 -0
- package/src/obligations/pragma.ts +195 -0
- package/src/{obligation-printer.ts → obligations/printer.ts} +65 -230
- package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
- package/src/obligations/regroup.ts +100 -0
- package/src/{obligation-generate.ts → obligations/simplify.ts} +130 -536
- package/src/{obligation-source.ts → obligations/source.ts} +174 -216
- package/src/{obligation-deref.ts → obligations/subexpression.ts} +84 -115
- package/src/obligations/substitution.ts +261 -0
- package/src/obligations/temporal.ts +321 -0
- package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
- package/src/parallel-worker.ts +184 -235
- package/src/parallel.ts +156 -91
- package/src/parser.ts +490 -188
- package/src/pcal/ast.ts +755 -0
- package/src/pcal/parse.ts +1487 -0
- package/src/pcal/tokenize.ts +487 -0
- package/src/pcal/translate.ts +1151 -0
- package/src/pcal/validate.ts +444 -0
- package/src/prover/decide-pool.ts +95 -0
- package/src/prover/deciders.ts +33 -0
- package/src/prover/first-order.ts +175 -0
- package/src/prover/isabelle/LICENSE +36 -0
- package/src/prover/isabelle/LICENSE-tlapm +26 -0
- package/src/prover/isabelle/decide.ts +44 -0
- package/src/prover/isabelle/encode.ts +445 -0
- package/src/prover/isabelle/isar/inner-syntax.ts +579 -0
- package/src/prover/isabelle/isar/method.ts +367 -0
- package/src/prover/isabelle/isar/proof.ts +28 -0
- package/src/prover/isabelle/isar/statement.ts +57 -0
- package/src/prover/isabelle/isar/theory.ts +192 -0
- package/src/prover/isabelle/isar/type-check.ts +278 -0
- package/src/prover/isabelle/provers/blast/blast.ts +258 -0
- package/src/prover/isabelle/provers/blast/branch.ts +322 -0
- package/src/prover/isabelle/provers/blast/prove.ts +347 -0
- package/src/prover/isabelle/provers/blast/rules.ts +330 -0
- package/src/prover/isabelle/provers/blast/state.ts +180 -0
- package/src/prover/isabelle/provers/blast/term.ts +546 -0
- package/src/prover/isabelle/provers/clasimp.ts +150 -0
- package/src/prover/isabelle/provers/classical.ts +389 -0
- package/src/prover/isabelle/provers/hypsubst.ts +433 -0
- package/src/prover/isabelle/pure/bicompose.ts +174 -0
- package/src/prover/isabelle/pure/consts.ts +32 -0
- package/src/prover/isabelle/pure/conv.ts +79 -0
- package/src/prover/isabelle/pure/drule.ts +264 -0
- package/src/prover/isabelle/pure/envir.ts +331 -0
- package/src/prover/isabelle/pure/goal.ts +53 -0
- package/src/prover/isabelle/pure/interrupt.ts +16 -0
- package/src/prover/isabelle/pure/list.ts +12 -0
- package/src/prover/isabelle/pure/logic.ts +330 -0
- package/src/prover/isabelle/pure/name.ts +98 -0
- package/src/prover/isabelle/pure/net.ts +215 -0
- package/src/prover/isabelle/pure/object-logic.ts +41 -0
- package/src/prover/isabelle/pure/pattern.ts +631 -0
- package/src/prover/isabelle/pure/raw-simplifier.ts +338 -0
- package/src/prover/isabelle/pure/rewriter.ts +602 -0
- package/src/prover/isabelle/pure/search.ts +68 -0
- package/src/prover/isabelle/pure/seq.ts +133 -0
- package/src/prover/isabelle/pure/simplifier.ts +106 -0
- package/src/prover/isabelle/pure/table.ts +201 -0
- package/src/prover/isabelle/pure/tactic.ts +168 -0
- package/src/prover/isabelle/pure/tactical.ts +264 -0
- package/src/prover/isabelle/pure/term-ord.ts +105 -0
- package/src/prover/isabelle/pure/term.ts +688 -0
- package/src/prover/isabelle/pure/thm.ts +783 -0
- package/src/prover/isabelle/pure/type.ts +121 -0
- package/src/prover/isabelle/pure/unify.ts +753 -0
- package/src/prover/isabelle/pure/variable.ts +25 -0
- package/src/prover/isabelle/tla/classical-setup.ts +101 -0
- package/src/prover/isabelle/tla/context.ts +74 -0
- package/src/prover/isabelle/tla/logic-data.ts +5 -0
- package/src/prover/isabelle/tla/logic.ts +215 -0
- package/src/prover/isabelle/tla/simpdata.ts +241 -0
- package/src/prover/isabelle/tools/intuitionistic.ts +132 -0
- package/src/prover/ocaml.ts +22 -0
- package/src/prover/prep/action.ts +508 -0
- package/src/prover/prep/enabled-axioms.ts +189 -0
- package/src/prover/prep/fingerprint.ts +388 -0
- package/src/prover/prep/level-comparison.ts +529 -0
- package/src/prover/prep/md5.ts +60 -0
- package/src/prover/prep/methods.ts +221 -0
- package/src/prover/prep/normalize.ts +309 -0
- package/src/prover/prove-worker.ts +22 -0
- package/src/prover/prove.ts +492 -0
- package/src/prover/ptl/decide.ts +68 -0
- package/src/prover/ptl/encode.ts +244 -0
- package/src/prover/ptl/sat.ts +151 -0
- package/src/prover/ptl/tableau.ts +276 -0
- package/src/prover/smt/axioms.ts +209 -0
- package/src/prover/smt/context.ts +108 -0
- package/src/prover/smt/data.ts +636 -0
- package/src/prover/smt/encode.ts +275 -0
- package/src/prover/smt/extensionality.ts +65 -0
- package/src/prover/smt/flatten.ts +112 -0
- package/src/prover/smt/format.ts +154 -0
- package/src/prover/smt/instances.ts +181 -0
- package/src/prover/smt/rewrite.ts +766 -0
- package/src/prover/smt/solver/act-cache.ts +265 -0
- package/src/prover/smt/solver/arith-rewriter.ts +962 -0
- package/src/prover/smt/solver/array.ts +22 -0
- package/src/prover/smt/solver/asserted-formulas.ts +469 -0
- package/src/prover/smt/solver/ast-lt.ts +157 -0
- package/src/prover/smt/solver/ast-util.ts +91 -0
- package/src/prover/smt/solver/ast.ts +1315 -0
- package/src/prover/smt/solver/auf-solver.ts +572 -0
- package/src/prover/smt/solver/case-split-queue.ts +178 -0
- package/src/prover/smt/solver/cg-table.ts +175 -0
- package/src/prover/smt/solver/clause.ts +276 -0
- package/src/prover/smt/solver/conflict-resolution.ts +343 -0
- package/src/prover/smt/solver/context.ts +1292 -0
- package/src/prover/smt/solver/ctx-simplify.ts +334 -0
- package/src/prover/smt/solver/der.ts +224 -0
- package/src/prover/smt/solver/dyn-ack.ts +141 -0
- package/src/prover/smt/solver/e-matching.ts +659 -0
- package/src/prover/smt/solver/enode.ts +259 -0
- package/src/prover/smt/solver/expr-ref.ts +21 -0
- package/src/prover/smt/solver/expr-safe-replace.ts +172 -0
- package/src/prover/smt/solver/fingerprints.ts +92 -0
- package/src/prover/smt/solver/flat-literals.ts +51 -0
- package/src/prover/smt/solver/goal.ts +138 -0
- package/src/prover/smt/solver/hash.ts +173 -0
- package/src/prover/smt/solver/hashtable.ts +166 -0
- package/src/prover/smt/solver/internalizer.ts +1381 -0
- package/src/prover/smt/solver/lbool.ts +5 -0
- package/src/prover/smt/solver/literal.ts +24 -0
- package/src/prover/smt/solver/lp/bound-propagator.ts +391 -0
- package/src/prover/smt/solver/lp/constraints.ts +78 -0
- package/src/prover/smt/solver/lp/containers.ts +296 -0
- package/src/prover/smt/solver/lp/core-solver.ts +504 -0
- package/src/prover/smt/solver/lp/cross-nested.ts +224 -0
- package/src/prover/smt/solver/lp/dep-intervals.ts +642 -0
- package/src/prover/smt/solver/lp/dependency.ts +51 -0
- package/src/prover/smt/solver/lp/dioph-eq.ts +1181 -0
- package/src/prover/smt/solver/lp/explanation.ts +46 -0
- package/src/prover/smt/solver/lp/gomory.ts +255 -0
- package/src/prover/smt/solver/lp/hnf-cutter.ts +125 -0
- package/src/prover/smt/solver/lp/hnf.ts +281 -0
- package/src/prover/smt/solver/lp/int-cube.ts +295 -0
- package/src/prover/smt/solver/lp/int-solver.ts +514 -0
- package/src/prover/smt/solver/lp/lar-solver.ts +816 -0
- package/src/prover/smt/solver/lp/lar-term.ts +62 -0
- package/src/prover/smt/solver/lp/lp-settings.ts +91 -0
- package/src/prover/smt/solver/lp/maximize-term.ts +347 -0
- package/src/prover/smt/solver/lp/nex-creator.ts +381 -0
- package/src/prover/smt/solver/lp/nex.ts +120 -0
- package/src/prover/smt/solver/lp/nla-backoff.ts +43 -0
- package/src/prover/smt/solver/lp/nla-basics.ts +398 -0
- package/src/prover/smt/solver/lp/nla-core.ts +968 -0
- package/src/prover/smt/solver/lp/nla-divisions.ts +332 -0
- package/src/prover/smt/solver/lp/nla-emonics.ts +373 -0
- package/src/prover/smt/solver/lp/nla-factorization.ts +30 -0
- package/src/prover/smt/solver/lp/nla-grobner.ts +904 -0
- package/src/prover/smt/solver/lp/nla-horner.ts +126 -0
- package/src/prover/smt/solver/lp/nla-intervals.ts +265 -0
- package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +715 -0
- package/src/prover/smt/solver/lp/nla-monotone.ts +59 -0
- package/src/prover/smt/solver/lp/nla-order.ts +307 -0
- package/src/prover/smt/solver/lp/nla-patcher.ts +112 -0
- package/src/prover/smt/solver/lp/nla-tangents.ts +251 -0
- package/src/prover/smt/solver/lp/nla-throttle.ts +85 -0
- package/src/prover/smt/solver/lp/nla-types.ts +124 -0
- package/src/prover/smt/solver/lp/nla-var-eqs.ts +141 -0
- package/src/prover/smt/solver/lp/nra-solver.ts +440 -0
- package/src/prover/smt/solver/lp/numeric-pair.ts +65 -0
- package/src/prover/smt/solver/lp/pdd-interval.ts +31 -0
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +184 -0
- package/src/prover/smt/solver/lp/pdd-solver.ts +408 -0
- package/src/prover/smt/solver/lp/pdd.ts +971 -0
- package/src/prover/smt/solver/lp/random-updater.ts +138 -0
- package/src/prover/smt/solver/lp/static-matrix.ts +246 -0
- package/src/prover/smt/solver/lp/union-find.ts +96 -0
- package/src/prover/smt/solver/mam-compiler.ts +847 -0
- package/src/prover/smt/solver/mam-interpreter.ts +400 -0
- package/src/prover/smt/solver/maximize-ac-sharing.ts +118 -0
- package/src/prover/smt/solver/model-checker.ts +347 -0
- package/src/prover/smt/solver/model-evaluator.ts +262 -0
- package/src/prover/smt/solver/model-finder.ts +155 -0
- package/src/prover/smt/solver/model-generator.ts +97 -0
- package/src/prover/smt/solver/model-macro-solver.ts +728 -0
- package/src/prover/smt/solver/nlsat/algebraic.ts +1161 -0
- package/src/prover/smt/solver/nlsat/atoms.ts +238 -0
- package/src/prover/smt/solver/nlsat/evaluator.ts +303 -0
- package/src/prover/smt/solver/nlsat/explain.ts +607 -0
- package/src/prover/smt/solver/nlsat/interval-set.ts +351 -0
- package/src/prover/smt/solver/nlsat/levelwise.ts +737 -0
- package/src/prover/smt/solver/nlsat/mpbq.ts +161 -0
- package/src/prover/smt/solver/nlsat/polynomial.ts +1722 -0
- package/src/prover/smt/solver/nlsat/solver.ts +911 -0
- package/src/prover/smt/solver/nlsat/types.ts +43 -0
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
- package/src/prover/smt/solver/nlsat/upolynomial.ts +996 -0
- package/src/prover/smt/solver/nnf.ts +469 -0
- package/src/prover/smt/solver/pattern-inference.ts +351 -0
- package/src/prover/smt/solver/poly-rewriter.ts +477 -0
- package/src/prover/smt/solver/propagate-values.ts +83 -0
- package/src/prover/smt/solver/proto-model.ts +551 -0
- package/src/prover/smt/solver/pull-quant.ts +139 -0
- package/src/prover/smt/solver/qe-lite-der.ts +526 -0
- package/src/prover/smt/solver/qe-lite-fm.ts +576 -0
- package/src/prover/smt/solver/qe-lite.ts +381 -0
- package/src/prover/smt/solver/qi-queue.ts +362 -0
- package/src/prover/smt/solver/quant-tactics.ts +117 -0
- package/src/prover/smt/solver/quantifier-analyzer.ts +562 -0
- package/src/prover/smt/solver/quantifier-manager.ts +186 -0
- package/src/prover/smt/solver/random-gen.ts +10 -0
- package/src/prover/smt/solver/rational.ts +165 -0
- package/src/prover/smt/solver/ref-vector.ts +62 -0
- package/src/prover/smt/solver/relevancy.ts +247 -0
- package/src/prover/smt/solver/rewriter-tpl.ts +1159 -0
- package/src/prover/smt/solver/rewriter.ts +843 -0
- package/src/prover/smt/solver/rlimit.ts +79 -0
- package/src/prover/smt/solver/smtlib-parser.ts +526 -0
- package/src/prover/smt/solver/solver.ts +71 -0
- package/src/prover/smt/solver/sort.ts +35 -0
- package/src/prover/smt/solver/sticky-generations.ts +69 -0
- package/src/prover/smt/solver/theory-lra-axioms.ts +340 -0
- package/src/prover/smt/solver/theory-lra-bounds.ts +226 -0
- package/src/prover/smt/solver/theory-lra-final-check.ts +252 -0
- package/src/prover/smt/solver/theory-lra-internalize.ts +476 -0
- package/src/prover/smt/solver/theory-lra-model.ts +243 -0
- package/src/prover/smt/solver/theory-lra-propagate.ts +405 -0
- package/src/prover/smt/solver/theory-lra-state.ts +43 -0
- package/src/prover/smt/solver/theory-lra.ts +56 -0
- package/src/prover/smt/solver/var-subst.ts +258 -0
- package/src/prover/smt/solver/z3-license.txt +10 -0
- package/src/prover/smt/table.ts +170 -0
- package/src/prover/tlapm/cache.ts +236 -0
- package/src/prover/tlapm/ocaml-marshal.ts +166 -0
- package/src/prover/tlapm/tlapm.ts +96 -0
- package/src/prover/tlaps-module.ts +510 -0
- package/src/prover/verdict.ts +13 -0
- package/src/prover/zenon/LICENSE +32 -0
- package/src/prover/zenon/check/check.ts +105 -0
- package/src/prover/zenon/check/definitions.ts +144 -0
- package/src/prover/zenon/check/equality.ts +182 -0
- package/src/prover/zenon/check/functions.ts +62 -0
- package/src/prover/zenon/check/keys.ts +125 -0
- package/src/prover/zenon/check/propositional.ts +104 -0
- package/src/prover/zenon/check/records.ts +188 -0
- package/src/prover/zenon/check/relations.ts +121 -0
- package/src/prover/zenon/check/rewrites.ts +224 -0
- package/src/prover/zenon/check/sets.ts +302 -0
- package/src/prover/zenon/check/terms.ts +127 -0
- package/src/prover/zenon/check/tla.ts +126 -0
- package/src/prover/zenon/decide.ts +107 -0
- package/src/prover/zenon/encode.ts +378 -0
- package/src/prover/zenon/eqrel.ts +300 -0
- package/src/prover/zenon/equality-rules.ts +435 -0
- package/src/prover/zenon/expr.ts +551 -0
- package/src/prover/zenon/index-table.ts +350 -0
- package/src/prover/zenon/isar-case.ts +513 -0
- package/src/prover/zenon/isar.ts +1249 -0
- package/src/prover/zenon/limits.ts +15 -0
- package/src/prover/zenon/llproof.ts +173 -0
- package/src/prover/zenon/mltoll.ts +1566 -0
- package/src/prover/zenon/node.ts +297 -0
- package/src/prover/zenon/ocaml.ts +169 -0
- package/src/prover/zenon/parse.ts +247 -0
- package/src/prover/zenon/phrase.ts +191 -0
- package/src/prover/zenon/proof.ts +198 -0
- package/src/prover/zenon/propositional-rules.ts +387 -0
- package/src/prover/zenon/rules.ts +94 -0
- package/src/prover/zenon/search.ts +288 -0
- package/src/prover/zenon/tla/functions.ts +151 -0
- package/src/prover/zenon/tla/llproof.ts +480 -0
- package/src/prover/zenon/tla/records.ts +225 -0
- package/src/prover/zenon/tla/rewrites.ts +447 -0
- package/src/prover/zenon/tla/sets.ts +304 -0
- package/src/prover/zenon/tla/terms.ts +162 -0
- package/src/prover/zenon/tla/tla.ts +506 -0
- package/src/randomization.ts +39 -27
- package/src/resolve.ts +1474 -426
- package/src/runtime.ts +25 -7
- package/src/sany/builtins.ts +147 -0
- package/src/sany/generator.ts +3111 -0
- package/src/sany/levels.ts +1205 -0
- package/src/sany/lexer.ts +544 -0
- package/src/sany/linter.ts +122 -0
- package/src/sany/modules.ts +1398 -0
- package/src/sany/nodes.ts +463 -0
- package/src/sany/parse-error.ts +2161 -0
- package/src/sany/report.ts +355 -0
- package/src/sany/selectors.ts +736 -0
- package/src/sany/source.ts +247 -0
- package/src/sany/xml.ts +1016 -0
- package/src/search.ts +969 -0
- package/src/spec-description.ts +66 -29
- package/src/{standard-levels.ts → standard-definitions.ts} +118 -2
- package/src/standard-modules.ts +215 -164
- package/src/state-graph.ts +181 -0
- package/src/subexpressions.ts +231 -171
- package/src/substitution-levels.ts +40 -19
- package/src/successors.ts +253 -125
- package/src/symmetry.ts +194 -54
- package/src/tableau.ts +60 -32
- package/src/tlc/fingerprint.ts +214 -0
- package/src/{tlc-modules.ts → tlc/jar-data.ts} +4 -0
- package/src/tlc/messages.ts +441 -0
- package/src/{tlc-order.ts → tlc/order.ts} +84 -16
- package/src/{tlc-random.ts → tlc/random.ts} +30 -189
- package/src/tlc/replay.ts +659 -0
- package/src/{tlc-summary.ts → tlc/summary.ts} +20 -5
- package/src/{tlc-module.ts → tlc/tlc-operators.ts} +59 -50
- package/src/{tlc-ext.ts → tlc/tlcext-operators.ts} +63 -45
- package/src/tlc/version.ts +19 -0
- package/src/transfer.ts +44 -32
- package/src/values.ts +843 -241
- package/src/worker.ts +62 -0
- package/dist/parallel.cjs +0 -12
- package/dist/parallel.js +0 -12
- package/dist/run-cli.cjs +0 -28
- package/dist/run-cli.js +0 -28
- package/src/canonical.ts +0 -39
- package/src/cli-options.ts +0 -58
- package/src/obligation-expression.ts +0 -1060
- package/src/obligation-module.ts +0 -1042
- package/src/run-cli.ts +0 -478
|
@@ -0,0 +1,79 @@
|
|
|
1
|
+
// Ported from Z3 (src/util/rlimit.h, src/util/rlimit.cpp, src/util/memory_manager.cpp), MIT
|
|
2
|
+
// license, see z3-license.txt. The resource limit of an ast_manager, shared by every context and
|
|
3
|
+
// rewriter that uses the manager. It cancels the work at the deadline, in milliseconds since the
|
|
4
|
+
// epoch, when the signal aborts, or when the heap is nearly full.
|
|
5
|
+
import type { GCProfiler } from "node:v8";
|
|
6
|
+
import { SmtCanceledError } from "../../../errors";
|
|
7
|
+
|
|
8
|
+
export class ResourceLimit {
|
|
9
|
+
// m_count: the steps taken, which MBQI also uses as a random seed.
|
|
10
|
+
count = 0;
|
|
11
|
+
private isCanceled = false;
|
|
12
|
+
// Watches for a full collection while the used size is past the threshold.
|
|
13
|
+
private profiler: GCProfiler | null = null;
|
|
14
|
+
|
|
15
|
+
constructor(
|
|
16
|
+
private deadline: number,
|
|
17
|
+
private signal?: AbortSignal,
|
|
18
|
+
) {}
|
|
19
|
+
|
|
20
|
+
// inc: counts a step and returns whether the work may go on. The clock and the heap are read on
|
|
21
|
+
// every 256th step, since a step costs less than reading them. A step can allocate kilobytes, so
|
|
22
|
+
// reading the heap less often lets it fill between two readings.
|
|
23
|
+
inc() {
|
|
24
|
+
this.count++;
|
|
25
|
+
if (
|
|
26
|
+
!this.isCanceled &&
|
|
27
|
+
(this.count & CLOCK_CHECK_MASK) === 0 &&
|
|
28
|
+
(Date.now() > this.deadline || this.signal?.aborted === true || this.isHeapNearlyFull())
|
|
29
|
+
) {
|
|
30
|
+
this.isCanceled = true;
|
|
31
|
+
this.release();
|
|
32
|
+
}
|
|
33
|
+
return !this.isCanceled;
|
|
34
|
+
}
|
|
35
|
+
|
|
36
|
+
// tactic::checkpoint: counts a step, and throws once the work is canceled.
|
|
37
|
+
checkpoint() {
|
|
38
|
+
if (!this.inc()) throw new SmtCanceledError();
|
|
39
|
+
}
|
|
40
|
+
|
|
41
|
+
// The used size counts garbage, such as what earlier work left, until the collector runs. So once
|
|
42
|
+
// it passes the threshold, the size after the next full collection decides.
|
|
43
|
+
private isHeapNearlyFull() {
|
|
44
|
+
if (v8 === undefined) return false;
|
|
45
|
+
const statistics = v8.getHeapStatistics();
|
|
46
|
+
const threshold = HEAP_FRACTION * (statistics.used_heap_size + statistics.total_available_size);
|
|
47
|
+
if (statistics.used_heap_size <= threshold) {
|
|
48
|
+
this.release();
|
|
49
|
+
return false;
|
|
50
|
+
}
|
|
51
|
+
if (this.profiler === null) {
|
|
52
|
+
this.profiler = new v8.GCProfiler();
|
|
53
|
+
this.profiler.start();
|
|
54
|
+
return false;
|
|
55
|
+
}
|
|
56
|
+
const collection = this.profiler
|
|
57
|
+
.stop()
|
|
58
|
+
.statistics.findLast((event) => event.gcType === "MarkSweepCompact");
|
|
59
|
+
this.profiler.start();
|
|
60
|
+
if (collection === undefined) return false;
|
|
61
|
+
this.release();
|
|
62
|
+
return collection.afterGC.heapStatistics.usedHeapSize > threshold;
|
|
63
|
+
}
|
|
64
|
+
|
|
65
|
+
// Stops watching the collector, which the work does when it ends.
|
|
66
|
+
release() {
|
|
67
|
+
this.profiler?.stop();
|
|
68
|
+
this.profiler = null;
|
|
69
|
+
}
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
// Z3 runs as its own process, where running out of memory ends only that process and tlapm counts
|
|
73
|
+
// the obligation as failed. The solver shares its caller's process instead, which running out of
|
|
74
|
+
// heap would end, so it stops before the heap fills, like Z3's max_memory in memory::allocate. The
|
|
75
|
+
// heap statistics come from node:v8. In V8, which Node and Deno use, the used and the available
|
|
76
|
+
// size add up to the heap limit. Bun reports the memory of the machine and no full collections.
|
|
77
|
+
const HEAP_FRACTION = 0.8;
|
|
78
|
+
const CLOCK_CHECK_MASK = 255;
|
|
79
|
+
const v8 = typeof process === "undefined" ? undefined : process.getBuiltinModule?.("node:v8");
|
|
@@ -0,0 +1,526 @@
|
|
|
1
|
+
// Ported from Z3 (src/parsers/smt2/smt2parser.cpp), MIT license, see z3-license.txt.
|
|
2
|
+
// Parses the SMT-LIB subset that tlapm emits into Z3-style expressions.
|
|
3
|
+
import { SmtParseError, SmtUnsupportedError } from "../../../errors";
|
|
4
|
+
import {
|
|
5
|
+
AstManager,
|
|
6
|
+
FAMILY_ARITH,
|
|
7
|
+
FAMILY_BASIC,
|
|
8
|
+
KIND_QUANTIFIER,
|
|
9
|
+
KIND_VAR,
|
|
10
|
+
OP_ABS,
|
|
11
|
+
OP_ADD,
|
|
12
|
+
OP_AND,
|
|
13
|
+
OP_DISTINCT,
|
|
14
|
+
OP_DIV,
|
|
15
|
+
OP_EQ,
|
|
16
|
+
OP_GE,
|
|
17
|
+
OP_GT,
|
|
18
|
+
OP_IDIV,
|
|
19
|
+
OP_IMPLIES,
|
|
20
|
+
OP_IS_INT,
|
|
21
|
+
OP_ITE,
|
|
22
|
+
OP_LE,
|
|
23
|
+
OP_LT,
|
|
24
|
+
OP_MOD,
|
|
25
|
+
OP_MUL,
|
|
26
|
+
OP_NOT,
|
|
27
|
+
OP_OR,
|
|
28
|
+
OP_SUB,
|
|
29
|
+
OP_TO_INT,
|
|
30
|
+
OP_TO_REAL,
|
|
31
|
+
OP_TRUE,
|
|
32
|
+
OP_FALSE,
|
|
33
|
+
OP_UMINUS,
|
|
34
|
+
OP_UNINTERPRETED,
|
|
35
|
+
OP_XOR,
|
|
36
|
+
SORT_BOOL,
|
|
37
|
+
SORT_INT,
|
|
38
|
+
SORT_REAL,
|
|
39
|
+
isArithSort,
|
|
40
|
+
} from "./ast";
|
|
41
|
+
import { Rational } from "./rational";
|
|
42
|
+
import { replaceFreeVars } from "./var-subst";
|
|
43
|
+
|
|
44
|
+
type SExpr = string | SExpr[];
|
|
45
|
+
|
|
46
|
+
// A name in scope: a variable bound by a quantifier, or a let binding's term. depth is the number of
|
|
47
|
+
// binders above it.
|
|
48
|
+
type Binding =
|
|
49
|
+
| { kind: "var"; depth: number; sort: number }
|
|
50
|
+
| { kind: "let"; depth: number; expr: number };
|
|
51
|
+
|
|
52
|
+
interface SmtProblem {
|
|
53
|
+
assertions: number[];
|
|
54
|
+
// Z3 prints no answer for a script without check-sat.
|
|
55
|
+
hasCheckSat: boolean;
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
// An application that parseTerm is parsing: its name, its list, where its arguments start on the
|
|
59
|
+
// result stack, and its next argument.
|
|
60
|
+
interface ApplicationFrame {
|
|
61
|
+
name: string;
|
|
62
|
+
list: SExpr[];
|
|
63
|
+
start: number;
|
|
64
|
+
next: number;
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
const BUILTIN_OPS = new Map<string, number>([
|
|
68
|
+
["and", OP_AND],
|
|
69
|
+
["or", OP_OR],
|
|
70
|
+
["not", OP_NOT],
|
|
71
|
+
["=>", OP_IMPLIES],
|
|
72
|
+
["xor", OP_XOR],
|
|
73
|
+
["ite", OP_ITE],
|
|
74
|
+
["distinct", OP_DISTINCT],
|
|
75
|
+
["+", OP_ADD],
|
|
76
|
+
["*", OP_MUL],
|
|
77
|
+
["/", OP_DIV],
|
|
78
|
+
["div", OP_IDIV],
|
|
79
|
+
["mod", OP_MOD],
|
|
80
|
+
["abs", OP_ABS],
|
|
81
|
+
["to_real", OP_TO_REAL],
|
|
82
|
+
["to_int", OP_TO_INT],
|
|
83
|
+
["is_int", OP_IS_INT],
|
|
84
|
+
]);
|
|
85
|
+
|
|
86
|
+
// arith_decl_plugin's use_coercion: the operators that are Real when any argument is Real.
|
|
87
|
+
const COERCING_OPS = new Set([OP_ADD, OP_SUB, OP_UMINUS, OP_MUL, OP_LE, OP_GE, OP_LT, OP_GT]);
|
|
88
|
+
|
|
89
|
+
const DECIMAL = /^([0-9]+)\.([0-9]+)$/;
|
|
90
|
+
|
|
91
|
+
const CHAINABLE_OPS = new Map<string, number>([
|
|
92
|
+
["=", OP_EQ],
|
|
93
|
+
["<=", OP_LE],
|
|
94
|
+
[">=", OP_GE],
|
|
95
|
+
["<", OP_LT],
|
|
96
|
+
[">", OP_GT],
|
|
97
|
+
]);
|
|
98
|
+
|
|
99
|
+
const tokenize = (text: string) => {
|
|
100
|
+
const tokens: string[] = [];
|
|
101
|
+
let position = 0;
|
|
102
|
+
while (position < text.length) {
|
|
103
|
+
const char = text[position];
|
|
104
|
+
if (char === ";") {
|
|
105
|
+
const end = text.indexOf("\n", position);
|
|
106
|
+
position = end === -1 ? text.length : end + 1;
|
|
107
|
+
} else if (char === "(" || char === ")") {
|
|
108
|
+
tokens.push(char);
|
|
109
|
+
position++;
|
|
110
|
+
} else if (char === " " || char === "\n" || char === "\t" || char === "\r") {
|
|
111
|
+
position++;
|
|
112
|
+
} else if (char === "|") {
|
|
113
|
+
const end = text.indexOf("|", position + 1);
|
|
114
|
+
if (end === -1) throw new SmtParseError("unterminated quoted symbol");
|
|
115
|
+
tokens.push(text.slice(position + 1, end));
|
|
116
|
+
position = end + 1;
|
|
117
|
+
} else if (char === '"') {
|
|
118
|
+
let end = position + 1;
|
|
119
|
+
while (end < text.length && (text[end] !== '"' || text[end + 1] === '"'))
|
|
120
|
+
end += text[end] === '"' ? 2 : 1;
|
|
121
|
+
tokens.push(text.slice(position, end + 1));
|
|
122
|
+
position = end + 1;
|
|
123
|
+
} else {
|
|
124
|
+
let end = position;
|
|
125
|
+
while (end < text.length && !' \n\t\r();|"'.includes(text[end])) end++;
|
|
126
|
+
tokens.push(text.slice(position, end));
|
|
127
|
+
position = end;
|
|
128
|
+
}
|
|
129
|
+
}
|
|
130
|
+
return tokens;
|
|
131
|
+
};
|
|
132
|
+
|
|
133
|
+
const readSExprs = (tokens: string[]) => {
|
|
134
|
+
const stack: SExpr[][] = [[]];
|
|
135
|
+
for (const token of tokens) {
|
|
136
|
+
if (token === "(") stack.push([]);
|
|
137
|
+
else if (token === ")") {
|
|
138
|
+
const list = stack.pop();
|
|
139
|
+
if (list === undefined || stack.length === 0)
|
|
140
|
+
throw new SmtParseError("unbalanced parentheses");
|
|
141
|
+
stack[stack.length - 1].push(list);
|
|
142
|
+
} else stack[stack.length - 1].push(token);
|
|
143
|
+
}
|
|
144
|
+
if (stack.length !== 1) throw new SmtParseError("unbalanced parentheses");
|
|
145
|
+
return stack[0];
|
|
146
|
+
};
|
|
147
|
+
|
|
148
|
+
const expectList = (sexpr: SExpr | undefined): SExpr[] => {
|
|
149
|
+
if (!Array.isArray(sexpr)) throw new SmtParseError("expected a list");
|
|
150
|
+
return sexpr;
|
|
151
|
+
};
|
|
152
|
+
|
|
153
|
+
const expectSymbol = (sexpr: SExpr | undefined): string => {
|
|
154
|
+
if (typeof sexpr !== "string") throw new SmtParseError("expected a symbol");
|
|
155
|
+
return sexpr;
|
|
156
|
+
};
|
|
157
|
+
|
|
158
|
+
// Parses a script, and hands each assertion to assertExpr as Z3's cmd_context does, before it parses
|
|
159
|
+
// the next command. Expressions are created in the order of Z3's parser, and live as long as there.
|
|
160
|
+
export const parseSmtlib = (
|
|
161
|
+
text: string,
|
|
162
|
+
manager: AstManager,
|
|
163
|
+
assertExpr: (assertion: number) => void,
|
|
164
|
+
): SmtProblem => {
|
|
165
|
+
const sorts = new Map<string, number>([
|
|
166
|
+
["Bool", SORT_BOOL],
|
|
167
|
+
["Int", SORT_INT],
|
|
168
|
+
["Real", SORT_REAL],
|
|
169
|
+
]);
|
|
170
|
+
const funcs = new Map<string, number>();
|
|
171
|
+
const assertions: number[] = [];
|
|
172
|
+
const scopes: Map<string, Binding>[] = [];
|
|
173
|
+
let depth = 0;
|
|
174
|
+
|
|
175
|
+
const parseSort = (sexpr: SExpr) => {
|
|
176
|
+
const sort = sorts.get(expectSymbol(sexpr));
|
|
177
|
+
if (sort === undefined) throw new SmtParseError(`unknown sort ${String(sexpr)}`);
|
|
178
|
+
return sort;
|
|
179
|
+
};
|
|
180
|
+
|
|
181
|
+
const lookup = (name: string) => {
|
|
182
|
+
for (let index = scopes.length - 1; index >= 0; index--) {
|
|
183
|
+
const binding = scopes[index].get(name);
|
|
184
|
+
if (binding !== undefined) return binding;
|
|
185
|
+
}
|
|
186
|
+
return undefined;
|
|
187
|
+
};
|
|
188
|
+
|
|
189
|
+
// basic_decl_plugin::join: Int and Real join to Real. Other sorts join only with themselves.
|
|
190
|
+
const getJoin = (args: number[]) => {
|
|
191
|
+
const argSorts = args.map((arg) => manager.sorts[arg]);
|
|
192
|
+
if (!argSorts.every(isArithSort)) return argSorts[0];
|
|
193
|
+
return argSorts.includes(SORT_REAL) ? SORT_REAL : SORT_INT;
|
|
194
|
+
};
|
|
195
|
+
|
|
196
|
+
// The sort of the arguments of a builtin, as Z3's decl plugins pick its declaration.
|
|
197
|
+
const getDomainSort = (op: number, args: number[]) => {
|
|
198
|
+
if (op === OP_ITE) return getJoin(args.slice(1));
|
|
199
|
+
if (op === OP_EQ || op === OP_DISTINCT) return getJoin(args);
|
|
200
|
+
if (COERCING_OPS.has(op)) return getJoin(args) === SORT_REAL ? SORT_REAL : SORT_INT;
|
|
201
|
+
if (op === OP_ABS || op === OP_TO_REAL || op === OP_TO_INT) return manager.sorts[args[0]];
|
|
202
|
+
if (op === OP_IDIV || op === OP_MOD) return SORT_INT;
|
|
203
|
+
if (op === OP_DIV || op === OP_IS_INT) return SORT_REAL;
|
|
204
|
+
return SORT_BOOL;
|
|
205
|
+
};
|
|
206
|
+
|
|
207
|
+
const getRange = (op: number, domainSort: number) =>
|
|
208
|
+
op === OP_TO_REAL || op === OP_DIV
|
|
209
|
+
? SORT_REAL
|
|
210
|
+
: op === OP_TO_INT || op === OP_IDIV || op === OP_MOD
|
|
211
|
+
? SORT_INT
|
|
212
|
+
: op === OP_ITE ||
|
|
213
|
+
op === OP_ABS ||
|
|
214
|
+
op === OP_ADD ||
|
|
215
|
+
op === OP_SUB ||
|
|
216
|
+
op === OP_UMINUS ||
|
|
217
|
+
op === OP_MUL
|
|
218
|
+
? domainSort
|
|
219
|
+
: SORT_BOOL;
|
|
220
|
+
|
|
221
|
+
// ast_manager::coerce_to: an Int argument of a Real position becomes to_real, and a Real argument
|
|
222
|
+
// of an Int position to_int.
|
|
223
|
+
const coerce = (arg: number, sort: number) => {
|
|
224
|
+
const argSort = manager.sorts[arg];
|
|
225
|
+
if (argSort === sort || !isArithSort(argSort) || !isArithSort(sort)) return arg;
|
|
226
|
+
return sort === SORT_REAL
|
|
227
|
+
? manager.mkApp(OP_TO_REAL, [arg], SORT_REAL)
|
|
228
|
+
: manager.mkApp(OP_TO_INT, [arg], SORT_INT);
|
|
229
|
+
};
|
|
230
|
+
|
|
231
|
+
// Coerces the arguments of an application to the sorts of its declaration, as Z3 does with its
|
|
232
|
+
// default int_real_coercions, then checks their sorts and number, so the solver only sees
|
|
233
|
+
// well-sorted terms, and that quantifiers occur only under Boolean connectives.
|
|
234
|
+
const mkApp = (decl: number, inputArgs: number[], domainSort?: number) => {
|
|
235
|
+
const op = manager.funcDecls[decl].op;
|
|
236
|
+
const name = manager.funcDecls[decl].name;
|
|
237
|
+
const isUninterpreted = op === OP_UNINTERPRETED;
|
|
238
|
+
const domain = manager.funcDecls[decl].domain;
|
|
239
|
+
const builtinSort = isUninterpreted ? -1 : (domainSort ?? getDomainSort(op, inputArgs));
|
|
240
|
+
const getExpected = (index: number) =>
|
|
241
|
+
isUninterpreted ? domain[index] : op === OP_ITE && index === 0 ? SORT_BOOL : builtinSort;
|
|
242
|
+
const args = inputArgs.map((arg, index) =>
|
|
243
|
+
getExpected(index) === undefined ? arg : coerce(arg, getExpected(index)),
|
|
244
|
+
);
|
|
245
|
+
const isArity = (min: number, max: number) => args.length >= min && args.length <= max;
|
|
246
|
+
const isArityOk = isUninterpreted
|
|
247
|
+
? args.length === domain.length
|
|
248
|
+
: op === OP_AND || op === OP_OR
|
|
249
|
+
? true
|
|
250
|
+
: op === OP_ITE
|
|
251
|
+
? isArity(3, 3)
|
|
252
|
+
: op === OP_EQ || op === OP_DISTINCT
|
|
253
|
+
? isArity(2, Infinity)
|
|
254
|
+
: op === OP_NOT ||
|
|
255
|
+
op === OP_UMINUS ||
|
|
256
|
+
op === OP_ABS ||
|
|
257
|
+
op === OP_TO_REAL ||
|
|
258
|
+
op === OP_TO_INT ||
|
|
259
|
+
op === OP_IS_INT
|
|
260
|
+
? isArity(1, 1)
|
|
261
|
+
: op === OP_IMPLIES ||
|
|
262
|
+
op === OP_XOR ||
|
|
263
|
+
op === OP_IDIV ||
|
|
264
|
+
op === OP_MOD ||
|
|
265
|
+
op === OP_DIV ||
|
|
266
|
+
op === OP_LE ||
|
|
267
|
+
op === OP_GE ||
|
|
268
|
+
op === OP_LT ||
|
|
269
|
+
op === OP_GT
|
|
270
|
+
? isArity(2, 2)
|
|
271
|
+
: isArity(1, Infinity);
|
|
272
|
+
const isBuiltinArith = manager.funcDecls[decl].family === FAMILY_ARITH;
|
|
273
|
+
const isWellSorted =
|
|
274
|
+
isArityOk &&
|
|
275
|
+
(!isBuiltinArith || isArithSort(builtinSort)) &&
|
|
276
|
+
args.every((arg, index) => manager.sorts[arg] === getExpected(index));
|
|
277
|
+
if (!isWellSorted) throw new SmtParseError(`ill-sorted application of ${name}`);
|
|
278
|
+
return manager.mkApp(
|
|
279
|
+
decl,
|
|
280
|
+
args,
|
|
281
|
+
isUninterpreted ? manager.funcDecls[decl].range : getRange(op, builtinSort),
|
|
282
|
+
);
|
|
283
|
+
};
|
|
284
|
+
|
|
285
|
+
const mkChain = (op: number, args: number[]) => {
|
|
286
|
+
const domainSort = getDomainSort(op, args);
|
|
287
|
+
const pairs: number[] = [];
|
|
288
|
+
for (let index = 0; index + 1 < args.length; index++)
|
|
289
|
+
pairs.push(mkApp(op, [args[index], args[index + 1]], domainSort));
|
|
290
|
+
return pairs.length === 1 ? pairs[0] : mkApp(OP_AND, pairs);
|
|
291
|
+
};
|
|
292
|
+
|
|
293
|
+
const expectBool = (expr: number) => {
|
|
294
|
+
if (manager.sorts[expr] !== SORT_BOOL) throw new SmtParseError("expected a formula");
|
|
295
|
+
return expr;
|
|
296
|
+
};
|
|
297
|
+
|
|
298
|
+
// push_pattern_frame with ignore_bad_patterns: (t1 ... tn) is a multi-pattern, (f a ...) a pattern
|
|
299
|
+
// of one term, and a pattern that starts with a constant is dropped unparsed.
|
|
300
|
+
const parsePattern = (sexpr: SExpr) => {
|
|
301
|
+
if (!Array.isArray(sexpr) || sexpr.length === 0) return undefined;
|
|
302
|
+
const head = sexpr[0];
|
|
303
|
+
if (Array.isArray(head)) return manager.mkPattern(sexpr.map(parseTerm));
|
|
304
|
+
const decl = head === "true" || head === "false" ? -1 : funcs.get(head);
|
|
305
|
+
if (decl === -1 || (decl !== undefined && manager.funcDecls[decl].domain.length === 0))
|
|
306
|
+
return undefined;
|
|
307
|
+
return manager.mkPattern([parseTerm(sexpr)]);
|
|
308
|
+
};
|
|
309
|
+
|
|
310
|
+
// pattern_validator: a pattern has no Boolean operator other than equality, no quantifier, and
|
|
311
|
+
// every variable of its quantifier.
|
|
312
|
+
const isValidPattern = (pattern: number, numDecls: number) => {
|
|
313
|
+
const found = new Set<number>();
|
|
314
|
+
const isValid = (expr: number): boolean => {
|
|
315
|
+
const kind = manager.kinds[expr];
|
|
316
|
+
if (kind === KIND_QUANTIFIER) return false;
|
|
317
|
+
if (kind === KIND_VAR) {
|
|
318
|
+
if (manager.values[expr] < numDecls) found.add(manager.values[expr]);
|
|
319
|
+
return true;
|
|
320
|
+
}
|
|
321
|
+
const funcDecl = manager.funcDecls[manager.decls[expr]];
|
|
322
|
+
if (
|
|
323
|
+
funcDecl.family === FAMILY_BASIC &&
|
|
324
|
+
funcDecl.op !== OP_EQ &&
|
|
325
|
+
funcDecl.op !== OP_TRUE &&
|
|
326
|
+
funcDecl.op !== OP_FALSE
|
|
327
|
+
)
|
|
328
|
+
return false;
|
|
329
|
+
return manager.everyArg(expr, isValid);
|
|
330
|
+
};
|
|
331
|
+
return manager.everyArg(pattern, isValid) && found.size === numDecls;
|
|
332
|
+
};
|
|
333
|
+
|
|
334
|
+
const parseQuantifier = (list: SExpr[], isForall: boolean) => {
|
|
335
|
+
const declarations = expectList(list[1]);
|
|
336
|
+
const scope = new Map<string, Binding>();
|
|
337
|
+
const names = declarations.map((declaration) => expectSymbol(expectList(declaration)[0]));
|
|
338
|
+
const varSorts = declarations.map((declaration, index) => {
|
|
339
|
+
const sort = parseSort(expectList(declaration)[1]);
|
|
340
|
+
scope.set(names[index], { kind: "var", depth: depth + index, sort });
|
|
341
|
+
return sort;
|
|
342
|
+
});
|
|
343
|
+
scopes.push(scope);
|
|
344
|
+
depth += varSorts.length;
|
|
345
|
+
// parse_sorted_vars: the variables are created first, the first declared with the largest index,
|
|
346
|
+
// and the parser's stack holds them until the quantifier is created.
|
|
347
|
+
const boundVars = varSorts.map((sort, index) =>
|
|
348
|
+
manager.mkVar(varSorts.length - 1 - index, sort),
|
|
349
|
+
);
|
|
350
|
+
for (const boundVar of boundVars) manager.incRef(boundVar);
|
|
351
|
+
const bodySExpr = list[2];
|
|
352
|
+
const isAnnotated = Array.isArray(bodySExpr) && bodySExpr[0] === "!";
|
|
353
|
+
const body = expectBool(parseTerm(isAnnotated ? bodySExpr[1] : bodySExpr));
|
|
354
|
+
const patterns: number[] = [];
|
|
355
|
+
let weight = 1;
|
|
356
|
+
let qid = "";
|
|
357
|
+
if (isAnnotated)
|
|
358
|
+
for (let index = 2; index < bodySExpr.length; index += 2) {
|
|
359
|
+
const keyword = bodySExpr[index];
|
|
360
|
+
const value = bodySExpr[index + 1];
|
|
361
|
+
if (keyword === ":pattern") {
|
|
362
|
+
const pattern = parsePattern(value);
|
|
363
|
+
if (pattern !== undefined) {
|
|
364
|
+
manager.incRef(pattern);
|
|
365
|
+
patterns.push(pattern);
|
|
366
|
+
}
|
|
367
|
+
} else if (keyword === ":weight") weight = Number(value);
|
|
368
|
+
else if (keyword === ":qid") qid = expectSymbol(value);
|
|
369
|
+
}
|
|
370
|
+
scopes.pop();
|
|
371
|
+
depth -= varSorts.length;
|
|
372
|
+
// pop_quant_frame: the invalid patterns leave the parser's stack before the quantifier is made,
|
|
373
|
+
// and the valid ones after.
|
|
374
|
+
let numKept = 0;
|
|
375
|
+
for (const pattern of patterns) {
|
|
376
|
+
if (!isValidPattern(pattern, varSorts.length)) continue;
|
|
377
|
+
manager.incRef(pattern);
|
|
378
|
+
manager.decRef(patterns[numKept]);
|
|
379
|
+
patterns[numKept] = pattern;
|
|
380
|
+
numKept++;
|
|
381
|
+
}
|
|
382
|
+
for (const removed of patterns.splice(numKept)) manager.decRef(removed);
|
|
383
|
+
const quantifier = manager.mkQuantifier({
|
|
384
|
+
isForall,
|
|
385
|
+
sorts: varSorts,
|
|
386
|
+
names,
|
|
387
|
+
body,
|
|
388
|
+
patterns,
|
|
389
|
+
weight,
|
|
390
|
+
qid,
|
|
391
|
+
});
|
|
392
|
+
for (const pattern of patterns) manager.decRef(pattern);
|
|
393
|
+
for (const boundVar of boundVars) manager.decRef(boundVar);
|
|
394
|
+
return quantifier;
|
|
395
|
+
};
|
|
396
|
+
|
|
397
|
+
const parseLet = (list: SExpr[]) => {
|
|
398
|
+
const scope = new Map<string, Binding>();
|
|
399
|
+
for (const binding of expectList(list[1])) {
|
|
400
|
+
const pair = expectList(binding);
|
|
401
|
+
const expr = parseTerm(pair[1]);
|
|
402
|
+
scope.set(expectSymbol(pair[0]), { kind: "let", depth, expr });
|
|
403
|
+
}
|
|
404
|
+
scopes.push(scope);
|
|
405
|
+
const body = parseTerm(list[2]);
|
|
406
|
+
scopes.pop();
|
|
407
|
+
return body;
|
|
408
|
+
};
|
|
409
|
+
|
|
410
|
+
const parseApp = (name: string, args: number[]) => {
|
|
411
|
+
const chainable = CHAINABLE_OPS.get(name);
|
|
412
|
+
if (chainable !== undefined) return mkChain(chainable, args);
|
|
413
|
+
if (name === "-") return mkApp(args.length === 1 ? OP_UMINUS : OP_SUB, args);
|
|
414
|
+
// ast_manager::mk_app: / is left associative, so more arguments nest to the left.
|
|
415
|
+
if (name === "/" && args.length > 2)
|
|
416
|
+
return args
|
|
417
|
+
.slice(1)
|
|
418
|
+
.reduce((dividend, divisor) => mkApp(OP_DIV, [dividend, divisor]), args[0]);
|
|
419
|
+
const op = BUILTIN_OPS.get(name);
|
|
420
|
+
if (op !== undefined) return mkApp(op, args);
|
|
421
|
+
const decl = funcs.get(name);
|
|
422
|
+
if (decl === undefined) throw new SmtParseError(`unknown function ${name}`);
|
|
423
|
+
return mkApp(decl, args);
|
|
424
|
+
};
|
|
425
|
+
|
|
426
|
+
// A term without nested applications to parse first: a symbol, a quantifier, a let or an
|
|
427
|
+
// annotation.
|
|
428
|
+
const parseLeaf = (sexpr: SExpr): number => {
|
|
429
|
+
if (typeof sexpr === "string") {
|
|
430
|
+
if (/^[0-9]+$/.test(sexpr)) return manager.mkNumeral(BigInt(sexpr));
|
|
431
|
+
const decimal = DECIMAL.exec(sexpr);
|
|
432
|
+
if (decimal !== null)
|
|
433
|
+
return manager.mkRealNumeral(
|
|
434
|
+
Rational.of(BigInt(decimal[1] + decimal[2]), 10n ** BigInt(decimal[2].length)),
|
|
435
|
+
);
|
|
436
|
+
if (sexpr === "true") return manager.trueExpr;
|
|
437
|
+
if (sexpr === "false") return manager.falseExpr;
|
|
438
|
+
const binding = lookup(sexpr);
|
|
439
|
+
if (binding?.kind === "var") return manager.mkVar(depth - 1 - binding.depth, binding.sort);
|
|
440
|
+
// Z3's var_shifter moves the free variables of a let binding up by the binders since. Its cache
|
|
441
|
+
// holds the terms it makes, but this parser holds no references, so it rebuilds the binding
|
|
442
|
+
// with replaceFreeVars.
|
|
443
|
+
if (binding !== undefined)
|
|
444
|
+
return depth === binding.depth
|
|
445
|
+
? binding.expr
|
|
446
|
+
: replaceFreeVars(manager, binding.expr, (variable, index, shift) =>
|
|
447
|
+
manager.mkVar(index + shift + depth - binding.depth, manager.sorts[variable]),
|
|
448
|
+
);
|
|
449
|
+
return parseApp(sexpr, []);
|
|
450
|
+
}
|
|
451
|
+
const head = sexpr[0];
|
|
452
|
+
if (head === "forall" || head === "exists") return parseQuantifier(sexpr, head === "forall");
|
|
453
|
+
if (head === "let") return parseLet(sexpr);
|
|
454
|
+
const named = parseTerm(sexpr[1]);
|
|
455
|
+
// name_expr: cmd_context keeps a named expression as a macro.
|
|
456
|
+
const nameIndex = sexpr.indexOf(":named");
|
|
457
|
+
if (nameIndex !== -1) {
|
|
458
|
+
manager.incRef(named);
|
|
459
|
+
manager.mkMacro(expectSymbol(sexpr[nameIndex + 1]), named);
|
|
460
|
+
}
|
|
461
|
+
return named;
|
|
462
|
+
};
|
|
463
|
+
|
|
464
|
+
// Applications keep their own stack, like Z3's parser, so deeply nested terms do not exhaust the
|
|
465
|
+
// call stack.
|
|
466
|
+
const parseTerm = (sexpr: SExpr): number => {
|
|
467
|
+
const frames: ApplicationFrame[] = [];
|
|
468
|
+
const results: number[] = [];
|
|
469
|
+
const enter = (current: SExpr) => {
|
|
470
|
+
const head = Array.isArray(current) ? current[0] : undefined;
|
|
471
|
+
if (
|
|
472
|
+
!Array.isArray(current) ||
|
|
473
|
+
head === "forall" ||
|
|
474
|
+
head === "exists" ||
|
|
475
|
+
head === "let" ||
|
|
476
|
+
head === "!"
|
|
477
|
+
)
|
|
478
|
+
results.push(parseLeaf(current));
|
|
479
|
+
else frames.push({ name: expectSymbol(head), list: current, start: results.length, next: 1 });
|
|
480
|
+
};
|
|
481
|
+
enter(sexpr);
|
|
482
|
+
while (frames.length > 0) {
|
|
483
|
+
const frame = frames[frames.length - 1];
|
|
484
|
+
if (frame.next < frame.list.length) {
|
|
485
|
+
enter(frame.list[frame.next++]);
|
|
486
|
+
continue;
|
|
487
|
+
}
|
|
488
|
+
frames.pop();
|
|
489
|
+
results.push(parseApp(frame.name, results.splice(frame.start)));
|
|
490
|
+
}
|
|
491
|
+
return results[0];
|
|
492
|
+
};
|
|
493
|
+
|
|
494
|
+
let hasCheckSat = false;
|
|
495
|
+
for (const command of readSExprs(tokenize(text))) {
|
|
496
|
+
const list = expectList(command);
|
|
497
|
+
const name = expectSymbol(list[0]);
|
|
498
|
+
if (name === "declare-sort") {
|
|
499
|
+
if (list[2] !== undefined && list[2] !== "0")
|
|
500
|
+
throw new SmtUnsupportedError("parametric sorts are not supported");
|
|
501
|
+
sorts.set(expectSymbol(list[1]), manager.mkSort(expectSymbol(list[1])));
|
|
502
|
+
} else if (name === "declare-fun" || name === "declare-const") {
|
|
503
|
+
const domain = name === "declare-fun" ? expectList(list[2]).map(parseSort) : [];
|
|
504
|
+
const range = parseSort(name === "declare-fun" ? list[3] : list[2]);
|
|
505
|
+
// builtin_signature_collides and is_transcendental_shadow_decl each apply the builtin of that
|
|
506
|
+
// name to fresh variables, which they then release.
|
|
507
|
+
for (let round = 0; round < 2; round++) {
|
|
508
|
+
const vars = domain.map((sort, index) => manager.mkVar(index, sort));
|
|
509
|
+
for (const domainVar of vars) manager.incRef(domainVar);
|
|
510
|
+
for (const domainVar of vars) manager.decRef(domainVar);
|
|
511
|
+
}
|
|
512
|
+
funcs.set(expectSymbol(list[1]), manager.mkFuncDecl(expectSymbol(list[1]), domain, range));
|
|
513
|
+
} else if (name === "assert") {
|
|
514
|
+
// cmd_context::assert_expr keeps the assertion, and passes it to the solver.
|
|
515
|
+
const assertion = expectBool(parseTerm(list[1]));
|
|
516
|
+
manager.incRef(assertion);
|
|
517
|
+
assertions.push(assertion);
|
|
518
|
+
assertExpr(assertion);
|
|
519
|
+
} else if (name === "check-sat") {
|
|
520
|
+
hasCheckSat = true;
|
|
521
|
+
break;
|
|
522
|
+
} else if (name === "push" || name === "pop" || name === "define-fun" || name === "define-sort")
|
|
523
|
+
throw new SmtUnsupportedError(`the command ${name} is not supported`);
|
|
524
|
+
}
|
|
525
|
+
return { assertions, hasCheckSat };
|
|
526
|
+
};
|
|
@@ -0,0 +1,71 @@
|
|
|
1
|
+
// Ported from Z3 (src/smt/smt_solver.cpp, src/smt/smt_kernel.cpp, src/smt/smt_setup.cpp), MIT
|
|
2
|
+
// license, see z3-license.txt. Decides an SMT-LIB problem the way `z3 -smt2 AUTO_CONFIG=false
|
|
3
|
+
// smt.MBQI=true` does for tlapm's UFNIA obligations.
|
|
4
|
+
import { isStackOverflow, SmtCanceledError, SmtUnsupportedError } from "../../../errors";
|
|
5
|
+
import type { DecideOptions, Verdict } from "../../verdict";
|
|
6
|
+
import { AssertedFormulas } from "./asserted-formulas";
|
|
7
|
+
import { AstManager } from "./ast";
|
|
8
|
+
import { Context } from "./context";
|
|
9
|
+
import { L_FALSE, L_TRUE } from "./lbool";
|
|
10
|
+
import { applyUfniaTactic } from "./quant-tactics";
|
|
11
|
+
import { ResourceLimit } from "./rlimit";
|
|
12
|
+
import { parseSmtlib } from "./smtlib-parser";
|
|
13
|
+
|
|
14
|
+
interface SmtCheck {
|
|
15
|
+
verdict: Verdict;
|
|
16
|
+
numInstances: number;
|
|
17
|
+
}
|
|
18
|
+
|
|
19
|
+
// The verdict, and the number of quantifier instances the search made.
|
|
20
|
+
export const checkSmt = (text: string, options: DecideOptions): SmtCheck => {
|
|
21
|
+
const manager = new AstManager(
|
|
22
|
+
new ResourceLimit(Date.now() + options.timeLimitMs, options.signal),
|
|
23
|
+
);
|
|
24
|
+
// combined_solver gives each assertion to the incremental smt kernel as well, which rewrites it
|
|
25
|
+
// when it is asserted and keeps it, though check-sat then runs the tactic on the assertions. The
|
|
26
|
+
// kernel's model finder counts a step of the resource limit when it is made, and
|
|
27
|
+
// solver::assert_expr counts one for each assertion.
|
|
28
|
+
const incremental = new AssertedFormulas(manager);
|
|
29
|
+
manager.limit.inc();
|
|
30
|
+
const problem = parseSmtlib(text, manager, (assertion) => {
|
|
31
|
+
manager.limit.inc();
|
|
32
|
+
incremental.assertExpr(assertion);
|
|
33
|
+
});
|
|
34
|
+
if (!problem.hasCheckSat) return { verdict: "unknown", numInstances: 0 };
|
|
35
|
+
const goal = applyUfniaTactic(manager, problem.assertions);
|
|
36
|
+
// and_then runs smt_tactic only on a goal that the preprocessing left undecided.
|
|
37
|
+
if (goal.isInconsistent || goal.forms.size === 0) {
|
|
38
|
+
manager.limit.release();
|
|
39
|
+
return { verdict: goal.isInconsistent ? "unsat" : "sat", numInstances: 0 };
|
|
40
|
+
}
|
|
41
|
+
// smt_tactic makes the context, which makes its asserted formulas first, and asserts the goal.
|
|
42
|
+
// setup_context then makes the theories, before the formulas are reduced.
|
|
43
|
+
const asserted = new AssertedFormulas(manager);
|
|
44
|
+
const context = new Context(manager, { isMbqi: true, relevancyLevel: 2 });
|
|
45
|
+
for (const assertion of goal.forms.items) asserted.assertExpr(assertion);
|
|
46
|
+
context.setupContext();
|
|
47
|
+
context.internalizeAssertions(asserted);
|
|
48
|
+
const result = context.search();
|
|
49
|
+
manager.limit.release();
|
|
50
|
+
return {
|
|
51
|
+
verdict: result === L_FALSE ? "unsat" : result === L_TRUE ? "sat" : "unknown",
|
|
52
|
+
numInstances: context.qmanager.getNumInstances(),
|
|
53
|
+
};
|
|
54
|
+
};
|
|
55
|
+
|
|
56
|
+
// Throws SmtParseError on malformed input. Input outside the subset the solver supports is unknown,
|
|
57
|
+
// and so is a search that runs past the time limit, that the signal aborts, or that exhausts the
|
|
58
|
+
// heap or the stack.
|
|
59
|
+
export const decideSmt = (text: string, options: DecideOptions): Verdict => {
|
|
60
|
+
try {
|
|
61
|
+
return checkSmt(text, options).verdict;
|
|
62
|
+
} catch (error) {
|
|
63
|
+
if (
|
|
64
|
+
error instanceof SmtUnsupportedError ||
|
|
65
|
+
error instanceof SmtCanceledError ||
|
|
66
|
+
isStackOverflow(error)
|
|
67
|
+
)
|
|
68
|
+
return "unknown";
|
|
69
|
+
throw error;
|
|
70
|
+
}
|
|
71
|
+
};
|