tla-ts 0.0.4-dev.702eb98 → 0.0.4-dev.7714e32
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 +32 -6
- package/dist/cli.cjs +1 -1
- package/dist/cli.js +1 -1
- package/dist/deciders.cjs +27 -27
- package/dist/deciders.js +34 -34
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +12 -14
- package/dist/index.d.ts +12 -14
- 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 +516 -25
- package/dist/prove.js +518 -27
- package/dist/run.cjs +45 -0
- package/dist/run.js +45 -0
- package/dist/tlapm.cjs +2 -2
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +76 -86
- package/dist/transfer.js +73 -83
- package/dist/worker.cjs +6 -6
- package/dist/worker.js +6 -6
- package/package.json +1 -1
- package/src/ast.ts +2 -2
- package/src/bags.ts +22 -23
- package/src/builtins.ts +16 -8
- package/src/check.ts +131 -1154
- package/src/{cli-options.ts → cli/options.ts} +54 -9
- package/src/cli/run.ts +63 -0
- package/src/cli/shared.ts +106 -0
- package/src/cli/tlapm.ts +374 -0
- package/src/{run-cli.ts → cli/tlc.ts} +112 -761
- package/src/cli/xml-exporter.ts +221 -0
- package/src/cli.ts +1 -1
- package/src/codegen.ts +17 -15
- package/src/config.ts +5 -5
- package/src/dependencies.ts +4 -6
- package/src/environment.ts +55 -60
- package/src/errors.ts +12 -36
- package/src/evaluate.ts +81 -101
- package/src/exit-codes.ts +1 -1
- package/src/fingerprints.ts +3 -3
- package/src/index.ts +2 -2
- package/src/instances.ts +56 -46
- package/src/java-overrides.ts +79 -41
- package/src/json.ts +31 -36
- package/src/levels.ts +10 -13
- package/src/{live-check.ts → liveness-checker.ts} +169 -142
- package/src/liveness.ts +38 -34
- package/src/obligations/action.ts +58 -105
- package/src/obligations/{anon.ts → anonymize.ts} +44 -52
- package/src/obligations/equality.ts +260 -0
- package/src/obligations/expression.ts +42 -530
- package/src/obligations/format.ts +7 -8
- package/src/obligations/generate.ts +93 -783
- package/src/obligations/index.ts +23 -23
- package/src/obligations/levels.ts +38 -44
- package/src/obligations/module.ts +106 -729
- package/src/obligations/normalize.ts +554 -0
- package/src/obligations/operators.ts +176 -0
- package/src/obligations/pragma.ts +35 -29
- package/src/obligations/printer.ts +98 -209
- package/src/obligations/proof.ts +0 -1
- package/src/obligations/regroup.ts +100 -0
- package/src/obligations/simplify.ts +668 -0
- package/src/obligations/source.ts +92 -192
- package/src/obligations/{deref.ts → subexpression.ts} +82 -113
- package/src/obligations/substitution.ts +261 -0
- package/src/obligations/temporal.ts +32 -30
- package/src/obligations/tuples.ts +37 -53
- package/src/parallel-worker.ts +37 -33
- package/src/parallel.ts +30 -24
- package/src/parser.ts +67 -74
- package/src/{pcal-ast.ts → pcal/ast.ts} +2 -17
- package/src/{pcal-parse.ts → pcal/parse.ts} +28 -64
- package/src/{pcal-tokenize.ts → pcal/tokenize.ts} +10 -39
- package/src/{pcal-translate.ts → pcal/translate.ts} +30 -109
- package/src/{pcal-validate.ts → pcal/validate.ts} +10 -20
- package/src/{prove → prover}/decide-pool.ts +14 -19
- package/src/{prove → prover}/deciders.ts +7 -1
- package/src/{obligations/pickle.ts → prover/first-order.ts} +79 -4
- package/src/{prove → prover}/isabelle/decide.ts +3 -6
- package/src/{prove → prover}/isabelle/encode.ts +106 -138
- package/src/{prove → prover}/isabelle/isar/inner-syntax.ts +1 -1
- package/src/{prove → prover}/isabelle/isar/method.ts +3 -3
- package/src/{prove → prover}/isabelle/isar/type-check.ts +1 -1
- package/src/{prove → prover}/isabelle/provers/blast/blast.ts +1 -1
- package/src/{prove → prover}/isabelle/provers/blast/branch.ts +1 -1
- package/src/{prove → prover}/isabelle/provers/blast/term.ts +3 -4
- package/src/{prove → prover}/isabelle/provers/clasimp.ts +1 -1
- package/src/{prove → prover}/isabelle/provers/classical.ts +3 -3
- package/src/{prove → prover}/isabelle/provers/hypsubst.ts +1 -9
- package/src/{prove → prover}/isabelle/pure/conv.ts +1 -1
- package/src/{prove → prover}/isabelle/pure/drule.ts +2 -2
- package/src/{prove → prover}/isabelle/pure/envir.ts +3 -35
- package/src/{prove → prover}/isabelle/pure/logic.ts +4 -76
- package/src/{prove → prover}/isabelle/pure/name.ts +1 -13
- package/src/{prove → prover}/isabelle/pure/net.ts +2 -49
- package/src/{prove → prover}/isabelle/pure/pattern.ts +3 -22
- package/src/{prove → prover}/isabelle/pure/raw-simplifier.ts +3 -18
- package/src/{prove → prover}/isabelle/pure/seq.ts +0 -23
- package/src/{prove → prover}/isabelle/pure/simplifier.ts +2 -8
- package/src/{prove → prover}/isabelle/pure/table.ts +1 -8
- package/src/{prove → prover}/isabelle/pure/tactic.ts +5 -113
- package/src/{prove → prover}/isabelle/pure/tactical.ts +1 -84
- package/src/{prove → prover}/isabelle/pure/term-ord.ts +1 -55
- package/src/{prove → prover}/isabelle/pure/term.ts +8 -128
- package/src/{prove → prover}/isabelle/pure/thm.ts +4 -27
- package/src/{prove → prover}/isabelle/pure/type.ts +0 -12
- package/src/{prove → prover}/isabelle/pure/unify.ts +1 -1
- package/src/{prove → prover}/isabelle/tla/classical-setup.ts +1 -1
- package/src/{prove → prover}/ocaml.ts +1 -1
- package/src/{prove → prover}/prep/action.ts +54 -66
- package/src/{prove → prover}/prep/enabled-axioms.ts +2 -2
- package/src/{prove → prover}/prep/fingerprint.ts +3 -3
- package/src/{prove → prover}/prep/level-comparison.ts +15 -38
- package/src/{prove → prover}/prep/md5.ts +2 -9
- package/src/{prove/prep/pragma.ts → prover/prep/methods.ts} +4 -4
- package/src/prover/prep/normalize.ts +309 -0
- package/src/{prove → prover}/prove-worker.ts +4 -11
- package/src/prover/prove.ts +492 -0
- package/src/{prove → prover}/ptl/encode.ts +19 -31
- package/src/{prove → prover}/smt/axioms.ts +78 -79
- package/src/{prove → prover}/smt/data.ts +16 -45
- package/src/{prove → prover}/smt/encode.ts +134 -28
- package/src/{prove → prover}/smt/extensionality.ts +14 -12
- package/src/{prove → prover}/smt/flatten.ts +3 -18
- package/src/{prove → prover}/smt/format.ts +14 -3
- package/src/{prove → prover}/smt/instances.ts +4 -5
- package/src/{prove → prover}/smt/rewrite.ts +41 -59
- package/src/{prove → prover}/smt/solver/ast-util.ts +0 -56
- package/src/{prove → prover}/smt/solver/case-split-queue.ts +1 -1
- package/src/{prove → prover}/smt/solver/enode.ts +1 -1
- package/src/{prove → prover}/smt/solver/lp/dep-intervals.ts +0 -14
- package/src/{prove → prover}/smt/solver/model-macro-solver.ts +1 -1
- package/src/{prove → prover}/smt/solver/nlsat/algebraic.ts +3 -3
- package/src/{prove → prover}/smt/solver/nlsat/atoms.ts +1 -1
- package/src/{prove → prover}/smt/solver/nlsat/explain.ts +1 -1
- package/src/{prove → prover}/smt/solver/nlsat/interval-set.ts +1 -1
- package/src/{prove → prover}/smt/solver/nlsat/levelwise.ts +4 -7
- package/src/{prove → prover}/smt/solver/nlsat/polynomial.ts +4 -4
- package/src/{prove → prover}/smt/solver/nlsat/upolynomial.ts +2 -2
- package/src/{prove → prover}/smt/solver/pattern-inference.ts +1 -1
- package/src/{prove → prover}/smt/solver/relevancy.ts +2 -2
- package/src/{prove → prover}/smt/solver/rewriter.ts +1 -1
- package/src/{prove → prover}/smt/solver/solver.ts +2 -2
- package/src/prover/tlapm/cache.ts +236 -0
- package/src/prover/tlapm/ocaml-marshal.ts +166 -0
- package/src/{prove → prover}/tlapm/tlapm.ts +1 -2
- package/src/prover/verdict.ts +13 -0
- package/src/{prove → prover}/zenon/decide.ts +5 -11
- package/src/{prove → prover}/zenon/encode.ts +40 -106
- package/src/{prove → prover}/zenon/eqrel.ts +1 -1
- package/src/{prove → prover}/zenon/equality-rules.ts +1 -1
- package/src/{prove → prover}/zenon/expr.ts +2 -2
- package/src/{prove → prover}/zenon/index-table.ts +1 -1
- package/src/{prove → prover}/zenon/isar.ts +1 -1
- package/src/{prove → prover}/zenon/llproof.ts +1 -1
- package/src/{prove → prover}/zenon/mltoll.ts +1 -1
- package/src/{prove → prover}/zenon/node.ts +1 -1
- package/src/{prove → prover}/zenon/search.ts +1 -1
- package/src/{prove → prover}/zenon/tla/terms.ts +1 -20
- package/src/{prove → prover}/zenon/tla/tla.ts +1 -1
- package/src/randomization.ts +19 -24
- package/src/resolve.ts +15 -22
- package/src/runtime.ts +8 -8
- package/src/{sany-builtins.ts → sany/builtins.ts} +1 -1
- package/src/{sany-generator.ts → sany/generator.ts} +38 -55
- package/src/{sany-levels.ts → sany/levels.ts} +45 -48
- package/src/{sany-lexer.ts → sany/lexer.ts} +2 -3
- package/src/{sany-linter.ts → sany/linter.ts} +1 -1
- package/src/{sany-modules.ts → sany/modules.ts} +2 -2
- package/src/{sany-nodes.ts → sany/nodes.ts} +2 -2
- package/src/{sany-parse-error.ts → sany/parse-error.ts} +2 -2
- package/src/{sany-report.ts → sany/report.ts} +16 -17
- package/src/{sany-selectors.ts → sany/selectors.ts} +3 -5
- package/src/{sany-source.ts → sany/source.ts} +6 -7
- package/src/{sany-xml.ts → sany/xml.ts} +5 -6
- package/src/search.ts +969 -0
- package/src/spec-description.ts +26 -20
- package/src/{standard-levels.ts → standard-definitions.ts} +118 -2
- package/src/standard-modules.ts +16 -20
- package/src/state-graph.ts +9 -8
- package/src/substitution-levels.ts +2 -2
- package/src/successors.ts +16 -19
- package/src/symmetry.ts +1 -1
- package/src/tableau.ts +6 -7
- package/src/tlc/fingerprint.ts +214 -0
- package/src/{tlc-messages.ts → tlc/messages.ts} +119 -7
- package/src/{tlc-order.ts → tlc/order.ts} +7 -7
- package/src/{tlc-random.ts → tlc/random.ts} +3 -213
- package/src/{tlc-replay.ts → tlc/replay.ts} +40 -36
- package/src/{tlc-module.ts → tlc/tlc-operators.ts} +9 -9
- package/src/{tlc-ext.ts → tlc/tlcext-operators.ts} +30 -25
- package/src/transfer.ts +32 -32
- package/src/values.ts +72 -67
- package/src/worker.ts +1 -4
- package/dist/run-cli.cjs +0 -38
- package/dist/run-cli.js +0 -38
- package/src/canonical.ts +0 -40
- package/src/obligations/ctx.ts +0 -64
- package/src/prove/prep/defs.ts +0 -27
- package/src/prove/prep/elab.ts +0 -156
- package/src/prove/prep/enabled.ts +0 -43
- package/src/prove/prep/flatten.ts +0 -70
- package/src/prove/prep/trivial.ts +0 -22
- package/src/prove/prove.ts +0 -417
- package/src/prove/smt/axiomatize.ts +0 -69
- package/src/prove/smt/simplify.ts +0 -57
- package/src/prove/verdict.ts +0 -13
- package/src/standard-ranges.ts +0 -116
- package/src/value-sources.ts +0 -29
- /package/src/{prove → prover}/isabelle/LICENSE +0 -0
- /package/src/{prove → prover}/isabelle/LICENSE-tlapm +0 -0
- /package/src/{prove → prover}/isabelle/isar/proof.ts +0 -0
- /package/src/{prove → prover}/isabelle/isar/statement.ts +0 -0
- /package/src/{prove → prover}/isabelle/isar/theory.ts +0 -0
- /package/src/{prove → prover}/isabelle/provers/blast/prove.ts +0 -0
- /package/src/{prove → prover}/isabelle/provers/blast/rules.ts +0 -0
- /package/src/{prove → prover}/isabelle/provers/blast/state.ts +0 -0
- /package/src/{prove → prover}/isabelle/pure/bicompose.ts +0 -0
- /package/src/{prove → prover}/isabelle/pure/consts.ts +0 -0
- /package/src/{prove → prover}/isabelle/pure/goal.ts +0 -0
- /package/src/{prove → prover}/isabelle/pure/interrupt.ts +0 -0
- /package/src/{prove → prover}/isabelle/pure/list.ts +0 -0
- /package/src/{prove → prover}/isabelle/pure/object-logic.ts +0 -0
- /package/src/{prove → prover}/isabelle/pure/rewriter.ts +0 -0
- /package/src/{prove → prover}/isabelle/pure/search.ts +0 -0
- /package/src/{prove → prover}/isabelle/pure/variable.ts +0 -0
- /package/src/{prove → prover}/isabelle/tla/context.ts +0 -0
- /package/src/{prove → prover}/isabelle/tla/logic-data.ts +0 -0
- /package/src/{prove → prover}/isabelle/tla/logic.ts +0 -0
- /package/src/{prove → prover}/isabelle/tla/simpdata.ts +0 -0
- /package/src/{prove → prover}/isabelle/tools/intuitionistic.ts +0 -0
- /package/src/{prove → prover}/ptl/decide.ts +0 -0
- /package/src/{prove → prover}/ptl/sat.ts +0 -0
- /package/src/{prove → prover}/ptl/tableau.ts +0 -0
- /package/src/{prove → prover}/smt/context.ts +0 -0
- /package/src/{prove → prover}/smt/solver/act-cache.ts +0 -0
- /package/src/{prove → prover}/smt/solver/arith-rewriter.ts +0 -0
- /package/src/{prove → prover}/smt/solver/array.ts +0 -0
- /package/src/{prove → prover}/smt/solver/asserted-formulas.ts +0 -0
- /package/src/{prove → prover}/smt/solver/ast-lt.ts +0 -0
- /package/src/{prove → prover}/smt/solver/ast.ts +0 -0
- /package/src/{prove → prover}/smt/solver/auf-solver.ts +0 -0
- /package/src/{prove → prover}/smt/solver/cg-table.ts +0 -0
- /package/src/{prove → prover}/smt/solver/clause.ts +0 -0
- /package/src/{prove → prover}/smt/solver/conflict-resolution.ts +0 -0
- /package/src/{prove → prover}/smt/solver/context.ts +0 -0
- /package/src/{prove → prover}/smt/solver/ctx-simplify.ts +0 -0
- /package/src/{prove → prover}/smt/solver/der.ts +0 -0
- /package/src/{prove → prover}/smt/solver/dyn-ack.ts +0 -0
- /package/src/{prove → prover}/smt/solver/e-matching.ts +0 -0
- /package/src/{prove → prover}/smt/solver/expr-ref.ts +0 -0
- /package/src/{prove → prover}/smt/solver/expr-safe-replace.ts +0 -0
- /package/src/{prove → prover}/smt/solver/fingerprints.ts +0 -0
- /package/src/{prove → prover}/smt/solver/flat-literals.ts +0 -0
- /package/src/{prove → prover}/smt/solver/goal.ts +0 -0
- /package/src/{prove → prover}/smt/solver/hash.ts +0 -0
- /package/src/{prove → prover}/smt/solver/hashtable.ts +0 -0
- /package/src/{prove → prover}/smt/solver/internalizer.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lbool.ts +0 -0
- /package/src/{prove → prover}/smt/solver/literal.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/bound-propagator.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/constraints.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/containers.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/core-solver.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/cross-nested.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/dependency.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/dioph-eq.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/explanation.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/gomory.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/hnf-cutter.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/hnf.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/int-cube.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/int-solver.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/lar-solver.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/lar-term.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/lp-settings.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/maximize-term.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/nex-creator.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/nex.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/nla-backoff.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/nla-basics.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/nla-core.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/nla-divisions.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/nla-emonics.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/nla-factorization.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/nla-grobner.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/nla-horner.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/nla-intervals.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/nla-monomial-bounds.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/nla-monotone.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/nla-order.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/nla-patcher.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/nla-tangents.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/nla-throttle.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/nla-types.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/nla-var-eqs.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/nra-solver.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/numeric-pair.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/pdd-interval.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/pdd-simplifier.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/pdd-solver.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/pdd.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/random-updater.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/static-matrix.ts +0 -0
- /package/src/{prove → prover}/smt/solver/lp/union-find.ts +0 -0
- /package/src/{prove → prover}/smt/solver/mam-compiler.ts +0 -0
- /package/src/{prove → prover}/smt/solver/mam-interpreter.ts +0 -0
- /package/src/{prove → prover}/smt/solver/maximize-ac-sharing.ts +0 -0
- /package/src/{prove → prover}/smt/solver/model-checker.ts +0 -0
- /package/src/{prove → prover}/smt/solver/model-evaluator.ts +0 -0
- /package/src/{prove → prover}/smt/solver/model-finder.ts +0 -0
- /package/src/{prove → prover}/smt/solver/model-generator.ts +0 -0
- /package/src/{prove → prover}/smt/solver/nlsat/evaluator.ts +0 -0
- /package/src/{prove → prover}/smt/solver/nlsat/mpbq.ts +0 -0
- /package/src/{prove → prover}/smt/solver/nlsat/solver.ts +0 -0
- /package/src/{prove → prover}/smt/solver/nlsat/types.ts +0 -0
- /package/src/{prove → prover}/smt/solver/nlsat/upolynomial-factorization.ts +0 -0
- /package/src/{prove → prover}/smt/solver/nnf.ts +0 -0
- /package/src/{prove → prover}/smt/solver/poly-rewriter.ts +0 -0
- /package/src/{prove → prover}/smt/solver/propagate-values.ts +0 -0
- /package/src/{prove → prover}/smt/solver/proto-model.ts +0 -0
- /package/src/{prove → prover}/smt/solver/pull-quant.ts +0 -0
- /package/src/{prove → prover}/smt/solver/qe-lite-der.ts +0 -0
- /package/src/{prove → prover}/smt/solver/qe-lite-fm.ts +0 -0
- /package/src/{prove → prover}/smt/solver/qe-lite.ts +0 -0
- /package/src/{prove → prover}/smt/solver/qi-queue.ts +0 -0
- /package/src/{prove → prover}/smt/solver/quant-tactics.ts +0 -0
- /package/src/{prove → prover}/smt/solver/quantifier-analyzer.ts +0 -0
- /package/src/{prove → prover}/smt/solver/quantifier-manager.ts +0 -0
- /package/src/{prove → prover}/smt/solver/random-gen.ts +0 -0
- /package/src/{prove → prover}/smt/solver/rational.ts +0 -0
- /package/src/{prove → prover}/smt/solver/ref-vector.ts +0 -0
- /package/src/{prove → prover}/smt/solver/rewriter-tpl.ts +0 -0
- /package/src/{prove → prover}/smt/solver/rlimit.ts +0 -0
- /package/src/{prove → prover}/smt/solver/smtlib-parser.ts +0 -0
- /package/src/{prove → prover}/smt/solver/sort.ts +0 -0
- /package/src/{prove → prover}/smt/solver/sticky-generations.ts +0 -0
- /package/src/{prove → prover}/smt/solver/theory-lra-axioms.ts +0 -0
- /package/src/{prove → prover}/smt/solver/theory-lra-bounds.ts +0 -0
- /package/src/{prove → prover}/smt/solver/theory-lra-final-check.ts +0 -0
- /package/src/{prove → prover}/smt/solver/theory-lra-internalize.ts +0 -0
- /package/src/{prove → prover}/smt/solver/theory-lra-model.ts +0 -0
- /package/src/{prove → prover}/smt/solver/theory-lra-propagate.ts +0 -0
- /package/src/{prove → prover}/smt/solver/theory-lra-state.ts +0 -0
- /package/src/{prove → prover}/smt/solver/theory-lra.ts +0 -0
- /package/src/{prove → prover}/smt/solver/var-subst.ts +0 -0
- /package/src/{prove → prover}/smt/solver/z3-license.txt +0 -0
- /package/src/{prove → prover}/smt/table.ts +0 -0
- /package/src/{prove → prover}/tlaps-module.ts +0 -0
- /package/src/{prove → prover}/zenon/LICENSE +0 -0
- /package/src/{prove → prover}/zenon/check/check.ts +0 -0
- /package/src/{prove → prover}/zenon/check/definitions.ts +0 -0
- /package/src/{prove → prover}/zenon/check/equality.ts +0 -0
- /package/src/{prove → prover}/zenon/check/functions.ts +0 -0
- /package/src/{prove → prover}/zenon/check/keys.ts +0 -0
- /package/src/{prove → prover}/zenon/check/propositional.ts +0 -0
- /package/src/{prove → prover}/zenon/check/records.ts +0 -0
- /package/src/{prove → prover}/zenon/check/relations.ts +0 -0
- /package/src/{prove → prover}/zenon/check/rewrites.ts +0 -0
- /package/src/{prove → prover}/zenon/check/sets.ts +0 -0
- /package/src/{prove → prover}/zenon/check/terms.ts +0 -0
- /package/src/{prove → prover}/zenon/check/tla.ts +0 -0
- /package/src/{prove → prover}/zenon/isar-case.ts +0 -0
- /package/src/{prove → prover}/zenon/limits.ts +0 -0
- /package/src/{prove → prover}/zenon/ocaml.ts +0 -0
- /package/src/{prove → prover}/zenon/parse.ts +0 -0
- /package/src/{prove → prover}/zenon/phrase.ts +0 -0
- /package/src/{prove → prover}/zenon/proof.ts +0 -0
- /package/src/{prove → prover}/zenon/propositional-rules.ts +0 -0
- /package/src/{prove → prover}/zenon/rules.ts +0 -0
- /package/src/{prove → prover}/zenon/tla/functions.ts +0 -0
- /package/src/{prove → prover}/zenon/tla/llproof.ts +0 -0
- /package/src/{prove → prover}/zenon/tla/records.ts +0 -0
- /package/src/{prove → prover}/zenon/tla/rewrites.ts +0 -0
- /package/src/{prove → prover}/zenon/tla/sets.ts +0 -0
- /package/src/{tlc-modules.ts → tlc/jar-data.ts} +0 -0
- /package/src/{tlc-summary.ts → tlc/summary.ts} +0 -0
- /package/src/{tlc-version.ts → tlc/version.ts} +0 -0
|
@@ -0,0 +1,492 @@
|
|
|
1
|
+
// Proves a module's obligations with tla-ts's own backends, in tlapm's order, or with tlapm.
|
|
2
|
+
|
|
3
|
+
import { TlaProverError, TlaUnsupportedError } from "../errors";
|
|
4
|
+
import { getChildren, mapHyp, type Expr, type Hyp, type Sequent } from "../obligations/expression";
|
|
5
|
+
import { getObligations, type PrintedObligation } from "../obligations";
|
|
6
|
+
import { formatObligation } from "../obligations/printer";
|
|
7
|
+
import { isWorkerSupported } from "../worker";
|
|
8
|
+
import { decide } from "./deciders";
|
|
9
|
+
import { createDecidePool, type DecidePool } from "./decide-pool";
|
|
10
|
+
import { encodeIsabelle, encodeIsabelleTheory } from "./isabelle/encode";
|
|
11
|
+
import { processObligation } from "./prep/action";
|
|
12
|
+
import { getFingerprint } from "./prep/fingerprint";
|
|
13
|
+
import {
|
|
14
|
+
expandDefs,
|
|
15
|
+
flatten,
|
|
16
|
+
isTrivial,
|
|
17
|
+
normalizeExpand,
|
|
18
|
+
normalizeSequent,
|
|
19
|
+
} from "./prep/normalize";
|
|
20
|
+
import { findMethods, type Method } from "./prep/methods";
|
|
21
|
+
import { encodePtl } from "./ptl/encode";
|
|
22
|
+
import { encodeSmt } from "./smt/encode";
|
|
23
|
+
import type { EncodingSession } from "./smt/rewrite";
|
|
24
|
+
import { encodeZenon } from "./zenon/encode";
|
|
25
|
+
import type { TlapmResult } from "./tlapm/tlapm";
|
|
26
|
+
import { TLAPS_MODULE } from "./tlaps-module";
|
|
27
|
+
import type { Verdict } from "./verdict";
|
|
28
|
+
|
|
29
|
+
interface ObligationBase {
|
|
30
|
+
id: number;
|
|
31
|
+
location: string;
|
|
32
|
+
text: string;
|
|
33
|
+
}
|
|
34
|
+
|
|
35
|
+
export interface ProvedObligation extends ObligationBase {
|
|
36
|
+
status: "proved";
|
|
37
|
+
prover: string;
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
export interface TrivialObligation extends ObligationBase {
|
|
41
|
+
status: "trivial";
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
export interface UnprovedObligation extends ObligationBase {
|
|
45
|
+
status: "failed" | "unsupported";
|
|
46
|
+
reason: string;
|
|
47
|
+
}
|
|
48
|
+
|
|
49
|
+
export type ProofObligation = ProvedObligation | TrivialObligation | UnprovedObligation;
|
|
50
|
+
|
|
51
|
+
export type ProofStatus = ProofObligation["status"];
|
|
52
|
+
|
|
53
|
+
export interface ProveResult {
|
|
54
|
+
obligations: ProofObligation[];
|
|
55
|
+
missingProofCount: number;
|
|
56
|
+
omittedProofCount: number;
|
|
57
|
+
}
|
|
58
|
+
|
|
59
|
+
export interface ProveOptions {
|
|
60
|
+
source: string;
|
|
61
|
+
loadModule?: (name: string) => string | undefined;
|
|
62
|
+
backend?: "tla-ts" | "tlapm";
|
|
63
|
+
signal?: AbortSignal;
|
|
64
|
+
onObligation?: (obligation: ProofObligation) => void;
|
|
65
|
+
workers?: number;
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
// What one method concluded about an obligation, as tlapm's toolbox messages report it.
|
|
69
|
+
export interface ProofAttempt {
|
|
70
|
+
method: Method;
|
|
71
|
+
isProved: boolean;
|
|
72
|
+
isReused: boolean;
|
|
73
|
+
reason?: string;
|
|
74
|
+
verdict?: Verdict;
|
|
75
|
+
timeUsedMs?: number;
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
interface ProofReport {
|
|
79
|
+
obligation: ProofObligation;
|
|
80
|
+
attempts: ProofAttempt[];
|
|
81
|
+
}
|
|
82
|
+
|
|
83
|
+
// Why a method left an obligation unproved: a prover decided so, or tla-ts couldn't try it.
|
|
84
|
+
interface MethodFailure {
|
|
85
|
+
reason: string;
|
|
86
|
+
isDecided: boolean;
|
|
87
|
+
}
|
|
88
|
+
|
|
89
|
+
// The SMT encoder numbers the CASE errors it standardizes across the run, so an obligation it
|
|
90
|
+
// encodes one in waits for every earlier obligation and starts from the count they leave.
|
|
91
|
+
interface ObligationTask {
|
|
92
|
+
done: Promise<void>;
|
|
93
|
+
session: { initial: number; current: EncodingSession } | undefined;
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
// What tlapm keeps across one run's obligations. An obligation waits for the last earlier one with
|
|
97
|
+
// its fingerprint, so obligations prove concurrently as they would in turn.
|
|
98
|
+
interface ProveRun {
|
|
99
|
+
tasks: ObligationTask[];
|
|
100
|
+
results: Map<string, Map<string, ProofAttempt>>;
|
|
101
|
+
isFingerprinted: (obligation: PrintedObligation) => boolean;
|
|
102
|
+
isProving: boolean;
|
|
103
|
+
lastByFingerprint: Map<string, Promise<void>>;
|
|
104
|
+
decide: DecidePool["decide"];
|
|
105
|
+
}
|
|
106
|
+
|
|
107
|
+
// The text Prep.ship sends a backend after Prep.normalize_expand. It throws a TlaUnsupportedError
|
|
108
|
+
// for what tla-ts can't encode.
|
|
109
|
+
type Encoder = (id: number, sequent: Sequent, method: Method, session: EncodingSession) => string;
|
|
110
|
+
|
|
111
|
+
// Action.process_obligation, the frontend for every backend but LS4, Isabelle included, then
|
|
112
|
+
// Prep.flatten.
|
|
113
|
+
const shipFirstOrder = (sequent: Sequent) => flatten(processObligation(sequent));
|
|
114
|
+
|
|
115
|
+
// Prep.gen_smt_solve writes the resource budget before the encoding.
|
|
116
|
+
const encodeSmtProblem: Encoder = (_id, sequent, method, session) =>
|
|
117
|
+
(method.rlimit === undefined ? "" : `(set-option :rlimit ${method.rlimit})\n`) +
|
|
118
|
+
encodeSmt(shipFirstOrder(sequent), session);
|
|
119
|
+
|
|
120
|
+
const ENCODERS: Record<string, Encoder> = {
|
|
121
|
+
smt: encodeSmtProblem,
|
|
122
|
+
z3: encodeSmtProblem,
|
|
123
|
+
zenon: (id, sequent) => encodeZenon(id, shipFirstOrder(sequent)),
|
|
124
|
+
// tlapm names the theory after its temporary file, and tla-ts after the obligation.
|
|
125
|
+
isabelle: (id, sequent, method) =>
|
|
126
|
+
encodeIsabelle(id, shipFirstOrder(sequent), method.tactic ?? "auto"),
|
|
127
|
+
// Pltl.process_obligation is LS4's frontend.
|
|
128
|
+
ls4: (_id, sequent) => encodePtl(sequent),
|
|
129
|
+
};
|
|
130
|
+
|
|
131
|
+
// The frontends and Prep.flatten add no CASE without OTHER, so the SMT encoder standardizes one
|
|
132
|
+
// only in an obligation that has one after Prep.normalize_expand.
|
|
133
|
+
const hasIncompleteCase = (expression: Expr): boolean =>
|
|
134
|
+
(expression.kind === "Case" && expression.other === undefined) ||
|
|
135
|
+
getChildren(expression).some(hasIncompleteCase);
|
|
136
|
+
|
|
137
|
+
const incompleteCaseHyps = new WeakMap<Hyp, boolean>();
|
|
138
|
+
|
|
139
|
+
const isIncompleteCaseHyp = (hyp: Hyp) => {
|
|
140
|
+
const known = incompleteCaseHyps.get(hyp);
|
|
141
|
+
if (known !== undefined) return known;
|
|
142
|
+
const expressions: Expr[] = [];
|
|
143
|
+
mapHyp(
|
|
144
|
+
hyp,
|
|
145
|
+
(inner) => {
|
|
146
|
+
expressions.push(inner);
|
|
147
|
+
return inner;
|
|
148
|
+
},
|
|
149
|
+
"all",
|
|
150
|
+
);
|
|
151
|
+
const isIncomplete = expressions.some(hasIncompleteCase);
|
|
152
|
+
incompleteCaseHyps.set(hyp, isIncomplete);
|
|
153
|
+
return isIncomplete;
|
|
154
|
+
};
|
|
155
|
+
|
|
156
|
+
const getModuleName = (source: string) => /-{4,}\s*MODULE\s+(\w+)/.exec(source)?.[1] ?? "Main";
|
|
157
|
+
|
|
158
|
+
const getObligationBase = (obligation: PrintedObligation): ObligationBase => ({
|
|
159
|
+
id: obligation.id,
|
|
160
|
+
location: obligation.location,
|
|
161
|
+
text: obligation.text,
|
|
162
|
+
});
|
|
163
|
+
|
|
164
|
+
const getUnprovedReport = (
|
|
165
|
+
obligation: PrintedObligation,
|
|
166
|
+
status: "failed" | "unsupported",
|
|
167
|
+
reason: string,
|
|
168
|
+
attempts: ProofAttempt[] = [],
|
|
169
|
+
): ProofReport => ({ obligation: { ...getObligationBase(obligation), status, reason }, attempts });
|
|
170
|
+
|
|
171
|
+
// A failed obligation as tlapm prints it: Prep.normalize_expand for a new failure, and
|
|
172
|
+
// Toolbox.normalize, which keeps pragmas, for a reused one.
|
|
173
|
+
export const formatNormalized = (obligation: PrintedObligation, isReused: boolean) =>
|
|
174
|
+
`${formatObligation(
|
|
175
|
+
isReused
|
|
176
|
+
? normalizeSequent(expandDefs(obligation.sequent, false))
|
|
177
|
+
: normalizeExpand(obligation),
|
|
178
|
+
)}\n`;
|
|
179
|
+
|
|
180
|
+
// The theory of the proofs Isabelle found. tlapm also writes Zenon's proofs there.
|
|
181
|
+
export const encodeProofTheory = (
|
|
182
|
+
name: string,
|
|
183
|
+
reports: ProofReport[],
|
|
184
|
+
obligations: PrintedObligation[],
|
|
185
|
+
) =>
|
|
186
|
+
encodeIsabelleTheory(
|
|
187
|
+
name,
|
|
188
|
+
reports.flatMap((report, index) =>
|
|
189
|
+
report.attempts
|
|
190
|
+
.filter(
|
|
191
|
+
(attempt) =>
|
|
192
|
+
attempt.method.prover === "isabelle" && attempt.isProved && !attempt.isReused,
|
|
193
|
+
)
|
|
194
|
+
.map((attempt) => ({
|
|
195
|
+
id: report.obligation.id,
|
|
196
|
+
sequent: shipFirstOrder(normalizeExpand(obligations[index])),
|
|
197
|
+
tactic: attempt.method.tactic ?? "auto",
|
|
198
|
+
})),
|
|
199
|
+
),
|
|
200
|
+
);
|
|
201
|
+
|
|
202
|
+
// The text one backend receives for an obligation, for comparing with tlapm's.
|
|
203
|
+
export const encodeForBackend = (
|
|
204
|
+
obligation: PrintedObligation,
|
|
205
|
+
prover: string,
|
|
206
|
+
session: EncodingSession,
|
|
207
|
+
) => {
|
|
208
|
+
const encode = ENCODERS[prover];
|
|
209
|
+
if (!encode) throw new TlaUnsupportedError(`the ${prover} backend`);
|
|
210
|
+
const methods = findMethods(obligation);
|
|
211
|
+
const method = methods.provers.find((candidate) => candidate.prover === prover) ?? {
|
|
212
|
+
prover,
|
|
213
|
+
timeLimitMs: Infinity,
|
|
214
|
+
};
|
|
215
|
+
return encode(obligation.id, normalizeExpand(obligation, methods), method, session);
|
|
216
|
+
};
|
|
217
|
+
|
|
218
|
+
// The SMT encoder's session for an obligation, from the count of CASE errors every earlier
|
|
219
|
+
// obligation leaves.
|
|
220
|
+
const getSession = async (run: ProveRun, index: number) => {
|
|
221
|
+
const task = run.tasks[index];
|
|
222
|
+
if (task.session) return task.session.current;
|
|
223
|
+
const earlier = run.tasks.slice(0, index);
|
|
224
|
+
await Promise.all(earlier.map((innerTask) => innerTask.done));
|
|
225
|
+
const initial = earlier.reduce(
|
|
226
|
+
(total, innerTask) =>
|
|
227
|
+
total +
|
|
228
|
+
(innerTask.session ? innerTask.session.current.caseErrors - innerTask.session.initial : 0),
|
|
229
|
+
0,
|
|
230
|
+
);
|
|
231
|
+
task.session = { initial, current: { caseErrors: initial } };
|
|
232
|
+
return task.session.current;
|
|
233
|
+
};
|
|
234
|
+
|
|
235
|
+
// Prep.ship: the provers the step cites, or tlapm's default ones when it cites none, each tried in
|
|
236
|
+
// turn until one proves the obligation. Prep.already_processed reuses what a prover concluded for
|
|
237
|
+
// an earlier obligation with the same fingerprint: a proof, or a failure within at least as much
|
|
238
|
+
// time. Unless the first prover's proof is reused, a trivial obligation needs no prover.
|
|
239
|
+
const proveWithBackends = async (
|
|
240
|
+
obligation: PrintedObligation,
|
|
241
|
+
index: number,
|
|
242
|
+
run: ProveRun,
|
|
243
|
+
signal: AbortSignal | undefined,
|
|
244
|
+
): Promise<ProofReport> => {
|
|
245
|
+
if (obligation.kind.kind === "Error")
|
|
246
|
+
return getUnprovedReport(obligation, "failed", obligation.kind.message);
|
|
247
|
+
const methods = findMethods(obligation);
|
|
248
|
+
const fingerprint = getFingerprint(obligation.sequent);
|
|
249
|
+
const earlier = run.lastByFingerprint.get(fingerprint);
|
|
250
|
+
run.lastByFingerprint.set(fingerprint, run.tasks[index].done);
|
|
251
|
+
await earlier;
|
|
252
|
+
const attempts: ProofAttempt[] = [];
|
|
253
|
+
const failures: MethodFailure[] = [];
|
|
254
|
+
const getProvedReport = (prover: string): ProofReport => ({
|
|
255
|
+
obligation: { ...getObligationBase(obligation), status: "proved", prover },
|
|
256
|
+
attempts,
|
|
257
|
+
});
|
|
258
|
+
// Prep.already_processed, which forgets the fingerprint's results on each call under --nofp.
|
|
259
|
+
const getPrior = (method: Method) => {
|
|
260
|
+
if (!run.isFingerprinted(obligation)) run.results.delete(fingerprint);
|
|
261
|
+
const prior = run.results.get(fingerprint)?.get(method.prover);
|
|
262
|
+
return prior?.method.tactic === method.tactic ? prior : undefined;
|
|
263
|
+
};
|
|
264
|
+
// Fpfile.get_timeout.
|
|
265
|
+
const getBudget = (method: Method) => method.rlimit ?? method.timeLimitMs / 1000;
|
|
266
|
+
const reuse = (prior: ProofAttempt) =>
|
|
267
|
+
attempts.push({ ...prior, isReused: true, timeUsedMs: undefined });
|
|
268
|
+
const record = (attempt: ProofAttempt) => {
|
|
269
|
+
attempts.push(attempt);
|
|
270
|
+
run.results.set(
|
|
271
|
+
fingerprint,
|
|
272
|
+
(run.results.get(fingerprint) ?? new Map()).set(attempt.method.prover, attempt),
|
|
273
|
+
);
|
|
274
|
+
};
|
|
275
|
+
const skip = (method: Method, reason: string) => {
|
|
276
|
+
attempts.push({ method, isProved: false, isReused: false, reason });
|
|
277
|
+
failures.push({ reason, isDecided: false });
|
|
278
|
+
};
|
|
279
|
+
const firstPrior = getPrior(methods.provers[0]);
|
|
280
|
+
if (firstPrior?.isProved) {
|
|
281
|
+
reuse(firstPrior);
|
|
282
|
+
return getProvedReport(firstPrior.method.prover);
|
|
283
|
+
}
|
|
284
|
+
const sequent = normalizeExpand(obligation, methods);
|
|
285
|
+
// Fpfile.fp_writes keeps no trivial result, but adds the fingerprint.
|
|
286
|
+
if (obligation.kind.kind === "Support" && isTrivial(sequent)) {
|
|
287
|
+
run.results.set(fingerprint, run.results.get(fingerprint) ?? new Map());
|
|
288
|
+
return { obligation: { ...getObligationBase(obligation), status: "trivial" }, attempts };
|
|
289
|
+
}
|
|
290
|
+
for (const method of methods.provers) {
|
|
291
|
+
const prior = getPrior(method);
|
|
292
|
+
if (prior?.isProved) {
|
|
293
|
+
reuse(prior);
|
|
294
|
+
return getProvedReport(method.prover);
|
|
295
|
+
}
|
|
296
|
+
if (prior && getBudget(prior.method) >= getBudget(method)) {
|
|
297
|
+
reuse(prior);
|
|
298
|
+
failures.push({
|
|
299
|
+
reason: `${method.prover} failed on an obligation with the same fingerprint`,
|
|
300
|
+
isDecided: true,
|
|
301
|
+
});
|
|
302
|
+
continue;
|
|
303
|
+
}
|
|
304
|
+
if (!run.isProving) continue;
|
|
305
|
+
// Prep.prove_with: the Trivial method proves anything.
|
|
306
|
+
if (method.prover === "trivial") return getProvedReport(method.prover);
|
|
307
|
+
const encode = ENCODERS[method.prover];
|
|
308
|
+
if (!encode) {
|
|
309
|
+
skip(method, `tla-ts has no ${method.prover} backend`);
|
|
310
|
+
continue;
|
|
311
|
+
}
|
|
312
|
+
try {
|
|
313
|
+
const isCaseNumbered =
|
|
314
|
+
encode === encodeSmtProblem &&
|
|
315
|
+
(sequent.context.some(isIncompleteCaseHyp) || hasIncompleteCase(sequent.active));
|
|
316
|
+
const session = isCaseNumbered ? await getSession(run, index) : { caseErrors: 0 };
|
|
317
|
+
const text = encode(obligation.id, sequent, method, session);
|
|
318
|
+
const decision = await run.decide(
|
|
319
|
+
method.prover,
|
|
320
|
+
text,
|
|
321
|
+
{ timeLimitMs: method.timeLimitMs, signal },
|
|
322
|
+
index,
|
|
323
|
+
);
|
|
324
|
+
const isProved = decision.verdict === "unsat";
|
|
325
|
+
record({
|
|
326
|
+
method,
|
|
327
|
+
isProved,
|
|
328
|
+
isReused: false,
|
|
329
|
+
...(!isProved && {
|
|
330
|
+
reason: decision.timeUsedMs >= method.timeLimitMs ? "timeout" : "false",
|
|
331
|
+
}),
|
|
332
|
+
verdict: decision.verdict,
|
|
333
|
+
timeUsedMs: decision.timeUsedMs,
|
|
334
|
+
});
|
|
335
|
+
if (isProved) return getProvedReport(method.prover);
|
|
336
|
+
failures.push({ reason: `${method.prover} answered ${decision.verdict}`, isDecided: true });
|
|
337
|
+
} catch (error) {
|
|
338
|
+
if (error instanceof TlaProverError) {
|
|
339
|
+
record({ method, isProved: false, isReused: false, reason: "false" });
|
|
340
|
+
failures.push({ reason: `${method.prover} failed: ${error.message}`, isDecided: true });
|
|
341
|
+
continue;
|
|
342
|
+
}
|
|
343
|
+
if (!(error instanceof TlaUnsupportedError)) throw error;
|
|
344
|
+
skip(method, `${method.prover} can't encode ${error.message}`);
|
|
345
|
+
}
|
|
346
|
+
}
|
|
347
|
+
return getUnprovedReport(
|
|
348
|
+
obligation,
|
|
349
|
+
failures.some((failure) => failure.isDecided) ? "failed" : "unsupported",
|
|
350
|
+
failures.map((failure) => failure.reason).join(", "),
|
|
351
|
+
attempts,
|
|
352
|
+
);
|
|
353
|
+
};
|
|
354
|
+
|
|
355
|
+
// An error that escapes proveWithBackends: what tla-ts can't handle is unsupported, and what tlapm
|
|
356
|
+
// refuses, as a frontend's soundness check, fails.
|
|
357
|
+
const getErrorReport = (obligation: PrintedObligation, error: unknown) => {
|
|
358
|
+
if (error instanceof TlaUnsupportedError)
|
|
359
|
+
return getUnprovedReport(obligation, "unsupported", error.message);
|
|
360
|
+
if (error instanceof TlaProverError)
|
|
361
|
+
return getUnprovedReport(obligation, "failed", error.message);
|
|
362
|
+
throw error;
|
|
363
|
+
};
|
|
364
|
+
|
|
365
|
+
interface ObligationsOptions {
|
|
366
|
+
workers?: number;
|
|
367
|
+
signal?: AbortSignal;
|
|
368
|
+
onReport?: (report: ProofReport, obligation: PrintedObligation) => void;
|
|
369
|
+
results?: Map<string, Map<string, ProofAttempt>>;
|
|
370
|
+
// --nofp and --nofpl.
|
|
371
|
+
isFingerprinted?: (obligation: PrintedObligation) => boolean;
|
|
372
|
+
// --noproving.
|
|
373
|
+
isProving?: boolean;
|
|
374
|
+
}
|
|
375
|
+
|
|
376
|
+
export const proveObligations = async (
|
|
377
|
+
obligations: PrintedObligation[],
|
|
378
|
+
options: ObligationsOptions,
|
|
379
|
+
) => {
|
|
380
|
+
const workerCount = options.workers ?? 1;
|
|
381
|
+
const pool =
|
|
382
|
+
workerCount > 1 && isWorkerSupported() ? await createDecidePool(workerCount) : undefined;
|
|
383
|
+
const onAbort = () => pool?.terminate(options.signal?.reason);
|
|
384
|
+
options.signal?.addEventListener("abort", onAbort);
|
|
385
|
+
const run: ProveRun = {
|
|
386
|
+
tasks: [],
|
|
387
|
+
results: options.results ?? new Map(),
|
|
388
|
+
isFingerprinted: options.isFingerprinted ?? (() => true),
|
|
389
|
+
isProving: options.isProving ?? true,
|
|
390
|
+
lastByFingerprint: new Map(),
|
|
391
|
+
decide:
|
|
392
|
+
pool?.decide ?? (async (prover, text, decideOptions) => decide(prover, text, decideOptions)),
|
|
393
|
+
};
|
|
394
|
+
// A few obligations per worker prove at once, and each reports once every earlier one has.
|
|
395
|
+
const limit = pool ? workerCount * 4 : 1;
|
|
396
|
+
const pending: Promise<ProofReport>[] = [];
|
|
397
|
+
const isSettled: boolean[] = [];
|
|
398
|
+
const running = new Set<Promise<void>>();
|
|
399
|
+
const reports: ProofReport[] = [];
|
|
400
|
+
const reportSettled = async () => {
|
|
401
|
+
while (isSettled[reports.length]) {
|
|
402
|
+
options.signal?.throwIfAborted();
|
|
403
|
+
const report = await pending[reports.length];
|
|
404
|
+
reports.push(report);
|
|
405
|
+
options.onReport?.(report, obligations[reports.length - 1]);
|
|
406
|
+
// HACK: backends on this thread run synchronously, so yield to let an abort land.
|
|
407
|
+
await new Promise((resolve) => setTimeout(resolve));
|
|
408
|
+
}
|
|
409
|
+
};
|
|
410
|
+
try {
|
|
411
|
+
for (const [index, obligation] of obligations.entries()) {
|
|
412
|
+
options.signal?.throwIfAborted();
|
|
413
|
+
const done = Promise.withResolvers<void>();
|
|
414
|
+
run.tasks.push({ done: done.promise, session: undefined });
|
|
415
|
+
const report = proveWithBackends(obligation, index, run, options.signal).catch(
|
|
416
|
+
(error: unknown) => getErrorReport(obligation, error),
|
|
417
|
+
);
|
|
418
|
+
pending.push(report);
|
|
419
|
+
running.add(done.promise);
|
|
420
|
+
const settle = () => {
|
|
421
|
+
isSettled[index] = true;
|
|
422
|
+
running.delete(done.promise);
|
|
423
|
+
done.resolve();
|
|
424
|
+
};
|
|
425
|
+
void report.then(settle, settle);
|
|
426
|
+
if (running.size >= limit) await Promise.race(running);
|
|
427
|
+
await reportSettled();
|
|
428
|
+
}
|
|
429
|
+
await Promise.all(running);
|
|
430
|
+
await reportSettled();
|
|
431
|
+
} finally {
|
|
432
|
+
options.signal?.removeEventListener("abort", onAbort);
|
|
433
|
+
pool?.terminate(new TlaProverError("prove stopped"));
|
|
434
|
+
}
|
|
435
|
+
return reports;
|
|
436
|
+
};
|
|
437
|
+
|
|
438
|
+
const getTlapmObligation = (
|
|
439
|
+
obligation: PrintedObligation,
|
|
440
|
+
result: TlapmResult | undefined,
|
|
441
|
+
): ProofObligation => ({
|
|
442
|
+
...getObligationBase(obligation),
|
|
443
|
+
...(result ?? { status: "unsupported", reason: "tlapm reported no result" }),
|
|
444
|
+
});
|
|
445
|
+
|
|
446
|
+
export const prove = async (options: ProveOptions): Promise<ProveResult> => {
|
|
447
|
+
const name = getModuleName(options.source);
|
|
448
|
+
const modules = new Map<string, string>();
|
|
449
|
+
const results = getObligations(
|
|
450
|
+
[{ file: `${name}.tla`, source: options.source }],
|
|
451
|
+
(moduleName) => {
|
|
452
|
+
const source = options.loadModule?.(moduleName);
|
|
453
|
+
if (source !== undefined) modules.set(moduleName, source);
|
|
454
|
+
const loaded = source ?? (moduleName === "TLAPS" ? TLAPS_MODULE : undefined);
|
|
455
|
+
return loaded === undefined ? undefined : { file: `${moduleName}.tla`, source: loaded };
|
|
456
|
+
},
|
|
457
|
+
);
|
|
458
|
+
const obligations = results.flatMap((result) => result.obligations);
|
|
459
|
+
const counts = {
|
|
460
|
+
missingProofCount: results.reduce((total, result) => total + result.summary.absent.length, 0),
|
|
461
|
+
omittedProofCount: results.reduce((total, result) => total + result.summary.omitted.length, 0),
|
|
462
|
+
};
|
|
463
|
+
if (options.backend === "tlapm") {
|
|
464
|
+
if (typeof process === "undefined" || process.versions?.node === undefined)
|
|
465
|
+
throw new TlaUnsupportedError("The tlapm backend runs only in Node and Bun.");
|
|
466
|
+
const tlapm = await import("./tlapm/tlapm");
|
|
467
|
+
const byId = new Map(obligations.map((obligation) => [obligation.id, obligation]));
|
|
468
|
+
const reported = await tlapm.proveWithTlapm(
|
|
469
|
+
name,
|
|
470
|
+
new Map([[name, options.source], ...modules]),
|
|
471
|
+
{
|
|
472
|
+
signal: options.signal,
|
|
473
|
+
onResult: (id, result) => {
|
|
474
|
+
const obligation = byId.get(id);
|
|
475
|
+
if (obligation) options.onObligation?.(getTlapmObligation(obligation, result));
|
|
476
|
+
},
|
|
477
|
+
},
|
|
478
|
+
);
|
|
479
|
+
return {
|
|
480
|
+
obligations: obligations.map((obligation) =>
|
|
481
|
+
getTlapmObligation(obligation, reported.get(obligation.id)),
|
|
482
|
+
),
|
|
483
|
+
...counts,
|
|
484
|
+
};
|
|
485
|
+
}
|
|
486
|
+
const reports = await proveObligations(obligations, {
|
|
487
|
+
workers: options.workers,
|
|
488
|
+
signal: options.signal,
|
|
489
|
+
onReport: (report) => options.onObligation?.(report.obligation),
|
|
490
|
+
});
|
|
491
|
+
return { obligations: reports.map((report) => report.obligation), ...counts };
|
|
492
|
+
};
|
|
@@ -4,39 +4,28 @@
|
|
|
4
4
|
// The text is the negated obligation.
|
|
5
5
|
|
|
6
6
|
import {
|
|
7
|
-
adjoin,
|
|
8
|
-
applyBuiltin,
|
|
9
|
-
at,
|
|
10
7
|
bumpBy,
|
|
11
|
-
mapAccumulate,
|
|
12
|
-
mapScoped,
|
|
13
8
|
shift,
|
|
14
9
|
shiftExpr,
|
|
15
10
|
substituteExpr,
|
|
16
11
|
substituteHyp,
|
|
12
|
+
type Substitution,
|
|
13
|
+
} from "../../obligations/substitution";
|
|
14
|
+
import {
|
|
15
|
+
adjoin,
|
|
16
|
+
applyBuiltin,
|
|
17
|
+
at,
|
|
18
|
+
mapAccumulate,
|
|
19
|
+
mapScoped,
|
|
17
20
|
type Builtin,
|
|
18
21
|
type Expr,
|
|
19
22
|
type Hyp,
|
|
20
|
-
type Level,
|
|
21
23
|
type Scope,
|
|
22
24
|
type Sequent,
|
|
23
|
-
type Substitution,
|
|
24
25
|
} from "../../obligations/expression";
|
|
25
|
-
import { renderDoc } from "../../obligations/format";
|
|
26
26
|
import { getLevelInfo } from "../../obligations/levels";
|
|
27
|
-
import { printExpression } from "../../obligations/printer";
|
|
28
27
|
import { expandAction, expandFairness, expandLeadsto, getTime } from "../../obligations/temporal";
|
|
29
|
-
import {
|
|
30
|
-
|
|
31
|
-
const KIND_NAMES: Record<Level, string> = {
|
|
32
|
-
Constant: "CONSTANT",
|
|
33
|
-
State: "STATE",
|
|
34
|
-
Action: "ACTION",
|
|
35
|
-
Temporal: "TEMPORAL",
|
|
36
|
-
Unknown: "Unknown",
|
|
37
|
-
};
|
|
38
|
-
|
|
39
|
-
const LEVEL_NAMES = ["CONSTANT", "STATE", "ACTION", "TEMPORAL"];
|
|
28
|
+
import { getHashName, LEVEL_NUMBER_PREFIXES, LEVEL_PREFIXES } from "../prep/action";
|
|
40
29
|
|
|
41
30
|
// Coalesce.rename_with_loc: each declared name gets its kind in front, or its level for a definition,
|
|
42
31
|
// as in VARIABLE_x_ and CONSTANT_i_, so atoms print with the names tlapm hashes. A variable a
|
|
@@ -51,7 +40,7 @@ const renameSequent = (scope: Scope | undefined, sequent: Sequent): Sequent => {
|
|
|
51
40
|
case "Fresh":
|
|
52
41
|
return {
|
|
53
42
|
...hyp,
|
|
54
|
-
name: `${
|
|
43
|
+
name: `${LEVEL_PREFIXES[hyp.level]}_${hyp.name}_`,
|
|
55
44
|
domain: hyp.domain && renameDeclarations(current, hyp.domain),
|
|
56
45
|
};
|
|
57
46
|
case "Flex":
|
|
@@ -60,7 +49,7 @@ const renameSequent = (scope: Scope | undefined, sequent: Sequent): Sequent => {
|
|
|
60
49
|
const definition = hyp.definition;
|
|
61
50
|
if (definition.kind !== "Operator") return hyp;
|
|
62
51
|
const body = renameDeclarations(current, definition.body);
|
|
63
|
-
const level =
|
|
52
|
+
const level = LEVEL_NUMBER_PREFIXES[getLevelInfo(current, body).level];
|
|
64
53
|
return {
|
|
65
54
|
...hyp,
|
|
66
55
|
definition: { ...definition, name: `${level}_${definition.name}_`, body },
|
|
@@ -93,7 +82,7 @@ const renameDeclarations = (scope: Scope | undefined, expression: Expr): Expr =>
|
|
|
93
82
|
...mapped,
|
|
94
83
|
bounds: mapped.bounds.map((bound) => ({
|
|
95
84
|
...bound,
|
|
96
|
-
name: `${
|
|
85
|
+
name: `${LEVEL_PREFIXES[bound.level]}_${bound.name}_`,
|
|
97
86
|
})),
|
|
98
87
|
};
|
|
99
88
|
case "Choose":
|
|
@@ -126,13 +115,12 @@ const prepareHyps = (scope: Scope | undefined, expression: Expr): Expr => {
|
|
|
126
115
|
};
|
|
127
116
|
for (const original of expression.sequent.context) {
|
|
128
117
|
const hyp = substituteHyp(state.substitution, original);
|
|
129
|
-
if (hyp.kind === "Fact") {
|
|
130
|
-
push({ ...hyp, expression: prepareHyps(state.scope, hyp.expression) });
|
|
131
|
-
state.substitution = bumpBy(1, state.substitution);
|
|
132
|
-
continue;
|
|
133
|
-
}
|
|
134
118
|
if (hyp.kind !== "Fresh" || !hyp.domain || original.kind !== "Fresh" || !original.domain) {
|
|
135
|
-
push(
|
|
119
|
+
push(
|
|
120
|
+
hyp.kind === "Fact"
|
|
121
|
+
? { ...hyp, expression: prepareHyps(state.scope, hyp.expression) }
|
|
122
|
+
: hyp,
|
|
123
|
+
);
|
|
136
124
|
state.substitution = bumpBy(1, state.substitution);
|
|
137
125
|
continue;
|
|
138
126
|
}
|
|
@@ -247,8 +235,8 @@ export const encodePtl = (sequent: Sequent): string => {
|
|
|
247
235
|
return facts.length === 0 ? goal : `(${facts.join(" & ")} -> ${goal})`;
|
|
248
236
|
}
|
|
249
237
|
}
|
|
250
|
-
// Pltl.coalesce_fol
|
|
251
|
-
return
|
|
238
|
+
// Pltl.coalesce_fol names an atom as Coalesce does.
|
|
239
|
+
return getHashName(hyps, expression);
|
|
252
240
|
};
|
|
253
241
|
const renamed = renameDeclarations(undefined, { kind: "Sequent", sequent });
|
|
254
242
|
const prepared = prepareHyps(undefined, expandAction(expandLeadsto(expandFairness(renamed))));
|