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
|
@@ -1,8 +1,4 @@
|
|
|
1
1
|
// Ported from Zenon's mlproof.ml, as shipped in tlapm. Copyright 2004 INRIA, see LICENSE.
|
|
2
|
-
//
|
|
3
|
-
// The proofs that the search builds and the checker reads. Each rule takes a fixed number of
|
|
4
|
-
// arguments, or at least a fixed number, so a rule application can't have the wrong arity. The
|
|
5
|
-
// rules of the TLA+ extension, Zenon's Ext, sit beside the core rules: their names don't clash.
|
|
6
2
|
|
|
7
3
|
import type { Expr } from "./expr";
|
|
8
4
|
import type { Definition } from "./parse";
|
|
@@ -14,7 +10,6 @@ type Five<Term> = [Term, Term, Term, Term, Term];
|
|
|
14
10
|
type Six<Term> = [Term, Term, Term, Term, Term, Term];
|
|
15
11
|
type Seven<Term> = [Term, Term, Term, Term, Term, Term, Term];
|
|
16
12
|
|
|
17
|
-
// The arguments of each rule that names neither a relation nor a definition.
|
|
18
13
|
interface PlainRuleArgs<Term> {
|
|
19
14
|
close: [Term];
|
|
20
15
|
false: [];
|
|
@@ -141,7 +136,6 @@ interface PlainRuleArgs<Term> {
|
|
|
141
136
|
tuple_len: Five<Term>;
|
|
142
137
|
}
|
|
143
138
|
|
|
144
|
-
// The rules that hold for any relation that the hypotheses make reflexive or symmetric.
|
|
145
139
|
interface RelationRuleArgs<Term> {
|
|
146
140
|
close_refl: [Term];
|
|
147
141
|
close_sym: Two<Term>;
|
|
@@ -167,14 +161,11 @@ type RelationRules<Term> = {
|
|
|
167
161
|
};
|
|
168
162
|
};
|
|
169
163
|
|
|
170
|
-
// A rule application, as in Zenon's Mlproof.rule. "definition" unfolds `definition`.
|
|
171
164
|
export type Rule<Term = Expr> =
|
|
172
165
|
| PlainRules<Term>[PlainRuleName]
|
|
173
166
|
| RelationRules<Term>[RelationRuleName]
|
|
174
167
|
| { name: "definition"; definition: Definition; args: Two<Term> };
|
|
175
168
|
|
|
176
|
-
// A proof of the formulas in `conclusions`: the node's rule applied to `uses`, with a subproof for
|
|
177
|
-
// each of its branches.
|
|
178
169
|
export interface Proof<Term = Expr> {
|
|
179
170
|
conclusions: Term[];
|
|
180
171
|
rule: Rule<Term>;
|
|
@@ -1,6 +1,4 @@
|
|
|
1
1
|
// Ported from Zenon's prove.ml, as shipped in tlapm. Copyright 2002 INRIA, see LICENSE.
|
|
2
|
-
//
|
|
3
|
-
// The rules for connectives and quantifiers, closing a branch, and unfolding definitions.
|
|
4
2
|
|
|
5
3
|
import { getStringValue } from "./equality-rules";
|
|
6
4
|
import { isApp, type Expr, type Expressions } from "./expr";
|
|
@@ -9,7 +7,6 @@ import type { Definition } from "./parse";
|
|
|
9
7
|
import { makeRelationRule, makeRule, type Rule } from "./proof";
|
|
10
8
|
import { makeNode, type RuleResult, type SearchRule } from "./rules";
|
|
11
9
|
|
|
12
|
-
// Zenon's is_conj and is_disj: how many more conjuncts or disjuncts a formula needs to reach m.
|
|
13
10
|
const countConjuncts = (formula: Expr, needed: number): number => {
|
|
14
11
|
if (needed <= 0) return 0;
|
|
15
12
|
if (formula.kind === "and")
|
|
@@ -350,8 +347,6 @@ export const addUnfold: SearchRule = (context, queue, formula, goalness) => {
|
|
|
350
347
|
wrap,
|
|
351
348
|
);
|
|
352
349
|
};
|
|
353
|
-
// Zenon tries applications before variables, each first as the formula itself, then as either
|
|
354
|
-
// side of a relation that is reflexive, symmetric or transitive.
|
|
355
350
|
for (const kind of ["app", "var"]) {
|
|
356
351
|
if (atom.kind === kind) {
|
|
357
352
|
const result = tryUnfold(atom, negate);
|
|
@@ -1,7 +1,4 @@
|
|
|
1
1
|
// Ported from Zenon's prove.ml, as shipped in tlapm. Copyright 2002 INRIA, see LICENSE.
|
|
2
|
-
//
|
|
3
|
-
// Zenon's newnodes: each rule in turn suggests nodes for a formula added to a branch, until one
|
|
4
|
-
// says that the rest don't apply.
|
|
5
2
|
|
|
6
3
|
import type { Relations } from "./eqrel";
|
|
7
4
|
import {
|
|
@@ -12,7 +9,7 @@ import {
|
|
|
12
9
|
addSymmetricMatches,
|
|
13
10
|
addTransitivity,
|
|
14
11
|
} from "./equality-rules";
|
|
15
|
-
import {
|
|
12
|
+
import type { Expr, Expressions } from "./expr";
|
|
16
13
|
import type { Index } from "./index-table";
|
|
17
14
|
import { insertNode, type Node, type Priority, type Queue } from "./node";
|
|
18
15
|
import type { Rule } from "./proof";
|
|
@@ -62,8 +59,7 @@ const addExtensions: SearchRule = (context, queue, formula, goalness) => {
|
|
|
62
59
|
return [insertAll(queue, result.nodes), result.isStopped];
|
|
63
60
|
};
|
|
64
61
|
|
|
65
|
-
// Zenon
|
|
66
|
-
// formula with its negation, whose heads always differ.
|
|
62
|
+
// Deviation from Zenon: newnodes_preunif is left out because it never adds a node.
|
|
67
63
|
const RULES: SearchRule[] = [
|
|
68
64
|
addAbsurd,
|
|
69
65
|
addClosure,
|
|
@@ -1,9 +1,4 @@
|
|
|
1
1
|
// Ported from Zenon's prove.ml, as shipped in tlapm. Copyright 2002 INRIA, see LICENSE.
|
|
2
|
-
//
|
|
3
|
-
// The tableau search. Each formula added to a branch suggests nodes, which wait in the queue by
|
|
4
|
-
// priority. The search takes the next node, and refutes each of its branches in turn. A branch is
|
|
5
|
-
// closed when it holds a formula and its negation. Zenon's mutually recursive search functions are
|
|
6
|
-
// one loop here, with an explicit stack of frames.
|
|
7
2
|
|
|
8
3
|
import { TlaZenonError } from "../../errors";
|
|
9
4
|
import { difference, isApp, isDisjoint, isMeta, union, type Expr } from "./expr";
|
|
@@ -23,7 +18,6 @@ const isTrivial = (context: SearchContext, formula: Expr) =>
|
|
|
23
18
|
formula.args[0] === formula.args[1] &&
|
|
24
19
|
context.relations.isReflexive(formula.symbol));
|
|
25
20
|
|
|
26
|
-
// Zenon's reduce_list: drops the formulas a branch already has, and reverses the rest.
|
|
27
21
|
const reduceBranch = (context: SearchContext, branch: Expr[]) => {
|
|
28
22
|
const exprs = context.exprs;
|
|
29
23
|
const index = context.index;
|
|
@@ -138,19 +132,14 @@ interface Frame {
|
|
|
138
132
|
interface SearchStatistics {
|
|
139
133
|
inferences: number;
|
|
140
134
|
proofNodes: number;
|
|
141
|
-
// The proofs that closed another branch from the lemma cache. Zenon counts the uses in mlrefc and
|
|
142
|
-
// prints each of these proofs once, as a lemma.
|
|
143
135
|
reusedProofs: Set<Proof>;
|
|
144
136
|
}
|
|
145
137
|
|
|
146
138
|
export type SearchFailure = "exhausted" | "time limit" | "memory limit" | "aborted";
|
|
147
139
|
|
|
148
|
-
// Zenon gives up
|
|
149
|
-
// current branch hold instead. On the corpus files where Zenon runs out of memory, its heap passes
|
|
150
|
-
// 1 GB with 1.9 to 5.5 million of them, and no proof that Zenon finds needs more than 1.3 million.
|
|
140
|
+
// Deviation from Zenon, which gives up at a 1 GB heap: its heap passes that with 1.9 million queued nodes.
|
|
151
141
|
const MAX_QUEUED_NODES = 1_900_000;
|
|
152
142
|
|
|
153
|
-
// The proof of the hypotheses' inconsistency, or why the search gave up.
|
|
154
143
|
export const search = (
|
|
155
144
|
context: SearchContext,
|
|
156
145
|
definitions: Definition[],
|
|
@@ -192,8 +181,6 @@ export const search = (
|
|
|
192
181
|
return proof;
|
|
193
182
|
};
|
|
194
183
|
|
|
195
|
-
// Zenon's next_branch and unwind: descend into the next open branch of a node, or close the node
|
|
196
|
-
// and pop frames until one has an open branch left.
|
|
197
184
|
const advance = (
|
|
198
185
|
searchNode: Node,
|
|
199
186
|
nodeQueue: Queue,
|
|
@@ -227,8 +214,6 @@ export const search = (
|
|
|
227
214
|
}
|
|
228
215
|
};
|
|
229
216
|
|
|
230
|
-
// Pops the frames that the proof closes. Returns the proof when it closes the root, and leaves the
|
|
231
|
-
// frame to continue on top of the stack otherwise, with the proof recorded.
|
|
232
217
|
const unwind = (proof: Proof): Proof | undefined => {
|
|
233
218
|
for (;;) {
|
|
234
219
|
const frame = stack.pop();
|
|
@@ -267,7 +252,6 @@ export const search = (
|
|
|
267
252
|
if (result !== undefined) return result;
|
|
268
253
|
continue;
|
|
269
254
|
}
|
|
270
|
-
// Zenon's next_node: the next node whose branches all add something new.
|
|
271
255
|
for (;;) {
|
|
272
256
|
statistics.inferences++;
|
|
273
257
|
const removed = removeNode(queue);
|
|
@@ -1,10 +1,8 @@
|
|
|
1
1
|
// Ported from Zenon's ext_tla.ml, as shipped in tlapm. Copyright 2008 INRIA, see LICENSE.
|
|
2
|
-
//
|
|
3
|
-
// The rules for functions: membership in a function set, isAFcn and function equality.
|
|
4
2
|
|
|
5
|
-
import { isApp
|
|
3
|
+
import { isApp } from "../expr";
|
|
6
4
|
import type { Priority } from "../node";
|
|
7
|
-
import { makeRule
|
|
5
|
+
import { makeRule } from "../proof";
|
|
8
6
|
import {
|
|
9
7
|
domain,
|
|
10
8
|
equal,
|
|
@@ -22,8 +20,6 @@ export const getFunctionSetNodes = (literal: Literal): Item[] | undefined => {
|
|
|
22
20
|
const formula = literal.formula;
|
|
23
21
|
const isNegated = literal.isNegated;
|
|
24
22
|
const relation = literal.relation;
|
|
25
|
-
const node = (priority: Priority, rule: Rule, branches: Expr[][]) =>
|
|
26
|
-
makeExtensionNode(literal, priority, rule, branches);
|
|
27
23
|
if (relation?.symbol === "TLA.in") {
|
|
28
24
|
const element = relation.args[0];
|
|
29
25
|
const set = relation.args[1];
|
|
@@ -31,8 +27,8 @@ export const getFunctionSetNodes = (literal: Literal): Item[] | undefined => {
|
|
|
31
27
|
const fcn = element;
|
|
32
28
|
const source = set.args[0];
|
|
33
29
|
const target = set.args[1];
|
|
34
|
-
const
|
|
35
|
-
const
|
|
30
|
+
const fcnFormula = exprs.eapp("TLA.isAFcn", [fcn]);
|
|
31
|
+
const domainFormula = equal(exprs, domain(exprs, fcn), source);
|
|
36
32
|
const bound = exprs.newVar();
|
|
37
33
|
const maps = exprs.eall(
|
|
38
34
|
bound,
|
|
@@ -43,21 +39,32 @@ export const getFunctionSetNodes = (literal: Literal): Item[] | undefined => {
|
|
|
43
39
|
),
|
|
44
40
|
);
|
|
45
41
|
if (!isNegated) {
|
|
46
|
-
const rule = makeRule("in_funcset", [
|
|
42
|
+
const rule = makeRule("in_funcset", [
|
|
43
|
+
formula,
|
|
44
|
+
fcnFormula,
|
|
45
|
+
domainFormula,
|
|
46
|
+
maps,
|
|
47
|
+
fcn,
|
|
48
|
+
source,
|
|
49
|
+
target,
|
|
50
|
+
]);
|
|
47
51
|
return [
|
|
48
|
-
...
|
|
49
|
-
...
|
|
52
|
+
...makeExtensionNode(literal, "arity", rule, [[fcnFormula, domainFormula]]),
|
|
53
|
+
...makeExtensionNode(literal, { instance: maps }, rule, [
|
|
54
|
+
[fcnFormula, domainFormula, maps],
|
|
55
|
+
]),
|
|
50
56
|
];
|
|
51
57
|
}
|
|
52
|
-
const notFcn = exprs.enot(
|
|
53
|
-
const notDomain = exprs.enot(
|
|
58
|
+
const notFcn = exprs.enot(fcnFormula);
|
|
59
|
+
const notDomain = exprs.enot(domainFormula);
|
|
54
60
|
const notMaps = exprs.enot(maps);
|
|
55
61
|
const priority: Priority =
|
|
56
62
|
fcn.kind === "app" && FUNCTION_CONSTRUCTORS.includes(fcn.symbol)
|
|
57
63
|
? "arity"
|
|
58
64
|
: { instance: notMaps };
|
|
59
65
|
const shortcut = isApp(fcn, "TLA.except", 3)
|
|
60
|
-
?
|
|
66
|
+
? makeExtensionNode(
|
|
67
|
+
literal,
|
|
61
68
|
"arity",
|
|
62
69
|
makeRule("except_notin_funcset", [
|
|
63
70
|
formula,
|
|
@@ -77,7 +84,8 @@ export const getFunctionSetNodes = (literal: Literal): Item[] | undefined => {
|
|
|
77
84
|
: [];
|
|
78
85
|
return [
|
|
79
86
|
...shortcut,
|
|
80
|
-
...
|
|
87
|
+
...makeExtensionNode(
|
|
88
|
+
literal,
|
|
81
89
|
priority,
|
|
82
90
|
makeRule("notin_funcset", [formula, notFcn, notDomain, notMaps, fcn, source, target]),
|
|
83
91
|
[[notFcn], [notDomain], [notMaps]],
|
|
@@ -94,22 +102,36 @@ export const getFunctionNodes = (literal: Literal): Item[] | undefined => {
|
|
|
94
102
|
const isNegated = literal.isNegated;
|
|
95
103
|
const atom = literal.atom;
|
|
96
104
|
const relation = literal.relation;
|
|
97
|
-
const node = (priority: Priority, rule: Rule, branches: Expr[][]) =>
|
|
98
|
-
makeExtensionNode(literal, priority, rule, branches);
|
|
99
105
|
if (isNegated && isApp(atom, "TLA.isAFcn", 1)) {
|
|
100
106
|
const fcn = atom.args[0];
|
|
101
107
|
if (isApp(fcn, "TLA.Fcn", 2))
|
|
102
|
-
return
|
|
108
|
+
return makeExtensionNode(
|
|
109
|
+
literal,
|
|
110
|
+
"prop",
|
|
111
|
+
makeRule("notisafcn_fcn", [formula, fcn.args[0], fcn.args[1]]),
|
|
112
|
+
[],
|
|
113
|
+
);
|
|
103
114
|
if (isApp(fcn, "TLA.except", 3))
|
|
104
|
-
return
|
|
115
|
+
return makeExtensionNode(
|
|
116
|
+
literal,
|
|
105
117
|
"prop",
|
|
106
118
|
makeRule("notisafcn_except", [formula, fcn.args[0], fcn.args[1], fcn.args[2]]),
|
|
107
119
|
[],
|
|
108
120
|
);
|
|
109
121
|
if (isApp(fcn, "TLA.oneArg", 2))
|
|
110
|
-
return
|
|
122
|
+
return makeExtensionNode(
|
|
123
|
+
literal,
|
|
124
|
+
"prop",
|
|
125
|
+
makeRule("notisafcn_onearg", [formula, fcn.args[0], fcn.args[1]]),
|
|
126
|
+
[],
|
|
127
|
+
);
|
|
111
128
|
if (isApp(fcn, "TLA.extend", 2))
|
|
112
|
-
return
|
|
129
|
+
return makeExtensionNode(
|
|
130
|
+
literal,
|
|
131
|
+
"prop",
|
|
132
|
+
makeRule("notisafcn_extend", [formula, fcn.args[0], fcn.args[1]]),
|
|
133
|
+
[],
|
|
134
|
+
);
|
|
113
135
|
}
|
|
114
136
|
if (relation?.symbol !== "=") return undefined;
|
|
115
137
|
const left = relation.args[0];
|
|
@@ -119,15 +141,18 @@ export const getFunctionNodes = (literal: Literal): Item[] | undefined => {
|
|
|
119
141
|
const sameDomain = equal(exprs, domain(exprs, left), domain(exprs, right));
|
|
120
142
|
const sameValue = equal(exprs, fapply(exprs, left, bound), fapply(exprs, right, bound));
|
|
121
143
|
if (!isNegated) {
|
|
122
|
-
const
|
|
144
|
+
const fcnEquivalence = exprs.eequiv(
|
|
123
145
|
exprs.eapp("TLA.isAFcn", [left]),
|
|
124
146
|
exprs.eapp("TLA.isAFcn", [right]),
|
|
125
147
|
);
|
|
126
148
|
const values = exprs.eall(bound, "", sameValue);
|
|
127
|
-
const result = exprs.eand(exprs.eand(
|
|
128
|
-
return
|
|
129
|
-
|
|
130
|
-
|
|
149
|
+
const result = exprs.eand(exprs.eand(fcnEquivalence, sameDomain), values);
|
|
150
|
+
return makeExtensionNode(
|
|
151
|
+
literal,
|
|
152
|
+
{ instance: values },
|
|
153
|
+
makeRule("funequal", [formula, result, left, right]),
|
|
154
|
+
[[result]],
|
|
155
|
+
);
|
|
131
156
|
}
|
|
132
157
|
const values = exprs.eall(
|
|
133
158
|
bound,
|
|
@@ -143,9 +168,12 @@ export const getFunctionNodes = (literal: Literal): Item[] | undefined => {
|
|
|
143
168
|
values,
|
|
144
169
|
),
|
|
145
170
|
);
|
|
146
|
-
return
|
|
147
|
-
|
|
148
|
-
|
|
171
|
+
return makeExtensionNode(
|
|
172
|
+
literal,
|
|
173
|
+
{ instance: values },
|
|
174
|
+
makeRule("notfunequal", [formula, result, left, right]),
|
|
175
|
+
[[result]],
|
|
176
|
+
);
|
|
149
177
|
}
|
|
150
178
|
return undefined;
|
|
151
179
|
};
|
|
@@ -1,14 +1,10 @@
|
|
|
1
1
|
// Ported from Zenon's ext_tla.ml, as shipped in tlapm. Copyright 2008 INRIA, see LICENSE.
|
|
2
|
-
//
|
|
3
|
-
// Zenon's to_llproof for the TLA+ extension: each rule becomes an extension rule of the low-level
|
|
4
|
-
// proof, named after the lemma in Zenon.thy that justifies it.
|
|
5
2
|
|
|
6
3
|
import { TlaZenonError } from "../../../errors";
|
|
7
4
|
import { difference, union, type Expr, type Expressions } from "../expr";
|
|
8
5
|
import { connect, type Lemma, type LlProof, type LlRule } from "../llproof";
|
|
9
6
|
import type { MlProof, Translated } from "../mltoll";
|
|
10
7
|
|
|
11
|
-
// The lemma's name, the terms it's instantiated with, the conclusions it uses and its branches.
|
|
12
8
|
type LlArgs = [string, Expr[], Expr[], Expr[][]];
|
|
13
9
|
|
|
14
10
|
type Shape = (name: string, args: Expr[]) => LlArgs;
|
|
@@ -72,7 +68,6 @@ const binbeta: Shape = (name, args) => {
|
|
|
72
68
|
return [`zenon_${name}`, rest, [first, second], [[hypothesisA], [hypothesisB]]];
|
|
73
69
|
};
|
|
74
70
|
|
|
75
|
-
// A conclusion, two terms and then the hypotheses, in one branch or one branch each.
|
|
76
71
|
const withTerms =
|
|
77
72
|
(isSplit: boolean): Shape =>
|
|
78
73
|
(name, args) => {
|
|
@@ -86,7 +81,6 @@ const withTerms =
|
|
|
86
81
|
];
|
|
87
82
|
};
|
|
88
83
|
|
|
89
|
-
// A conclusion and then the hypotheses, in one branch or one branch each.
|
|
90
84
|
const withoutTerms =
|
|
91
85
|
(isSplit: boolean): Shape =>
|
|
92
86
|
(name, args) => {
|
|
@@ -107,7 +101,6 @@ const getCaseBranches = (args: Expr[]): Expr[][] =>
|
|
|
107
101
|
: [args]
|
|
108
102
|
: [args.slice(0, 2), ...getCaseBranches(args.slice(2))];
|
|
109
103
|
|
|
110
|
-
// Zenon's to_llargs, by rule name. The rules missing here take one hypothesis.
|
|
111
104
|
const SHAPES: Record<string, Shape> = {
|
|
112
105
|
in_emptyset: (name, args) => [`zenon_${name}`, args.slice(1), args.slice(0, 1), []],
|
|
113
106
|
in_nat_0: close,
|
|
@@ -194,14 +187,12 @@ const SHAPES: Record<string, Shape> = {
|
|
|
194
187
|
record_notisafcn: close,
|
|
195
188
|
};
|
|
196
189
|
|
|
197
|
-
// Zenon's Ext_tla.to_llproof, for a rule of the extension and its translated subproofs.
|
|
198
190
|
export const getTlaLlProof = (
|
|
199
191
|
translateExpr: (expression: Expr) => Expr,
|
|
200
192
|
exprs: Expressions,
|
|
201
193
|
proof: MlProof,
|
|
202
194
|
subproofs: Translated[],
|
|
203
195
|
): Translated => {
|
|
204
|
-
const tr = translateExpr;
|
|
205
196
|
const rule = proof.rule;
|
|
206
197
|
const member = (element: Expr, set: Expr) => exprs.eapp("TLA.in", [element, set]);
|
|
207
198
|
const equal = (left: Expr, right: Expr) => exprs.eapp("=", [left, right]);
|
|
@@ -213,18 +204,24 @@ export const getTlaLlProof = (
|
|
|
213
204
|
branches: Expr[][],
|
|
214
205
|
nodeSubproofs: LlProof[],
|
|
215
206
|
): LlProof => ({
|
|
216
|
-
conclusions: conclusions.map(
|
|
207
|
+
conclusions: conclusions.map(translateExpr),
|
|
217
208
|
rule: {
|
|
218
209
|
kind: "extension",
|
|
219
210
|
name,
|
|
220
|
-
args: args.map(
|
|
221
|
-
conclusions: ruleConclusions.map(
|
|
222
|
-
branches: branches.map((branch) => branch.map(
|
|
211
|
+
args: args.map(translateExpr),
|
|
212
|
+
conclusions: ruleConclusions.map(translateExpr),
|
|
213
|
+
branches: branches.map((branch) => branch.map(translateExpr)),
|
|
223
214
|
},
|
|
224
215
|
subproofs: nodeSubproofs,
|
|
225
216
|
});
|
|
226
217
|
|
|
227
|
-
|
|
218
|
+
const splitSet = (set: Expr, isSetOf: boolean) =>
|
|
219
|
+
set.kind === "app" &&
|
|
220
|
+
set.symbol === (isSetOf ? "TLA.set" : "TLA.addElt") &&
|
|
221
|
+
set.args.length >= (isSetOf ? 1 : 2)
|
|
222
|
+
? [set.args[0], isSetOf ? exprs.eapp("TLA.set", set.args.slice(1)) : set.args[1]]
|
|
223
|
+
: undefined;
|
|
224
|
+
|
|
228
225
|
const getMembership = (
|
|
229
226
|
element: Expr,
|
|
230
227
|
set: Expr,
|
|
@@ -240,12 +237,7 @@ export const getTlaLlProof = (
|
|
|
240
237
|
extension(conclusions, "zenon_in_emptyset", [element], [member(element, set)], [], []),
|
|
241
238
|
[],
|
|
242
239
|
];
|
|
243
|
-
const split =
|
|
244
|
-
set.kind === "app" &&
|
|
245
|
-
set.symbol === (isSetOf ? "TLA.set" : "TLA.addElt") &&
|
|
246
|
-
set.args.length >= (isSetOf ? 1 : 2)
|
|
247
|
-
? [set.args[0], isSetOf ? exprs.eapp("TLA.set", set.args.slice(1)) : set.args[1]]
|
|
248
|
-
: undefined;
|
|
240
|
+
const split = splitSet(set, isSetOf);
|
|
249
241
|
const first = remaining[0];
|
|
250
242
|
if (split === undefined || first === undefined) {
|
|
251
243
|
if (!isSetOf && remaining.length === 1) return remaining[0];
|
|
@@ -254,13 +246,13 @@ export const getTlaLlProof = (
|
|
|
254
246
|
const value = split[0];
|
|
255
247
|
const rest = split[1];
|
|
256
248
|
const conclusion = member(element, set);
|
|
257
|
-
const
|
|
258
|
-
const
|
|
249
|
+
const valueEquality = equal(element, value);
|
|
250
|
+
const restMembership = member(element, rest);
|
|
259
251
|
const next = getMembership(
|
|
260
252
|
element,
|
|
261
253
|
rest,
|
|
262
254
|
remaining.slice(1),
|
|
263
|
-
[
|
|
255
|
+
[restMembership, ...conclusions],
|
|
264
256
|
isSetOf,
|
|
265
257
|
);
|
|
266
258
|
const extras = difference(union(first[1], next[1]), conclusions);
|
|
@@ -270,14 +262,13 @@ export const getTlaLlProof = (
|
|
|
270
262
|
"zenon_in_addElt",
|
|
271
263
|
[element, value, rest],
|
|
272
264
|
[conclusion],
|
|
273
|
-
[[
|
|
265
|
+
[[valueEquality], [restMembership]],
|
|
274
266
|
[first[0], next[0]],
|
|
275
267
|
),
|
|
276
268
|
extras,
|
|
277
269
|
];
|
|
278
270
|
};
|
|
279
271
|
|
|
280
|
-
// The non-membership in an enumerated set, one element at a time.
|
|
281
272
|
const getNonMembership = (
|
|
282
273
|
element: Expr,
|
|
283
274
|
set: Expr,
|
|
@@ -285,23 +276,18 @@ export const getTlaLlProof = (
|
|
|
285
276
|
conclusions: Expr[],
|
|
286
277
|
isSetOf: boolean,
|
|
287
278
|
): Translated => {
|
|
288
|
-
const split =
|
|
289
|
-
set.kind === "app" &&
|
|
290
|
-
set.symbol === (isSetOf ? "TLA.set" : "TLA.addElt") &&
|
|
291
|
-
set.args.length >= (isSetOf ? 1 : 2)
|
|
292
|
-
? [set.args[0], isSetOf ? exprs.eapp("TLA.set", set.args.slice(1)) : set.args[1]]
|
|
293
|
-
: undefined;
|
|
279
|
+
const split = splitSet(set, isSetOf);
|
|
294
280
|
if (split === undefined) return sub;
|
|
295
281
|
const value = split[0];
|
|
296
282
|
const rest = split[1];
|
|
297
283
|
const conclusion = exprs.enot(member(element, set));
|
|
298
|
-
const
|
|
299
|
-
const
|
|
284
|
+
const valueInequality = exprs.enot(equal(element, value));
|
|
285
|
+
const restNonMembership = exprs.enot(member(element, rest));
|
|
300
286
|
const next = getNonMembership(
|
|
301
287
|
element,
|
|
302
288
|
rest,
|
|
303
289
|
sub,
|
|
304
|
-
[
|
|
290
|
+
[valueInequality, restNonMembership, ...conclusions],
|
|
305
291
|
isSetOf,
|
|
306
292
|
);
|
|
307
293
|
const extras = difference(next[1], conclusions);
|
|
@@ -311,7 +297,7 @@ export const getTlaLlProof = (
|
|
|
311
297
|
"zenon_notin_addElt",
|
|
312
298
|
[element, value, rest],
|
|
313
299
|
[conclusion],
|
|
314
|
-
[[
|
|
300
|
+
[[valueInequality, restNonMembership]],
|
|
315
301
|
[next[0]],
|
|
316
302
|
),
|
|
317
303
|
extras,
|
|
@@ -367,10 +353,9 @@ export const getTlaLlProof = (
|
|
|
367
353
|
}
|
|
368
354
|
};
|
|
369
355
|
|
|
370
|
-
// Zenon's Ext_tla.postprocess: the lemmas with each $notequiv written as a negated equivalence.
|
|
371
356
|
export const postprocessTla = (exprs: Expressions, lemmas: Lemma[]): Lemma[] => {
|
|
372
357
|
const cache = new Map<Expr, Expr>();
|
|
373
|
-
const
|
|
358
|
+
const postprocess = (expression: Expr): Expr => {
|
|
374
359
|
const cached = cache.get(expression);
|
|
375
360
|
if (cached !== undefined) return cached;
|
|
376
361
|
const result = ((): Expr => {
|
|
@@ -383,35 +368,35 @@ export const postprocessTla = (exprs: Expressions, lemmas: Lemma[]): Lemma[] =>
|
|
|
383
368
|
throw new TlaZenonError("Zenon: a metavariable in a low-level proof");
|
|
384
369
|
case "app": {
|
|
385
370
|
if (expression.symbol !== "$notequiv")
|
|
386
|
-
return exprs.eapp(expression.symbol, expression.args.map(
|
|
371
|
+
return exprs.eapp(expression.symbol, expression.args.map(postprocess));
|
|
387
372
|
if (expression.args.length !== 2)
|
|
388
373
|
throw new TlaZenonError("Zenon: $notequiv without two arguments");
|
|
389
|
-
const right =
|
|
390
|
-
return exprs.enot(exprs.eequiv(
|
|
374
|
+
const right = postprocess(expression.args[1]);
|
|
375
|
+
return exprs.enot(exprs.eequiv(postprocess(expression.args[0]), right));
|
|
391
376
|
}
|
|
392
377
|
case "not":
|
|
393
|
-
return exprs.enot(
|
|
378
|
+
return exprs.enot(postprocess(expression.args[0]));
|
|
394
379
|
case "and":
|
|
395
380
|
case "or":
|
|
396
381
|
case "imply":
|
|
397
382
|
case "equiv": {
|
|
398
|
-
const right =
|
|
399
|
-
return connect(exprs, expression.kind,
|
|
383
|
+
const right = postprocess(expression.args[1]);
|
|
384
|
+
return connect(exprs, expression.kind, postprocess(expression.args[0]), right);
|
|
400
385
|
}
|
|
401
386
|
case "all":
|
|
402
|
-
return exprs.eall(expression.args[0], expression.symbol,
|
|
387
|
+
return exprs.eall(expression.args[0], expression.symbol, postprocess(expression.args[1]));
|
|
403
388
|
case "ex":
|
|
404
|
-
return exprs.eex(expression.args[0], expression.symbol,
|
|
389
|
+
return exprs.eex(expression.args[0], expression.symbol, postprocess(expression.args[1]));
|
|
405
390
|
case "tau":
|
|
406
|
-
return exprs.etau(expression.args[0], expression.symbol,
|
|
391
|
+
return exprs.etau(expression.args[0], expression.symbol, postprocess(expression.args[1]));
|
|
407
392
|
case "lam":
|
|
408
|
-
return exprs.elam(expression.args[0], expression.symbol,
|
|
393
|
+
return exprs.elam(expression.args[0], expression.symbol, postprocess(expression.args[1]));
|
|
409
394
|
}
|
|
410
395
|
})();
|
|
411
396
|
cache.set(expression, result);
|
|
412
397
|
return result;
|
|
413
398
|
};
|
|
414
|
-
const
|
|
399
|
+
const postprocessRule = (rule: LlRule): LlRule => {
|
|
415
400
|
switch (rule.kind) {
|
|
416
401
|
case "false":
|
|
417
402
|
case "nottrue":
|
|
@@ -419,62 +404,70 @@ export const postprocessTla = (exprs: Expressions, lemmas: Lemma[]): Lemma[] =>
|
|
|
419
404
|
case "axiom":
|
|
420
405
|
case "cut":
|
|
421
406
|
case "notnot":
|
|
422
|
-
return { kind: rule.kind, formula:
|
|
407
|
+
return { kind: rule.kind, formula: postprocess(rule.formula) };
|
|
423
408
|
case "noteq":
|
|
424
|
-
return { kind: "noteq", term:
|
|
409
|
+
return { kind: "noteq", term: postprocess(rule.term) };
|
|
425
410
|
case "eqsym":
|
|
426
411
|
case "notequal":
|
|
427
|
-
return { kind: rule.kind, left:
|
|
412
|
+
return { kind: rule.kind, left: postprocess(rule.left), right: postprocess(rule.right) };
|
|
428
413
|
case "connect":
|
|
429
414
|
case "notconnect":
|
|
430
415
|
return {
|
|
431
416
|
kind: rule.kind,
|
|
432
417
|
connective: rule.connective,
|
|
433
|
-
left:
|
|
434
|
-
right:
|
|
418
|
+
left: postprocess(rule.left),
|
|
419
|
+
right: postprocess(rule.right),
|
|
435
420
|
};
|
|
436
421
|
case "ex":
|
|
437
422
|
case "all":
|
|
438
423
|
case "notex":
|
|
439
424
|
case "notall":
|
|
440
|
-
return {
|
|
425
|
+
return {
|
|
426
|
+
kind: rule.kind,
|
|
427
|
+
quantified: postprocess(rule.quantified),
|
|
428
|
+
term: postprocess(rule.term),
|
|
429
|
+
};
|
|
441
430
|
case "pnotp":
|
|
442
|
-
return {
|
|
431
|
+
return {
|
|
432
|
+
kind: "pnotp",
|
|
433
|
+
positive: postprocess(rule.positive),
|
|
434
|
+
negative: postprocess(rule.negative),
|
|
435
|
+
};
|
|
443
436
|
case "congruencelr":
|
|
444
437
|
case "congruencerl":
|
|
445
438
|
return {
|
|
446
439
|
kind: rule.kind,
|
|
447
|
-
context:
|
|
448
|
-
left:
|
|
449
|
-
right:
|
|
440
|
+
context: postprocess(rule.context),
|
|
441
|
+
left: postprocess(rule.left),
|
|
442
|
+
right: postprocess(rule.right),
|
|
450
443
|
};
|
|
451
444
|
case "definition":
|
|
452
445
|
return {
|
|
453
446
|
kind: "definition",
|
|
454
447
|
name: rule.name,
|
|
455
|
-
folded:
|
|
456
|
-
unfolded:
|
|
448
|
+
folded: postprocess(rule.folded),
|
|
449
|
+
unfolded: postprocess(rule.unfolded),
|
|
457
450
|
};
|
|
458
451
|
case "extension":
|
|
459
452
|
return {
|
|
460
453
|
kind: "extension",
|
|
461
454
|
name: rule.name,
|
|
462
|
-
args: rule.args.map(
|
|
463
|
-
conclusions: rule.conclusions.map(
|
|
464
|
-
branches: rule.branches.map((branch) => branch.map(
|
|
455
|
+
args: rule.args.map(postprocess),
|
|
456
|
+
conclusions: rule.conclusions.map(postprocess),
|
|
457
|
+
branches: rule.branches.map((branch) => branch.map(postprocess)),
|
|
465
458
|
};
|
|
466
459
|
case "lemma":
|
|
467
|
-
return { kind: "lemma", name: rule.name, args: rule.args.map(
|
|
460
|
+
return { kind: "lemma", name: rule.name, args: rule.args.map(postprocess) };
|
|
468
461
|
}
|
|
469
462
|
};
|
|
470
|
-
const
|
|
471
|
-
conclusions: tree.conclusions.map(
|
|
472
|
-
rule:
|
|
473
|
-
subproofs: tree.subproofs.map(
|
|
463
|
+
const postprocessTree = (tree: LlProof): LlProof => ({
|
|
464
|
+
conclusions: tree.conclusions.map(postprocess),
|
|
465
|
+
rule: postprocessRule(tree.rule),
|
|
466
|
+
subproofs: tree.subproofs.map(postprocessTree),
|
|
474
467
|
});
|
|
475
468
|
return lemmas.map((lemma) => ({
|
|
476
469
|
name: lemma.name,
|
|
477
|
-
params: lemma.params.map((param): [string, Expr] => [param[0],
|
|
478
|
-
proof:
|
|
470
|
+
params: lemma.params.map((param): [string, Expr] => [param[0], postprocess(param[1])]),
|
|
471
|
+
proof: postprocessTree(lemma.proof),
|
|
479
472
|
}));
|
|
480
473
|
};
|