tla-ts 0.0.4 → 0.0.5
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 +37 -126
- package/dist/cli.cjs +1 -1
- package/dist/cli.js +1 -1
- package/dist/deciders.cjs +366 -0
- package/dist/deciders.js +366 -0
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +46 -12
- package/dist/index.d.ts +46 -12
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -4
- package/dist/parallel-worker.js +1 -4
- package/dist/prove-worker.cjs +9 -0
- package/dist/prove-worker.d.cts +9 -0
- package/dist/prove-worker.d.ts +9 -0
- package/dist/prove-worker.js +9 -0
- package/dist/prove.cjs +1006 -0
- package/dist/prove.js +1006 -0
- package/dist/run.cjs +45 -0
- package/dist/run.js +45 -0
- package/dist/tlapm.cjs +10 -0
- package/dist/tlapm.js +10 -0
- package/dist/transfer.cjs +76 -92
- package/dist/transfer.js +76 -92
- package/dist/worker.cjs +21 -0
- package/dist/worker.js +21 -0
- package/package.json +21 -12
- package/src/ast.ts +2 -2
- package/src/bags.ts +22 -23
- package/src/builtins.ts +16 -8
- package/src/check.ts +131 -1153
- package/src/{cli-options.ts → cli/options.ts} +54 -9
- package/src/cli/run.ts +63 -0
- package/src/cli/shared.ts +106 -0
- package/src/cli/tlapm.ts +374 -0
- package/src/{run-cli.ts → cli/tlc.ts} +115 -721
- package/src/cli/xml-exporter.ts +221 -0
- package/src/cli.ts +1 -1
- package/src/codegen.ts +43 -22
- package/src/config.ts +5 -5
- package/src/dependencies.ts +4 -6
- package/src/environment.ts +55 -60
- package/src/errors.ts +97 -35
- package/src/evaluate.ts +361 -181
- package/src/exit-codes.ts +1 -1
- package/src/fingerprints.ts +3 -3
- package/src/index.ts +10 -0
- package/src/instances.ts +56 -46
- package/src/java-overrides.ts +79 -41
- package/src/json.ts +31 -36
- package/src/levels.ts +10 -13
- package/src/{live-check.ts → liveness-checker.ts} +207 -141
- package/src/liveness.ts +38 -34
- package/src/{obligation-action.ts → obligations/action.ts} +248 -74
- package/src/{obligation-anon.ts → obligations/anonymize.ts} +55 -57
- package/src/obligations/equality.ts +260 -0
- package/src/obligations/expression.ts +618 -0
- package/src/{obligation-format.ts → obligations/format.ts} +7 -8
- package/src/obligations/generate.ts +457 -0
- package/src/{obligations.ts → obligations/index.ts} +46 -32
- package/src/{obligation-levels.ts → obligations/levels.ts} +44 -40
- package/src/obligations/module.ts +445 -0
- package/src/obligations/normalize.ts +554 -0
- package/src/obligations/operators.ts +176 -0
- package/src/obligations/pragma.ts +195 -0
- package/src/{obligation-printer.ts → obligations/printer.ts} +65 -230
- package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
- package/src/obligations/regroup.ts +100 -0
- package/src/{obligation-generate.ts → obligations/simplify.ts} +130 -536
- package/src/{obligation-source.ts → obligations/source.ts} +172 -216
- package/src/{obligation-deref.ts → obligations/subexpression.ts} +84 -115
- package/src/obligations/substitution.ts +261 -0
- package/src/obligations/temporal.ts +321 -0
- package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
- package/src/parallel-worker.ts +39 -51
- package/src/parallel.ts +39 -66
- package/src/parser.ts +67 -74
- package/src/{pcal-ast.ts → pcal/ast.ts} +2 -17
- package/src/{pcal-parse.ts → pcal/parse.ts} +28 -64
- package/src/{pcal-tokenize.ts → pcal/tokenize.ts} +10 -39
- package/src/{pcal-translate.ts → pcal/translate.ts} +30 -109
- package/src/{pcal-validate.ts → pcal/validate.ts} +10 -20
- package/src/prover/decide-pool.ts +95 -0
- package/src/prover/deciders.ts +33 -0
- package/src/prover/first-order.ts +175 -0
- package/src/prover/isabelle/LICENSE +36 -0
- package/src/prover/isabelle/LICENSE-tlapm +26 -0
- package/src/prover/isabelle/decide.ts +44 -0
- package/src/prover/isabelle/encode.ts +445 -0
- package/src/prover/isabelle/isar/inner-syntax.ts +579 -0
- package/src/prover/isabelle/isar/method.ts +367 -0
- package/src/prover/isabelle/isar/proof.ts +28 -0
- package/src/prover/isabelle/isar/statement.ts +57 -0
- package/src/prover/isabelle/isar/theory.ts +192 -0
- package/src/prover/isabelle/isar/type-check.ts +278 -0
- package/src/prover/isabelle/provers/blast/blast.ts +258 -0
- package/src/prover/isabelle/provers/blast/branch.ts +322 -0
- package/src/prover/isabelle/provers/blast/prove.ts +347 -0
- package/src/prover/isabelle/provers/blast/rules.ts +330 -0
- package/src/prover/isabelle/provers/blast/state.ts +180 -0
- package/src/prover/isabelle/provers/blast/term.ts +546 -0
- package/src/prover/isabelle/provers/clasimp.ts +150 -0
- package/src/prover/isabelle/provers/classical.ts +389 -0
- package/src/prover/isabelle/provers/hypsubst.ts +433 -0
- package/src/prover/isabelle/pure/bicompose.ts +174 -0
- package/src/prover/isabelle/pure/consts.ts +32 -0
- package/src/prover/isabelle/pure/conv.ts +79 -0
- package/src/prover/isabelle/pure/drule.ts +264 -0
- package/src/prover/isabelle/pure/envir.ts +331 -0
- package/src/prover/isabelle/pure/goal.ts +53 -0
- package/src/prover/isabelle/pure/interrupt.ts +16 -0
- package/src/prover/isabelle/pure/list.ts +12 -0
- package/src/prover/isabelle/pure/logic.ts +330 -0
- package/src/prover/isabelle/pure/name.ts +98 -0
- package/src/prover/isabelle/pure/net.ts +215 -0
- package/src/prover/isabelle/pure/object-logic.ts +41 -0
- package/src/prover/isabelle/pure/pattern.ts +631 -0
- package/src/prover/isabelle/pure/raw-simplifier.ts +338 -0
- package/src/prover/isabelle/pure/rewriter.ts +602 -0
- package/src/prover/isabelle/pure/search.ts +68 -0
- package/src/prover/isabelle/pure/seq.ts +133 -0
- package/src/prover/isabelle/pure/simplifier.ts +106 -0
- package/src/prover/isabelle/pure/table.ts +201 -0
- package/src/prover/isabelle/pure/tactic.ts +168 -0
- package/src/prover/isabelle/pure/tactical.ts +264 -0
- package/src/prover/isabelle/pure/term-ord.ts +105 -0
- package/src/prover/isabelle/pure/term.ts +688 -0
- package/src/prover/isabelle/pure/thm.ts +783 -0
- package/src/prover/isabelle/pure/type.ts +121 -0
- package/src/prover/isabelle/pure/unify.ts +753 -0
- package/src/prover/isabelle/pure/variable.ts +25 -0
- package/src/prover/isabelle/tla/classical-setup.ts +101 -0
- package/src/prover/isabelle/tla/context.ts +74 -0
- package/src/prover/isabelle/tla/logic-data.ts +5 -0
- package/src/prover/isabelle/tla/logic.ts +215 -0
- package/src/prover/isabelle/tla/simpdata.ts +241 -0
- package/src/prover/isabelle/tools/intuitionistic.ts +132 -0
- package/src/prover/ocaml.ts +22 -0
- package/src/prover/prep/action.ts +508 -0
- package/src/prover/prep/enabled-axioms.ts +189 -0
- package/src/prover/prep/fingerprint.ts +388 -0
- package/src/prover/prep/level-comparison.ts +529 -0
- package/src/prover/prep/md5.ts +60 -0
- package/src/prover/prep/methods.ts +221 -0
- package/src/prover/prep/normalize.ts +309 -0
- package/src/prover/prove-worker.ts +22 -0
- package/src/prover/prove.ts +492 -0
- package/src/prover/ptl/decide.ts +68 -0
- package/src/prover/ptl/encode.ts +244 -0
- package/src/prover/ptl/sat.ts +151 -0
- package/src/prover/ptl/tableau.ts +276 -0
- package/src/prover/smt/axioms.ts +209 -0
- package/src/prover/smt/context.ts +108 -0
- package/src/prover/smt/data.ts +636 -0
- package/src/prover/smt/encode.ts +275 -0
- package/src/prover/smt/extensionality.ts +65 -0
- package/src/prover/smt/flatten.ts +112 -0
- package/src/prover/smt/format.ts +154 -0
- package/src/prover/smt/instances.ts +181 -0
- package/src/prover/smt/rewrite.ts +766 -0
- package/src/prover/smt/solver/act-cache.ts +265 -0
- package/src/prover/smt/solver/arith-rewriter.ts +962 -0
- package/src/prover/smt/solver/array.ts +22 -0
- package/src/prover/smt/solver/asserted-formulas.ts +469 -0
- package/src/prover/smt/solver/ast-lt.ts +157 -0
- package/src/prover/smt/solver/ast-util.ts +91 -0
- package/src/prover/smt/solver/ast.ts +1315 -0
- package/src/prover/smt/solver/auf-solver.ts +572 -0
- package/src/prover/smt/solver/case-split-queue.ts +178 -0
- package/src/prover/smt/solver/cg-table.ts +175 -0
- package/src/prover/smt/solver/clause.ts +276 -0
- package/src/prover/smt/solver/conflict-resolution.ts +343 -0
- package/src/prover/smt/solver/context.ts +1292 -0
- package/src/prover/smt/solver/ctx-simplify.ts +334 -0
- package/src/prover/smt/solver/der.ts +224 -0
- package/src/prover/smt/solver/dyn-ack.ts +141 -0
- package/src/prover/smt/solver/e-matching.ts +659 -0
- package/src/prover/smt/solver/enode.ts +259 -0
- package/src/prover/smt/solver/expr-ref.ts +21 -0
- package/src/prover/smt/solver/expr-safe-replace.ts +172 -0
- package/src/prover/smt/solver/fingerprints.ts +92 -0
- package/src/prover/smt/solver/flat-literals.ts +51 -0
- package/src/prover/smt/solver/goal.ts +138 -0
- package/src/prover/smt/solver/hash.ts +173 -0
- package/src/prover/smt/solver/hashtable.ts +166 -0
- package/src/prover/smt/solver/internalizer.ts +1381 -0
- package/src/prover/smt/solver/lbool.ts +5 -0
- package/src/prover/smt/solver/literal.ts +24 -0
- package/src/prover/smt/solver/lp/bound-propagator.ts +391 -0
- package/src/prover/smt/solver/lp/constraints.ts +78 -0
- package/src/prover/smt/solver/lp/containers.ts +296 -0
- package/src/prover/smt/solver/lp/core-solver.ts +504 -0
- package/src/prover/smt/solver/lp/cross-nested.ts +224 -0
- package/src/prover/smt/solver/lp/dep-intervals.ts +642 -0
- package/src/prover/smt/solver/lp/dependency.ts +51 -0
- package/src/prover/smt/solver/lp/dioph-eq.ts +1181 -0
- package/src/prover/smt/solver/lp/explanation.ts +46 -0
- package/src/prover/smt/solver/lp/gomory.ts +255 -0
- package/src/prover/smt/solver/lp/hnf-cutter.ts +125 -0
- package/src/prover/smt/solver/lp/hnf.ts +281 -0
- package/src/prover/smt/solver/lp/int-cube.ts +295 -0
- package/src/prover/smt/solver/lp/int-solver.ts +514 -0
- package/src/prover/smt/solver/lp/lar-solver.ts +816 -0
- package/src/prover/smt/solver/lp/lar-term.ts +62 -0
- package/src/prover/smt/solver/lp/lp-settings.ts +91 -0
- package/src/prover/smt/solver/lp/maximize-term.ts +347 -0
- package/src/prover/smt/solver/lp/nex-creator.ts +381 -0
- package/src/prover/smt/solver/lp/nex.ts +120 -0
- package/src/prover/smt/solver/lp/nla-backoff.ts +43 -0
- package/src/prover/smt/solver/lp/nla-basics.ts +398 -0
- package/src/prover/smt/solver/lp/nla-core.ts +968 -0
- package/src/prover/smt/solver/lp/nla-divisions.ts +332 -0
- package/src/prover/smt/solver/lp/nla-emonics.ts +373 -0
- package/src/prover/smt/solver/lp/nla-factorization.ts +30 -0
- package/src/prover/smt/solver/lp/nla-grobner.ts +904 -0
- package/src/prover/smt/solver/lp/nla-horner.ts +126 -0
- package/src/prover/smt/solver/lp/nla-intervals.ts +265 -0
- package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +715 -0
- package/src/prover/smt/solver/lp/nla-monotone.ts +59 -0
- package/src/prover/smt/solver/lp/nla-order.ts +307 -0
- package/src/prover/smt/solver/lp/nla-patcher.ts +112 -0
- package/src/prover/smt/solver/lp/nla-tangents.ts +251 -0
- package/src/prover/smt/solver/lp/nla-throttle.ts +85 -0
- package/src/prover/smt/solver/lp/nla-types.ts +124 -0
- package/src/prover/smt/solver/lp/nla-var-eqs.ts +141 -0
- package/src/prover/smt/solver/lp/nra-solver.ts +440 -0
- package/src/prover/smt/solver/lp/numeric-pair.ts +65 -0
- package/src/prover/smt/solver/lp/pdd-interval.ts +31 -0
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +184 -0
- package/src/prover/smt/solver/lp/pdd-solver.ts +408 -0
- package/src/prover/smt/solver/lp/pdd.ts +971 -0
- package/src/prover/smt/solver/lp/random-updater.ts +138 -0
- package/src/prover/smt/solver/lp/static-matrix.ts +246 -0
- package/src/prover/smt/solver/lp/union-find.ts +96 -0
- package/src/prover/smt/solver/mam-compiler.ts +847 -0
- package/src/prover/smt/solver/mam-interpreter.ts +400 -0
- package/src/prover/smt/solver/maximize-ac-sharing.ts +118 -0
- package/src/prover/smt/solver/model-checker.ts +347 -0
- package/src/prover/smt/solver/model-evaluator.ts +262 -0
- package/src/prover/smt/solver/model-finder.ts +155 -0
- package/src/prover/smt/solver/model-generator.ts +97 -0
- package/src/prover/smt/solver/model-macro-solver.ts +728 -0
- package/src/prover/smt/solver/nlsat/algebraic.ts +1161 -0
- package/src/prover/smt/solver/nlsat/atoms.ts +238 -0
- package/src/prover/smt/solver/nlsat/evaluator.ts +303 -0
- package/src/prover/smt/solver/nlsat/explain.ts +607 -0
- package/src/prover/smt/solver/nlsat/interval-set.ts +351 -0
- package/src/prover/smt/solver/nlsat/levelwise.ts +737 -0
- package/src/prover/smt/solver/nlsat/mpbq.ts +161 -0
- package/src/prover/smt/solver/nlsat/polynomial.ts +1722 -0
- package/src/prover/smt/solver/nlsat/solver.ts +911 -0
- package/src/prover/smt/solver/nlsat/types.ts +43 -0
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
- package/src/prover/smt/solver/nlsat/upolynomial.ts +996 -0
- package/src/prover/smt/solver/nnf.ts +469 -0
- package/src/prover/smt/solver/pattern-inference.ts +351 -0
- package/src/prover/smt/solver/poly-rewriter.ts +477 -0
- package/src/prover/smt/solver/propagate-values.ts +83 -0
- package/src/prover/smt/solver/proto-model.ts +551 -0
- package/src/prover/smt/solver/pull-quant.ts +139 -0
- package/src/prover/smt/solver/qe-lite-der.ts +526 -0
- package/src/prover/smt/solver/qe-lite-fm.ts +576 -0
- package/src/prover/smt/solver/qe-lite.ts +381 -0
- package/src/prover/smt/solver/qi-queue.ts +362 -0
- package/src/prover/smt/solver/quant-tactics.ts +117 -0
- package/src/prover/smt/solver/quantifier-analyzer.ts +562 -0
- package/src/prover/smt/solver/quantifier-manager.ts +186 -0
- package/src/prover/smt/solver/random-gen.ts +10 -0
- package/src/prover/smt/solver/rational.ts +165 -0
- package/src/prover/smt/solver/ref-vector.ts +62 -0
- package/src/prover/smt/solver/relevancy.ts +247 -0
- package/src/prover/smt/solver/rewriter-tpl.ts +1159 -0
- package/src/prover/smt/solver/rewriter.ts +843 -0
- package/src/prover/smt/solver/rlimit.ts +79 -0
- package/src/prover/smt/solver/smtlib-parser.ts +526 -0
- package/src/prover/smt/solver/solver.ts +71 -0
- package/src/prover/smt/solver/sort.ts +35 -0
- package/src/prover/smt/solver/sticky-generations.ts +69 -0
- package/src/prover/smt/solver/theory-lra-axioms.ts +340 -0
- package/src/prover/smt/solver/theory-lra-bounds.ts +226 -0
- package/src/prover/smt/solver/theory-lra-final-check.ts +252 -0
- package/src/prover/smt/solver/theory-lra-internalize.ts +476 -0
- package/src/prover/smt/solver/theory-lra-model.ts +243 -0
- package/src/prover/smt/solver/theory-lra-propagate.ts +405 -0
- package/src/prover/smt/solver/theory-lra-state.ts +43 -0
- package/src/prover/smt/solver/theory-lra.ts +56 -0
- package/src/prover/smt/solver/var-subst.ts +258 -0
- package/src/prover/smt/solver/z3-license.txt +10 -0
- package/src/prover/smt/table.ts +170 -0
- package/src/prover/tlapm/cache.ts +236 -0
- package/src/prover/tlapm/ocaml-marshal.ts +166 -0
- package/src/prover/tlapm/tlapm.ts +96 -0
- package/src/prover/tlaps-module.ts +510 -0
- package/src/prover/verdict.ts +13 -0
- package/src/prover/zenon/LICENSE +32 -0
- package/src/prover/zenon/check/check.ts +105 -0
- package/src/prover/zenon/check/definitions.ts +144 -0
- package/src/prover/zenon/check/equality.ts +182 -0
- package/src/prover/zenon/check/functions.ts +62 -0
- package/src/prover/zenon/check/keys.ts +125 -0
- package/src/prover/zenon/check/propositional.ts +104 -0
- package/src/prover/zenon/check/records.ts +188 -0
- package/src/prover/zenon/check/relations.ts +121 -0
- package/src/prover/zenon/check/rewrites.ts +224 -0
- package/src/prover/zenon/check/sets.ts +302 -0
- package/src/prover/zenon/check/terms.ts +127 -0
- package/src/prover/zenon/check/tla.ts +126 -0
- package/src/prover/zenon/decide.ts +107 -0
- package/src/prover/zenon/encode.ts +378 -0
- package/src/prover/zenon/eqrel.ts +300 -0
- package/src/prover/zenon/equality-rules.ts +435 -0
- package/src/prover/zenon/expr.ts +551 -0
- package/src/prover/zenon/index-table.ts +350 -0
- package/src/prover/zenon/isar-case.ts +513 -0
- package/src/prover/zenon/isar.ts +1249 -0
- package/src/prover/zenon/limits.ts +15 -0
- package/src/prover/zenon/llproof.ts +173 -0
- package/src/prover/zenon/mltoll.ts +1566 -0
- package/src/prover/zenon/node.ts +297 -0
- package/src/prover/zenon/ocaml.ts +169 -0
- package/src/prover/zenon/parse.ts +247 -0
- package/src/prover/zenon/phrase.ts +191 -0
- package/src/prover/zenon/proof.ts +198 -0
- package/src/prover/zenon/propositional-rules.ts +387 -0
- package/src/prover/zenon/rules.ts +94 -0
- package/src/prover/zenon/search.ts +288 -0
- package/src/prover/zenon/tla/functions.ts +151 -0
- package/src/prover/zenon/tla/llproof.ts +480 -0
- package/src/prover/zenon/tla/records.ts +225 -0
- package/src/prover/zenon/tla/rewrites.ts +447 -0
- package/src/prover/zenon/tla/sets.ts +304 -0
- package/src/prover/zenon/tla/terms.ts +162 -0
- package/src/prover/zenon/tla/tla.ts +506 -0
- package/src/randomization.ts +19 -24
- package/src/resolve.ts +15 -22
- package/src/runtime.ts +8 -8
- package/src/{sany-builtins.ts → sany/builtins.ts} +1 -1
- package/src/{sany-generator.ts → sany/generator.ts} +38 -55
- package/src/{sany-levels.ts → sany/levels.ts} +45 -48
- package/src/{sany-lexer.ts → sany/lexer.ts} +2 -3
- package/src/{sany-linter.ts → sany/linter.ts} +1 -1
- package/src/{sany-modules.ts → sany/modules.ts} +2 -2
- package/src/{sany-nodes.ts → sany/nodes.ts} +2 -2
- package/src/{sany-parse-error.ts → sany/parse-error.ts} +2 -2
- package/src/{sany-report.ts → sany/report.ts} +16 -17
- package/src/{sany-selectors.ts → sany/selectors.ts} +3 -5
- package/src/{sany-source.ts → sany/source.ts} +6 -7
- package/src/{sany-xml.ts → sany/xml.ts} +5 -6
- package/src/search.ts +969 -0
- package/src/spec-description.ts +26 -20
- package/src/{standard-levels.ts → standard-definitions.ts} +118 -2
- package/src/standard-modules.ts +21 -22
- package/src/state-graph.ts +9 -8
- package/src/substitution-levels.ts +2 -2
- package/src/successors.ts +39 -23
- package/src/symmetry.ts +1 -1
- package/src/tableau.ts +6 -7
- package/src/tlc/fingerprint.ts +214 -0
- package/src/{tlc-messages.ts → tlc/messages.ts} +119 -7
- package/src/{tlc-order.ts → tlc/order.ts} +7 -7
- package/src/{tlc-random.ts → tlc/random.ts} +3 -190
- package/src/{tlc-replay.ts → tlc/replay.ts} +40 -36
- package/src/{tlc-module.ts → tlc/tlc-operators.ts} +9 -9
- package/src/{tlc-ext.ts → tlc/tlcext-operators.ts} +30 -25
- package/src/{tlc-version.ts → tlc/version.ts} +8 -7
- package/src/transfer.ts +32 -32
- package/src/values.ts +166 -111
- package/src/worker.ts +62 -0
- package/dist/parallel.cjs +0 -12
- package/dist/parallel.js +0 -12
- package/dist/run-cli.cjs +0 -55
- package/dist/run-cli.js +0 -55
- package/src/canonical.ts +0 -40
- package/src/obligation-expression.ts +0 -1060
- package/src/obligation-module.ts +0 -1042
- package/src/standard-ranges.ts +0 -116
- package/src/value-sources.ts +0 -29
- /package/src/{tlc-modules.ts → tlc/jar-data.ts} +0 -0
- /package/src/{tlc-summary.ts → tlc/summary.ts} +0 -0
|
@@ -0,0 +1,302 @@
|
|
|
1
|
+
// The checks of the TLA+ extension's rules for set membership, set equality and subsets, after the
|
|
2
|
+
// lemmas in Zenon.thy that justify them.
|
|
3
|
+
|
|
4
|
+
import type { PlainRuleName } from "../proof";
|
|
5
|
+
import {
|
|
6
|
+
and,
|
|
7
|
+
app,
|
|
8
|
+
ensure,
|
|
9
|
+
equal,
|
|
10
|
+
equiv,
|
|
11
|
+
expectApp,
|
|
12
|
+
expectNot,
|
|
13
|
+
fapply,
|
|
14
|
+
imply,
|
|
15
|
+
instantiate,
|
|
16
|
+
isApp,
|
|
17
|
+
isVariable,
|
|
18
|
+
member,
|
|
19
|
+
not,
|
|
20
|
+
domain,
|
|
21
|
+
type Checker,
|
|
22
|
+
type RuleSpec,
|
|
23
|
+
type SpecTable,
|
|
24
|
+
type Term,
|
|
25
|
+
} from "./terms";
|
|
26
|
+
|
|
27
|
+
const getMembershipSpec = (
|
|
28
|
+
formula: Term,
|
|
29
|
+
isNegated: boolean,
|
|
30
|
+
constructor: string,
|
|
31
|
+
arity: number,
|
|
32
|
+
) => {
|
|
33
|
+
const atom = isNegated ? expectNot(formula) : formula;
|
|
34
|
+
const sides = expectApp(atom, "TLA.in", 2);
|
|
35
|
+
return { element: sides[0], operands: expectApp(sides[1], constructor, arity), set: sides[1] };
|
|
36
|
+
};
|
|
37
|
+
|
|
38
|
+
const getSetEqualSpec = (formula: Term, isNegated: boolean, checker: Checker): RuleSpec => {
|
|
39
|
+
const sides = expectApp(isNegated ? expectNot(formula) : formula, "=", 2);
|
|
40
|
+
const extensional = checker.bind("all", "", (bound) =>
|
|
41
|
+
equiv(member(bound, sides[0]), member(bound, sides[1])),
|
|
42
|
+
);
|
|
43
|
+
return { premises: [formula], branches: [[isNegated ? not(extensional) : extensional]] };
|
|
44
|
+
};
|
|
45
|
+
|
|
46
|
+
export const SET_RULES = {
|
|
47
|
+
in_emptyset: (args) => {
|
|
48
|
+
ensure(isVariable(expectApp(args[0], "TLA.in", 2)[1], "TLA.emptyset"));
|
|
49
|
+
return { premises: [args[0]], branches: [] };
|
|
50
|
+
},
|
|
51
|
+
in_upair: (args) => {
|
|
52
|
+
const spec = getMembershipSpec(args[0], false, "TLA.upair", 2);
|
|
53
|
+
return {
|
|
54
|
+
premises: [args[0]],
|
|
55
|
+
branches: spec.operands.map((inner) => [equal(spec.element, inner)]),
|
|
56
|
+
};
|
|
57
|
+
},
|
|
58
|
+
notin_upair: (args) => {
|
|
59
|
+
const spec = getMembershipSpec(args[0], true, "TLA.upair", 2);
|
|
60
|
+
return {
|
|
61
|
+
premises: [args[0]],
|
|
62
|
+
branches: [spec.operands.map((inner) => not(equal(spec.element, inner)))],
|
|
63
|
+
};
|
|
64
|
+
},
|
|
65
|
+
in_addElt: (args) => {
|
|
66
|
+
const spec = getMembershipSpec(args[0], false, "TLA.addElt", 2);
|
|
67
|
+
const branches: Term[][] = [];
|
|
68
|
+
let rest = spec.set;
|
|
69
|
+
while (isApp(rest, "TLA.addElt", 2)) {
|
|
70
|
+
branches.push([equal(spec.element, rest.args[0])]);
|
|
71
|
+
rest = rest.args[1];
|
|
72
|
+
}
|
|
73
|
+
return {
|
|
74
|
+
premises: [args[0]],
|
|
75
|
+
branches: isVariable(rest, "TLA.emptyset")
|
|
76
|
+
? branches
|
|
77
|
+
: [...branches, [member(spec.element, rest)]],
|
|
78
|
+
};
|
|
79
|
+
},
|
|
80
|
+
notin_addElt: (args) => {
|
|
81
|
+
const spec = getMembershipSpec(args[0], true, "TLA.addElt", 2);
|
|
82
|
+
const formulas: Term[] = [];
|
|
83
|
+
let rest = spec.set;
|
|
84
|
+
while (isApp(rest, "TLA.addElt", 2)) {
|
|
85
|
+
formulas.push(not(equal(spec.element, rest.args[0])));
|
|
86
|
+
rest = rest.args[1];
|
|
87
|
+
}
|
|
88
|
+
if (!isVariable(rest, "TLA.emptyset")) formulas.push(not(member(spec.element, rest)));
|
|
89
|
+
return { premises: [args[0]], branches: [formulas] };
|
|
90
|
+
},
|
|
91
|
+
in_set: (args) => {
|
|
92
|
+
const sides = expectApp(args[0], "TLA.in", 2);
|
|
93
|
+
const elements = expectApp(sides[1], "TLA.set");
|
|
94
|
+
return { premises: [args[0]], branches: elements.map((inner) => [equal(sides[0], inner)]) };
|
|
95
|
+
},
|
|
96
|
+
notin_set: (args) => {
|
|
97
|
+
const sides = expectApp(expectNot(args[0]), "TLA.in", 2);
|
|
98
|
+
const elements = expectApp(sides[1], "TLA.set");
|
|
99
|
+
return {
|
|
100
|
+
premises: [args[0]],
|
|
101
|
+
branches: [elements.map((inner) => not(equal(sides[0], inner)))],
|
|
102
|
+
};
|
|
103
|
+
},
|
|
104
|
+
in_SUBSET: (args) => {
|
|
105
|
+
const spec = getMembershipSpec(args[0], false, "TLA.SUBSET", 1);
|
|
106
|
+
return {
|
|
107
|
+
premises: [args[0]],
|
|
108
|
+
branches: [[app("TLA.subseteq", [spec.element, spec.operands[0]])]],
|
|
109
|
+
};
|
|
110
|
+
},
|
|
111
|
+
notin_SUBSET: (args) => {
|
|
112
|
+
const spec = getMembershipSpec(args[0], true, "TLA.SUBSET", 1);
|
|
113
|
+
return {
|
|
114
|
+
premises: [args[0]],
|
|
115
|
+
branches: [[not(app("TLA.subseteq", [spec.element, spec.operands[0]]))]],
|
|
116
|
+
};
|
|
117
|
+
},
|
|
118
|
+
in_UNION: (args, checker) => {
|
|
119
|
+
const spec = getMembershipSpec(args[0], false, "TLA.UNION", 1);
|
|
120
|
+
const exists = checker.bind("ex", "", (bound) =>
|
|
121
|
+
and(member(bound, spec.operands[0]), member(spec.element, bound)),
|
|
122
|
+
);
|
|
123
|
+
return { premises: [args[0]], branches: [[exists]] };
|
|
124
|
+
},
|
|
125
|
+
notin_UNION: (args, checker) => {
|
|
126
|
+
const spec = getMembershipSpec(args[0], true, "TLA.UNION", 1);
|
|
127
|
+
const exists = checker.bind("ex", "", (bound) =>
|
|
128
|
+
and(member(bound, spec.operands[0]), member(spec.element, bound)),
|
|
129
|
+
);
|
|
130
|
+
return { premises: [args[0]], branches: [[not(exists)]] };
|
|
131
|
+
},
|
|
132
|
+
in_cup: (args) => {
|
|
133
|
+
const spec = getMembershipSpec(args[0], false, "TLA.cup", 2);
|
|
134
|
+
return {
|
|
135
|
+
premises: [args[0]],
|
|
136
|
+
branches: spec.operands.map((inner) => [member(spec.element, inner)]),
|
|
137
|
+
};
|
|
138
|
+
},
|
|
139
|
+
notin_cup: (args) => {
|
|
140
|
+
const spec = getMembershipSpec(args[0], true, "TLA.cup", 2);
|
|
141
|
+
return {
|
|
142
|
+
premises: [args[0]],
|
|
143
|
+
branches: [spec.operands.map((inner) => not(member(spec.element, inner)))],
|
|
144
|
+
};
|
|
145
|
+
},
|
|
146
|
+
in_cap: (args) => {
|
|
147
|
+
const spec = getMembershipSpec(args[0], false, "TLA.cap", 2);
|
|
148
|
+
return {
|
|
149
|
+
premises: [args[0]],
|
|
150
|
+
branches: [spec.operands.map((inner) => member(spec.element, inner))],
|
|
151
|
+
};
|
|
152
|
+
},
|
|
153
|
+
notin_cap: (args) => {
|
|
154
|
+
const spec = getMembershipSpec(args[0], true, "TLA.cap", 2);
|
|
155
|
+
return {
|
|
156
|
+
premises: [args[0]],
|
|
157
|
+
branches: spec.operands.map((inner) => [not(member(spec.element, inner))]),
|
|
158
|
+
};
|
|
159
|
+
},
|
|
160
|
+
in_setminus: (args) => {
|
|
161
|
+
const spec = getMembershipSpec(args[0], false, "TLA.setminus", 2);
|
|
162
|
+
return {
|
|
163
|
+
premises: [args[0]],
|
|
164
|
+
branches: [
|
|
165
|
+
[member(spec.element, spec.operands[0]), not(member(spec.element, spec.operands[1]))],
|
|
166
|
+
],
|
|
167
|
+
};
|
|
168
|
+
},
|
|
169
|
+
notin_setminus: (args) => {
|
|
170
|
+
const spec = getMembershipSpec(args[0], true, "TLA.setminus", 2);
|
|
171
|
+
return {
|
|
172
|
+
premises: [args[0]],
|
|
173
|
+
branches: [
|
|
174
|
+
[not(member(spec.element, spec.operands[0]))],
|
|
175
|
+
[member(spec.element, spec.operands[1])],
|
|
176
|
+
],
|
|
177
|
+
};
|
|
178
|
+
},
|
|
179
|
+
in_subsetof: (args) => {
|
|
180
|
+
const spec = getMembershipSpec(args[0], false, "TLA.subsetOf", 2);
|
|
181
|
+
const predicate = spec.operands[1];
|
|
182
|
+
ensure(predicate.kind === "lam");
|
|
183
|
+
return {
|
|
184
|
+
premises: [args[0]],
|
|
185
|
+
branches: [[member(spec.element, spec.operands[0]), instantiate(predicate, spec.element)]],
|
|
186
|
+
};
|
|
187
|
+
},
|
|
188
|
+
notin_subsetof: (args) => {
|
|
189
|
+
const spec = getMembershipSpec(args[0], true, "TLA.subsetOf", 2);
|
|
190
|
+
const predicate = spec.operands[1];
|
|
191
|
+
ensure(predicate.kind === "lam");
|
|
192
|
+
return {
|
|
193
|
+
premises: [args[0]],
|
|
194
|
+
branches: [
|
|
195
|
+
[not(member(spec.element, spec.operands[0]))],
|
|
196
|
+
[not(instantiate(predicate, spec.element))],
|
|
197
|
+
],
|
|
198
|
+
};
|
|
199
|
+
},
|
|
200
|
+
in_setofall: (args, checker) => {
|
|
201
|
+
const spec = getMembershipSpec(args[0], false, "TLA.setOfAll", 2);
|
|
202
|
+
const mapping = spec.operands[1];
|
|
203
|
+
ensure(mapping.kind === "lam");
|
|
204
|
+
const exists = checker.bind("ex", "", (bound) =>
|
|
205
|
+
and(member(bound, spec.operands[0]), equal(spec.element, instantiate(mapping, bound))),
|
|
206
|
+
);
|
|
207
|
+
return { premises: [args[0]], branches: [[exists]] };
|
|
208
|
+
},
|
|
209
|
+
notin_setofall: (args, checker) => {
|
|
210
|
+
const spec = getMembershipSpec(args[0], true, "TLA.setOfAll", 2);
|
|
211
|
+
const mapping = spec.operands[1];
|
|
212
|
+
ensure(mapping.kind === "lam");
|
|
213
|
+
const exists = checker.bind("ex", "", (bound) =>
|
|
214
|
+
and(member(bound, spec.operands[0]), equal(spec.element, instantiate(mapping, bound))),
|
|
215
|
+
);
|
|
216
|
+
return { premises: [args[0]], branches: [[not(exists)]] };
|
|
217
|
+
},
|
|
218
|
+
in_funcset: (args, checker) => {
|
|
219
|
+
const spec = getMembershipSpec(args[0], false, "TLA.FuncSet", 2);
|
|
220
|
+
const fcn = spec.element;
|
|
221
|
+
const maps = checker.bind("all", "", (bound) =>
|
|
222
|
+
imply(member(bound, spec.operands[0]), member(fapply(fcn, bound), spec.operands[1])),
|
|
223
|
+
);
|
|
224
|
+
return {
|
|
225
|
+
premises: [args[0]],
|
|
226
|
+
branches: [[app("TLA.isAFcn", [fcn]), equal(domain(fcn), spec.operands[0]), maps]],
|
|
227
|
+
};
|
|
228
|
+
},
|
|
229
|
+
notin_funcset: (args, checker) => {
|
|
230
|
+
const spec = getMembershipSpec(args[0], true, "TLA.FuncSet", 2);
|
|
231
|
+
const fcn = spec.element;
|
|
232
|
+
const maps = checker.bind("all", "", (bound) =>
|
|
233
|
+
imply(member(bound, spec.operands[0]), member(fapply(fcn, bound), spec.operands[1])),
|
|
234
|
+
);
|
|
235
|
+
return {
|
|
236
|
+
premises: [args[0]],
|
|
237
|
+
branches: [
|
|
238
|
+
[not(app("TLA.isAFcn", [fcn]))],
|
|
239
|
+
[not(equal(domain(fcn), spec.operands[0]))],
|
|
240
|
+
[not(maps)],
|
|
241
|
+
],
|
|
242
|
+
};
|
|
243
|
+
},
|
|
244
|
+
except_notin_funcset: (args) => {
|
|
245
|
+
const spec = getMembershipSpec(args[0], true, "TLA.FuncSet", 2);
|
|
246
|
+
const except = expectApp(spec.element, "TLA.except", 3);
|
|
247
|
+
return {
|
|
248
|
+
premises: [args[0]],
|
|
249
|
+
branches: [[not(member(except[0], spec.set))], [not(member(except[2], spec.operands[1]))]],
|
|
250
|
+
};
|
|
251
|
+
},
|
|
252
|
+
setequalempty: (args, checker) => {
|
|
253
|
+
const sides = expectApp(args[0], "=", 2);
|
|
254
|
+
ensure(isVariable(sides[1], "TLA.emptyset"));
|
|
255
|
+
return {
|
|
256
|
+
premises: [args[0]],
|
|
257
|
+
branches: [[checker.bind("all", "", (bound) => not(member(bound, sides[0])))]],
|
|
258
|
+
};
|
|
259
|
+
},
|
|
260
|
+
setemptyequal: (args, checker) => {
|
|
261
|
+
const sides = expectApp(args[0], "=", 2);
|
|
262
|
+
ensure(isVariable(sides[0], "TLA.emptyset"));
|
|
263
|
+
return {
|
|
264
|
+
premises: [args[0]],
|
|
265
|
+
branches: [[checker.bind("all", "", (bound) => not(member(bound, sides[1])))]],
|
|
266
|
+
};
|
|
267
|
+
},
|
|
268
|
+
setequal: (args, checker) => getSetEqualSpec(args[0], false, checker),
|
|
269
|
+
notsetequal: (args, checker) => getSetEqualSpec(args[0], true, checker),
|
|
270
|
+
cup_subseteq: (args) => {
|
|
271
|
+
const sides = expectApp(args[0], "TLA.subseteq", 2);
|
|
272
|
+
const union = expectApp(sides[0], "TLA.cup", 2);
|
|
273
|
+
return {
|
|
274
|
+
premises: [args[0]],
|
|
275
|
+
branches: [union.map((inner) => app("TLA.subseteq", [inner, sides[1]]))],
|
|
276
|
+
};
|
|
277
|
+
},
|
|
278
|
+
not_cup_subseteq: (args) => {
|
|
279
|
+
const sides = expectApp(expectNot(args[0]), "TLA.subseteq", 2);
|
|
280
|
+
const union = expectApp(sides[0], "TLA.cup", 2);
|
|
281
|
+
return {
|
|
282
|
+
premises: [args[0]],
|
|
283
|
+
branches: union.map((inner) => [not(app("TLA.subseteq", [inner, sides[1]]))]),
|
|
284
|
+
};
|
|
285
|
+
},
|
|
286
|
+
subseteq_cap: (args) => {
|
|
287
|
+
const sides = expectApp(args[0], "TLA.subseteq", 2);
|
|
288
|
+
const intersection = expectApp(sides[1], "TLA.cap", 2);
|
|
289
|
+
return {
|
|
290
|
+
premises: [args[0]],
|
|
291
|
+
branches: [intersection.map((inner) => app("TLA.subseteq", [sides[0], inner]))],
|
|
292
|
+
};
|
|
293
|
+
},
|
|
294
|
+
not_subseteq_cap: (args) => {
|
|
295
|
+
const sides = expectApp(expectNot(args[0]), "TLA.subseteq", 2);
|
|
296
|
+
const intersection = expectApp(sides[1], "TLA.cap", 2);
|
|
297
|
+
return {
|
|
298
|
+
premises: [args[0]],
|
|
299
|
+
branches: intersection.map((inner) => [not(app("TLA.subseteq", [sides[0], inner]))]),
|
|
300
|
+
};
|
|
301
|
+
},
|
|
302
|
+
} satisfies Partial<SpecTable<PlainRuleName>>;
|
|
@@ -0,0 +1,127 @@
|
|
|
1
|
+
// What the rule checks share: the formulas they build and take apart, and how a check rejects a
|
|
2
|
+
// proof.
|
|
3
|
+
|
|
4
|
+
import type { ExprKind } from "../expr";
|
|
5
|
+
import type { Definition } from "../parse";
|
|
6
|
+
import type { PlainRuleName, RuleArgs } from "../proof";
|
|
7
|
+
|
|
8
|
+
type TermKind = ExprKind | "subst";
|
|
9
|
+
|
|
10
|
+
// A formula as the checker sees it. The prover's expressions fit this shape. "subst" stands for
|
|
11
|
+
// its first argument with the variable named `symbol` replaced by its second argument.
|
|
12
|
+
export interface Term {
|
|
13
|
+
kind: TermKind;
|
|
14
|
+
symbol: string;
|
|
15
|
+
args: Term[];
|
|
16
|
+
}
|
|
17
|
+
|
|
18
|
+
export interface CheckContext {
|
|
19
|
+
hypotheses: Term[];
|
|
20
|
+
definitions: Definition[];
|
|
21
|
+
}
|
|
22
|
+
|
|
23
|
+
// What a rule needs on its branch: its premises, and the formulas each of its branches adds.
|
|
24
|
+
export interface RuleSpec {
|
|
25
|
+
premises: Term[];
|
|
26
|
+
branches: Term[][];
|
|
27
|
+
}
|
|
28
|
+
|
|
29
|
+
export type RelationProperty = "reflexive" | "symmetric" | "transitive";
|
|
30
|
+
|
|
31
|
+
// What a variable stands for while printing a key: the depth of its binder, or a term substituted
|
|
32
|
+
// for it with the environment where the substitution was made. A substituted term prints where it
|
|
33
|
+
// lands, so its own binders get depths below the binders around it.
|
|
34
|
+
export type Binding = number | { formula: Term; env: Env; operators?: Operators };
|
|
35
|
+
|
|
36
|
+
export type Env = Map<string, Binding>;
|
|
37
|
+
|
|
38
|
+
export type Operators = Map<string, Term>;
|
|
39
|
+
|
|
40
|
+
// One check of a proof, with the caches that last as long as it does.
|
|
41
|
+
export interface Checker {
|
|
42
|
+
context: CheckContext;
|
|
43
|
+
// A canonical text for a formula up to the names of bound variables.
|
|
44
|
+
getKey: (formula: Term, env: Env, depth: number, operators?: Operators) => string;
|
|
45
|
+
getTopKey: (formula: Term) => string;
|
|
46
|
+
isSame: (left: Term, right: Term) => boolean;
|
|
47
|
+
// A binder whose variable can't clash with any name in the input.
|
|
48
|
+
bind: (kind: "all" | "ex", type: string, build: (bound: Term) => Term) => Term;
|
|
49
|
+
// Rejects the proof unless the hypotheses give the relation these properties.
|
|
50
|
+
ensureRelation: (symbol: string, properties: RelationProperty[]) => void;
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
// The check of each rule, given the rule's arguments and the formulas the proof says it uses.
|
|
54
|
+
export type SpecTable<Name extends PlainRuleName> = {
|
|
55
|
+
[Key in Name]: (args: RuleArgs<Key, Term>, checker: Checker, uses: Term[]) => RuleSpec;
|
|
56
|
+
};
|
|
57
|
+
|
|
58
|
+
// Raised inside a rule check to reject the proof.
|
|
59
|
+
export class UncheckedError extends Error {}
|
|
60
|
+
|
|
61
|
+
export const ensure: (condition: boolean) => asserts condition = (condition) => {
|
|
62
|
+
if (!condition) throw new UncheckedError();
|
|
63
|
+
};
|
|
64
|
+
|
|
65
|
+
export const term = (kind: TermKind, symbol: string, args: Term[]): Term => ({
|
|
66
|
+
kind,
|
|
67
|
+
symbol,
|
|
68
|
+
args,
|
|
69
|
+
});
|
|
70
|
+
export const variable = (name: string) => term("var", name, []);
|
|
71
|
+
export const app = (symbol: string, args: Term[]) => term("app", symbol, args);
|
|
72
|
+
export const not = (operand: Term) => term("not", "", [operand]);
|
|
73
|
+
export const and = (left: Term, right: Term) => term("and", "", [left, right]);
|
|
74
|
+
export const or = (left: Term, right: Term) => term("or", "", [left, right]);
|
|
75
|
+
export const imply = (left: Term, right: Term) => term("imply", "", [left, right]);
|
|
76
|
+
export const equiv = (left: Term, right: Term) => term("equiv", "", [left, right]);
|
|
77
|
+
export const equal = (left: Term, right: Term) => app("=", [left, right]);
|
|
78
|
+
export const member = (element: Term, set: Term) => app("TLA.in", [element, set]);
|
|
79
|
+
export const fapply = (fcn: Term, argument: Term) => app("TLA.fapply", [fcn, argument]);
|
|
80
|
+
export const domain = (fcn: Term) => app("TLA.DOMAIN", [fcn]);
|
|
81
|
+
export const TRUE = term("true", "", []);
|
|
82
|
+
export const FALSE = term("false", "", []);
|
|
83
|
+
|
|
84
|
+
// Instantiates the body of a binder with a term.
|
|
85
|
+
export const instantiate = (binder: Term, value: Term) =>
|
|
86
|
+
term("subst", binder.args[0].symbol, [binder.args[1], value]);
|
|
87
|
+
|
|
88
|
+
export const isApp = (formula: Term, symbol: string, arity?: number) =>
|
|
89
|
+
formula.kind === "app" &&
|
|
90
|
+
formula.symbol === symbol &&
|
|
91
|
+
(arity === undefined || formula.args.length === arity);
|
|
92
|
+
|
|
93
|
+
export const expectApp = (formula: Term, symbol: string, arity?: number) => {
|
|
94
|
+
ensure(isApp(formula, symbol, arity));
|
|
95
|
+
return formula.args;
|
|
96
|
+
};
|
|
97
|
+
|
|
98
|
+
export const expectKind = (formula: Term, kind: TermKind) => {
|
|
99
|
+
ensure(formula.kind === kind);
|
|
100
|
+
return formula.args;
|
|
101
|
+
};
|
|
102
|
+
|
|
103
|
+
export const expectNot = (formula: Term) => expectKind(formula, "not")[0];
|
|
104
|
+
|
|
105
|
+
export const isVariable = (formula: Term, name: string) =>
|
|
106
|
+
formula.kind === "var" && formula.symbol === name;
|
|
107
|
+
|
|
108
|
+
// The text of a string literal. Escapes could spell one string two ways, so they don't count.
|
|
109
|
+
export const getStringText = (formula: Term) => {
|
|
110
|
+
ensure(isApp(formula, "$string", 1) && formula.args[0].kind === "var");
|
|
111
|
+
const text = formula.args[0].symbol;
|
|
112
|
+
ensure(!text.includes("\\"));
|
|
113
|
+
return text;
|
|
114
|
+
};
|
|
115
|
+
|
|
116
|
+
export const getPairs = (args: Term[]) => {
|
|
117
|
+
ensure(args.length % 2 === 0);
|
|
118
|
+
const pairs: [Term, Term][] = [];
|
|
119
|
+
for (let index = 0; index < args.length; index += 2) pairs.push([args[index], args[index + 1]]);
|
|
120
|
+
return pairs;
|
|
121
|
+
};
|
|
122
|
+
|
|
123
|
+
export const makeNatural = (count: number) => {
|
|
124
|
+
let result = variable("0");
|
|
125
|
+
for (let index = 0; index < count; index++) result = fapply(variable("TLA.Succ"), result);
|
|
126
|
+
return result;
|
|
127
|
+
};
|
|
@@ -0,0 +1,126 @@
|
|
|
1
|
+
// The checks of the TLA+ extension's rules for booleans, CHOOSE, natural numbers, bounded
|
|
2
|
+
// quantifiers and equal propositions, after the lemmas in Zenon.thy that justify them.
|
|
3
|
+
|
|
4
|
+
import type { PlainRuleName } from "../proof";
|
|
5
|
+
import {
|
|
6
|
+
ensure,
|
|
7
|
+
equal,
|
|
8
|
+
equiv,
|
|
9
|
+
expectApp,
|
|
10
|
+
expectNot,
|
|
11
|
+
instantiate,
|
|
12
|
+
isVariable,
|
|
13
|
+
member,
|
|
14
|
+
not,
|
|
15
|
+
term,
|
|
16
|
+
type RuleSpec,
|
|
17
|
+
type SpecTable,
|
|
18
|
+
type Term,
|
|
19
|
+
} from "./terms";
|
|
20
|
+
|
|
21
|
+
// From P and a = b, or ~P and a = b, where P is one side: P differs from that side, or the other
|
|
22
|
+
// side holds.
|
|
23
|
+
const getPropositionEqualitySpec = (
|
|
24
|
+
args: Term[],
|
|
25
|
+
isNegated: boolean,
|
|
26
|
+
isLeft: boolean,
|
|
27
|
+
): RuleSpec => {
|
|
28
|
+
const proposition = isNegated ? expectNot(args[0]) : args[0];
|
|
29
|
+
const sides = expectApp(args[1], "=", 2);
|
|
30
|
+
const matched = isLeft ? sides[0] : sides[1];
|
|
31
|
+
const other = isLeft ? sides[1] : sides[0];
|
|
32
|
+
return {
|
|
33
|
+
premises: [args[0], args[1]],
|
|
34
|
+
branches: [[not(equal(proposition, matched))], [isNegated ? not(other) : other]],
|
|
35
|
+
};
|
|
36
|
+
};
|
|
37
|
+
|
|
38
|
+
export const TLA_RULES = {
|
|
39
|
+
eq_x_true: (args) => {
|
|
40
|
+
const sides = expectApp(args[0], "=", 2);
|
|
41
|
+
ensure(sides[1].kind === "true");
|
|
42
|
+
return { premises: [args[0]], branches: [[sides[0]]] };
|
|
43
|
+
},
|
|
44
|
+
eq_true_x: (args) => {
|
|
45
|
+
const sides = expectApp(args[0], "=", 2);
|
|
46
|
+
ensure(sides[0].kind === "true");
|
|
47
|
+
return { premises: [args[0]], branches: [[sides[1]]] };
|
|
48
|
+
},
|
|
49
|
+
noteq_x_true: (args) => {
|
|
50
|
+
const sides = expectApp(expectNot(args[0]), "=", 2);
|
|
51
|
+
ensure(sides[1].kind === "true");
|
|
52
|
+
return { premises: [args[0]], branches: [[not(sides[0])]] };
|
|
53
|
+
},
|
|
54
|
+
noteq_true_x: (args) => {
|
|
55
|
+
const sides = expectApp(expectNot(args[0]), "=", 2);
|
|
56
|
+
ensure(sides[0].kind === "true");
|
|
57
|
+
return { premises: [args[0]], branches: [[not(sides[1])]] };
|
|
58
|
+
},
|
|
59
|
+
eq_x_false: (args) => {
|
|
60
|
+
const sides = expectApp(args[0], "=", 2);
|
|
61
|
+
ensure(sides[1].kind === "false");
|
|
62
|
+
return { premises: [args[0]], branches: [[not(sides[0])]] };
|
|
63
|
+
},
|
|
64
|
+
eq_false_x: (args) => {
|
|
65
|
+
const sides = expectApp(args[0], "=", 2);
|
|
66
|
+
ensure(sides[0].kind === "false");
|
|
67
|
+
return { premises: [args[0]], branches: [[not(sides[1])]] };
|
|
68
|
+
},
|
|
69
|
+
choose_diff_choose: (args, checker) => {
|
|
70
|
+
const left = args[2];
|
|
71
|
+
const right = args[3];
|
|
72
|
+
ensure(left.kind === "lam" && right.kind === "lam" && left.symbol === right.symbol);
|
|
73
|
+
const choice = (lambda: Term) => term("tau", lambda.symbol, lambda.args);
|
|
74
|
+
ensure(checker.isSame(args[0], not(equal(choice(left), choice(right)))));
|
|
75
|
+
const differ = checker.bind("ex", left.symbol, (bound) =>
|
|
76
|
+
not(equiv(instantiate(left, bound), instantiate(right, bound))),
|
|
77
|
+
);
|
|
78
|
+
return { premises: [args[0]], branches: [[differ]] };
|
|
79
|
+
},
|
|
80
|
+
// Zenon writes ~(P <=> Q) as $notequiv(P, Q).
|
|
81
|
+
notequivdef: (_args, _checker, uses) => {
|
|
82
|
+
ensure(uses.length === 1);
|
|
83
|
+
const sides = expectApp(uses[0], "$notequiv", 2);
|
|
84
|
+
return { premises: [uses[0]], branches: [[not(equiv(sides[0], sides[1]))]] };
|
|
85
|
+
},
|
|
86
|
+
notequalchoose: (args) => {
|
|
87
|
+
const predicate = args[3];
|
|
88
|
+
ensure(predicate.kind === "lam");
|
|
89
|
+
const exists = term("ex", predicate.symbol, predicate.args);
|
|
90
|
+
return {
|
|
91
|
+
premises: [],
|
|
92
|
+
branches: [[exists], [not(exists), not(instantiate(predicate, args[4]))]],
|
|
93
|
+
};
|
|
94
|
+
},
|
|
95
|
+
in_nat_0: (args) => {
|
|
96
|
+
const sides = expectApp(expectNot(args[0]), "TLA.in", 2);
|
|
97
|
+
ensure(isVariable(sides[0], "0") && isVariable(sides[1], "arith.N"));
|
|
98
|
+
return { premises: [args[0]], branches: [] };
|
|
99
|
+
},
|
|
100
|
+
in_nat_succ: (args) => {
|
|
101
|
+
const sides = expectApp(expectNot(args[0]), "TLA.in", 2);
|
|
102
|
+
const successor = expectApp(sides[0], "TLA.fapply", 2);
|
|
103
|
+
ensure(isVariable(successor[0], "TLA.Succ") && isVariable(sides[1], "arith.N"));
|
|
104
|
+
return { premises: [args[0]], branches: [[not(member(successor[1], sides[1]))]] };
|
|
105
|
+
},
|
|
106
|
+
box_p: (args) => ({ premises: [args[0]], branches: [[expectApp(args[0], "TLA.box", 1)[0]]] }),
|
|
107
|
+
all_in: (args, checker) => {
|
|
108
|
+
const bounded = expectApp(args[0], "TLA.bAll", 2);
|
|
109
|
+
const sides = expectApp(args[1], "TLA.in", 2);
|
|
110
|
+
ensure(checker.isSame(bounded[0], sides[1]) && bounded[1].kind === "lam");
|
|
111
|
+
return { premises: [args[0], args[1]], branches: [[instantiate(bounded[1], sides[0])]] };
|
|
112
|
+
},
|
|
113
|
+
notex_in: (args, checker) => {
|
|
114
|
+
const bounded = expectApp(expectNot(args[0]), "TLA.bEx", 2);
|
|
115
|
+
const sides = expectApp(args[1], "TLA.in", 2);
|
|
116
|
+
ensure(checker.isSame(bounded[0], sides[1]) && bounded[1].kind === "lam");
|
|
117
|
+
return {
|
|
118
|
+
premises: [args[0], args[1]],
|
|
119
|
+
branches: [[not(instantiate(bounded[1], sides[0]))]],
|
|
120
|
+
};
|
|
121
|
+
},
|
|
122
|
+
p_eq_l: (args) => getPropositionEqualitySpec(args, false, true),
|
|
123
|
+
p_eq_r: (args) => getPropositionEqualitySpec(args, false, false),
|
|
124
|
+
np_eq_l: (args) => getPropositionEqualitySpec(args, true, true),
|
|
125
|
+
np_eq_r: (args) => getPropositionEqualitySpec(args, true, false),
|
|
126
|
+
} satisfies Partial<SpecTable<PlainRuleName>>;
|
|
@@ -0,0 +1,107 @@
|
|
|
1
|
+
// Ported from Zenon's main.ml, as shipped in tlapm. Copyright 1997 INRIA, see LICENSE.
|
|
2
|
+
//
|
|
3
|
+
// Runs Zenon on a .znn file as tlapm does, with -oisar. A proof counts only once the independent
|
|
4
|
+
// checker accepts it. tlapm passes -max-time 1d and kills Zenon at its own timeout instead, whether
|
|
5
|
+
// Zenon is still reading, searching or printing the proof.
|
|
6
|
+
|
|
7
|
+
import { TlaZenonError } from "../../errors";
|
|
8
|
+
import type { DecideOptions } from "../verdict";
|
|
9
|
+
import { checkProof } from "./check/check";
|
|
10
|
+
import { createRelations } from "./eqrel";
|
|
11
|
+
import { createExpressions } from "./expr";
|
|
12
|
+
import { createIndex } from "./index-table";
|
|
13
|
+
import { getLimitFailure } from "./limits";
|
|
14
|
+
import { printIsar } from "./isar";
|
|
15
|
+
import { parseZenon } from "./parse";
|
|
16
|
+
import { separate } from "./phrase";
|
|
17
|
+
import type { Proof } from "./proof";
|
|
18
|
+
import { search, type SearchFailure } from "./search";
|
|
19
|
+
import { getBuiltInDefinitions, PREDEFINED_SYMBOLS } from "./tla/tla";
|
|
20
|
+
|
|
21
|
+
interface ZenonRun {
|
|
22
|
+
proof: Proof | undefined;
|
|
23
|
+
// Why Zenon gave up: in the search, or at the limits while it checked or printed the proof.
|
|
24
|
+
// "zenon error" stands for the exceptions that stop Zenon mid-search.
|
|
25
|
+
failure: SearchFailure | "zenon error" | undefined;
|
|
26
|
+
// Zenon's -oisar output, once the checker accepts the proof and the printer ends within the
|
|
27
|
+
// limits.
|
|
28
|
+
isar: string | undefined;
|
|
29
|
+
nodesSearched: number;
|
|
30
|
+
maxBranchFormulas: number;
|
|
31
|
+
proofNodes: number;
|
|
32
|
+
formulasCreated: number;
|
|
33
|
+
}
|
|
34
|
+
|
|
35
|
+
// The search and its statistics, which match the -stats output of the OCaml Zenon. Throws
|
|
36
|
+
// TlaZenonError when the text isn't a valid .znn file.
|
|
37
|
+
export const runZenon = (text: string, options: DecideOptions): ZenonRun => {
|
|
38
|
+
const limits = { deadline: Date.now() + options.timeLimitMs, signal: options.signal };
|
|
39
|
+
const exprs = createExpressions();
|
|
40
|
+
const parsed = parseZenon(exprs, text);
|
|
41
|
+
const phrases = [...getBuiltInDefinitions(exprs), ...parsed];
|
|
42
|
+
const separated = separate(PREDEFINED_SYMBOLS, phrases);
|
|
43
|
+
const relations = createRelations(exprs);
|
|
44
|
+
for (const hypothesis of separated.hypotheses) relations.analyse(hypothesis.formula);
|
|
45
|
+
const hypotheses = separated.hypotheses.filter(
|
|
46
|
+
(hypothesis) => !relations.isSubsumed(hypothesis.formula),
|
|
47
|
+
);
|
|
48
|
+
const index = createIndex(exprs);
|
|
49
|
+
const statistics = { inferences: 0, proofNodes: 0, reusedProofs: new Set<Proof>() };
|
|
50
|
+
const outcome = (() => {
|
|
51
|
+
try {
|
|
52
|
+
return search(
|
|
53
|
+
{ index, relations, exprs },
|
|
54
|
+
separated.definitions,
|
|
55
|
+
hypotheses,
|
|
56
|
+
limits,
|
|
57
|
+
statistics,
|
|
58
|
+
);
|
|
59
|
+
} catch (error) {
|
|
60
|
+
if (error instanceof TlaZenonError) return "zenon error";
|
|
61
|
+
throw error;
|
|
62
|
+
}
|
|
63
|
+
})();
|
|
64
|
+
const proof = typeof outcome === "string" ? undefined : outcome;
|
|
65
|
+
const isChecked =
|
|
66
|
+
proof !== undefined &&
|
|
67
|
+
checkProof(
|
|
68
|
+
proof,
|
|
69
|
+
{
|
|
70
|
+
hypotheses: phrases.flatMap((phrase) => (phrase.kind === "hyp" ? [phrase.formula] : [])),
|
|
71
|
+
definitions: separated.definitions,
|
|
72
|
+
},
|
|
73
|
+
limits,
|
|
74
|
+
);
|
|
75
|
+
const isar = isChecked
|
|
76
|
+
? printIsar(proof, {
|
|
77
|
+
exprs,
|
|
78
|
+
phrases: parsed,
|
|
79
|
+
sharedProofs: statistics.reusedProofs,
|
|
80
|
+
relations,
|
|
81
|
+
limits,
|
|
82
|
+
})
|
|
83
|
+
: undefined;
|
|
84
|
+
return {
|
|
85
|
+
proof,
|
|
86
|
+
failure:
|
|
87
|
+
typeof outcome === "string"
|
|
88
|
+
? outcome
|
|
89
|
+
: isar === undefined
|
|
90
|
+
? getLimitFailure(limits)
|
|
91
|
+
: undefined,
|
|
92
|
+
isar,
|
|
93
|
+
nodesSearched: statistics.inferences,
|
|
94
|
+
maxBranchFormulas: index.getTopFormulaCount(),
|
|
95
|
+
proofNodes: statistics.proofNodes,
|
|
96
|
+
formulasCreated: exprs.getCreatedCount(),
|
|
97
|
+
};
|
|
98
|
+
};
|
|
99
|
+
|
|
100
|
+
type ZenonDecision = { verdict: "unsat"; proof: string } | { verdict: "unknown" };
|
|
101
|
+
|
|
102
|
+
// Zenon's verdict on a .znn file: "unsat" with the Isar proof that tlapm writes, when Zenon refutes
|
|
103
|
+
// the hypotheses with a proof that the checker accepts and prints it within the time limit.
|
|
104
|
+
export const decideZenon = (text: string, options: DecideOptions): ZenonDecision => {
|
|
105
|
+
const isar = runZenon(text, options).isar;
|
|
106
|
+
return isar === undefined ? { verdict: "unknown" } : { verdict: "unsat", proof: isar };
|
|
107
|
+
};
|