tla-ts 0.0.8 → 0.0.9-dev.0493be549
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 +30 -0
- package/dist/compile.cjs +23 -0
- package/dist/compile.js +23 -0
- package/dist/deciders.cjs +28 -28
- package/dist/deciders.js +43 -43
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +98 -19
- package/dist/index.d.ts +98 -19
- 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 +116 -36
- package/dist/prove.js +116 -36
- package/dist/run.cjs +143 -31
- package/dist/run.js +143 -31
- package/dist/tlapm.cjs +2 -2
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +128 -106
- package/dist/transfer.js +128 -106
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +3 -1
- package/src/ast.ts +7 -21
- package/src/bags.ts +99 -99
- package/src/builtins.ts +44 -75
- package/src/bundled-modules.ts +1 -8
- package/src/check.ts +605 -311
- package/src/cli/options.ts +12 -6
- package/src/cli/run.ts +2 -2
- package/src/cli/runtime-invariants.ts +135 -0
- package/src/cli/shared.ts +20 -9
- package/src/cli/tlapm.ts +0 -12
- package/src/cli/tlc-arguments.ts +646 -0
- package/src/cli/tlc-usage.ts +362 -0
- package/src/cli/tlc.ts +545 -218
- package/src/cli/typescript.ts +23 -0
- package/src/cli/xml-exporter.ts +4 -16
- package/src/cli.ts +0 -1
- package/src/codegen.ts +191 -69
- package/src/config.ts +140 -109
- package/src/coverage.ts +837 -0
- package/src/dependencies.ts +314 -24
- package/src/dfid.ts +618 -0
- package/src/environment.ts +263 -129
- package/src/errors.ts +70 -55
- package/src/evaluate.ts +734 -980
- package/src/exit-codes.ts +37 -3
- package/src/fingerprints.ts +10 -10
- package/src/index.ts +3 -0
- package/src/instances.ts +79 -11
- package/src/java-overrides.ts +2 -12
- package/src/json-reader.ts +456 -0
- package/src/json.ts +262 -139
- package/src/levels.ts +2 -3
- package/src/lexer.ts +150 -70
- package/src/liveness-checker.ts +10 -18
- package/src/liveness.ts +122 -64
- package/src/obligations/action.ts +4 -28
- package/src/obligations/anonymize.ts +84 -80
- package/src/obligations/equality.ts +1 -1
- package/src/obligations/expression.ts +2 -19
- package/src/obligations/format.ts +1 -9
- package/src/obligations/generate.ts +1 -11
- package/src/obligations/index.ts +0 -11
- package/src/obligations/levels.ts +4 -8
- package/src/obligations/module.ts +1 -15
- package/src/obligations/normalize.ts +5 -24
- package/src/obligations/operators.ts +1 -2
- package/src/obligations/pragma.ts +1 -10
- package/src/obligations/printer.ts +47 -46
- package/src/obligations/proof.ts +1 -5
- package/src/obligations/regroup.ts +1 -4
- package/src/obligations/simplify.ts +3 -14
- package/src/obligations/source.ts +1 -21
- package/src/obligations/subexpression.ts +5 -11
- package/src/obligations/substitution.ts +1 -3
- package/src/obligations/temporal.ts +8 -14
- package/src/obligations/tuples.ts +3 -9
- package/src/parallel-worker.ts +31 -38
- package/src/parallel.ts +41 -17
- package/src/parser.ts +436 -90
- package/src/pcal/ast.ts +7 -28
- package/src/pcal/parse.ts +11 -39
- package/src/pcal/tokenize.ts +4 -20
- package/src/pcal/translate.ts +10 -42
- package/src/pcal/validate.ts +3 -21
- package/src/pretty-print.ts +1 -2
- package/src/prover/decide-pool.ts +5 -10
- package/src/prover/deciders.ts +0 -4
- package/src/prover/first-order.ts +0 -11
- package/src/prover/isabelle/decide.ts +0 -6
- package/src/prover/isabelle/encode.ts +11 -23
- package/src/prover/isabelle/isar/inner-syntax.ts +108 -114
- package/src/prover/isabelle/isar/method.ts +25 -38
- package/src/prover/isabelle/isar/proof.ts +1 -10
- package/src/prover/isabelle/isar/statement.ts +1 -6
- package/src/prover/isabelle/isar/theory.ts +15 -26
- package/src/prover/isabelle/isar/type-check.ts +11 -25
- package/src/prover/isabelle/provers/blast/blast.ts +10 -41
- package/src/prover/isabelle/provers/blast/branch.ts +1 -32
- package/src/prover/isabelle/provers/blast/prove.ts +1 -35
- package/src/prover/isabelle/provers/blast/rules.ts +6 -44
- package/src/prover/isabelle/provers/blast/state.ts +2 -28
- package/src/prover/isabelle/provers/blast/term.ts +9 -36
- package/src/prover/isabelle/provers/clasimp.ts +1 -13
- package/src/prover/isabelle/provers/classical.ts +14 -42
- package/src/prover/isabelle/provers/hypsubst.ts +11 -25
- package/src/prover/isabelle/pure/bicompose.ts +16 -13
- package/src/prover/isabelle/pure/consts.ts +1 -7
- package/src/prover/isabelle/pure/conv.ts +1 -9
- package/src/prover/isabelle/pure/drule.ts +24 -40
- package/src/prover/isabelle/pure/envir.ts +3 -52
- package/src/prover/isabelle/pure/goal.ts +1 -7
- package/src/prover/isabelle/pure/interrupt.ts +0 -5
- package/src/prover/isabelle/pure/list.ts +0 -3
- package/src/prover/isabelle/pure/logic.ts +1 -14
- package/src/prover/isabelle/pure/name.ts +2 -9
- package/src/prover/isabelle/pure/net.ts +3 -59
- package/src/prover/isabelle/pure/object-logic.ts +3 -10
- package/src/prover/isabelle/pure/pattern.ts +2 -19
- package/src/prover/isabelle/pure/raw-simplifier.ts +13 -49
- package/src/prover/isabelle/pure/rewriter.ts +26 -58
- package/src/prover/isabelle/pure/search.ts +3 -10
- package/src/prover/isabelle/pure/seq.ts +1 -10
- package/src/prover/isabelle/pure/simplifier.ts +4 -12
- package/src/prover/isabelle/pure/table.ts +1 -31
- package/src/prover/isabelle/pure/tactic.ts +12 -22
- package/src/prover/isabelle/pure/tactical.ts +6 -12
- package/src/prover/isabelle/pure/term-ord.ts +2 -6
- package/src/prover/isabelle/pure/term.ts +2 -43
- package/src/prover/isabelle/pure/thm.ts +13 -36
- package/src/prover/isabelle/pure/type.ts +2 -15
- package/src/prover/isabelle/pure/unify.ts +20 -30
- package/src/prover/isabelle/pure/variable.ts +3 -7
- package/src/prover/isabelle/tla/classical-setup.ts +9 -19
- package/src/prover/isabelle/tla/context.ts +8 -16
- package/src/prover/isabelle/tla/logic.ts +4 -11
- package/src/prover/isabelle/tla/simpdata.ts +46 -34
- package/src/prover/isabelle/tools/intuitionistic.ts +1 -10
- package/src/prover/ocaml.ts +0 -6
- package/src/prover/prep/action.ts +4 -36
- package/src/prover/prep/enabled-axioms.ts +12 -19
- package/src/prover/prep/fingerprint.ts +0 -16
- package/src/prover/prep/level-comparison.ts +8 -12
- package/src/prover/prep/md5.ts +0 -2
- package/src/prover/prep/methods.ts +9 -36
- package/src/prover/prep/normalize.ts +4 -28
- package/src/prover/prove-worker.ts +0 -2
- package/src/prover/prove.ts +0 -36
- package/src/prover/ptl/decide.ts +7 -12
- package/src/prover/ptl/encode.ts +14 -36
- package/src/prover/ptl/sat.ts +24 -32
- package/src/prover/ptl/tableau.ts +12 -26
- package/src/prover/smt/axioms.ts +0 -7
- package/src/prover/smt/context.ts +19 -26
- package/src/prover/smt/data.ts +51 -54
- package/src/prover/smt/encode.ts +14 -35
- package/src/prover/smt/extensionality.ts +0 -10
- package/src/prover/smt/flatten.ts +3 -22
- package/src/prover/smt/format.ts +5 -10
- package/src/prover/smt/instances.ts +0 -10
- package/src/prover/smt/rewrite.ts +66 -101
- package/src/prover/smt/solver/act-cache.ts +0 -15
- package/src/prover/smt/solver/arith-rewriter.ts +3 -48
- package/src/prover/smt/solver/array.ts +1 -3
- package/src/prover/smt/solver/asserted-formulas.ts +1 -43
- package/src/prover/smt/solver/ast-lt.ts +1 -11
- package/src/prover/smt/solver/ast-util.ts +1 -6
- package/src/prover/smt/solver/ast.ts +1 -143
- package/src/prover/smt/solver/auf-solver.ts +6 -39
- package/src/prover/smt/solver/case-split-queue.ts +1 -9
- package/src/prover/smt/solver/cg-table.ts +1 -18
- package/src/prover/smt/solver/clause.ts +1 -27
- package/src/prover/smt/solver/conflict-resolution.ts +0 -9
- package/src/prover/smt/solver/context.ts +4 -61
- package/src/prover/smt/solver/ctx-simplify.ts +14 -41
- package/src/prover/smt/solver/der.ts +2 -21
- package/src/prover/smt/solver/dyn-ack.ts +1 -11
- package/src/prover/smt/solver/e-matching.ts +3 -34
- package/src/prover/smt/solver/enode.ts +1 -21
- package/src/prover/smt/solver/expr-ref.ts +1 -5
- package/src/prover/smt/solver/expr-safe-replace.ts +0 -5
- package/src/prover/smt/solver/fingerprints.ts +1 -12
- package/src/prover/smt/solver/flat-literals.ts +1 -9
- package/src/prover/smt/solver/goal.ts +2 -14
- package/src/prover/smt/solver/hash.ts +0 -8
- package/src/prover/smt/solver/hashtable.ts +1 -12
- package/src/prover/smt/solver/internalizer.ts +6 -98
- package/src/prover/smt/solver/lbool.ts +1 -2
- package/src/prover/smt/solver/literal.ts +0 -3
- package/src/prover/smt/solver/lp/bound-propagator.ts +8 -26
- package/src/prover/smt/solver/lp/constraints.ts +2 -8
- package/src/prover/smt/solver/lp/containers.ts +12 -30
- package/src/prover/smt/solver/lp/core-solver.ts +10 -31
- package/src/prover/smt/solver/lp/cross-nested.ts +6 -20
- package/src/prover/smt/solver/lp/dep-intervals.ts +7 -22
- package/src/prover/smt/solver/lp/dependency.ts +1 -4
- package/src/prover/smt/solver/lp/dioph-eq.ts +12 -98
- package/src/prover/smt/solver/lp/explanation.ts +1 -6
- package/src/prover/smt/solver/lp/gomory.ts +9 -22
- package/src/prover/smt/solver/lp/hnf-cutter.ts +17 -23
- package/src/prover/smt/solver/lp/hnf.ts +11 -26
- package/src/prover/smt/solver/lp/int-cube.ts +15 -36
- package/src/prover/smt/solver/lp/int-solver.ts +4 -34
- package/src/prover/smt/solver/lp/lar-solver.ts +32 -81
- package/src/prover/smt/solver/lp/lar-term.ts +1 -5
- package/src/prover/smt/solver/lp/lp-settings.ts +1 -14
- package/src/prover/smt/solver/lp/maximize-term.ts +20 -45
- package/src/prover/smt/solver/lp/nex-creator.ts +5 -28
- package/src/prover/smt/solver/lp/nex.ts +1 -6
- package/src/prover/smt/solver/lp/nla-backoff.ts +1 -4
- package/src/prover/smt/solver/lp/nla-basics.ts +5 -30
- package/src/prover/smt/solver/lp/nla-core.ts +35 -130
- package/src/prover/smt/solver/lp/nla-divisions.ts +32 -42
- package/src/prover/smt/solver/lp/nla-emonics.ts +4 -21
- package/src/prover/smt/solver/lp/nla-factorization.ts +1 -4
- package/src/prover/smt/solver/lp/nla-grobner.ts +15 -69
- package/src/prover/smt/solver/lp/nla-horner.ts +3 -11
- package/src/prover/smt/solver/lp/nla-intervals.ts +2 -12
- package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +16 -41
- package/src/prover/smt/solver/lp/nla-monotone.ts +2 -6
- package/src/prover/smt/solver/lp/nla-order.ts +2 -13
- package/src/prover/smt/solver/lp/nla-patcher.ts +4 -7
- package/src/prover/smt/solver/lp/nla-tangents.ts +1 -9
- package/src/prover/smt/solver/lp/nla-throttle.ts +1 -6
- package/src/prover/smt/solver/lp/nla-types.ts +1 -11
- package/src/prover/smt/solver/lp/nla-var-eqs.ts +4 -25
- package/src/prover/smt/solver/lp/nra-solver.ts +5 -52
- package/src/prover/smt/solver/lp/numeric-pair.ts +1 -4
- package/src/prover/smt/solver/lp/pdd-interval.ts +1 -3
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +2 -14
- package/src/prover/smt/solver/lp/pdd-solver.ts +4 -33
- package/src/prover/smt/solver/lp/pdd.ts +7 -70
- package/src/prover/smt/solver/lp/random-updater.ts +1 -8
- package/src/prover/smt/solver/lp/static-matrix.ts +9 -19
- package/src/prover/smt/solver/lp/union-find.ts +1 -6
- package/src/prover/smt/solver/mam-compiler.ts +14 -56
- package/src/prover/smt/solver/mam-interpreter.ts +1 -21
- package/src/prover/smt/solver/maximize-ac-sharing.ts +2 -17
- package/src/prover/smt/solver/model-checker.ts +2 -36
- package/src/prover/smt/solver/model-evaluator.ts +3 -29
- package/src/prover/smt/solver/model-finder.ts +3 -15
- package/src/prover/smt/solver/model-generator.ts +1 -12
- package/src/prover/smt/solver/model-macro-solver.ts +12 -69
- package/src/prover/smt/solver/nlsat/algebraic.ts +55 -151
- package/src/prover/smt/solver/nlsat/atoms.ts +5 -19
- package/src/prover/smt/solver/nlsat/evaluator.ts +17 -22
- package/src/prover/smt/solver/nlsat/explain.ts +3 -47
- package/src/prover/smt/solver/nlsat/interval-set.ts +9 -50
- package/src/prover/smt/solver/nlsat/levelwise.ts +48 -129
- package/src/prover/smt/solver/nlsat/mpbq.ts +3 -14
- package/src/prover/smt/solver/nlsat/polynomial.ts +17 -156
- package/src/prover/smt/solver/nlsat/solver.ts +7 -67
- package/src/prover/smt/solver/nlsat/types.ts +1 -8
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +1 -44
- package/src/prover/smt/solver/nlsat/upolynomial.ts +11 -92
- package/src/prover/smt/solver/nnf.ts +3 -38
- package/src/prover/smt/solver/pattern-inference.ts +2 -15
- package/src/prover/smt/solver/poly-rewriter.ts +3 -23
- package/src/prover/smt/solver/propagate-values.ts +1 -10
- package/src/prover/smt/solver/proto-model.ts +3 -48
- package/src/prover/smt/solver/pull-quant.ts +1 -12
- package/src/prover/smt/solver/qe-lite-der.ts +1 -29
- package/src/prover/smt/solver/qe-lite-fm.ts +2 -25
- package/src/prover/smt/solver/qe-lite.ts +3 -33
- package/src/prover/smt/solver/qi-queue.ts +1 -16
- package/src/prover/smt/solver/quant-tactics.ts +5 -22
- package/src/prover/smt/solver/quantifier-analyzer.ts +17 -37
- package/src/prover/smt/solver/quantifier-manager.ts +1 -8
- package/src/prover/smt/solver/random-gen.ts +1 -2
- package/src/prover/smt/solver/rational.ts +1 -8
- package/src/prover/smt/solver/ref-vector.ts +1 -6
- package/src/prover/smt/solver/relevancy.ts +2 -15
- package/src/prover/smt/solver/rewriter-tpl.ts +3 -147
- package/src/prover/smt/solver/rewriter.ts +3 -85
- package/src/prover/smt/solver/rlimit.ts +2 -20
- package/src/prover/smt/solver/smtlib-parser.ts +2 -37
- package/src/prover/smt/solver/solver.ts +23 -34
- package/src/prover/smt/solver/sort.ts +1 -5
- package/src/prover/smt/solver/sticky-generations.ts +0 -5
- package/src/prover/smt/solver/theory-lra-axioms.ts +3 -24
- package/src/prover/smt/solver/theory-lra-bounds.ts +0 -5
- package/src/prover/smt/solver/theory-lra-final-check.ts +4 -22
- package/src/prover/smt/solver/theory-lra-internalize.ts +1 -27
- package/src/prover/smt/solver/theory-lra-model.ts +4 -19
- package/src/prover/smt/solver/theory-lra-propagate.ts +1 -15
- package/src/prover/smt/solver/theory-lra-state.ts +3 -8
- package/src/prover/smt/solver/theory-lra.ts +1 -8
- package/src/prover/smt/solver/var-subst.ts +2 -26
- package/src/prover/smt/table.ts +0 -8
- package/src/prover/tlapm/cache.ts +20 -25
- package/src/prover/tlapm/ocaml-marshal.ts +19 -21
- package/src/prover/tlapm/tlapm.ts +12 -17
- package/src/prover/verdict.ts +0 -2
- package/src/prover/zenon/check/check.ts +0 -9
- package/src/prover/zenon/check/definitions.ts +5 -15
- package/src/prover/zenon/check/equality.ts +0 -8
- package/src/prover/zenon/check/functions.ts +0 -4
- package/src/prover/zenon/check/keys.ts +0 -7
- package/src/prover/zenon/check/propositional.ts +0 -3
- package/src/prover/zenon/check/records.ts +0 -5
- package/src/prover/zenon/check/relations.ts +0 -13
- package/src/prover/zenon/check/rewrites.ts +0 -6
- package/src/prover/zenon/check/sets.ts +0 -3
- package/src/prover/zenon/check/terms.ts +0 -17
- package/src/prover/zenon/check/tla.ts +0 -6
- package/src/prover/zenon/decide.ts +0 -12
- package/src/prover/zenon/encode.ts +1 -8
- package/src/prover/zenon/eqrel.ts +0 -13
- package/src/prover/zenon/equality-rules.ts +0 -4
- package/src/prover/zenon/expr.ts +1 -26
- package/src/prover/zenon/index-table.ts +17 -38
- package/src/prover/zenon/isar-case.ts +9 -19
- package/src/prover/zenon/isar.ts +1 -29
- package/src/prover/zenon/limits.ts +0 -4
- package/src/prover/zenon/llproof.ts +0 -9
- package/src/prover/zenon/mltoll.ts +54 -76
- package/src/prover/zenon/node.ts +1 -11
- package/src/prover/zenon/ocaml.ts +1 -17
- package/src/prover/zenon/parse.ts +2 -7
- package/src/prover/zenon/phrase.ts +1 -11
- package/src/prover/zenon/proof.ts +0 -9
- package/src/prover/zenon/propositional-rules.ts +0 -5
- package/src/prover/zenon/rules.ts +2 -6
- package/src/prover/zenon/search.ts +1 -17
- package/src/prover/zenon/tla/functions.ts +57 -29
- package/src/prover/zenon/tla/llproof.ts +63 -70
- package/src/prover/zenon/tla/records.ts +56 -27
- package/src/prover/zenon/tla/rewrites.ts +12 -19
- package/src/prover/zenon/tla/sets.ts +68 -39
- package/src/prover/zenon/tla/terms.ts +0 -6
- package/src/prover/zenon/tla/tla.ts +59 -58
- package/src/randomization.ts +84 -35
- package/src/resolve.ts +18 -60
- package/src/runtime.ts +11 -4
- package/src/sany/builtins.ts +3 -4
- package/src/sany/generator.ts +128 -176
- package/src/sany/levels.ts +6 -30
- package/src/sany/lexer.ts +7 -23
- package/src/sany/linter.ts +31 -29
- package/src/sany/modules.ts +1 -5
- package/src/sany/nodes.ts +0 -31
- package/src/sany/parse-error.ts +39 -117
- package/src/sany/report.ts +29 -63
- package/src/sany/selectors.ts +15 -39
- package/src/sany/source.ts +1 -17
- package/src/sany/xml.ts +13 -63
- package/src/search.ts +536 -180
- package/src/simulate.ts +694 -0
- package/src/spec-description.ts +167 -49
- package/src/standard-definitions.ts +2 -3
- package/src/standard-modules.ts +264 -68
- package/src/state-graph.ts +51 -18
- package/src/subexpressions.ts +31 -5
- package/src/substitution-levels.ts +2 -3
- package/src/successors.ts +269 -85
- package/src/symmetry.ts +59 -147
- package/src/tableau.ts +27 -24
- package/src/tlc/fingerprint.ts +226 -151
- package/src/tlc/jar-data.ts +113 -6
- package/src/tlc/messages.ts +122 -37
- package/src/tlc/order.ts +56 -82
- package/src/tlc/random.ts +16 -16
- package/src/tlc/replay.ts +564 -212
- package/src/tlc/summary.ts +2 -4
- package/src/tlc/tlc-operators.ts +81 -36
- package/src/tlc/tlcext-operators.ts +138 -117
- package/src/tlc/trace-spec.ts +273 -0
- package/src/tlc/value-stream.ts +143 -0
- package/src/tlc/version.ts +2 -4
- package/src/transfer.ts +22 -25
- package/src/typescript/actions.ts +481 -0
- package/src/typescript/collections.ts +600 -0
- package/src/typescript/compile.ts +65 -0
- package/src/typescript/context.ts +94 -0
- package/src/typescript/emit.ts +121 -0
- package/src/typescript/expressions.ts +496 -0
- package/src/typescript/formula.ts +152 -0
- package/src/typescript/functions.ts +284 -0
- package/src/typescript/model.ts +163 -0
- package/src/typescript/names.ts +114 -0
- package/src/typescript/program.ts +48 -0
- package/src/typescript/properties.ts +139 -0
- package/src/typescript/scope.ts +112 -0
- package/src/typescript/steps.ts +165 -0
- package/src/typescript/types.ts +171 -0
- package/src/values.ts +910 -318
- package/src/worker.ts +7 -8
package/src/prover/prove.ts
CHANGED
|
@@ -1,5 +1,3 @@
|
|
|
1
|
-
// Proves a module's obligations with tla-ts's own backends, in tlapm's order, or with tlapm.
|
|
2
|
-
|
|
3
1
|
import { TlaProverError, TlaUnsupportedError } from "../errors";
|
|
4
2
|
import { getChildren, mapHyp, type Expr, type Hyp, type Sequent } from "../obligations/expression";
|
|
5
3
|
import { getObligations, type PrintedObligation } from "../obligations";
|
|
@@ -65,7 +63,6 @@ export interface ProveOptions {
|
|
|
65
63
|
workers?: number;
|
|
66
64
|
}
|
|
67
65
|
|
|
68
|
-
// What one method concluded about an obligation, as tlapm's toolbox messages report it.
|
|
69
66
|
export interface ProofAttempt {
|
|
70
67
|
method: Method;
|
|
71
68
|
isProved: boolean;
|
|
@@ -80,21 +77,16 @@ interface ProofReport {
|
|
|
80
77
|
attempts: ProofAttempt[];
|
|
81
78
|
}
|
|
82
79
|
|
|
83
|
-
// Why a method left an obligation unproved: a prover decided so, or tla-ts couldn't try it.
|
|
84
80
|
interface MethodFailure {
|
|
85
81
|
reason: string;
|
|
86
82
|
isDecided: boolean;
|
|
87
83
|
}
|
|
88
84
|
|
|
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
85
|
interface ObligationTask {
|
|
92
86
|
done: Promise<void>;
|
|
93
87
|
session: { initial: number; current: EncodingSession } | undefined;
|
|
94
88
|
}
|
|
95
89
|
|
|
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
90
|
interface ProveRun {
|
|
99
91
|
tasks: ObligationTask[];
|
|
100
92
|
results: Map<string, Map<string, ProofAttempt>>;
|
|
@@ -104,15 +96,10 @@ interface ProveRun {
|
|
|
104
96
|
decide: DecidePool["decide"];
|
|
105
97
|
}
|
|
106
98
|
|
|
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
99
|
type Encoder = (id: number, sequent: Sequent, method: Method, session: EncodingSession) => string;
|
|
110
100
|
|
|
111
|
-
// Action.process_obligation, the frontend for every backend but LS4, Isabelle included, then
|
|
112
|
-
// Prep.flatten.
|
|
113
101
|
const shipFirstOrder = (sequent: Sequent) => flatten(processObligation(sequent));
|
|
114
102
|
|
|
115
|
-
// Prep.gen_smt_solve writes the resource budget before the encoding.
|
|
116
103
|
const encodeSmtProblem: Encoder = (_id, sequent, method, session) =>
|
|
117
104
|
(method.rlimit === undefined ? "" : `(set-option :rlimit ${method.rlimit})\n`) +
|
|
118
105
|
encodeSmt(shipFirstOrder(sequent), session);
|
|
@@ -121,15 +108,11 @@ const ENCODERS: Record<string, Encoder> = {
|
|
|
121
108
|
smt: encodeSmtProblem,
|
|
122
109
|
z3: encodeSmtProblem,
|
|
123
110
|
zenon: (id, sequent) => encodeZenon(id, shipFirstOrder(sequent)),
|
|
124
|
-
// tlapm names the theory after its temporary file, and tla-ts after the obligation.
|
|
125
111
|
isabelle: (id, sequent, method) =>
|
|
126
112
|
encodeIsabelle(id, shipFirstOrder(sequent), method.tactic ?? "auto"),
|
|
127
|
-
// Pltl.process_obligation is LS4's frontend.
|
|
128
113
|
ls4: (_id, sequent) => encodePtl(sequent),
|
|
129
114
|
};
|
|
130
115
|
|
|
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
116
|
const hasIncompleteCase = (expression: Expr): boolean =>
|
|
134
117
|
(expression.kind === "Case" && expression.other === undefined) ||
|
|
135
118
|
getChildren(expression).some(hasIncompleteCase);
|
|
@@ -168,8 +151,6 @@ const getUnprovedReport = (
|
|
|
168
151
|
attempts: ProofAttempt[] = [],
|
|
169
152
|
): ProofReport => ({ obligation: { ...getObligationBase(obligation), status, reason }, attempts });
|
|
170
153
|
|
|
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
154
|
export const formatNormalized = (obligation: PrintedObligation, isReused: boolean) =>
|
|
174
155
|
`${formatObligation(
|
|
175
156
|
isReused
|
|
@@ -177,7 +158,6 @@ export const formatNormalized = (obligation: PrintedObligation, isReused: boolea
|
|
|
177
158
|
: normalizeExpand(obligation),
|
|
178
159
|
)}\n`;
|
|
179
160
|
|
|
180
|
-
// The theory of the proofs Isabelle found. tlapm also writes Zenon's proofs there.
|
|
181
161
|
export const encodeProofTheory = (
|
|
182
162
|
name: string,
|
|
183
163
|
reports: ProofReport[],
|
|
@@ -199,7 +179,6 @@ export const encodeProofTheory = (
|
|
|
199
179
|
),
|
|
200
180
|
);
|
|
201
181
|
|
|
202
|
-
// The text one backend receives for an obligation, for comparing with tlapm's.
|
|
203
182
|
export const encodeForBackend = (
|
|
204
183
|
obligation: PrintedObligation,
|
|
205
184
|
prover: string,
|
|
@@ -215,8 +194,6 @@ export const encodeForBackend = (
|
|
|
215
194
|
return encode(obligation.id, normalizeExpand(obligation, methods), method, session);
|
|
216
195
|
};
|
|
217
196
|
|
|
218
|
-
// The SMT encoder's session for an obligation, from the count of CASE errors every earlier
|
|
219
|
-
// obligation leaves.
|
|
220
197
|
const getSession = async (run: ProveRun, index: number) => {
|
|
221
198
|
const task = run.tasks[index];
|
|
222
199
|
if (task.session) return task.session.current;
|
|
@@ -232,10 +209,6 @@ const getSession = async (run: ProveRun, index: number) => {
|
|
|
232
209
|
return task.session.current;
|
|
233
210
|
};
|
|
234
211
|
|
|
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
212
|
const proveWithBackends = async (
|
|
240
213
|
obligation: PrintedObligation,
|
|
241
214
|
index: number,
|
|
@@ -255,13 +228,11 @@ const proveWithBackends = async (
|
|
|
255
228
|
obligation: { ...getObligationBase(obligation), status: "proved", prover },
|
|
256
229
|
attempts,
|
|
257
230
|
});
|
|
258
|
-
// Prep.already_processed, which forgets the fingerprint's results on each call under --nofp.
|
|
259
231
|
const getPrior = (method: Method) => {
|
|
260
232
|
if (!run.isFingerprinted(obligation)) run.results.delete(fingerprint);
|
|
261
233
|
const prior = run.results.get(fingerprint)?.get(method.prover);
|
|
262
234
|
return prior?.method.tactic === method.tactic ? prior : undefined;
|
|
263
235
|
};
|
|
264
|
-
// Fpfile.get_timeout.
|
|
265
236
|
const getBudget = (method: Method) => method.rlimit ?? method.timeLimitMs / 1000;
|
|
266
237
|
const reuse = (prior: ProofAttempt) =>
|
|
267
238
|
attempts.push({ ...prior, isReused: true, timeUsedMs: undefined });
|
|
@@ -282,7 +253,6 @@ const proveWithBackends = async (
|
|
|
282
253
|
return getProvedReport(firstPrior.method.prover);
|
|
283
254
|
}
|
|
284
255
|
const sequent = normalizeExpand(obligation, methods);
|
|
285
|
-
// Fpfile.fp_writes keeps no trivial result, but adds the fingerprint.
|
|
286
256
|
if (obligation.kind.kind === "Support" && isTrivial(sequent)) {
|
|
287
257
|
run.results.set(fingerprint, run.results.get(fingerprint) ?? new Map());
|
|
288
258
|
return { obligation: { ...getObligationBase(obligation), status: "trivial" }, attempts };
|
|
@@ -302,7 +272,6 @@ const proveWithBackends = async (
|
|
|
302
272
|
continue;
|
|
303
273
|
}
|
|
304
274
|
if (!run.isProving) continue;
|
|
305
|
-
// Prep.prove_with: the Trivial method proves anything.
|
|
306
275
|
if (method.prover === "trivial") return getProvedReport(method.prover);
|
|
307
276
|
const encode = ENCODERS[method.prover];
|
|
308
277
|
if (!encode) {
|
|
@@ -352,8 +321,6 @@ const proveWithBackends = async (
|
|
|
352
321
|
);
|
|
353
322
|
};
|
|
354
323
|
|
|
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
324
|
const getErrorReport = (obligation: PrintedObligation, error: unknown) => {
|
|
358
325
|
if (error instanceof TlaUnsupportedError)
|
|
359
326
|
return getUnprovedReport(obligation, "unsupported", error.message);
|
|
@@ -367,9 +334,7 @@ interface ObligationsOptions {
|
|
|
367
334
|
signal?: AbortSignal;
|
|
368
335
|
onReport?: (report: ProofReport, obligation: PrintedObligation) => void;
|
|
369
336
|
results?: Map<string, Map<string, ProofAttempt>>;
|
|
370
|
-
// --nofp and --nofpl.
|
|
371
337
|
isFingerprinted?: (obligation: PrintedObligation) => boolean;
|
|
372
|
-
// --noproving.
|
|
373
338
|
isProving?: boolean;
|
|
374
339
|
}
|
|
375
340
|
|
|
@@ -391,7 +356,6 @@ export const proveObligations = async (
|
|
|
391
356
|
decide:
|
|
392
357
|
pool?.decide ?? (async (prover, text, decideOptions) => decide(prover, text, decideOptions)),
|
|
393
358
|
};
|
|
394
|
-
// A few obligations per worker prove at once, and each reports once every earlier one has.
|
|
395
359
|
const limit = pool ? workerCount * 4 : 1;
|
|
396
360
|
const pending: Promise<ProofReport>[] = [];
|
|
397
361
|
const isSettled: boolean[] = [];
|
package/src/prover/ptl/decide.ts
CHANGED
|
@@ -1,17 +1,12 @@
|
|
|
1
|
-
// Decides the text tlapm sends LS4, as LS4 does: unsat when the negated obligation has no model,
|
|
2
|
-
// which proves the obligation.
|
|
3
|
-
|
|
4
1
|
import { TlaSyntaxError } from "../../errors";
|
|
5
2
|
import type { DecideOptions, Verdict } from "../verdict";
|
|
6
3
|
import { getSatisfiability, type PtlFormula } from "./tableau";
|
|
7
4
|
|
|
8
|
-
// LS4's input syntax, as tlapm writes it: every operator is parenthesized except the facts of a
|
|
9
|
-
// sequent, which are joined by & before ->.
|
|
10
5
|
const parseLs4 = (text: string): PtlFormula => {
|
|
11
6
|
const tokens = text.match(/<->|->|[()~&|]|[\w']+|\S/g) ?? [];
|
|
12
|
-
|
|
7
|
+
let position = 0;
|
|
13
8
|
const take = (expected?: string) => {
|
|
14
|
-
const token = tokens[
|
|
9
|
+
const token = tokens[position++];
|
|
15
10
|
if (token === undefined || (expected !== undefined && token !== expected))
|
|
16
11
|
throw new TlaSyntaxError(
|
|
17
12
|
`Expected ${expected ?? "a formula"} in LS4 input, found ${token ?? "the end"}`,
|
|
@@ -35,7 +30,7 @@ const parseLs4 = (text: string): PtlFormula => {
|
|
|
35
30
|
};
|
|
36
31
|
const parseJunction = (operator: string, kind: "And" | "Or", parseOperand: () => PtlFormula) => {
|
|
37
32
|
const operands = [parseOperand()];
|
|
38
|
-
while (tokens[
|
|
33
|
+
while (tokens[position] === operator) {
|
|
39
34
|
take();
|
|
40
35
|
operands.push(parseOperand());
|
|
41
36
|
}
|
|
@@ -43,19 +38,19 @@ const parseLs4 = (text: string): PtlFormula => {
|
|
|
43
38
|
};
|
|
44
39
|
const parseImplies = (): PtlFormula => {
|
|
45
40
|
const left = parseJunction("|", "Or", () => parseJunction("&", "And", parseUnary));
|
|
46
|
-
if (tokens[
|
|
41
|
+
if (tokens[position] !== "->") return left;
|
|
47
42
|
take();
|
|
48
43
|
return { kind: "Implies", left, right: parseImplies() };
|
|
49
44
|
};
|
|
50
45
|
const parseEquiv = (): PtlFormula => {
|
|
51
46
|
const left = parseImplies();
|
|
52
|
-
if (tokens[
|
|
47
|
+
if (tokens[position] !== "<->") return left;
|
|
53
48
|
take();
|
|
54
49
|
return { kind: "Equiv", left, right: parseEquiv() };
|
|
55
50
|
};
|
|
56
51
|
const formula = parseEquiv();
|
|
57
|
-
if (
|
|
58
|
-
throw new TlaSyntaxError(`Expected the end of LS4 input, found ${tokens[
|
|
52
|
+
if (position < tokens.length)
|
|
53
|
+
throw new TlaSyntaxError(`Expected the end of LS4 input, found ${tokens[position]}`);
|
|
59
54
|
return formula;
|
|
60
55
|
};
|
|
61
56
|
|
package/src/prover/ptl/encode.ts
CHANGED
|
@@ -1,8 +1,3 @@
|
|
|
1
|
-
// tlapm's PTL backend up to the text it sends LS4 (Pltl.process_obligation, Prep.flatten, and
|
|
2
|
-
// Ls4's printer): temporal operators reduce to [], <> and prime, assumptions that hold
|
|
3
|
-
// always get a [], and every other subformula becomes an atom named by a hash of its printed form.
|
|
4
|
-
// The text is the negated obligation.
|
|
5
|
-
|
|
6
1
|
import {
|
|
7
2
|
bumpBy,
|
|
8
3
|
shift,
|
|
@@ -27,9 +22,6 @@ import { getLevelInfo } from "../../obligations/levels";
|
|
|
27
22
|
import { expandAction, expandFairness, expandLeadsto, getTime } from "../../obligations/temporal";
|
|
28
23
|
import { getHashName, LEVEL_NUMBER_PREFIXES, LEVEL_PREFIXES } from "../prep/action";
|
|
29
24
|
|
|
30
|
-
// Coalesce.rename_with_loc: each declared name gets its kind in front, or its level for a definition,
|
|
31
|
-
// as in VARIABLE_x_ and CONSTANT_i_, so atoms print with the names tlapm hashes. A variable a
|
|
32
|
-
// temporal quantifier binds keeps its name.
|
|
33
25
|
const renameSequent = (scope: Scope | undefined, sequent: Sequent): Sequent => {
|
|
34
26
|
const [inner, context] = mapAccumulate(
|
|
35
27
|
scope,
|
|
@@ -93,38 +85,30 @@ const renameDeclarations = (scope: Scope | undefined, expression: Expr): Expr =>
|
|
|
93
85
|
}
|
|
94
86
|
};
|
|
95
87
|
|
|
96
|
-
interface PreparedHyps {
|
|
97
|
-
scope: Scope | undefined;
|
|
98
|
-
substitution: Substitution;
|
|
99
|
-
context: Hyp[];
|
|
100
|
-
}
|
|
101
|
-
|
|
102
|
-
// Pltl.expand_domains and Pltl.box_assumptions: NEW x \in S becomes NEW x and the fact x \in S, and
|
|
103
|
-
// each visible fact that holds always gets a [].
|
|
104
88
|
const prepareHyps = (scope: Scope | undefined, expression: Expr): Expr => {
|
|
105
89
|
if (expression.kind !== "Sequent")
|
|
106
90
|
return mapScoped(scope, expression, prepareHyps, adjoin, "all");
|
|
107
|
-
|
|
91
|
+
let innerScope = scope;
|
|
92
|
+
let substitution: Substitution = shift(0);
|
|
93
|
+
const context: Hyp[] = [];
|
|
108
94
|
const push = (hyp: Hyp) => {
|
|
109
95
|
const prepared =
|
|
110
96
|
hyp.kind === "Fact" && hyp.visibility === "Visible" && hyp.time === "Always"
|
|
111
97
|
? { ...hyp, expression: applyBuiltin("BoxTrue", [hyp.expression], hyp.expression) }
|
|
112
98
|
: hyp;
|
|
113
|
-
|
|
114
|
-
|
|
99
|
+
context.push(prepared);
|
|
100
|
+
innerScope = adjoin(innerScope, prepared);
|
|
115
101
|
};
|
|
116
102
|
for (const original of expression.sequent.context) {
|
|
117
|
-
const hyp = substituteHyp(
|
|
103
|
+
const hyp = substituteHyp(substitution, original);
|
|
118
104
|
if (hyp.kind !== "Fresh" || !hyp.domain || original.kind !== "Fresh" || !original.domain) {
|
|
119
105
|
push(
|
|
120
|
-
hyp.kind === "Fact"
|
|
121
|
-
? { ...hyp, expression: prepareHyps(state.scope, hyp.expression) }
|
|
122
|
-
: hyp,
|
|
106
|
+
hyp.kind === "Fact" ? { ...hyp, expression: prepareHyps(innerScope, hyp.expression) } : hyp,
|
|
123
107
|
);
|
|
124
|
-
|
|
108
|
+
substitution = bumpBy(1, substitution);
|
|
125
109
|
continue;
|
|
126
110
|
}
|
|
127
|
-
const domain = prepareHyps(
|
|
111
|
+
const domain = prepareHyps(innerScope, hyp.domain);
|
|
128
112
|
push({ ...hyp, domain: undefined });
|
|
129
113
|
// tlapm judges the time of the domain as written, one hypothesis too deep.
|
|
130
114
|
push({
|
|
@@ -135,19 +119,19 @@ const prepareHyps = (scope: Scope | undefined, expression: Expr): Expr => {
|
|
|
135
119
|
domain,
|
|
136
120
|
),
|
|
137
121
|
visibility: hyp.domainVisibility,
|
|
138
|
-
time: hyp.level === "Constant" ? getTime(
|
|
122
|
+
time: hyp.level === "Constant" ? getTime(innerScope, original.domain) : "Now",
|
|
139
123
|
location: hyp.location,
|
|
140
124
|
});
|
|
141
|
-
|
|
125
|
+
substitution = {
|
|
142
126
|
kind: "Compose",
|
|
143
127
|
outer: shift(1),
|
|
144
|
-
inner: bumpBy(1,
|
|
128
|
+
inner: bumpBy(1, substitution),
|
|
145
129
|
};
|
|
146
130
|
}
|
|
147
|
-
const active = substituteExpr(
|
|
131
|
+
const active = substituteExpr(substitution, expression.sequent.active);
|
|
148
132
|
return {
|
|
149
133
|
...expression,
|
|
150
|
-
sequent: { context
|
|
134
|
+
sequent: { context, active: prepareHyps(innerScope, active) },
|
|
151
135
|
};
|
|
152
136
|
};
|
|
153
137
|
|
|
@@ -166,8 +150,6 @@ const UNARY: Partial<Record<Builtin, string>> = {
|
|
|
166
150
|
Prime: "next",
|
|
167
151
|
};
|
|
168
152
|
|
|
169
|
-
// Prep.flatten, which tlapm applies after Pltl.process_obligation has made every equality an atom:
|
|
170
|
-
// TRUE drops out of the conjunctions of each visible fact, and a fact left with nothing disappears.
|
|
171
153
|
const removeTrue = (expression: Expr): Expr | undefined => {
|
|
172
154
|
if (expression.kind === "Internal" && expression.builtin === "TRUE") return undefined;
|
|
173
155
|
if (expression.kind === "List" && expression.bullet !== "Or") {
|
|
@@ -189,10 +171,7 @@ const removeTrue = (expression: Expr): Expr | undefined => {
|
|
|
189
171
|
|
|
190
172
|
const TRUE_TEXT = "(cc | ~ cc)";
|
|
191
173
|
|
|
192
|
-
// The text tlapm sends LS4 for an obligation after Prep.normalize_expand.
|
|
193
174
|
export const encodePtl = (sequent: Sequent): string => {
|
|
194
|
-
// Ls4's printer. A sequent becomes an implication from its visible facts, joined by &, and
|
|
195
|
-
// Prep.flatten applies to the facts of the outermost one.
|
|
196
175
|
const print = (hyps: Hyp[], expression: Expr, isOutermost = false): string => {
|
|
197
176
|
const recurse = (inner: Expr) => print(hyps, inner);
|
|
198
177
|
switch (expression.kind) {
|
|
@@ -235,7 +214,6 @@ export const encodePtl = (sequent: Sequent): string => {
|
|
|
235
214
|
return facts.length === 0 ? goal : `(${facts.join(" & ")} -> ${goal})`;
|
|
236
215
|
}
|
|
237
216
|
}
|
|
238
|
-
// Pltl.coalesce_fol names an atom as Coalesce does.
|
|
239
217
|
return getHashName(hyps, expression);
|
|
240
218
|
};
|
|
241
219
|
const renamed = renameDeclarations(undefined, { kind: "Sequent", sequent });
|
package/src/prover/ptl/sat.ts
CHANGED
|
@@ -1,9 +1,3 @@
|
|
|
1
|
-
// A conflict-driven clause learning SAT solver for the clauses of one tableau node. A literal is a
|
|
2
|
-
// variable number, negated when below zero. The solver keeps what it learns across calls, which add
|
|
3
|
-
// clauses or assume literals. It decides each open variable false first, so a model sets few
|
|
4
|
-
// variables, and a model holds 1 for each true variable and -1 for each false one. It gives up at
|
|
5
|
-
// the first conflict after isExpired turns true.
|
|
6
|
-
|
|
7
1
|
const getIndex = (literal: number) => (literal > 0 ? 2 * literal : -2 * literal + 1);
|
|
8
2
|
|
|
9
3
|
export const createSolver = (variableCount: number, isExpired: () => boolean) => {
|
|
@@ -15,7 +9,9 @@ export const createSolver = (variableCount: number, isExpired: () => boolean) =>
|
|
|
15
9
|
const watches: number[][][] = Array.from({ length: 2 * variableCount + 2 }, () => []);
|
|
16
10
|
const trail: number[] = [];
|
|
17
11
|
const levelStarts: number[] = [];
|
|
18
|
-
|
|
12
|
+
let head = 0;
|
|
13
|
+
let bump = 1;
|
|
14
|
+
let isUnsatisfiable = false;
|
|
19
15
|
const getValue = (literal: number) => (literal > 0 ? values[literal] : -values[-literal]);
|
|
20
16
|
const assign = (literal: number, reason: number[] | undefined) => {
|
|
21
17
|
const variable = Math.abs(literal);
|
|
@@ -28,11 +24,9 @@ export const createSolver = (variableCount: number, isExpired: () => boolean) =>
|
|
|
28
24
|
watches[getIndex(clause[0])].push(clause);
|
|
29
25
|
watches[getIndex(clause[1])].push(clause);
|
|
30
26
|
};
|
|
31
|
-
// Moves each watch off a literal that turned false, and returns the clause of a conflict. The
|
|
32
|
-
// literal a clause implies sits first in it.
|
|
33
27
|
const propagate = () => {
|
|
34
|
-
for (;
|
|
35
|
-
const falsified = -trail[
|
|
28
|
+
for (; head < trail.length; head++) {
|
|
29
|
+
const falsified = -trail[head];
|
|
36
30
|
const watching = watches[getIndex(falsified)];
|
|
37
31
|
for (let position = 0; position < watching.length; position++) {
|
|
38
32
|
const clause = watching[position];
|
|
@@ -59,39 +53,38 @@ export const createSolver = (variableCount: number, isExpired: () => boolean) =>
|
|
|
59
53
|
const size = levelStarts[level];
|
|
60
54
|
while (trail.length > size) values[Math.abs(trail.pop() ?? 0)] = 0;
|
|
61
55
|
levelStarts.length = level;
|
|
62
|
-
|
|
56
|
+
head = trail.length;
|
|
63
57
|
};
|
|
64
|
-
// Resolves the conflict back to the first literal of the current level that all its paths pass
|
|
65
|
-
// through, and returns the learned clause with that literal first.
|
|
66
58
|
const analyze = (conflict: number[]) => {
|
|
67
59
|
const learned = [0];
|
|
68
60
|
const current = levelStarts.length;
|
|
69
|
-
|
|
61
|
+
let pendingCount = 0;
|
|
62
|
+
let resolved = 0;
|
|
63
|
+
let trailIndex = trail.length - 1;
|
|
70
64
|
for (let clause: number[] | undefined = conflict; ;) {
|
|
71
|
-
for (const literal of clause?.slice(
|
|
65
|
+
for (const literal of clause?.slice(resolved === 0 ? 0 : 1) ?? []) {
|
|
72
66
|
const variable = Math.abs(literal);
|
|
73
67
|
if (seen[variable] || levels[variable] === 0) continue;
|
|
74
68
|
seen[variable] = 1;
|
|
75
|
-
activities[variable] +=
|
|
76
|
-
if (levels[variable] === current)
|
|
69
|
+
activities[variable] += bump;
|
|
70
|
+
if (levels[variable] === current) pendingCount++;
|
|
77
71
|
else learned.push(literal);
|
|
78
72
|
}
|
|
79
|
-
while (!seen[Math.abs(trail[
|
|
80
|
-
|
|
81
|
-
seen[Math.abs(
|
|
82
|
-
clause = reasons[Math.abs(
|
|
83
|
-
if (--
|
|
73
|
+
while (!seen[Math.abs(trail[trailIndex])]) trailIndex--;
|
|
74
|
+
resolved = trail[trailIndex--];
|
|
75
|
+
seen[Math.abs(resolved)] = 0;
|
|
76
|
+
clause = reasons[Math.abs(resolved)];
|
|
77
|
+
if (--pendingCount === 0) break;
|
|
84
78
|
}
|
|
85
|
-
learned[0] = -
|
|
79
|
+
learned[0] = -resolved;
|
|
86
80
|
learned.forEach((literal) => (seen[Math.abs(literal)] = 0));
|
|
87
|
-
|
|
81
|
+
bump *= 1.05;
|
|
88
82
|
return learned;
|
|
89
83
|
};
|
|
90
|
-
// Literals false for good are dropped, since the solver adds clauses only at level 0.
|
|
91
84
|
const addClause = (clause: number[]) => {
|
|
92
85
|
backtrack(0);
|
|
93
86
|
const literals = [...new Set(clause)];
|
|
94
|
-
if (
|
|
87
|
+
if (isUnsatisfiable || literals.some((literal) => getValue(literal) > 0)) return;
|
|
95
88
|
if (literals.some((literal) => literals.includes(-literal))) return;
|
|
96
89
|
const open = literals.filter((literal) => getValue(literal) === 0);
|
|
97
90
|
if (open.length > 1) {
|
|
@@ -99,21 +92,20 @@ export const createSolver = (variableCount: number, isExpired: () => boolean) =>
|
|
|
99
92
|
return;
|
|
100
93
|
}
|
|
101
94
|
if (open.length === 0) {
|
|
102
|
-
|
|
95
|
+
isUnsatisfiable = true;
|
|
103
96
|
return;
|
|
104
97
|
}
|
|
105
98
|
assign(open[0], undefined);
|
|
106
|
-
if (propagate())
|
|
99
|
+
if (propagate()) isUnsatisfiable = true;
|
|
107
100
|
};
|
|
108
|
-
// A model of the clauses in which every assumed literal holds, or unsat when there is none.
|
|
109
101
|
const solve = (assumptions: number[]): Int8Array | "unsat" | "unknown" => {
|
|
110
102
|
backtrack(0);
|
|
111
|
-
if (
|
|
103
|
+
if (isUnsatisfiable) return "unsat";
|
|
112
104
|
for (;;) {
|
|
113
105
|
const conflict = propagate();
|
|
114
106
|
if (conflict) {
|
|
115
107
|
if (levelStarts.length === 0) {
|
|
116
|
-
|
|
108
|
+
isUnsatisfiable = true;
|
|
117
109
|
return "unsat";
|
|
118
110
|
}
|
|
119
111
|
if (isExpired()) return "unknown";
|
|
@@ -1,8 +1,3 @@
|
|
|
1
|
-
// Decides satisfiability of propositional linear temporal logic over infinite traces, the logic LS4
|
|
2
|
-
// decides. A tableau node is the set of formulas that must hold now. A SAT call per step picks the
|
|
3
|
-
// atoms and the formulas the next node must hold, and the formula is satisfiable when a reachable
|
|
4
|
-
// strongly connected component can fulfill every eventuality it postpones.
|
|
5
|
-
|
|
6
1
|
import type { Verdict } from "../verdict";
|
|
7
2
|
import { createSolver } from "./sat";
|
|
8
3
|
|
|
@@ -11,7 +6,6 @@ export type PtlFormula =
|
|
|
11
6
|
| { kind: "Not" | "Next" | "Always" | "Eventually"; body: PtlFormula }
|
|
12
7
|
| { kind: "And" | "Or" | "Implies" | "Equiv"; left: PtlFormula; right: PtlFormula };
|
|
13
8
|
|
|
14
|
-
// Formulas in negation normal form, numbered so that equal formulas share a number.
|
|
15
9
|
type Normal =
|
|
16
10
|
| { kind: "Constant"; value: boolean }
|
|
17
11
|
| { kind: "Literal"; atom: string; isPositive: boolean }
|
|
@@ -40,19 +34,19 @@ const createTable = () => {
|
|
|
40
34
|
};
|
|
41
35
|
const getConstant = (value: boolean) => intern(String(value), { kind: "Constant", value });
|
|
42
36
|
const getJunction = (kind: "And" | "Or", operands: number[]): number => {
|
|
43
|
-
const
|
|
37
|
+
const isAbsorbing = kind === "Or";
|
|
44
38
|
const children = new Set<number>();
|
|
45
39
|
for (const operand of operands) {
|
|
46
40
|
const normal = normals[operand];
|
|
47
41
|
if (normal.kind === "Constant") {
|
|
48
|
-
if (normal.value ===
|
|
42
|
+
if (normal.value === isAbsorbing) return operand;
|
|
49
43
|
continue;
|
|
50
44
|
}
|
|
51
45
|
if (normal.kind === kind) normal.children.forEach((child) => children.add(child));
|
|
52
46
|
else children.add(operand);
|
|
53
47
|
}
|
|
54
48
|
const sorted = [...children].sort((left, right) => left - right);
|
|
55
|
-
if (sorted.length === 0) return getConstant(!
|
|
49
|
+
if (sorted.length === 0) return getConstant(!isAbsorbing);
|
|
56
50
|
if (sorted.length === 1) return sorted[0];
|
|
57
51
|
return intern(`${kind}(${sorted.join(",")})`, { kind, children: sorted });
|
|
58
52
|
};
|
|
@@ -114,10 +108,6 @@ const createTable = () => {
|
|
|
114
108
|
return { normals, normalize };
|
|
115
109
|
};
|
|
116
110
|
|
|
117
|
-
// Every way to satisfy the formulas now, keeping only the steps that require the fewest next
|
|
118
|
-
// formulas and leave the fewest eventualities pending. A step that requires more of both can only
|
|
119
|
-
// do what a smaller one can, so dropping it keeps the decision complete. Undefined once isExpired
|
|
120
|
-
// turns true.
|
|
121
111
|
const getSteps = (
|
|
122
112
|
normals: Normal[],
|
|
123
113
|
formulas: number[],
|
|
@@ -128,8 +118,8 @@ const getSteps = (
|
|
|
128
118
|
const nexts = new Map<number, number>();
|
|
129
119
|
const pendings = new Map<number, number>();
|
|
130
120
|
const literals = new Map<number, number>();
|
|
131
|
-
|
|
132
|
-
const createVariable = () => ++
|
|
121
|
+
let variableCount = 0;
|
|
122
|
+
const createVariable = () => ++variableCount;
|
|
133
123
|
const getVariable = <Key>(variables: Map<Key, number>, key: Key) => {
|
|
134
124
|
const existing = variables.get(key);
|
|
135
125
|
if (existing !== undefined) return existing;
|
|
@@ -137,7 +127,6 @@ const getSteps = (
|
|
|
137
127
|
variables.set(key, variable);
|
|
138
128
|
return variable;
|
|
139
129
|
};
|
|
140
|
-
// Plaisted-Greenbaum: a formula's literal implies the formula, which suffices in normal form.
|
|
141
130
|
const encode = (formula: number): number => {
|
|
142
131
|
const cached = literals.get(formula);
|
|
143
132
|
if (cached !== undefined) return cached;
|
|
@@ -184,14 +173,12 @@ const getSteps = (
|
|
|
184
173
|
};
|
|
185
174
|
formulas.forEach((formula) => clauses.push([encode(formula)]));
|
|
186
175
|
const choices = [...nexts.values(), ...pendings.values()];
|
|
187
|
-
const solver = createSolver(
|
|
176
|
+
const solver = createSolver(variableCount, isExpired);
|
|
188
177
|
clauses.forEach(solver.addClause);
|
|
189
178
|
const steps: Step[] = [];
|
|
190
179
|
for (;;) {
|
|
191
180
|
const model = solver.solve([]);
|
|
192
181
|
if (typeof model === "string") return model === "unsat" ? steps : undefined;
|
|
193
|
-
// Drops each chosen variable that a model with no other choice can do without. A variable one
|
|
194
|
-
// pass keeps stays needed as the set shrinks, so the set that remains is minimal.
|
|
195
182
|
const minimal = choices.reduce<Int8Array | undefined>((current, choice) => {
|
|
196
183
|
if (current?.[choice] !== 1) return current;
|
|
197
184
|
const unchosen = choices.filter((other) => current[other] !== 1);
|
|
@@ -209,7 +196,6 @@ const getSteps = (
|
|
|
209
196
|
}
|
|
210
197
|
};
|
|
211
198
|
|
|
212
|
-
// Whether the formula is satisfiable, or unknown once isExpired turns true.
|
|
213
199
|
export const getSatisfiability = (formula: PtlFormula, isExpired: () => boolean): Verdict => {
|
|
214
200
|
const table = createTable();
|
|
215
201
|
const nodes: number[][] = [];
|
|
@@ -230,12 +216,12 @@ export const getSatisfiability = (formula: PtlFormula, isExpired: () => boolean)
|
|
|
230
216
|
if (!steps) return "unknown";
|
|
231
217
|
edges.push(steps.map((step) => ({ target: getNode(step.next), pending: step.pending })));
|
|
232
218
|
}
|
|
233
|
-
// Tarjan's algorithm, checking each component as it closes.
|
|
234
219
|
const indices = new Int32Array(nodes.length).fill(-1);
|
|
235
220
|
const lowlinks = new Int32Array(nodes.length);
|
|
236
221
|
const components = new Int32Array(nodes.length).fill(-1);
|
|
237
222
|
const stack: number[] = [];
|
|
238
|
-
|
|
223
|
+
let nextIndex = 0;
|
|
224
|
+
let componentCount = 0;
|
|
239
225
|
const isFair = (component: number) => {
|
|
240
226
|
const inner = edges.flatMap((outgoing, source) =>
|
|
241
227
|
components[source] === component
|
|
@@ -252,9 +238,9 @@ export const getSatisfiability = (formula: PtlFormula, isExpired: () => boolean)
|
|
|
252
238
|
return unfulfilled.length === 0;
|
|
253
239
|
};
|
|
254
240
|
const visit = (node: number): boolean => {
|
|
255
|
-
indices[node] =
|
|
256
|
-
lowlinks[node] =
|
|
257
|
-
|
|
241
|
+
indices[node] = nextIndex;
|
|
242
|
+
lowlinks[node] = nextIndex;
|
|
243
|
+
nextIndex++;
|
|
258
244
|
stack.push(node);
|
|
259
245
|
for (const edge of edges[node]) {
|
|
260
246
|
if (indices[edge.target] === -1) {
|
|
@@ -265,7 +251,7 @@ export const getSatisfiability = (formula: PtlFormula, isExpired: () => boolean)
|
|
|
265
251
|
}
|
|
266
252
|
}
|
|
267
253
|
if (lowlinks[node] !== indices[node]) return false;
|
|
268
|
-
const component =
|
|
254
|
+
const component = componentCount++;
|
|
269
255
|
for (let member = stack.pop(); member !== undefined; member = stack.pop()) {
|
|
270
256
|
components[member] = component;
|
|
271
257
|
if (member === node) break;
|
package/src/prover/smt/axioms.ts
CHANGED
|
@@ -1,5 +1,3 @@
|
|
|
1
|
-
// encode/n_axioms.ml: the formulas of the axioms that depend on a count or on fields.
|
|
2
|
-
|
|
3
1
|
import {
|
|
4
2
|
call,
|
|
5
3
|
CAST_INT,
|
|
@@ -18,7 +16,6 @@ import {
|
|
|
18
16
|
} from "./format";
|
|
19
17
|
import { axiom, TYPED_SYMBOLS, type AxiomArgument } from "./table";
|
|
20
18
|
|
|
21
|
-
// The arithmetic symbols with a Typing axiom: each one's SMT-LIB operator and arity.
|
|
22
19
|
export const TYPED_OPERATORS: Record<string, [string, number]> = {
|
|
23
20
|
IntPlus: ["+", 2],
|
|
24
21
|
IntMinus: ["-", 2],
|
|
@@ -79,7 +76,6 @@ export const getIntegers = (count: number) =>
|
|
|
79
76
|
|
|
80
77
|
export const getFieldKeys = (fields: string[]) => fields.map((field) => tla(`StrLit_${field}`));
|
|
81
78
|
|
|
82
|
-
// TupExcept and RecExcept: updating one component of a tuple or record.
|
|
83
79
|
const getComponentExcepts = (
|
|
84
80
|
prefix: string,
|
|
85
81
|
args: AxiomArgument[],
|
|
@@ -104,8 +100,6 @@ export const getTupleExcepts = (count: number) =>
|
|
|
104
100
|
export const getRecordExcepts = (fields: string[]) =>
|
|
105
101
|
getComponentExcepts("Rec", [fields], tla(`Record_${fields.join("_")}`), getFieldKeys(fields));
|
|
106
102
|
|
|
107
|
-
// TupIsafcn, TupDomDef and TupAppDef, or their Rec counterparts: a tuple or record is the
|
|
108
|
-
// function from its keys to its components. The empty tuple has no domain or components to define.
|
|
109
103
|
const getComponentFunction = (
|
|
110
104
|
prefix: string,
|
|
111
105
|
args: AxiomArgument[],
|
|
@@ -172,7 +166,6 @@ export const getRecordAxioms = (fields: string[], isExcept: boolean) => [
|
|
|
172
166
|
...(isExcept ? getRecordExcepts(fields) : []),
|
|
173
167
|
];
|
|
174
168
|
|
|
175
|
-
// The set of tuples or records whose components are in the given sets.
|
|
176
169
|
export const getComponentSet = (
|
|
177
170
|
name: string,
|
|
178
171
|
args: AxiomArgument[],
|