tla-ts 0.0.9 → 0.0.10-dev.63a6693bd
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 +29 -1
- package/dist/compile.cjs +23 -0
- package/dist/compile.js +23 -0
- package/dist/deciders.cjs +29 -29
- package/dist/deciders.js +42 -42
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +106 -10
- package/dist/index.d.ts +106 -10
- 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 +117 -37
- 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 +129 -104
- package/dist/transfer.js +129 -104
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +3 -1
- package/src/ast.ts +48 -62
- package/src/bags.ts +99 -102
- package/src/builtins.ts +28 -75
- package/src/bundled-modules.ts +1 -8
- package/src/check-failure.ts +116 -0
- package/src/check-trace.ts +282 -0
- package/src/check.ts +599 -754
- package/src/cli/options.ts +12 -32
- package/src/cli/run.ts +0 -2
- package/src/cli/runtime-invariants.ts +136 -0
- package/src/cli/shared.ts +19 -12
- package/src/cli/tlapm.ts +14 -25
- package/src/cli/tlc-arguments.ts +652 -0
- package/src/cli/tlc-output.ts +687 -0
- package/src/cli/tlc-usage.ts +361 -0
- package/src/cli/tlc.ts +309 -658
- package/src/cli/typescript.ts +23 -0
- package/src/cli/xml-exporter.ts +27 -49
- package/src/cli.ts +0 -1
- package/src/codegen.ts +196 -74
- package/src/config.ts +140 -109
- package/src/coverage.ts +830 -0
- package/src/dependencies.ts +14 -53
- package/src/dfid.ts +618 -0
- package/src/environment-config.ts +315 -0
- package/src/environment.ts +169 -335
- package/src/errors.ts +71 -55
- package/src/evaluate.ts +598 -340
- package/src/exit-codes.ts +37 -3
- package/src/fingerprints.ts +75 -11
- package/src/index.ts +3 -0
- package/src/instances.ts +126 -21
- package/src/java-hash.ts +7 -0
- package/src/java-overrides.ts +4 -19
- package/src/json-reader.ts +455 -0
- package/src/json.ts +252 -139
- package/src/levels.ts +46 -58
- package/src/lexer.ts +80 -100
- package/src/liveness-checker.ts +103 -153
- package/src/liveness.ts +150 -109
- package/src/obligations/action.ts +8 -39
- package/src/obligations/anonymize.ts +88 -82
- package/src/obligations/equality.ts +1 -1
- package/src/obligations/expression.ts +20 -21
- package/src/obligations/format.ts +1 -9
- package/src/obligations/generate.ts +46 -49
- package/src/obligations/index.ts +2 -13
- package/src/obligations/levels.ts +4 -8
- package/src/obligations/module.ts +28 -53
- package/src/obligations/normalize.ts +7 -25
- 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 +42 -58
- package/src/obligations/source.ts +48 -78
- package/src/obligations/subexpression.ts +5 -11
- package/src/obligations/substitution.ts +1 -3
- package/src/obligations/temporal.ts +13 -19
- package/src/obligations/tuples.ts +3 -9
- package/src/parallel-worker.ts +30 -60
- package/src/parallel.ts +57 -71
- package/src/parser.ts +584 -316
- package/src/pcal/ast.ts +53 -86
- package/src/pcal/parse.ts +144 -219
- package/src/pcal/tokenize.ts +91 -131
- package/src/pcal/translate.ts +83 -130
- package/src/pcal/validate.ts +48 -68
- package/src/pretty-print.ts +7 -8
- package/src/prover/decide-pool.ts +8 -13
- package/src/prover/deciders.ts +3 -7
- 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 +114 -115
- package/src/prover/isabelle/isar/method.ts +29 -53
- 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 +26 -36
- package/src/prover/isabelle/isar/type-check.ts +17 -31
- package/src/prover/isabelle/provers/blast/blast.ts +17 -104
- 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 +28 -51
- package/src/prover/isabelle/pure/bicompose.ts +25 -38
- package/src/prover/isabelle/pure/consts.ts +1 -7
- package/src/prover/isabelle/pure/conv.ts +3 -17
- package/src/prover/isabelle/pure/drule.ts +33 -42
- 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 +2 -15
- 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 +17 -62
- package/src/prover/isabelle/pure/rewriter.ts +31 -67
- 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 +3 -32
- package/src/prover/isabelle/pure/tactic.ts +12 -22
- package/src/prover/isabelle/pure/tactical.ts +48 -47
- 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 +27 -47
- 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 +17 -24
- package/src/prover/isabelle/tla/context.ts +15 -18
- package/src/prover/isabelle/tla/logic.ts +14 -32
- package/src/prover/isabelle/tla/simpdata.ts +46 -43
- package/src/prover/isabelle/tools/intuitionistic.ts +1 -10
- package/src/prover/ocaml.ts +0 -6
- package/src/prover/prep/action.ts +14 -54
- package/src/prover/prep/enabled-axioms.ts +12 -19
- package/src/prover/prep/fingerprint.ts +2 -21
- package/src/prover/prep/level-comparison.ts +8 -12
- package/src/prover/prep/md5.ts +0 -2
- package/src/prover/prep/methods.ts +33 -39
- package/src/prover/prep/normalize.ts +4 -28
- package/src/prover/prove-worker.ts +0 -2
- package/src/prover/prove.ts +87 -100
- 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 +20 -28
- package/src/prover/smt/data.ts +433 -424
- package/src/prover/smt/encode.ts +43 -52
- 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 +663 -667
- 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 -165
- package/src/prover/smt/solver/auf-solver.ts +8 -44
- 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 +7 -64
- 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 +4 -35
- 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 +1 -6
- 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 +7 -100
- 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 +9 -102
- 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 +36 -135
- 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 +18 -58
- 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 +3 -37
- package/src/prover/smt/solver/model-evaluator.ts +3 -29
- package/src/prover/smt/solver/model-finder.ts +15 -32
- package/src/prover/smt/solver/model-generator.ts +1 -12
- package/src/prover/smt/solver/model-macro-solver.ts +23 -88
- package/src/prover/smt/solver/nlsat/algebraic.ts +63 -159
- package/src/prover/smt/solver/nlsat/atoms.ts +25 -23
- package/src/prover/smt/solver/nlsat/evaluator.ts +17 -22
- package/src/prover/smt/solver/nlsat/explain.ts +10 -69
- package/src/prover/smt/solver/nlsat/interval-set.ts +9 -50
- package/src/prover/smt/solver/nlsat/levelwise.ts +49 -135
- package/src/prover/smt/solver/nlsat/mpbq.ts +3 -14
- package/src/prover/smt/solver/nlsat/polynomial.ts +29 -159
- package/src/prover/smt/solver/nlsat/solver.ts +18 -90
- package/src/prover/smt/solver/nlsat/types.ts +1 -8
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +2 -45
- 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 -52
- 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 +27 -47
- package/src/prover/smt/solver/quantifier-manager.ts +2 -13
- 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 +80 -131
- 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 +1 -7
- package/src/prover/smt/solver/theory-lra-final-check.ts +4 -22
- package/src/prover/smt/solver/theory-lra-internalize.ts +6 -43
- 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 +45 -40
- package/src/prover/tlapm/ocaml-marshal.ts +19 -21
- package/src/prover/tlapm/tlapm.ts +21 -20
- package/src/prover/verdict.ts +7 -2
- package/src/prover/zenon/check/check.ts +1 -11
- 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 +1 -6
- package/src/prover/zenon/check/relations.ts +2 -14
- package/src/prover/zenon/check/rewrites.ts +2 -21
- package/src/prover/zenon/check/sets.ts +40 -61
- package/src/prover/zenon/check/terms.ts +1 -19
- 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 +2 -13
- package/src/prover/zenon/equality-rules.ts +0 -4
- package/src/prover/zenon/expr.ts +8 -26
- package/src/prover/zenon/index-table.ts +26 -57
- package/src/prover/zenon/isar-case.ts +9 -19
- package/src/prover/zenon/isar.ts +36 -64
- package/src/prover/zenon/limits.ts +0 -4
- package/src/prover/zenon/llproof.ts +2 -20
- package/src/prover/zenon/mltoll.ts +66 -104
- package/src/prover/zenon/node.ts +1 -11
- package/src/prover/zenon/ocaml.ts +1 -17
- package/src/prover/zenon/parse.ts +4 -12
- 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 +5 -31
- package/src/prover/zenon/tla/functions.ts +59 -31
- package/src/prover/zenon/tla/llproof.ts +67 -76
- package/src/prover/zenon/tla/records.ts +57 -33
- package/src/prover/zenon/tla/rewrites.ts +12 -19
- package/src/prover/zenon/tla/sets.ts +83 -53
- package/src/prover/zenon/tla/terms.ts +0 -6
- package/src/prover/zenon/tla/tla.ts +66 -64
- package/src/randomization.ts +81 -35
- package/src/resolve.ts +67 -184
- package/src/runtime.ts +22 -22
- package/src/sany/builtins.ts +2 -5
- package/src/sany/generation.ts +394 -0
- package/src/sany/generator-def-entries.ts +210 -0
- package/src/sany/generator-definitions.ts +686 -0
- package/src/sany/generator-expressions.ts +1100 -0
- package/src/sany/generator-proofs.ts +662 -0
- package/src/sany/generator.ts +191 -2764
- package/src/sany/levels.ts +6 -34
- package/src/sany/lexer.ts +58 -77
- package/src/sany/linter.ts +1 -9
- package/src/sany/modules.ts +1 -5
- package/src/sany/nodes.ts +5 -43
- package/src/sany/parse-error.ts +39 -117
- package/src/sany/report.ts +32 -69
- package/src/sany/selectors.ts +49 -76
- package/src/sany/source.ts +1 -17
- package/src/sany/xml.ts +35 -117
- package/src/search.ts +541 -163
- package/src/simulate.ts +709 -0
- package/src/spec-description.ts +192 -100
- package/src/standard-definitions.ts +0 -4
- package/src/standard-modules.ts +264 -95
- package/src/state-graph.ts +52 -31
- package/src/subexpressions.ts +69 -52
- package/src/substitution-levels.ts +7 -7
- package/src/successors.ts +266 -99
- package/src/symmetry.ts +33 -25
- package/src/tableau.ts +27 -24
- package/src/tlc/fingerprint.ts +183 -67
- package/src/tlc/jar-data.ts +112 -6
- package/src/tlc/messages.ts +125 -54
- package/src/tlc/order.ts +39 -69
- package/src/tlc/random.ts +37 -49
- package/src/tlc/replay.ts +553 -228
- package/src/tlc/summary.ts +36 -47
- package/src/tlc/tlc-operators.ts +78 -44
- package/src/tlc/tlcext-operators.ts +139 -122
- package/src/tlc/trace-spec.ts +249 -0
- package/src/tlc/value-stream.ts +139 -0
- package/src/tlc/version.ts +1 -4
- package/src/transfer.ts +22 -25
- package/src/typescript/actions.ts +479 -0
- package/src/typescript/collections.ts +614 -0
- package/src/typescript/compile.ts +63 -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 +154 -0
- package/src/typescript/functions.ts +284 -0
- package/src/typescript/model.ts +162 -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 +167 -0
- package/src/typescript/types.ts +171 -0
- package/src/values.ts +832 -484
- package/src/worker.ts +7 -8
|
@@ -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
|
-
import {
|
|
5
|
+
import type { Lemma, LlProof, 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,
|
|
@@ -128,11 +121,7 @@ const SHAPES: Record<string, Shape> = {
|
|
|
128
121
|
if (third === undefined) throw getShapeError(name);
|
|
129
122
|
return [`zenon_${name}`, rest, [conclusion], [[first, second, third]]];
|
|
130
123
|
},
|
|
131
|
-
except_notin_funcset:
|
|
132
|
-
const [conclusion, first, second, ...rest] = args;
|
|
133
|
-
if (second === undefined) throw getShapeError(name);
|
|
134
|
-
return [`zenon_${name}`, rest, [conclusion], [[first], [second]]];
|
|
135
|
-
},
|
|
124
|
+
except_notin_funcset: beta,
|
|
136
125
|
notin_funcset: (name, args) => {
|
|
137
126
|
const [conclusion, first, second, third, ...rest] = args;
|
|
138
127
|
if (third === undefined) throw getShapeError(name);
|
|
@@ -194,14 +183,12 @@ const SHAPES: Record<string, Shape> = {
|
|
|
194
183
|
record_notisafcn: close,
|
|
195
184
|
};
|
|
196
185
|
|
|
197
|
-
// Zenon's Ext_tla.to_llproof, for a rule of the extension and its translated subproofs.
|
|
198
186
|
export const getTlaLlProof = (
|
|
199
187
|
translateExpr: (expression: Expr) => Expr,
|
|
200
188
|
exprs: Expressions,
|
|
201
189
|
proof: MlProof,
|
|
202
190
|
subproofs: Translated[],
|
|
203
191
|
): Translated => {
|
|
204
|
-
const tr = translateExpr;
|
|
205
192
|
const rule = proof.rule;
|
|
206
193
|
const member = (element: Expr, set: Expr) => exprs.eapp("TLA.in", [element, set]);
|
|
207
194
|
const equal = (left: Expr, right: Expr) => exprs.eapp("=", [left, right]);
|
|
@@ -213,18 +200,24 @@ export const getTlaLlProof = (
|
|
|
213
200
|
branches: Expr[][],
|
|
214
201
|
nodeSubproofs: LlProof[],
|
|
215
202
|
): LlProof => ({
|
|
216
|
-
conclusions: conclusions.map(
|
|
203
|
+
conclusions: conclusions.map(translateExpr),
|
|
217
204
|
rule: {
|
|
218
205
|
kind: "extension",
|
|
219
206
|
name,
|
|
220
|
-
args: args.map(
|
|
221
|
-
conclusions: ruleConclusions.map(
|
|
222
|
-
branches: branches.map((branch) => branch.map(
|
|
207
|
+
args: args.map(translateExpr),
|
|
208
|
+
conclusions: ruleConclusions.map(translateExpr),
|
|
209
|
+
branches: branches.map((branch) => branch.map(translateExpr)),
|
|
223
210
|
},
|
|
224
211
|
subproofs: nodeSubproofs,
|
|
225
212
|
});
|
|
226
213
|
|
|
227
|
-
|
|
214
|
+
const splitSet = (set: Expr, isSetOf: boolean) =>
|
|
215
|
+
set.kind === "app" &&
|
|
216
|
+
set.symbol === (isSetOf ? "TLA.set" : "TLA.addElt") &&
|
|
217
|
+
set.args.length >= (isSetOf ? 1 : 2)
|
|
218
|
+
? [set.args[0], isSetOf ? exprs.eapp("TLA.set", set.args.slice(1)) : set.args[1]]
|
|
219
|
+
: undefined;
|
|
220
|
+
|
|
228
221
|
const getMembership = (
|
|
229
222
|
element: Expr,
|
|
230
223
|
set: Expr,
|
|
@@ -240,12 +233,7 @@ export const getTlaLlProof = (
|
|
|
240
233
|
extension(conclusions, "zenon_in_emptyset", [element], [member(element, set)], [], []),
|
|
241
234
|
[],
|
|
242
235
|
];
|
|
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;
|
|
236
|
+
const split = splitSet(set, isSetOf);
|
|
249
237
|
const first = remaining[0];
|
|
250
238
|
if (split === undefined || first === undefined) {
|
|
251
239
|
if (!isSetOf && remaining.length === 1) return remaining[0];
|
|
@@ -254,13 +242,13 @@ export const getTlaLlProof = (
|
|
|
254
242
|
const value = split[0];
|
|
255
243
|
const rest = split[1];
|
|
256
244
|
const conclusion = member(element, set);
|
|
257
|
-
const
|
|
258
|
-
const
|
|
245
|
+
const valueEquality = equal(element, value);
|
|
246
|
+
const restMembership = member(element, rest);
|
|
259
247
|
const next = getMembership(
|
|
260
248
|
element,
|
|
261
249
|
rest,
|
|
262
250
|
remaining.slice(1),
|
|
263
|
-
[
|
|
251
|
+
[restMembership, ...conclusions],
|
|
264
252
|
isSetOf,
|
|
265
253
|
);
|
|
266
254
|
const extras = difference(union(first[1], next[1]), conclusions);
|
|
@@ -270,14 +258,13 @@ export const getTlaLlProof = (
|
|
|
270
258
|
"zenon_in_addElt",
|
|
271
259
|
[element, value, rest],
|
|
272
260
|
[conclusion],
|
|
273
|
-
[[
|
|
261
|
+
[[valueEquality], [restMembership]],
|
|
274
262
|
[first[0], next[0]],
|
|
275
263
|
),
|
|
276
264
|
extras,
|
|
277
265
|
];
|
|
278
266
|
};
|
|
279
267
|
|
|
280
|
-
// The non-membership in an enumerated set, one element at a time.
|
|
281
268
|
const getNonMembership = (
|
|
282
269
|
element: Expr,
|
|
283
270
|
set: Expr,
|
|
@@ -285,23 +272,18 @@ export const getTlaLlProof = (
|
|
|
285
272
|
conclusions: Expr[],
|
|
286
273
|
isSetOf: boolean,
|
|
287
274
|
): 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;
|
|
275
|
+
const split = splitSet(set, isSetOf);
|
|
294
276
|
if (split === undefined) return sub;
|
|
295
277
|
const value = split[0];
|
|
296
278
|
const rest = split[1];
|
|
297
279
|
const conclusion = exprs.enot(member(element, set));
|
|
298
|
-
const
|
|
299
|
-
const
|
|
280
|
+
const valueInequality = exprs.enot(equal(element, value));
|
|
281
|
+
const restNonMembership = exprs.enot(member(element, rest));
|
|
300
282
|
const next = getNonMembership(
|
|
301
283
|
element,
|
|
302
284
|
rest,
|
|
303
285
|
sub,
|
|
304
|
-
[
|
|
286
|
+
[valueInequality, restNonMembership, ...conclusions],
|
|
305
287
|
isSetOf,
|
|
306
288
|
);
|
|
307
289
|
const extras = difference(next[1], conclusions);
|
|
@@ -311,7 +293,7 @@ export const getTlaLlProof = (
|
|
|
311
293
|
"zenon_notin_addElt",
|
|
312
294
|
[element, value, rest],
|
|
313
295
|
[conclusion],
|
|
314
|
-
[[
|
|
296
|
+
[[valueInequality, restNonMembership]],
|
|
315
297
|
[next[0]],
|
|
316
298
|
),
|
|
317
299
|
extras,
|
|
@@ -367,10 +349,9 @@ export const getTlaLlProof = (
|
|
|
367
349
|
}
|
|
368
350
|
};
|
|
369
351
|
|
|
370
|
-
// Zenon's Ext_tla.postprocess: the lemmas with each $notequiv written as a negated equivalence.
|
|
371
352
|
export const postprocessTla = (exprs: Expressions, lemmas: Lemma[]): Lemma[] => {
|
|
372
353
|
const cache = new Map<Expr, Expr>();
|
|
373
|
-
const
|
|
354
|
+
const postprocess = (expression: Expr): Expr => {
|
|
374
355
|
const cached = cache.get(expression);
|
|
375
356
|
if (cached !== undefined) return cached;
|
|
376
357
|
const result = ((): Expr => {
|
|
@@ -383,35 +364,37 @@ export const postprocessTla = (exprs: Expressions, lemmas: Lemma[]): Lemma[] =>
|
|
|
383
364
|
throw new TlaZenonError("Zenon: a metavariable in a low-level proof");
|
|
384
365
|
case "app": {
|
|
385
366
|
if (expression.symbol !== "$notequiv")
|
|
386
|
-
return exprs.eapp(expression.symbol, expression.args.map(
|
|
367
|
+
return exprs.eapp(expression.symbol, expression.args.map(postprocess));
|
|
387
368
|
if (expression.args.length !== 2)
|
|
388
369
|
throw new TlaZenonError("Zenon: $notequiv without two arguments");
|
|
389
|
-
const right =
|
|
390
|
-
return exprs.enot(exprs.eequiv(
|
|
370
|
+
const right = postprocess(expression.args[1]);
|
|
371
|
+
return exprs.enot(exprs.eequiv(postprocess(expression.args[0]), right));
|
|
391
372
|
}
|
|
392
373
|
case "not":
|
|
393
|
-
return exprs.enot(
|
|
374
|
+
return exprs.enot(postprocess(expression.args[0]));
|
|
394
375
|
case "and":
|
|
395
376
|
case "or":
|
|
396
377
|
case "imply":
|
|
397
378
|
case "equiv": {
|
|
398
|
-
const right =
|
|
399
|
-
return
|
|
379
|
+
const right = postprocess(expression.args[1]);
|
|
380
|
+
return exprs.binary(expression.kind, postprocess(expression.args[0]), right);
|
|
400
381
|
}
|
|
401
382
|
case "all":
|
|
402
|
-
return exprs.eall(expression.args[0], expression.symbol, pp(expression.args[1]));
|
|
403
383
|
case "ex":
|
|
404
|
-
return exprs.eex(expression.args[0], expression.symbol, pp(expression.args[1]));
|
|
405
384
|
case "tau":
|
|
406
|
-
return exprs.etau(expression.args[0], expression.symbol, pp(expression.args[1]));
|
|
407
385
|
case "lam":
|
|
408
|
-
return exprs.
|
|
386
|
+
return exprs.binder(
|
|
387
|
+
expression.kind,
|
|
388
|
+
expression.args[0],
|
|
389
|
+
expression.symbol,
|
|
390
|
+
postprocess(expression.args[1]),
|
|
391
|
+
);
|
|
409
392
|
}
|
|
410
393
|
})();
|
|
411
394
|
cache.set(expression, result);
|
|
412
395
|
return result;
|
|
413
396
|
};
|
|
414
|
-
const
|
|
397
|
+
const postprocessRule = (rule: LlRule): LlRule => {
|
|
415
398
|
switch (rule.kind) {
|
|
416
399
|
case "false":
|
|
417
400
|
case "nottrue":
|
|
@@ -419,62 +402,70 @@ export const postprocessTla = (exprs: Expressions, lemmas: Lemma[]): Lemma[] =>
|
|
|
419
402
|
case "axiom":
|
|
420
403
|
case "cut":
|
|
421
404
|
case "notnot":
|
|
422
|
-
return { kind: rule.kind, formula:
|
|
405
|
+
return { kind: rule.kind, formula: postprocess(rule.formula) };
|
|
423
406
|
case "noteq":
|
|
424
|
-
return { kind: "noteq", term:
|
|
407
|
+
return { kind: "noteq", term: postprocess(rule.term) };
|
|
425
408
|
case "eqsym":
|
|
426
409
|
case "notequal":
|
|
427
|
-
return { kind: rule.kind, left:
|
|
410
|
+
return { kind: rule.kind, left: postprocess(rule.left), right: postprocess(rule.right) };
|
|
428
411
|
case "connect":
|
|
429
412
|
case "notconnect":
|
|
430
413
|
return {
|
|
431
414
|
kind: rule.kind,
|
|
432
415
|
connective: rule.connective,
|
|
433
|
-
left:
|
|
434
|
-
right:
|
|
416
|
+
left: postprocess(rule.left),
|
|
417
|
+
right: postprocess(rule.right),
|
|
435
418
|
};
|
|
436
419
|
case "ex":
|
|
437
420
|
case "all":
|
|
438
421
|
case "notex":
|
|
439
422
|
case "notall":
|
|
440
|
-
return {
|
|
423
|
+
return {
|
|
424
|
+
kind: rule.kind,
|
|
425
|
+
quantified: postprocess(rule.quantified),
|
|
426
|
+
term: postprocess(rule.term),
|
|
427
|
+
};
|
|
441
428
|
case "pnotp":
|
|
442
|
-
return {
|
|
429
|
+
return {
|
|
430
|
+
kind: "pnotp",
|
|
431
|
+
positive: postprocess(rule.positive),
|
|
432
|
+
negative: postprocess(rule.negative),
|
|
433
|
+
};
|
|
443
434
|
case "congruencelr":
|
|
444
435
|
case "congruencerl":
|
|
445
436
|
return {
|
|
446
437
|
kind: rule.kind,
|
|
447
|
-
context:
|
|
448
|
-
left:
|
|
449
|
-
right:
|
|
438
|
+
context: postprocess(rule.context),
|
|
439
|
+
left: postprocess(rule.left),
|
|
440
|
+
right: postprocess(rule.right),
|
|
450
441
|
};
|
|
451
442
|
case "definition":
|
|
452
443
|
return {
|
|
453
444
|
kind: "definition",
|
|
454
445
|
name: rule.name,
|
|
455
|
-
folded:
|
|
456
|
-
unfolded:
|
|
446
|
+
folded: postprocess(rule.folded),
|
|
447
|
+
unfolded: postprocess(rule.unfolded),
|
|
457
448
|
};
|
|
458
449
|
case "extension":
|
|
459
450
|
return {
|
|
460
451
|
kind: "extension",
|
|
461
452
|
name: rule.name,
|
|
462
|
-
args: rule.args.map(
|
|
463
|
-
conclusions: rule.conclusions.map(
|
|
464
|
-
branches: rule.branches.map((branch) => branch.map(
|
|
453
|
+
args: rule.args.map(postprocess),
|
|
454
|
+
conclusions: rule.conclusions.map(postprocess),
|
|
455
|
+
branches: rule.branches.map((branch) => branch.map(postprocess)),
|
|
465
456
|
};
|
|
466
457
|
case "lemma":
|
|
467
|
-
return { kind: "lemma", name: rule.name, args: rule.args.map(
|
|
458
|
+
return { kind: "lemma", name: rule.name, args: rule.args.map(postprocess) };
|
|
468
459
|
}
|
|
469
460
|
};
|
|
470
|
-
const
|
|
471
|
-
conclusions: tree.conclusions.map(
|
|
472
|
-
rule:
|
|
473
|
-
subproofs: tree.subproofs.map(
|
|
461
|
+
const postprocessTree = (tree: LlProof): LlProof => ({
|
|
462
|
+
conclusions: tree.conclusions.map(postprocess),
|
|
463
|
+
rule: postprocessRule(tree.rule),
|
|
464
|
+
subproofs: tree.subproofs.map(postprocessTree),
|
|
474
465
|
});
|
|
475
466
|
return lemmas.map((lemma) => ({
|
|
476
467
|
name: lemma.name,
|
|
477
|
-
params: lemma.params.map((param): [string, Expr] => [param[0],
|
|
478
|
-
proof:
|
|
468
|
+
params: lemma.params.map((param): [string, Expr] => [param[0], postprocess(param[1])]),
|
|
469
|
+
proof: postprocessTree(lemma.proof),
|
|
479
470
|
}));
|
|
480
471
|
};
|
|
@@ -1,11 +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 tuples and records.
|
|
4
2
|
|
|
5
|
-
import { compareExprs, isApp, type Expr } from "../expr";
|
|
3
|
+
import { compareExprs, getStringName, isApp, type Expr } from "../expr";
|
|
6
4
|
import { stableSort } from "../ocaml";
|
|
7
|
-
import
|
|
8
|
-
import { makeRule, type Rule } from "../proof";
|
|
5
|
+
import { makeRule } from "../proof";
|
|
9
6
|
import {
|
|
10
7
|
domain,
|
|
11
8
|
equal,
|
|
@@ -20,12 +17,6 @@ import {
|
|
|
20
17
|
type Literal,
|
|
21
18
|
} from "./terms";
|
|
22
19
|
|
|
23
|
-
const getStringName = (expression: Expr) =>
|
|
24
|
-
isApp(expression, "$string", 1) && expression.args[0].kind === "var"
|
|
25
|
-
? expression.args[0].symbol
|
|
26
|
-
: undefined;
|
|
27
|
-
|
|
28
|
-
// Zenon's check_record_labels on sorted fields: false for Invalid_record, a repeated label.
|
|
29
20
|
const hasDistinctLabels = (pairs: [Expr, Expr][]) => {
|
|
30
21
|
for (let index = 0; index + 1 < pairs.length; index++) {
|
|
31
22
|
const left = pairs[index][0];
|
|
@@ -56,10 +47,8 @@ export const getTupleNodes = (literal: Literal): Item[] | undefined => {
|
|
|
56
47
|
const isNegated = literal.isNegated;
|
|
57
48
|
const atom = literal.atom;
|
|
58
49
|
const relation = literal.relation;
|
|
59
|
-
const node = (priority: Priority, rule: Rule, branches: Expr[][]) =>
|
|
60
|
-
makeExtensionNode(literal, priority, rule, branches);
|
|
61
50
|
if (isNegated && isApp(atom, "TLA.isASeq", 1) && isApp(atom.args[0], "TLA.tuple"))
|
|
62
|
-
return
|
|
51
|
+
return makeExtensionNode(literal, "prop", makeRule("tuple_notisaseq", [formula]), []);
|
|
63
52
|
if (relation === undefined) return undefined;
|
|
64
53
|
const left = relation.args[0];
|
|
65
54
|
const right = relation.args[1];
|
|
@@ -67,11 +56,21 @@ export const getTupleNodes = (literal: Literal): Item[] | undefined => {
|
|
|
67
56
|
const isMembership = relation.symbol === "TLA.in";
|
|
68
57
|
if (!isNegated && isEquality && isApp(left, "TLA.tuple") && isApp(right, "TLA.tuple")) {
|
|
69
58
|
if (left.args.length !== right.args.length)
|
|
70
|
-
return
|
|
59
|
+
return makeExtensionNode(
|
|
60
|
+
literal,
|
|
61
|
+
"prop",
|
|
62
|
+
makeRule("tuple_eq_mismatch", [formula, formula]),
|
|
63
|
+
[],
|
|
64
|
+
);
|
|
71
65
|
const equalities = left.args.map((inner, position) =>
|
|
72
66
|
equal(exprs, inner, right.args[position]),
|
|
73
67
|
);
|
|
74
|
-
return
|
|
68
|
+
return makeExtensionNode(
|
|
69
|
+
literal,
|
|
70
|
+
"prop",
|
|
71
|
+
makeRule("tuple_eq_match", [formula, ...equalities]),
|
|
72
|
+
[equalities],
|
|
73
|
+
);
|
|
75
74
|
}
|
|
76
75
|
if (isMembership && isApp(right, "TLA.Product", 1) && isApp(right.args[0], "TLA.tuple")) {
|
|
77
76
|
const element = left;
|
|
@@ -80,16 +79,24 @@ export const getTupleNodes = (literal: Literal): Item[] | undefined => {
|
|
|
80
79
|
const components = tuple.args.map((inner, position) =>
|
|
81
80
|
member(exprs, fapply(exprs, element, makeNatural(exprs, position + 1)), inner),
|
|
82
81
|
);
|
|
83
|
-
const
|
|
84
|
-
const
|
|
82
|
+
const sequenceFormula = exprs.eapp("TLA.isASeq", [element]);
|
|
83
|
+
const lengthFormula = equal(
|
|
85
84
|
exprs,
|
|
86
85
|
exprs.eapp("TLA.Len", [element]),
|
|
87
86
|
makeNatural(exprs, tuple.args.length),
|
|
88
87
|
);
|
|
89
|
-
return
|
|
88
|
+
return makeExtensionNode(
|
|
89
|
+
literal,
|
|
90
90
|
"prop",
|
|
91
|
-
makeRule("in_product", [
|
|
92
|
-
|
|
91
|
+
makeRule("in_product", [
|
|
92
|
+
formula,
|
|
93
|
+
element,
|
|
94
|
+
tuple,
|
|
95
|
+
sequenceFormula,
|
|
96
|
+
lengthFormula,
|
|
97
|
+
...components,
|
|
98
|
+
]),
|
|
99
|
+
[[sequenceFormula, lengthFormula, ...components]],
|
|
93
100
|
);
|
|
94
101
|
}
|
|
95
102
|
if (
|
|
@@ -108,7 +115,8 @@ export const getTupleNodes = (literal: Literal): Item[] | undefined => {
|
|
|
108
115
|
),
|
|
109
116
|
...components,
|
|
110
117
|
];
|
|
111
|
-
return
|
|
118
|
+
return makeExtensionNode(
|
|
119
|
+
literal,
|
|
112
120
|
"prop",
|
|
113
121
|
makeRule("notin_product", [formula, element, tuple, ...formulas]),
|
|
114
122
|
getBranches(formulas),
|
|
@@ -123,10 +131,8 @@ export const getRecordNodes = (literal: Literal): Item[] | undefined => {
|
|
|
123
131
|
const isNegated = literal.isNegated;
|
|
124
132
|
const atom = literal.atom;
|
|
125
133
|
const relation = literal.relation;
|
|
126
|
-
const node = (priority: Priority, rule: Rule, branches: Expr[][]) =>
|
|
127
|
-
makeExtensionNode(literal, priority, rule, branches);
|
|
128
134
|
if (isNegated && isApp(atom, "TLA.isAFcn", 1) && isApp(atom.args[0], "TLA.record"))
|
|
129
|
-
return
|
|
135
|
+
return makeExtensionNode(literal, "prop", makeRule("record_notisafcn", [formula]), []);
|
|
130
136
|
if (relation === undefined) return undefined;
|
|
131
137
|
const left = relation.args[0];
|
|
132
138
|
const right = relation.args[1];
|
|
@@ -140,14 +146,27 @@ export const getRecordNodes = (literal: Literal): Item[] | undefined => {
|
|
|
140
146
|
leftFields.length === rightFields.length &&
|
|
141
147
|
leftFields.every((field, position) => field[0] === rightFields[position][0]);
|
|
142
148
|
if (!isMatch)
|
|
143
|
-
return isNegated
|
|
149
|
+
return isNegated
|
|
150
|
+
? []
|
|
151
|
+
: makeExtensionNode(
|
|
152
|
+
literal,
|
|
153
|
+
"prop",
|
|
154
|
+
makeRule("record_eq_mismatch", [formula, formula]),
|
|
155
|
+
[],
|
|
156
|
+
);
|
|
144
157
|
const equalities = leftFields.map((field, position) =>
|
|
145
158
|
equal(exprs, field[1], rightFields[position][1]),
|
|
146
159
|
);
|
|
147
160
|
if (!isNegated)
|
|
148
|
-
return
|
|
161
|
+
return makeExtensionNode(
|
|
162
|
+
literal,
|
|
163
|
+
"prop",
|
|
164
|
+
makeRule("record_eq_match", [formula, ...equalities]),
|
|
165
|
+
[equalities],
|
|
166
|
+
);
|
|
149
167
|
const inequalities = equalities.map((inner) => exprs.enot(inner));
|
|
150
|
-
return
|
|
168
|
+
return makeExtensionNode(
|
|
169
|
+
literal,
|
|
151
170
|
"prop",
|
|
152
171
|
makeRule("record_neq_match", [formula, ...inequalities]),
|
|
153
172
|
getBranches(inequalities),
|
|
@@ -171,7 +190,8 @@ export const getRecordNodes = (literal: Literal): Item[] | undefined => {
|
|
|
171
190
|
),
|
|
172
191
|
...pairs.map((pair) => exprs.enot(equal(exprs, fapply(exprs, other, pair[0]), pair[1]))),
|
|
173
192
|
];
|
|
174
|
-
return
|
|
193
|
+
return makeExtensionNode(
|
|
194
|
+
literal,
|
|
175
195
|
"prop",
|
|
176
196
|
makeRule(record === right ? "neq_record" : "record_neq", [
|
|
177
197
|
formula,
|
|
@@ -194,9 +214,12 @@ export const getRecordNodes = (literal: Literal): Item[] | undefined => {
|
|
|
194
214
|
equal(exprs, domain(exprs, left), labels),
|
|
195
215
|
...pairs.map((pair) => member(exprs, fapply(exprs, left, pair[0]), pair[1])),
|
|
196
216
|
];
|
|
197
|
-
return
|
|
198
|
-
|
|
199
|
-
|
|
217
|
+
return makeExtensionNode(
|
|
218
|
+
literal,
|
|
219
|
+
"prop",
|
|
220
|
+
makeRule("in_recordset", [formula, left, right, ...formulas]),
|
|
221
|
+
[formulas],
|
|
222
|
+
);
|
|
200
223
|
}
|
|
201
224
|
if (isApp(left, "TLA.record")) {
|
|
202
225
|
const leftLabels = getSortedLabels(left.args);
|
|
@@ -215,7 +238,8 @@ export const getRecordNodes = (literal: Literal): Item[] | undefined => {
|
|
|
215
238
|
exprs.enot(equal(exprs, domain(exprs, left), labels)),
|
|
216
239
|
...pairs.map((pair) => exprs.enot(member(exprs, fapply(exprs, left, pair[0]), pair[1]))),
|
|
217
240
|
];
|
|
218
|
-
return
|
|
241
|
+
return makeExtensionNode(
|
|
242
|
+
literal,
|
|
219
243
|
"prop",
|
|
220
244
|
makeRule("notin_recordset", [formula, left, right, ...formulas]),
|
|
221
245
|
getBranches(formulas),
|
|
@@ -1,7 +1,4 @@
|
|
|
1
1
|
// Ported from Zenon's ext_tla.ml, as shipped in tlapm. Copyright 2008 INRIA, see LICENSE.
|
|
2
|
-
//
|
|
3
|
-
// Rewriting a subterm: unfolding a definition, evaluating a function application, IF, CASE or a
|
|
4
|
-
// formula used as a term, or replacing the subterm with an equal one from the branch.
|
|
5
2
|
|
|
6
3
|
import { TlaZenonError } from "../../../errors";
|
|
7
4
|
import {
|
|
@@ -29,8 +26,7 @@ import {
|
|
|
29
26
|
type TlaContext,
|
|
30
27
|
} from "./terms";
|
|
31
28
|
|
|
32
|
-
|
|
33
|
-
const parseInteger = (text: string) =>
|
|
29
|
+
const parseOcamlInteger = (text: string) =>
|
|
34
30
|
/^[-+]?(0[xX][0-9a-fA-F_]+|0[oO][0-7_]+|0[bB][01_]+|0[uU][0-9_]+|[0-9][0-9_]*)$/.test(text)
|
|
35
31
|
? Number(text.replace(/_/g, "").replace(/^([-+]?)0[uU]/, "$1"))
|
|
36
32
|
: undefined;
|
|
@@ -43,7 +39,7 @@ const getNaturalConstant = (expression: Expr): number | undefined => {
|
|
|
43
39
|
current = current.args[1];
|
|
44
40
|
}
|
|
45
41
|
if (current.kind !== "var") return undefined;
|
|
46
|
-
const value =
|
|
42
|
+
const value = parseOcamlInteger(current.symbol);
|
|
47
43
|
return value === undefined ? undefined : accumulator + value;
|
|
48
44
|
};
|
|
49
45
|
|
|
@@ -100,20 +96,19 @@ const getRewrites = (
|
|
|
100
96
|
const lambda = exprs.elam(hole, "", frame);
|
|
101
97
|
const fill = (inner: Expr) => exprs.substitute([[hole, inner]], frame);
|
|
102
98
|
const makeBoolCase = (getRule: (prefix: [Expr, Expr, Expr, Expr, Expr, Expr]) => Rule) => {
|
|
103
|
-
const
|
|
99
|
+
const trueEquality = equal(exprs, term, TRUE);
|
|
104
100
|
const whenTrue = fill(TRUE);
|
|
105
|
-
const
|
|
101
|
+
const falseEquality = equal(exprs, term, FALSE);
|
|
106
102
|
const whenFalse = fill(FALSE);
|
|
107
103
|
return make(
|
|
108
|
-
getRule([fill(term),
|
|
104
|
+
getRule([fill(term), trueEquality, whenTrue, falseEquality, whenFalse, lambda]),
|
|
109
105
|
[],
|
|
110
106
|
[
|
|
111
|
-
[
|
|
112
|
-
[
|
|
107
|
+
[trueEquality, whenTrue],
|
|
108
|
+
[falseEquality, whenFalse],
|
|
113
109
|
],
|
|
114
110
|
);
|
|
115
111
|
};
|
|
116
|
-
// Rewrites the term with the equalities on the branch whose other side has one of these heads.
|
|
117
112
|
const makeEqualityRewrites = (wrapped: Expr, heads: string[], subterm: Expr) => {
|
|
118
113
|
const hasGoodHead = (other: Expr) =>
|
|
119
114
|
(other.kind === "app" || other.kind === "var") &&
|
|
@@ -199,19 +194,19 @@ const getRewrites = (
|
|
|
199
194
|
const point = fcn.args[1];
|
|
200
195
|
const value = fcn.args[2];
|
|
201
196
|
const inDomain = member(exprs, argument, domain(exprs, base));
|
|
202
|
-
const
|
|
197
|
+
const pointEquality = equal(exprs, point, argument);
|
|
203
198
|
const changed = fill(value);
|
|
204
|
-
const
|
|
199
|
+
const pointInequality = exprs.enot(equal(exprs, point, argument));
|
|
205
200
|
const unchanged = fill(fapply(exprs, base, argument));
|
|
206
201
|
const outside = exprs.enot(inDomain);
|
|
207
202
|
return make(
|
|
208
203
|
makeRule("fapplyexcept", [
|
|
209
204
|
fill(term),
|
|
210
205
|
inDomain,
|
|
211
|
-
|
|
206
|
+
pointEquality,
|
|
212
207
|
changed,
|
|
213
208
|
inDomain,
|
|
214
|
-
|
|
209
|
+
pointInequality,
|
|
215
210
|
unchanged,
|
|
216
211
|
outside,
|
|
217
212
|
lambda,
|
|
@@ -221,7 +216,7 @@ const getRewrites = (
|
|
|
221
216
|
argument,
|
|
222
217
|
]),
|
|
223
218
|
[],
|
|
224
|
-
[[inDomain,
|
|
219
|
+
[[inDomain, pointEquality, changed], [inDomain, pointInequality, unchanged], [outside]],
|
|
225
220
|
);
|
|
226
221
|
}
|
|
227
222
|
if (isApp(fcn, "TLA.tuple") && isInOneTo(argument, fcn.args.length)) {
|
|
@@ -394,8 +389,6 @@ const hasExistential = (exprs: Expressions, index: Index, choice: BinderExpr) =>
|
|
|
394
389
|
return index.isMember(exprs.eex(choice.args[0], choice.symbol, body));
|
|
395
390
|
};
|
|
396
391
|
|
|
397
|
-
// Zenon's find_rewrites: the rewrites of the outermost subterm that has some, looking through
|
|
398
|
-
// applications and negations.
|
|
399
392
|
const findRewrites = (
|
|
400
393
|
context: TlaContext,
|
|
401
394
|
isInTerm: boolean,
|