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,10 +1,6 @@
|
|
|
1
|
-
// encode/n_rewrite.ml, type/t_synth.ml, and encode/n_standardize.ml: a TLA+ expression as an
|
|
2
|
-
// SMT-LIB term over the sort Idv. Set extensionality is in extensionality.ts, and the axioms each
|
|
3
|
-
// flattened symbol brings are in instances.ts.
|
|
4
|
-
|
|
5
1
|
import { TlaUnsupportedError } from "../../errors";
|
|
6
2
|
import { normalizeApply, shiftExpr } from "../../obligations/substitution";
|
|
7
|
-
import {
|
|
3
|
+
import type { Bound, Builtin, Expr, Sequent } from "../../obligations/expression";
|
|
8
4
|
import { createContext, type Identifier } from "./context";
|
|
9
5
|
import {
|
|
10
6
|
createFlattener,
|
|
@@ -48,17 +44,14 @@ import {
|
|
|
48
44
|
interface Term {
|
|
49
45
|
isBool: boolean;
|
|
50
46
|
text: string;
|
|
51
|
-
// Type.Synthesize: the Int-sorted form of a term that is an integer before it's cast to Idv.
|
|
52
47
|
integer?: string;
|
|
53
48
|
}
|
|
54
49
|
|
|
55
|
-
// What tlapm keeps across the obligations of one run.
|
|
56
50
|
export interface EncodingSession {
|
|
57
51
|
caseErrors: number;
|
|
58
52
|
}
|
|
59
53
|
|
|
60
54
|
export interface Mode {
|
|
61
|
-
// Whether the text encodes a fact that tlapm leaves out, which may declare operators.
|
|
62
55
|
isOmitted: boolean;
|
|
63
56
|
polarity: Polarity;
|
|
64
57
|
at: string | undefined;
|
|
@@ -77,690 +70,693 @@ export interface Env {
|
|
|
77
70
|
rest: Env | undefined;
|
|
78
71
|
}
|
|
79
72
|
|
|
80
|
-
|
|
81
|
-
|
|
73
|
+
export interface Encoder {
|
|
74
|
+
session: EncodingSession;
|
|
75
|
+
flattener: ReturnType<typeof createFlattener>;
|
|
76
|
+
anonymous: Map<string, number>;
|
|
77
|
+
recordFields: Map<string, string[]>;
|
|
78
|
+
context: ReturnType<typeof createContext>;
|
|
79
|
+
declared: Map<string, Identifier>;
|
|
80
|
+
}
|
|
81
|
+
|
|
82
82
|
interface NestedContext {
|
|
83
83
|
env: Env | undefined;
|
|
84
84
|
mode: Mode;
|
|
85
85
|
wrappers: ((body: string) => string)[];
|
|
86
86
|
}
|
|
87
87
|
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
|
|
109
|
-
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
144
|
-
|
|
145
|
-
|
|
88
|
+
const toBool = (term: Term) =>
|
|
89
|
+
term.isBool ? term.text : `(= ${resolveTriggers(term.text, true)} ${TT_IDV})`;
|
|
90
|
+
|
|
91
|
+
const toIdv = (term: Term) =>
|
|
92
|
+
term.isBool ? `(${CAST_BOOL} ${resolveTriggers(term.text, true)})` : term.text;
|
|
93
|
+
|
|
94
|
+
const wrapBool = (text: string): Term => ({ isBool: true, text });
|
|
95
|
+
|
|
96
|
+
const wrapIdv = (text: string): Term => ({ isBool: false, text });
|
|
97
|
+
|
|
98
|
+
const getBinding = (env: Env | undefined, index: number): Binding => {
|
|
99
|
+
const found = Array.from({ length: index - 1 }).reduce<Env | undefined>(
|
|
100
|
+
(current) => current?.rest,
|
|
101
|
+
env,
|
|
102
|
+
);
|
|
103
|
+
if (!found) throw new TlaUnsupportedError("a reference outside the obligation");
|
|
104
|
+
return found.binding;
|
|
105
|
+
};
|
|
106
|
+
|
|
107
|
+
export const push = (env: Env | undefined, binding: Binding): Env => ({ binding, rest: env });
|
|
108
|
+
|
|
109
|
+
const getFree = (text: string, depth: number) =>
|
|
110
|
+
[...new Set(text.match(/[^\s()]+#\d+/g))]
|
|
111
|
+
.filter((variable) => getDepth(variable) < depth)
|
|
112
|
+
.toSorted((left, right) => getDepth(left) - getDepth(right));
|
|
113
|
+
|
|
114
|
+
export const getUniqueName = (encoder: Encoder, name: string) => {
|
|
115
|
+
const identifier = encoder.context.adjoin(name);
|
|
116
|
+
encoder.context.enter(identifier);
|
|
117
|
+
encoder.declared.set(identifier.name, identifier);
|
|
118
|
+
return identifier.name;
|
|
119
|
+
};
|
|
120
|
+
|
|
121
|
+
const clearPolarity = (mode: Mode): Mode => ({ ...mode, polarity: "Neither" });
|
|
122
|
+
|
|
123
|
+
const invert = (mode: Mode): Mode => ({
|
|
124
|
+
...mode,
|
|
125
|
+
polarity:
|
|
126
|
+
mode.polarity === "Positive"
|
|
127
|
+
? "Negative"
|
|
128
|
+
: mode.polarity === "Negative"
|
|
129
|
+
? "Positive"
|
|
130
|
+
: "Neither",
|
|
131
|
+
});
|
|
132
|
+
|
|
133
|
+
export const encodeIdv = (encoder: Encoder, expression: Expr, env: Env | undefined, mode: Mode) =>
|
|
134
|
+
toIdv(encode(encoder, expression, env, clearPolarity(mode)));
|
|
135
|
+
|
|
136
|
+
export const encodeBool = (encoder: Encoder, expression: Expr, env: Env | undefined, mode: Mode) =>
|
|
137
|
+
toBool(encode(encoder, expression, env, mode));
|
|
138
|
+
|
|
139
|
+
// tlapm's Rewrite encodes each Ditto's copy of a domain, so each copy flattens again.
|
|
140
|
+
const encodeDomains = (encoder: Encoder, bounds: Bound[], env: Env | undefined, mode: Mode) =>
|
|
141
|
+
bounds
|
|
142
|
+
.reduce<(Expr | undefined)[]>((domains, bound) => {
|
|
143
|
+
if (bound.domain.kind === "Ditto") return [...domains, domains.at(-1)];
|
|
144
|
+
if (bound.domain.kind === "NoDomain") return [...domains, undefined];
|
|
145
|
+
return [...domains, bound.domain.expression];
|
|
146
|
+
}, [])
|
|
147
|
+
.map((domain) => (domain === undefined ? undefined : encodeIdv(encoder, domain, env, mode)));
|
|
148
|
+
|
|
149
|
+
const getDomains = (
|
|
150
|
+
encoder: Encoder,
|
|
151
|
+
bounds: Bound[],
|
|
152
|
+
env: Env | undefined,
|
|
153
|
+
mode: Mode,
|
|
154
|
+
construct: string,
|
|
155
|
+
) =>
|
|
156
|
+
encodeDomains(encoder, bounds, env, mode).map((domain) => {
|
|
157
|
+
if (domain === undefined) throw new TlaUnsupportedError(`${construct} without a domain`);
|
|
158
|
+
return domain;
|
|
146
159
|
});
|
|
147
160
|
|
|
148
|
-
|
|
149
|
-
|
|
150
|
-
|
|
151
|
-
|
|
152
|
-
|
|
153
|
-
|
|
154
|
-
|
|
155
|
-
|
|
156
|
-
const encodeDomains = (bounds: Bound[], env: Env | undefined, mode: Mode) =>
|
|
157
|
-
bounds
|
|
158
|
-
.reduce<(Expr | undefined)[]>((domains, bound) => {
|
|
159
|
-
if (bound.domain.kind === "Ditto") return [...domains, domains.at(-1)];
|
|
160
|
-
if (bound.domain.kind === "NoDomain") return [...domains, undefined];
|
|
161
|
-
return [...domains, bound.domain.expression];
|
|
162
|
-
}, [])
|
|
163
|
-
.map((domain) => (domain === undefined ? undefined : encodeIdv(domain, env, mode)));
|
|
164
|
-
|
|
165
|
-
const getDomains = (bounds: Bound[], env: Env | undefined, mode: Mode, construct: string) =>
|
|
166
|
-
encodeDomains(bounds, env, mode).map((domain) => {
|
|
167
|
-
if (domain === undefined) throw new TlaUnsupportedError(`${construct} without a domain`);
|
|
168
|
-
return domain;
|
|
169
|
-
});
|
|
170
|
-
|
|
171
|
-
const bindVariables = (names: string[], env: Env | undefined, mode: Mode) => {
|
|
172
|
-
const variables = names.map((name, index) => getVariable(name, mode.depth + index));
|
|
173
|
-
const inner = variables.reduce<Env | undefined>(
|
|
174
|
-
(current, symbol) => push(current, { kind: "constant", symbol }),
|
|
175
|
-
env,
|
|
176
|
-
);
|
|
177
|
-
return { variables, env: inner, mode: { ...mode, depth: mode.depth + names.length } };
|
|
178
|
-
};
|
|
179
|
-
|
|
180
|
-
const encodeQuantifier = (
|
|
181
|
-
expression: Extract<Expr, { kind: "Quant" }>,
|
|
182
|
-
env: Env | undefined,
|
|
183
|
-
mode: Mode,
|
|
184
|
-
) => {
|
|
185
|
-
const domains = encodeDomains(expression.bounds, env, mode);
|
|
186
|
-
const bound = bindVariables(
|
|
187
|
-
expression.bounds.map((innerBound) => innerBound.name),
|
|
188
|
-
env,
|
|
189
|
-
mode,
|
|
190
|
-
);
|
|
191
|
-
const body = encodeBool(expression.body, bound.env, bound.mode);
|
|
192
|
-
const guards = bound.variables.flatMap((variable, index) =>
|
|
193
|
-
domains[index] === undefined ? [] : [`(${MEM} ${variable} ${domains[index]})`],
|
|
194
|
-
);
|
|
195
|
-
return expression.quantifier === "Forall"
|
|
196
|
-
? `(forall (${getBinders(bound.variables)}) ${guards.length === 0 ? body : `(=> ${conjoin(guards)} ${body})`})`
|
|
197
|
-
: `(exists (${getBinders(bound.variables)}) ${conjoin([...guards, body])})`;
|
|
198
|
-
};
|
|
199
|
-
|
|
200
|
-
const encodeSetSt = (
|
|
201
|
-
expression: Extract<Expr, { kind: "SetSt" }>,
|
|
202
|
-
env: Env | undefined,
|
|
203
|
-
mode: Mode,
|
|
204
|
-
) => {
|
|
205
|
-
const domain = encodeIdv(expression.domain, env, mode);
|
|
206
|
-
const bound = bindVariables([expression.name], env, neither(mode));
|
|
207
|
-
const body = encodeBool(expression.body, bound.env, bound.mode);
|
|
208
|
-
const free = getFree(body, mode.depth);
|
|
209
|
-
const symbol = flatten(
|
|
210
|
-
"SetSt",
|
|
211
|
-
body,
|
|
212
|
-
mode,
|
|
213
|
-
(name) => getSetStAxioms(name, free, body, bound.variables[0]),
|
|
214
|
-
free.length + 1,
|
|
215
|
-
);
|
|
216
|
-
return idv(call(symbol, [domain, ...free]));
|
|
217
|
-
};
|
|
218
|
-
|
|
219
|
-
const encodeSetOf = (
|
|
220
|
-
expression: Extract<Expr, { kind: "SetOf" }>,
|
|
221
|
-
env: Env | undefined,
|
|
222
|
-
mode: Mode,
|
|
223
|
-
) => {
|
|
224
|
-
const domains = getDomains(expression.bounds, env, mode, "a set of values");
|
|
225
|
-
const bound = bindVariables(
|
|
226
|
-
expression.bounds.map((innerBound) => innerBound.name),
|
|
227
|
-
env,
|
|
228
|
-
neither(mode),
|
|
229
|
-
);
|
|
230
|
-
const element = encodeIdv(expression.element, bound.env, bound.mode);
|
|
231
|
-
const free = getFree(element, mode.depth);
|
|
232
|
-
const count = domains.length;
|
|
233
|
-
const symbol = flatten(
|
|
234
|
-
`SetOf_${count}`,
|
|
235
|
-
element,
|
|
236
|
-
mode,
|
|
237
|
-
(name) => getSetOfAxioms(name, free, element, bound.variables),
|
|
238
|
-
count + free.length,
|
|
239
|
-
);
|
|
240
|
-
return idv(call(symbol, [...domains, ...free]));
|
|
241
|
-
};
|
|
242
|
-
|
|
243
|
-
// Rewrite.elim_multiarg: a function of several arguments is a function of a tuple.
|
|
244
|
-
const encodeFunction = (
|
|
245
|
-
expression: Extract<Expr, { kind: "Fcn" }>,
|
|
246
|
-
env: Env | undefined,
|
|
247
|
-
mode: Mode,
|
|
248
|
-
) => {
|
|
249
|
-
const domains = getDomains(expression.bounds, env, mode, "a function");
|
|
250
|
-
const domain =
|
|
251
|
-
domains.length === 1 ? domains[0] : call(tla(`Product_${domains.length}`), domains);
|
|
252
|
-
const variable = getVariable(
|
|
253
|
-
domains.length === 1 ? expression.bounds[0].name : "x",
|
|
254
|
-
mode.depth,
|
|
255
|
-
);
|
|
256
|
-
const inner = { ...neither(mode), depth: mode.depth + 1 };
|
|
257
|
-
const bodyEnv =
|
|
258
|
-
domains.length === 1
|
|
259
|
-
? push(env, { kind: "constant", symbol: variable })
|
|
260
|
-
: getIntegers(domains.length).reduce<Env | undefined>(
|
|
261
|
-
(current, key) =>
|
|
262
|
-
push(current, { kind: "constant", symbol: `(${FUN_APP} ${variable} ${key})` }),
|
|
263
|
-
env,
|
|
264
|
-
);
|
|
265
|
-
const body = encodeIdv(expression.body, bodyEnv, inner);
|
|
266
|
-
const free = getFree(body, mode.depth);
|
|
267
|
-
const symbol = flatten(
|
|
268
|
-
"FunFcn",
|
|
269
|
-
body,
|
|
270
|
-
mode,
|
|
271
|
-
(name, axioms) => getFunctionAxioms(name, free, body, variable, axioms),
|
|
272
|
-
free.length + 1,
|
|
273
|
-
);
|
|
274
|
-
return idv(call(symbol, [domain, ...free]));
|
|
275
|
-
};
|
|
276
|
-
|
|
277
|
-
// Elab: CHOOSE x \in S : P is CHOOSE x : x \in S /\ P.
|
|
278
|
-
const encodeChoose = (
|
|
279
|
-
expression: Extract<Expr, { kind: "Choose" }>,
|
|
280
|
-
env: Env | undefined,
|
|
281
|
-
mode: Mode,
|
|
282
|
-
) => {
|
|
283
|
-
const bound = bindVariables([expression.name], env, neither(mode));
|
|
284
|
-
const variable = bound.variables[0];
|
|
285
|
-
const domain =
|
|
286
|
-
expression.domain && `(${MEM} ${variable} ${encodeIdv(expression.domain, env, mode)})`;
|
|
287
|
-
const predicate = encodeBool(expression.body, bound.env, bound.mode);
|
|
288
|
-
const body = domain === undefined ? predicate : conjoin([domain, predicate]);
|
|
289
|
-
const free = getFree(body, mode.depth);
|
|
290
|
-
const symbol = flatten(
|
|
291
|
-
"Choose",
|
|
292
|
-
body,
|
|
293
|
-
mode,
|
|
294
|
-
(name) => getChooseAxioms(name, free, body, variable),
|
|
295
|
-
free.length,
|
|
296
|
-
);
|
|
297
|
-
return idv(call(symbol, free));
|
|
298
|
-
};
|
|
299
|
-
|
|
300
|
-
// Type.Synthesize compares values of the same sort only above type level 1, so two formulas are
|
|
301
|
-
// compared as values.
|
|
302
|
-
const encodeEquality = (args: Expr[], env: Env | undefined, mode: Mode, isNegated: boolean) =>
|
|
303
|
-
getEquality(
|
|
304
|
-
encodeIdv(args[0], env, mode),
|
|
305
|
-
encodeIdv(args[1], env, mode),
|
|
306
|
-
mode.polarity,
|
|
307
|
-
isNegated,
|
|
308
|
-
);
|
|
161
|
+
const bindVariables = (names: string[], env: Env | undefined, mode: Mode) => {
|
|
162
|
+
const variables = names.map((name, index) => getVariable(name, mode.depth + index));
|
|
163
|
+
const inner = variables.reduce<Env | undefined>(
|
|
164
|
+
(current, symbol) => push(current, { kind: "constant", symbol }),
|
|
165
|
+
env,
|
|
166
|
+
);
|
|
167
|
+
return { variables, env: inner, mode: { ...mode, depth: mode.depth + names.length } };
|
|
168
|
+
};
|
|
309
169
|
|
|
310
|
-
|
|
311
|
-
|
|
312
|
-
|
|
313
|
-
|
|
314
|
-
|
|
315
|
-
|
|
316
|
-
|
|
317
|
-
|
|
318
|
-
|
|
319
|
-
|
|
320
|
-
|
|
321
|
-
|
|
322
|
-
|
|
323
|
-
|
|
324
|
-
|
|
325
|
-
|
|
326
|
-
|
|
327
|
-
|
|
328
|
-
|
|
329
|
-
|
|
330
|
-
|
|
331
|
-
|
|
332
|
-
|
|
333
|
-
|
|
334
|
-
|
|
335
|
-
|
|
336
|
-
|
|
337
|
-
|
|
338
|
-
|
|
339
|
-
|
|
340
|
-
|
|
341
|
-
|
|
342
|
-
|
|
343
|
-
|
|
344
|
-
|
|
345
|
-
|
|
346
|
-
|
|
347
|
-
|
|
348
|
-
|
|
349
|
-
|
|
350
|
-
|
|
351
|
-
|
|
352
|
-
|
|
353
|
-
|
|
354
|
-
|
|
355
|
-
|
|
356
|
-
|
|
357
|
-
|
|
358
|
-
|
|
359
|
-
|
|
360
|
-
|
|
361
|
-
|
|
362
|
-
|
|
363
|
-
|
|
364
|
-
|
|
365
|
-
|
|
366
|
-
|
|
367
|
-
|
|
368
|
-
|
|
369
|
-
|
|
370
|
-
|
|
371
|
-
|
|
372
|
-
|
|
373
|
-
|
|
374
|
-
|
|
375
|
-
|
|
376
|
-
|
|
377
|
-
|
|
378
|
-
|
|
170
|
+
const encodeQuantifier = (
|
|
171
|
+
encoder: Encoder,
|
|
172
|
+
expression: Extract<Expr, { kind: "Quant" }>,
|
|
173
|
+
env: Env | undefined,
|
|
174
|
+
mode: Mode,
|
|
175
|
+
) => {
|
|
176
|
+
const domains = encodeDomains(encoder, expression.bounds, env, mode);
|
|
177
|
+
const bound = bindVariables(
|
|
178
|
+
expression.bounds.map((innerBound) => innerBound.name),
|
|
179
|
+
env,
|
|
180
|
+
mode,
|
|
181
|
+
);
|
|
182
|
+
const body = encodeBool(encoder, expression.body, bound.env, bound.mode);
|
|
183
|
+
const guards = bound.variables.flatMap((variable, index) =>
|
|
184
|
+
domains[index] === undefined ? [] : [`(${MEM} ${variable} ${domains[index]})`],
|
|
185
|
+
);
|
|
186
|
+
return expression.quantifier === "Forall"
|
|
187
|
+
? `(forall (${getBinders(bound.variables)}) ${guards.length === 0 ? body : `(=> ${conjoin(guards)} ${body})`})`
|
|
188
|
+
: `(exists (${getBinders(bound.variables)}) ${conjoin([...guards, body])})`;
|
|
189
|
+
};
|
|
190
|
+
|
|
191
|
+
const encodeSetSt = (
|
|
192
|
+
encoder: Encoder,
|
|
193
|
+
expression: Extract<Expr, { kind: "SetSt" }>,
|
|
194
|
+
env: Env | undefined,
|
|
195
|
+
mode: Mode,
|
|
196
|
+
) => {
|
|
197
|
+
const domain = encodeIdv(encoder, expression.domain, env, mode);
|
|
198
|
+
const bound = bindVariables([expression.name], env, clearPolarity(mode));
|
|
199
|
+
const body = encodeBool(encoder, expression.body, bound.env, bound.mode);
|
|
200
|
+
const free = getFree(body, mode.depth);
|
|
201
|
+
const symbol = encoder.flattener.flatten(
|
|
202
|
+
"SetSt",
|
|
203
|
+
body,
|
|
204
|
+
mode,
|
|
205
|
+
(name) => getSetStAxioms(name, free, body, bound.variables[0]),
|
|
206
|
+
free.length + 1,
|
|
207
|
+
);
|
|
208
|
+
return wrapIdv(call(symbol, [domain, ...free]));
|
|
209
|
+
};
|
|
210
|
+
|
|
211
|
+
const encodeSetOf = (
|
|
212
|
+
encoder: Encoder,
|
|
213
|
+
expression: Extract<Expr, { kind: "SetOf" }>,
|
|
214
|
+
env: Env | undefined,
|
|
215
|
+
mode: Mode,
|
|
216
|
+
) => {
|
|
217
|
+
const domains = getDomains(encoder, expression.bounds, env, mode, "a set of values");
|
|
218
|
+
const bound = bindVariables(
|
|
219
|
+
expression.bounds.map((innerBound) => innerBound.name),
|
|
220
|
+
env,
|
|
221
|
+
clearPolarity(mode),
|
|
222
|
+
);
|
|
223
|
+
const element = encodeIdv(encoder, expression.element, bound.env, bound.mode);
|
|
224
|
+
const free = getFree(element, mode.depth);
|
|
225
|
+
const count = domains.length;
|
|
226
|
+
const symbol = encoder.flattener.flatten(
|
|
227
|
+
`SetOf_${count}`,
|
|
228
|
+
element,
|
|
229
|
+
mode,
|
|
230
|
+
(name) => getSetOfAxioms(name, free, element, bound.variables),
|
|
231
|
+
count + free.length,
|
|
232
|
+
);
|
|
233
|
+
return wrapIdv(call(symbol, [...domains, ...free]));
|
|
234
|
+
};
|
|
235
|
+
|
|
236
|
+
const encodeFunction = (
|
|
237
|
+
encoder: Encoder,
|
|
238
|
+
expression: Extract<Expr, { kind: "Fcn" }>,
|
|
239
|
+
env: Env | undefined,
|
|
240
|
+
mode: Mode,
|
|
241
|
+
) => {
|
|
242
|
+
const domains = getDomains(encoder, expression.bounds, env, mode, "a function");
|
|
243
|
+
const domain =
|
|
244
|
+
domains.length === 1 ? domains[0] : call(tla(`Product_${domains.length}`), domains);
|
|
245
|
+
const variable = getVariable(domains.length === 1 ? expression.bounds[0].name : "x", mode.depth);
|
|
246
|
+
const inner = { ...clearPolarity(mode), depth: mode.depth + 1 };
|
|
247
|
+
const bodyEnv =
|
|
248
|
+
domains.length === 1
|
|
249
|
+
? push(env, { kind: "constant", symbol: variable })
|
|
250
|
+
: getIntegers(domains.length).reduce<Env | undefined>(
|
|
251
|
+
(current, key) =>
|
|
252
|
+
push(current, { kind: "constant", symbol: `(${FUN_APP} ${variable} ${key})` }),
|
|
253
|
+
env,
|
|
379
254
|
);
|
|
380
|
-
|
|
381
|
-
|
|
382
|
-
|
|
383
|
-
|
|
384
|
-
|
|
385
|
-
|
|
386
|
-
|
|
387
|
-
|
|
388
|
-
|
|
389
|
-
|
|
390
|
-
|
|
255
|
+
const body = encodeIdv(encoder, expression.body, bodyEnv, inner);
|
|
256
|
+
const free = getFree(body, mode.depth);
|
|
257
|
+
const symbol = encoder.flattener.flatten(
|
|
258
|
+
"FunFcn",
|
|
259
|
+
body,
|
|
260
|
+
mode,
|
|
261
|
+
(name, axioms) => getFunctionAxioms(name, free, body, variable, axioms),
|
|
262
|
+
free.length + 1,
|
|
263
|
+
);
|
|
264
|
+
return wrapIdv(call(symbol, [domain, ...free]));
|
|
265
|
+
};
|
|
266
|
+
|
|
267
|
+
const encodeChoose = (
|
|
268
|
+
encoder: Encoder,
|
|
269
|
+
expression: Extract<Expr, { kind: "Choose" }>,
|
|
270
|
+
env: Env | undefined,
|
|
271
|
+
mode: Mode,
|
|
272
|
+
) => {
|
|
273
|
+
const bound = bindVariables([expression.name], env, clearPolarity(mode));
|
|
274
|
+
const variable = bound.variables[0];
|
|
275
|
+
const domain =
|
|
276
|
+
expression.domain && `(${MEM} ${variable} ${encodeIdv(encoder, expression.domain, env, mode)})`;
|
|
277
|
+
const predicate = encodeBool(encoder, expression.body, bound.env, bound.mode);
|
|
278
|
+
const body = domain === undefined ? predicate : conjoin([domain, predicate]);
|
|
279
|
+
const free = getFree(body, mode.depth);
|
|
280
|
+
const symbol = encoder.flattener.flatten(
|
|
281
|
+
"Choose",
|
|
282
|
+
body,
|
|
283
|
+
mode,
|
|
284
|
+
(name) => getChooseAxioms(name, free, body, variable),
|
|
285
|
+
free.length,
|
|
286
|
+
);
|
|
287
|
+
return wrapIdv(call(symbol, free));
|
|
288
|
+
};
|
|
289
|
+
|
|
290
|
+
const encodeEquality = (
|
|
291
|
+
encoder: Encoder,
|
|
292
|
+
args: Expr[],
|
|
293
|
+
env: Env | undefined,
|
|
294
|
+
mode: Mode,
|
|
295
|
+
isNegated: boolean,
|
|
296
|
+
) =>
|
|
297
|
+
getEquality(
|
|
298
|
+
encodeIdv(encoder, args[0], env, mode),
|
|
299
|
+
encodeIdv(encoder, args[1], env, mode),
|
|
300
|
+
mode.polarity,
|
|
301
|
+
isNegated,
|
|
302
|
+
);
|
|
303
|
+
|
|
304
|
+
const getSelectionTest = (encoder: Encoder, test: Expr, env: Env | undefined, mode: Mode) => {
|
|
305
|
+
const lambda = test.kind === "Lambda" && test.params.length === 1 ? test : undefined;
|
|
306
|
+
const bound = bindVariables([lambda?.params[0].name ?? "x1"], env, clearPolarity(mode));
|
|
307
|
+
const body = encodeBool(
|
|
308
|
+
encoder,
|
|
309
|
+
lambda?.body ?? {
|
|
310
|
+
kind: "Apply",
|
|
311
|
+
operator: shiftExpr(1, test),
|
|
312
|
+
args: [{ kind: "Ix", index: 1 }],
|
|
313
|
+
},
|
|
314
|
+
bound.env,
|
|
315
|
+
bound.mode,
|
|
316
|
+
);
|
|
317
|
+
return { body, variable: bound.variables[0] };
|
|
318
|
+
};
|
|
319
|
+
|
|
320
|
+
const encodeBuiltin = (
|
|
321
|
+
encoder: Encoder,
|
|
322
|
+
builtin: Builtin,
|
|
323
|
+
args: Expr[],
|
|
324
|
+
env: Env | undefined,
|
|
325
|
+
mode: Mode,
|
|
326
|
+
): Term => {
|
|
327
|
+
const encodeArgs = () => args.map((arg) => encodeIdv(encoder, arg, env, mode));
|
|
328
|
+
switch (builtin) {
|
|
329
|
+
case "Conj":
|
|
330
|
+
return wrapBool(conjoin(args.map((arg) => encodeBool(encoder, arg, env, mode))));
|
|
331
|
+
case "Disj":
|
|
332
|
+
return wrapBool(disjoin(args.map((arg) => encodeBool(encoder, arg, env, mode))));
|
|
333
|
+
case "Implies":
|
|
334
|
+
return wrapBool(
|
|
335
|
+
`(=> ${encodeBool(encoder, args[0], env, invert(mode))} ${encodeBool(encoder, args[1], env, mode)})`,
|
|
336
|
+
);
|
|
337
|
+
case "Equiv":
|
|
338
|
+
return wrapBool(
|
|
339
|
+
`(= ${args.map((arg) => encodeBool(encoder, arg, env, clearPolarity(mode))).join(" ")})`,
|
|
340
|
+
);
|
|
341
|
+
case "Neg":
|
|
342
|
+
return wrapBool(`(not ${encodeBool(encoder, args[0], env, invert(mode))})`);
|
|
343
|
+
case "Eq":
|
|
344
|
+
return wrapBool(encodeEquality(encoder, args, env, mode, false));
|
|
345
|
+
case "Neq":
|
|
346
|
+
return wrapBool(encodeEquality(encoder, args, env, mode, true));
|
|
347
|
+
case "Mem":
|
|
348
|
+
return wrapBool(call(MEM, encodeArgs()));
|
|
349
|
+
case "Notmem":
|
|
350
|
+
return wrapBool(`(not ${call(MEM, encodeArgs())})`);
|
|
351
|
+
case "Subseteq":
|
|
352
|
+
return wrapBool(call(SUBSET_EQ, encodeArgs()));
|
|
353
|
+
case "Lteq":
|
|
354
|
+
return wrapBool(call(INT_LTEQ, encodeArgs()));
|
|
355
|
+
case "Gteq":
|
|
356
|
+
return wrapBool(call(INT_LTEQ, encodeArgs().toReversed()));
|
|
357
|
+
case "Lt":
|
|
358
|
+
case "Gt": {
|
|
359
|
+
// Rewrite copies the operands before Flatten, which flattens each copy again.
|
|
360
|
+
const getOperands = () => (builtin === "Lt" ? encodeArgs() : encodeArgs().toReversed());
|
|
361
|
+
return wrapBool(
|
|
362
|
+
`(and ${call(INT_LTEQ, getOperands())} (distinct ${getOperands().join(" ")}))`,
|
|
363
|
+
);
|
|
391
364
|
}
|
|
392
|
-
|
|
393
|
-
|
|
394
|
-
|
|
395
|
-
|
|
396
|
-
|
|
397
|
-
|
|
398
|
-
|
|
399
|
-
|
|
400
|
-
|
|
401
|
-
|
|
402
|
-
|
|
403
|
-
if (args.length > 0) throw new TlaUnsupportedError(`an applied ${binding.kind}`);
|
|
404
|
-
return idv(binding.symbol);
|
|
405
|
-
case "operator":
|
|
406
|
-
if (args.length !== binding.arity)
|
|
407
|
-
throw new TlaUnsupportedError("an operator applied to the wrong number of arguments");
|
|
408
|
-
return idv(
|
|
409
|
-
call(
|
|
410
|
-
binding.symbol,
|
|
411
|
-
args.map((arg) => encodeIdv(arg, env, mode)),
|
|
412
|
-
),
|
|
413
|
-
);
|
|
414
|
-
// Flatten: an application of a second-order operator, which has no axioms, is a fresh
|
|
415
|
-
// operator of its first-order arguments and the bound variables its others use.
|
|
416
|
-
case "secondOrder": {
|
|
417
|
-
if (args.length !== binding.shapes.length)
|
|
418
|
-
throw new TlaUnsupportedError("an operator applied to the wrong number of arguments");
|
|
419
|
-
const operands = args.map((arg, index) => {
|
|
420
|
-
if (binding.shapes[index] === 0)
|
|
421
|
-
return { isFirstOrder: true, text: encodeIdv(arg, env, mode) };
|
|
422
|
-
// An operator's name as the argument stands for the operator, which compare_expr
|
|
423
|
-
// matches by name.
|
|
424
|
-
if (arg.kind === "Ix") {
|
|
425
|
-
const argument = getBinding(env, arg.index);
|
|
426
|
-
if (argument.kind !== "operator")
|
|
427
|
-
throw new TlaUnsupportedError("an operator argument that isn't a LAMBDA");
|
|
428
|
-
return { isFirstOrder: false, text: argument.symbol };
|
|
429
|
-
}
|
|
430
|
-
if (arg.kind !== "Lambda")
|
|
431
|
-
throw new TlaUnsupportedError("an operator argument that isn't a LAMBDA");
|
|
432
|
-
const bound = bindVariables(
|
|
433
|
-
arg.params.map((param) => param.name),
|
|
434
|
-
env,
|
|
435
|
-
neither(mode),
|
|
436
|
-
);
|
|
437
|
-
return { isFirstOrder: false, text: encodeIdv(arg.body, bound.env, bound.mode) };
|
|
438
|
-
});
|
|
439
|
-
const firstOrder = operands.flatMap((operand) =>
|
|
440
|
-
operand.isFirstOrder ? [operand.text] : [],
|
|
441
|
-
);
|
|
442
|
-
const higherOrder = operands.flatMap((operand) =>
|
|
443
|
-
operand.isFirstOrder ? [] : [operand.text],
|
|
444
|
-
);
|
|
445
|
-
const free = getFree(higherOrder.join(" "), mode.depth);
|
|
446
|
-
const symbol = flatten(
|
|
447
|
-
"",
|
|
448
|
-
higherOrder.join(" "),
|
|
449
|
-
mode,
|
|
450
|
-
() => [],
|
|
451
|
-
firstOrder.length + free.length,
|
|
452
|
-
binding.name,
|
|
453
|
-
);
|
|
454
|
-
return idv(call(symbol, [...firstOrder, ...free]));
|
|
455
|
-
}
|
|
456
|
-
case "unsupported":
|
|
457
|
-
throw new TlaUnsupportedError(binding.reason);
|
|
365
|
+
case "SelectSeq": {
|
|
366
|
+
const test = getSelectionTest(encoder, args[1], env, mode);
|
|
367
|
+
const free = getFree(test.body, mode.depth);
|
|
368
|
+
const symbol = encoder.flattener.flatten(
|
|
369
|
+
"SelectSeq",
|
|
370
|
+
test.body,
|
|
371
|
+
mode,
|
|
372
|
+
(name) => getSelectSeqAxioms(name, free, test.body, test.variable),
|
|
373
|
+
free.length + 1,
|
|
374
|
+
);
|
|
375
|
+
return wrapIdv(call(symbol, [encodeIdv(encoder, args[0], env, mode), ...free]));
|
|
458
376
|
}
|
|
459
|
-
|
|
460
|
-
|
|
461
|
-
|
|
462
|
-
|
|
463
|
-
|
|
464
|
-
|
|
465
|
-
|
|
466
|
-
|
|
467
|
-
|
|
468
|
-
|
|
469
|
-
|
|
470
|
-
|
|
471
|
-
// Standardize: an opaque name the Action frontend introduces is an anonymous operator, named
|
|
472
|
-
// OPAQUE_ when it has no arguments.
|
|
473
|
-
const encodeOpaque = (name: string, args: Expr[], env: Env | undefined, mode: Mode) => {
|
|
474
|
-
if (args.length === 0 && name.endsWith("#prime"))
|
|
475
|
-
return idv(getPrimed(env, name.slice(0, -"#prime".length)));
|
|
476
|
-
const anonymousName = args.length === 0 ? `Anon_OPAQUE_${name}` : `Anon_${name}`;
|
|
477
|
-
anonymous.set(anonymousName, args.length);
|
|
478
|
-
return idv(
|
|
479
|
-
call(
|
|
480
|
-
tla(anonymousName),
|
|
481
|
-
args.map((arg) => encodeIdv(arg, env, mode)),
|
|
482
|
-
),
|
|
483
|
-
);
|
|
484
|
-
};
|
|
485
|
-
|
|
486
|
-
const encodeExcept = (
|
|
487
|
-
expression: Extract<Expr, { kind: "Except" }>,
|
|
488
|
-
env: Env | undefined,
|
|
489
|
-
mode: Mode,
|
|
490
|
-
) =>
|
|
491
|
-
expression.specs.reduce(
|
|
492
|
-
(base, spec) => {
|
|
493
|
-
// Elab.desugar: @ is the value at the whole trail.
|
|
494
|
-
const update = (value: string, trail: typeof spec.trail): string => {
|
|
495
|
-
if (trail.length === 0) return encodeIdv(spec.value, env, { ...mode, at: value });
|
|
496
|
-
const point = trail[0];
|
|
497
|
-
const encodeKey = () =>
|
|
498
|
-
point.kind === "Dot"
|
|
499
|
-
? tla(`StrLit_${point.field}`)
|
|
500
|
-
: encodeIdv(point.expression, env, mode);
|
|
501
|
-
const key = encodeKey();
|
|
502
|
-
// Elab.desugar repeats the key in the value it updates, and Flatten counts both.
|
|
503
|
-
const inner = update(
|
|
504
|
-
`(${FUN_APP} ${value} ${trail.length > 1 ? encodeKey() : key})`,
|
|
505
|
-
trail.slice(1),
|
|
506
|
-
);
|
|
507
|
-
return `(${FUN_EXCEPT} ${value} ${key} ${inner})`;
|
|
508
|
-
};
|
|
509
|
-
return update(base, spec.trail);
|
|
510
|
-
},
|
|
511
|
-
encodeIdv(expression.function, env, mode),
|
|
512
|
-
);
|
|
377
|
+
case "Unprimable": {
|
|
378
|
+
const term = encode(encoder, args[0], env, clearPolarity(mode));
|
|
379
|
+
return { ...term, text: `(${UNPRIMABLE} ${term.text})` };
|
|
380
|
+
}
|
|
381
|
+
default: {
|
|
382
|
+
const symbol = BUILTIN_SYMBOLS[builtin];
|
|
383
|
+
if (symbol === undefined) throw new TlaUnsupportedError(`the operator ${builtin}`);
|
|
384
|
+
return wrapIdv(call(symbol, encodeArgs()));
|
|
385
|
+
}
|
|
386
|
+
}
|
|
387
|
+
};
|
|
513
388
|
|
|
514
|
-
|
|
515
|
-
|
|
516
|
-
|
|
517
|
-
|
|
518
|
-
|
|
519
|
-
|
|
520
|
-
|
|
521
|
-
|
|
522
|
-
|
|
523
|
-
|
|
524
|
-
|
|
525
|
-
|
|
526
|
-
|
|
527
|
-
|
|
528
|
-
|
|
529
|
-
|
|
530
|
-
|
|
531
|
-
|
|
532
|
-
|
|
533
|
-
|
|
534
|
-
|
|
535
|
-
|
|
536
|
-
|
|
537
|
-
(
|
|
538
|
-
|
|
539
|
-
|
|
389
|
+
const encodeReference = (
|
|
390
|
+
encoder: Encoder,
|
|
391
|
+
binding: Binding,
|
|
392
|
+
args: Expr[],
|
|
393
|
+
env: Env | undefined,
|
|
394
|
+
mode: Mode,
|
|
395
|
+
): Term => {
|
|
396
|
+
switch (binding.kind) {
|
|
397
|
+
case "constant":
|
|
398
|
+
case "variable":
|
|
399
|
+
if (args.length > 0) throw new TlaUnsupportedError(`an applied ${binding.kind}`);
|
|
400
|
+
return wrapIdv(binding.symbol);
|
|
401
|
+
case "operator":
|
|
402
|
+
if (args.length !== binding.arity)
|
|
403
|
+
throw new TlaUnsupportedError("an operator applied to the wrong number of arguments");
|
|
404
|
+
return wrapIdv(
|
|
405
|
+
call(
|
|
406
|
+
binding.symbol,
|
|
407
|
+
args.map((arg) => encodeIdv(encoder, arg, env, mode)),
|
|
408
|
+
),
|
|
409
|
+
);
|
|
410
|
+
case "secondOrder": {
|
|
411
|
+
if (args.length !== binding.shapes.length)
|
|
412
|
+
throw new TlaUnsupportedError("an operator applied to the wrong number of arguments");
|
|
413
|
+
const operands = args.map((arg, index) => {
|
|
414
|
+
if (binding.shapes[index] === 0)
|
|
415
|
+
return { isFirstOrder: true, text: encodeIdv(encoder, arg, env, mode) };
|
|
416
|
+
if (arg.kind === "Ix") {
|
|
417
|
+
const argument = getBinding(env, arg.index);
|
|
418
|
+
if (argument.kind !== "operator")
|
|
419
|
+
throw new TlaUnsupportedError("an operator argument that isn't a LAMBDA");
|
|
420
|
+
return { isFirstOrder: false, text: argument.symbol };
|
|
421
|
+
}
|
|
422
|
+
if (arg.kind !== "Lambda")
|
|
423
|
+
throw new TlaUnsupportedError("an operator argument that isn't a LAMBDA");
|
|
424
|
+
const bound = bindVariables(
|
|
425
|
+
arg.params.map((param) => param.name),
|
|
426
|
+
env,
|
|
427
|
+
clearPolarity(mode),
|
|
428
|
+
);
|
|
429
|
+
return { isFirstOrder: false, text: encodeIdv(encoder, arg.body, bound.env, bound.mode) };
|
|
430
|
+
});
|
|
431
|
+
const firstOrder = operands.flatMap((operand) =>
|
|
432
|
+
operand.isFirstOrder ? [operand.text] : [],
|
|
433
|
+
);
|
|
434
|
+
const higherOrder = operands.flatMap((operand) =>
|
|
435
|
+
operand.isFirstOrder ? [] : [operand.text],
|
|
540
436
|
);
|
|
541
|
-
|
|
437
|
+
const free = getFree(higherOrder.join(" "), mode.depth);
|
|
438
|
+
const symbol = encoder.flattener.flatten(
|
|
439
|
+
"",
|
|
440
|
+
higherOrder.join(" "),
|
|
441
|
+
mode,
|
|
442
|
+
() => [],
|
|
443
|
+
firstOrder.length + free.length,
|
|
444
|
+
binding.name,
|
|
445
|
+
);
|
|
446
|
+
return wrapIdv(call(symbol, [...firstOrder, ...free]));
|
|
542
447
|
}
|
|
543
|
-
|
|
544
|
-
|
|
448
|
+
case "unsupported":
|
|
449
|
+
throw new TlaUnsupportedError(binding.reason);
|
|
450
|
+
}
|
|
451
|
+
};
|
|
452
|
+
|
|
453
|
+
const getPrimed = (env: Env | undefined, name: string): string => {
|
|
454
|
+
if (!env) throw new TlaUnsupportedError(`a primed declaration that isn't a variable`);
|
|
455
|
+
const binding = env.binding;
|
|
456
|
+
return binding.kind === "variable" && binding.name === name
|
|
457
|
+
? binding.primed
|
|
458
|
+
: getPrimed(env.rest, name);
|
|
459
|
+
};
|
|
460
|
+
|
|
461
|
+
const encodeOpaque = (
|
|
462
|
+
encoder: Encoder,
|
|
463
|
+
name: string,
|
|
464
|
+
args: Expr[],
|
|
465
|
+
env: Env | undefined,
|
|
466
|
+
mode: Mode,
|
|
467
|
+
) => {
|
|
468
|
+
if (args.length === 0 && name.endsWith("#prime"))
|
|
469
|
+
return wrapIdv(getPrimed(env, name.slice(0, -"#prime".length)));
|
|
470
|
+
const anonymousName = args.length === 0 ? `Anon_OPAQUE_${name}` : `Anon_${name}`;
|
|
471
|
+
encoder.anonymous.set(anonymousName, args.length);
|
|
472
|
+
return wrapIdv(
|
|
473
|
+
call(
|
|
474
|
+
tla(anonymousName),
|
|
475
|
+
args.map((arg) => encodeIdv(encoder, arg, env, mode)),
|
|
476
|
+
),
|
|
477
|
+
);
|
|
478
|
+
};
|
|
479
|
+
|
|
480
|
+
const encodeExcept = (
|
|
481
|
+
encoder: Encoder,
|
|
482
|
+
expression: Extract<Expr, { kind: "Except" }>,
|
|
483
|
+
env: Env | undefined,
|
|
484
|
+
mode: Mode,
|
|
485
|
+
) =>
|
|
486
|
+
expression.specs.reduce(
|
|
487
|
+
(base, spec) => {
|
|
488
|
+
const update = (value: string, trail: typeof spec.trail): string => {
|
|
489
|
+
if (trail.length === 0) return encodeIdv(encoder, spec.value, env, { ...mode, at: value });
|
|
490
|
+
const point = trail[0];
|
|
491
|
+
const encodeKey = () =>
|
|
492
|
+
point.kind === "Dot"
|
|
493
|
+
? tla(`StrLit_${point.field}`)
|
|
494
|
+
: encodeIdv(encoder, point.expression, env, mode);
|
|
495
|
+
const key = encodeKey();
|
|
496
|
+
// Elab.desugar repeats the key in the value it updates, and Flatten counts both.
|
|
497
|
+
const inner = update(
|
|
498
|
+
`(${FUN_APP} ${value} ${trail.length > 1 ? encodeKey() : key})`,
|
|
499
|
+
trail.slice(1),
|
|
500
|
+
);
|
|
501
|
+
return `(${FUN_EXCEPT} ${value} ${key} ${inner})`;
|
|
502
|
+
};
|
|
503
|
+
return update(base, spec.trail);
|
|
504
|
+
},
|
|
505
|
+
encodeIdv(encoder, expression.function, env, mode),
|
|
506
|
+
);
|
|
507
|
+
|
|
508
|
+
const getCaseError = (encoder: Encoder) => {
|
|
509
|
+
encoder.session.caseErrors++;
|
|
510
|
+
const name = `Anon_incomplete_case_error_${encoder.session.caseErrors}`;
|
|
511
|
+
encoder.anonymous.set(name, 0);
|
|
512
|
+
return tla(name);
|
|
513
|
+
};
|
|
514
|
+
|
|
515
|
+
const encodeCase = (
|
|
516
|
+
encoder: Encoder,
|
|
517
|
+
expression: Extract<Expr, { kind: "Case" }>,
|
|
518
|
+
env: Env | undefined,
|
|
519
|
+
mode: Mode,
|
|
520
|
+
): Term => {
|
|
521
|
+
const bodies = expression.arms.map((arm) => encode(encoder, arm.body, env, mode));
|
|
522
|
+
const other: Term = expression.other
|
|
523
|
+
? encode(encoder, expression.other, env, mode)
|
|
524
|
+
: wrapIdv(getCaseError(encoder));
|
|
525
|
+
const isBool = other.isBool && bodies.every((body) => body.isBool);
|
|
526
|
+
const isInteger =
|
|
527
|
+
other.integer !== undefined && bodies.every((body) => body.integer !== undefined);
|
|
528
|
+
if (isInteger) {
|
|
529
|
+
const integer = expression.arms.reduceRight(
|
|
545
530
|
(rest, arm, index) =>
|
|
546
|
-
`(ite ${encodeBool(arm.condition, env, mode)} ${
|
|
547
|
-
|
|
531
|
+
`(ite ${encodeBool(encoder, arm.condition, env, clearPolarity(mode))} ${bodies[index].integer} ${rest})`,
|
|
532
|
+
other.integer ?? "",
|
|
548
533
|
);
|
|
549
|
-
return { isBool, text };
|
|
550
|
-
}
|
|
551
|
-
|
|
552
|
-
const
|
|
553
|
-
|
|
554
|
-
(
|
|
555
|
-
|
|
556
|
-
|
|
557
|
-
|
|
558
|
-
|
|
559
|
-
|
|
560
|
-
|
|
561
|
-
|
|
562
|
-
|
|
563
|
-
|
|
564
|
-
|
|
565
|
-
|
|
566
|
-
|
|
567
|
-
|
|
568
|
-
|
|
569
|
-
|
|
570
|
-
|
|
571
|
-
|
|
572
|
-
|
|
573
|
-
env: bound.env,
|
|
574
|
-
mode: bound.mode,
|
|
575
|
-
wrappers: [
|
|
576
|
-
...state.wrappers,
|
|
577
|
-
(body) => `(forall ((${variable} Idv)) ${guard ? `(=> ${guard} ${body})` : body})`,
|
|
578
|
-
],
|
|
579
|
-
};
|
|
580
|
-
}
|
|
581
|
-
case "Fact": {
|
|
582
|
-
const fact =
|
|
583
|
-
hyp.visibility === "Visible"
|
|
584
|
-
? encodeBool(hyp.expression, state.env, invert(state.mode))
|
|
585
|
-
: undefined;
|
|
534
|
+
return { isBool: false, text: `(${CAST_INT} ${integer})`, integer };
|
|
535
|
+
}
|
|
536
|
+
const convert = (term: Term) => (isBool ? term.text : toIdv(term));
|
|
537
|
+
const text = expression.arms.reduceRight(
|
|
538
|
+
(rest, arm, index) =>
|
|
539
|
+
`(ite ${encodeBool(encoder, arm.condition, env, mode)} ${convert(bodies[index])} ${rest})`,
|
|
540
|
+
convert(other),
|
|
541
|
+
);
|
|
542
|
+
return { isBool, text };
|
|
543
|
+
};
|
|
544
|
+
|
|
545
|
+
const encodeSequent = (
|
|
546
|
+
encoder: Encoder,
|
|
547
|
+
sequent: Sequent,
|
|
548
|
+
env: Env | undefined,
|
|
549
|
+
mode: Mode,
|
|
550
|
+
): string => {
|
|
551
|
+
const steps = sequent.context.reduce<NestedContext>(
|
|
552
|
+
(state, hyp) => {
|
|
553
|
+
switch (hyp.kind) {
|
|
554
|
+
case "Fresh": {
|
|
555
|
+
if (hyp.shape > 0) {
|
|
556
|
+
if (!state.mode.isOmitted) throw new TlaUnsupportedError("a second-order ASSUME");
|
|
557
|
+
const variable = getVariable(hyp.name, state.mode.depth);
|
|
586
558
|
return {
|
|
587
|
-
env: push(state.env, { kind: "
|
|
588
|
-
mode: state.mode,
|
|
589
|
-
wrappers:
|
|
590
|
-
? [...state.wrappers, (body) => `(=> ${fact} ${body})`]
|
|
591
|
-
: state.wrappers,
|
|
559
|
+
env: push(state.env, { kind: "operator", symbol: variable, arity: hyp.shape }),
|
|
560
|
+
mode: { ...state.mode, depth: state.mode.depth + 1 },
|
|
561
|
+
wrappers: [...state.wrappers, (body) => `(forall ((${variable} Idv)) ${body})`],
|
|
592
562
|
};
|
|
593
563
|
}
|
|
594
|
-
|
|
595
|
-
throw new TlaUnsupportedError(
|
|
564
|
+
if (hyp.level !== "Constant")
|
|
565
|
+
throw new TlaUnsupportedError("a NEW declaration that isn't constant");
|
|
566
|
+
const domain = hyp.domain && encodeIdv(encoder, hyp.domain, state.env, state.mode);
|
|
567
|
+
const bound = bindVariables([hyp.name], state.env, state.mode);
|
|
568
|
+
const variable = bound.variables[0];
|
|
569
|
+
const guard = domain && `(${MEM} ${variable} ${domain})`;
|
|
570
|
+
return {
|
|
571
|
+
env: bound.env,
|
|
572
|
+
mode: bound.mode,
|
|
573
|
+
wrappers: [
|
|
574
|
+
...state.wrappers,
|
|
575
|
+
(body) => `(forall ((${variable} Idv)) ${guard ? `(=> ${guard} ${body})` : body})`,
|
|
576
|
+
],
|
|
577
|
+
};
|
|
596
578
|
}
|
|
597
|
-
|
|
598
|
-
|
|
599
|
-
|
|
600
|
-
|
|
601
|
-
|
|
602
|
-
|
|
603
|
-
|
|
604
|
-
|
|
605
|
-
|
|
606
|
-
|
|
607
|
-
switch (expression.kind) {
|
|
608
|
-
case "Ix":
|
|
609
|
-
return encodeReference(getBinding(env, expression.index), [], env, mode);
|
|
610
|
-
case "Internal":
|
|
611
|
-
switch (expression.builtin) {
|
|
612
|
-
case "TRUE":
|
|
613
|
-
return bool("true");
|
|
614
|
-
case "FALSE":
|
|
615
|
-
return bool("false");
|
|
616
|
-
case "BOOLEAN":
|
|
617
|
-
return idv(BOOL_SET);
|
|
618
|
-
case "STRING":
|
|
619
|
-
return idv(STR_SET);
|
|
620
|
-
case "Nat":
|
|
621
|
-
return idv(NAT_SET);
|
|
622
|
-
case "Int":
|
|
623
|
-
return idv(INT_SET);
|
|
624
|
-
default:
|
|
625
|
-
throw new TlaUnsupportedError(`the operator ${expression.builtin}`);
|
|
579
|
+
case "Fact": {
|
|
580
|
+
const fact =
|
|
581
|
+
hyp.visibility === "Visible"
|
|
582
|
+
? encodeBool(encoder, hyp.expression, state.env, invert(state.mode))
|
|
583
|
+
: undefined;
|
|
584
|
+
return {
|
|
585
|
+
env: push(state.env, { kind: "unsupported", reason: "a reference to a fact" }),
|
|
586
|
+
mode: state.mode,
|
|
587
|
+
wrappers: fact ? [...state.wrappers, (body) => `(=> ${fact} ${body})`] : state.wrappers,
|
|
588
|
+
};
|
|
626
589
|
}
|
|
627
|
-
|
|
628
|
-
|
|
629
|
-
if (operator.kind === "Internal")
|
|
630
|
-
return encodeBuiltin(operator.builtin, expression.args, env, mode);
|
|
631
|
-
if (operator.kind === "Ix")
|
|
632
|
-
return encodeReference(getBinding(env, operator.index), expression.args, env, mode);
|
|
633
|
-
if (operator.kind === "Opaque")
|
|
634
|
-
return encodeOpaque(operator.name, expression.args, env, mode);
|
|
635
|
-
if (operator.kind === "Lambda")
|
|
636
|
-
return encode(normalizeApply(operator, expression.args), env, mode);
|
|
637
|
-
throw new TlaUnsupportedError(`an application of ${operator.kind}`);
|
|
638
|
-
}
|
|
639
|
-
case "Sequent":
|
|
640
|
-
return bool(encodeSequent(expression.sequent, env, mode));
|
|
641
|
-
case "With":
|
|
642
|
-
case "Parens":
|
|
643
|
-
return encode(expression.expression, env, mode);
|
|
644
|
-
case "If": {
|
|
645
|
-
const condition = encodeBool(expression.condition, env, mode);
|
|
646
|
-
const consequent = encode(expression.consequent, env, mode);
|
|
647
|
-
const alternative = encode(expression.alternative, env, mode);
|
|
648
|
-
if (consequent.integer !== undefined && alternative.integer !== undefined) {
|
|
649
|
-
const integer = `(ite ${resolveTriggers(condition, true)} ${consequent.integer} ${alternative.integer})`;
|
|
650
|
-
return { isBool: false, text: `(${CAST_INT} ${integer})`, integer };
|
|
651
|
-
}
|
|
652
|
-
return consequent.isBool && alternative.isBool
|
|
653
|
-
? bool(`(ite ${condition} ${consequent.text} ${alternative.text})`)
|
|
654
|
-
: idv(`(ite ${condition} ${toIdv(consequent)} ${toIdv(alternative)})`);
|
|
655
|
-
}
|
|
656
|
-
case "List": {
|
|
657
|
-
const items = expression.items.map((item) => encodeBool(item, env, mode));
|
|
658
|
-
return bool(expression.bullet === "Or" ? disjoin(items) : conjoin(items));
|
|
590
|
+
default:
|
|
591
|
+
throw new TlaUnsupportedError(`a ${hyp.kind} in a nested ASSUME`);
|
|
659
592
|
}
|
|
660
|
-
|
|
661
|
-
|
|
662
|
-
|
|
663
|
-
|
|
664
|
-
|
|
665
|
-
|
|
666
|
-
|
|
667
|
-
|
|
668
|
-
|
|
669
|
-
|
|
670
|
-
|
|
671
|
-
|
|
672
|
-
|
|
673
|
-
|
|
674
|
-
|
|
675
|
-
|
|
676
|
-
|
|
677
|
-
|
|
678
|
-
|
|
679
|
-
|
|
680
|
-
|
|
681
|
-
|
|
682
|
-
)
|
|
683
|
-
|
|
684
|
-
|
|
685
|
-
|
|
686
|
-
|
|
687
|
-
|
|
688
|
-
|
|
689
|
-
),
|
|
690
|
-
);
|
|
691
|
-
case "Fcn":
|
|
692
|
-
return encodeFunction(expression, env, mode);
|
|
693
|
-
// Rewrite.elim_multiarg: f[a, b] applies f to the tuple <<a, b>>.
|
|
694
|
-
case "FcnApp": {
|
|
695
|
-
const encodedFunction = encodeIdv(expression.function, env, mode);
|
|
696
|
-
const args = expression.args.map((arg) => encodeIdv(arg, env, mode));
|
|
697
|
-
const argument = args.length === 1 ? args[0] : call(tla(`Tuple_${args.length}`), args);
|
|
698
|
-
return idv(`(${FUN_APP} ${encodedFunction} ${argument})`);
|
|
593
|
+
},
|
|
594
|
+
{ env, mode, wrappers: [] },
|
|
595
|
+
);
|
|
596
|
+
return steps.wrappers.reduceRight(
|
|
597
|
+
(body, wrap) => wrap(body),
|
|
598
|
+
encodeBool(encoder, sequent.active, steps.env, steps.mode),
|
|
599
|
+
);
|
|
600
|
+
};
|
|
601
|
+
|
|
602
|
+
const encode = (encoder: Encoder, expression: Expr, env: Env | undefined, mode: Mode): Term => {
|
|
603
|
+
switch (expression.kind) {
|
|
604
|
+
case "Ix":
|
|
605
|
+
return encodeReference(encoder, getBinding(env, expression.index), [], env, mode);
|
|
606
|
+
case "Internal":
|
|
607
|
+
switch (expression.builtin) {
|
|
608
|
+
case "TRUE":
|
|
609
|
+
return wrapBool("true");
|
|
610
|
+
case "FALSE":
|
|
611
|
+
return wrapBool("false");
|
|
612
|
+
case "BOOLEAN":
|
|
613
|
+
return wrapIdv(BOOL_SET);
|
|
614
|
+
case "STRING":
|
|
615
|
+
return wrapIdv(STR_SET);
|
|
616
|
+
case "Nat":
|
|
617
|
+
return wrapIdv(NAT_SET);
|
|
618
|
+
case "Int":
|
|
619
|
+
return wrapIdv(INT_SET);
|
|
620
|
+
default:
|
|
621
|
+
throw new TlaUnsupportedError(`the operator ${expression.builtin}`);
|
|
699
622
|
}
|
|
700
|
-
|
|
701
|
-
|
|
702
|
-
|
|
703
|
-
|
|
704
|
-
|
|
705
|
-
|
|
706
|
-
|
|
707
|
-
|
|
708
|
-
|
|
709
|
-
|
|
710
|
-
|
|
711
|
-
recordFields.set(`Record_${suffix}`, names);
|
|
712
|
-
recordFields.set(`RecordSet_${suffix}`, names);
|
|
713
|
-
return idv(
|
|
714
|
-
call(
|
|
715
|
-
tla(`${expression.kind === "Record" ? "Record" : "RecordSet"}_${suffix}`),
|
|
716
|
-
expression.fields.map((field) => encodeIdv(field.value, env, mode)),
|
|
717
|
-
),
|
|
623
|
+
case "Apply": {
|
|
624
|
+
const operator = expression.operator;
|
|
625
|
+
if (operator.kind === "Internal")
|
|
626
|
+
return encodeBuiltin(encoder, operator.builtin, expression.args, env, mode);
|
|
627
|
+
if (operator.kind === "Ix")
|
|
628
|
+
return encodeReference(
|
|
629
|
+
encoder,
|
|
630
|
+
getBinding(env, operator.index),
|
|
631
|
+
expression.args,
|
|
632
|
+
env,
|
|
633
|
+
mode,
|
|
718
634
|
);
|
|
635
|
+
if (operator.kind === "Opaque")
|
|
636
|
+
return encodeOpaque(encoder, operator.name, expression.args, env, mode);
|
|
637
|
+
if (operator.kind === "Lambda")
|
|
638
|
+
return encode(encoder, normalizeApply(operator, expression.args), env, mode);
|
|
639
|
+
throw new TlaUnsupportedError(`an application of ${operator.kind}`);
|
|
640
|
+
}
|
|
641
|
+
case "Sequent":
|
|
642
|
+
return wrapBool(encodeSequent(encoder, expression.sequent, env, mode));
|
|
643
|
+
case "With":
|
|
644
|
+
case "Parens":
|
|
645
|
+
return encode(encoder, expression.expression, env, mode);
|
|
646
|
+
case "If": {
|
|
647
|
+
const condition = encodeBool(encoder, expression.condition, env, mode);
|
|
648
|
+
const consequent = encode(encoder, expression.consequent, env, mode);
|
|
649
|
+
const alternative = encode(encoder, expression.alternative, env, mode);
|
|
650
|
+
if (consequent.integer !== undefined && alternative.integer !== undefined) {
|
|
651
|
+
const integer = `(ite ${resolveTriggers(condition, true)} ${consequent.integer} ${alternative.integer})`;
|
|
652
|
+
return { isBool: false, text: `(${CAST_INT} ${integer})`, integer };
|
|
719
653
|
}
|
|
720
|
-
|
|
721
|
-
|
|
722
|
-
|
|
723
|
-
|
|
724
|
-
|
|
725
|
-
|
|
726
|
-
|
|
727
|
-
return encodeCase(expression, env, mode);
|
|
728
|
-
case "String":
|
|
729
|
-
return idv(tla(`StrLit_${expression.value}`));
|
|
730
|
-
case "Num":
|
|
731
|
-
if (expression.fraction !== "") throw new TlaUnsupportedError("a real number");
|
|
732
|
-
return {
|
|
733
|
-
isBool: false,
|
|
734
|
-
text: `(${CAST_INT} ${BigInt(expression.integer)})`,
|
|
735
|
-
integer: String(BigInt(expression.integer)),
|
|
736
|
-
};
|
|
737
|
-
case "At":
|
|
738
|
-
if (mode.at === undefined) throw new TlaUnsupportedError("@ outside EXCEPT");
|
|
739
|
-
return idv(mode.at);
|
|
740
|
-
case "Tquant":
|
|
741
|
-
case "Tsub":
|
|
742
|
-
case "Fair":
|
|
743
|
-
throw new TlaUnsupportedError("a temporal formula");
|
|
744
|
-
default:
|
|
745
|
-
throw new TlaUnsupportedError(`the expression ${expression.kind}`);
|
|
654
|
+
return consequent.isBool && alternative.isBool
|
|
655
|
+
? wrapBool(`(ite ${condition} ${consequent.text} ${alternative.text})`)
|
|
656
|
+
: wrapIdv(`(ite ${condition} ${toIdv(consequent)} ${toIdv(alternative)})`);
|
|
657
|
+
}
|
|
658
|
+
case "List": {
|
|
659
|
+
const items = expression.items.map((item) => encodeBool(encoder, item, env, mode));
|
|
660
|
+
return wrapBool(expression.bullet === "Or" ? disjoin(items) : conjoin(items));
|
|
746
661
|
}
|
|
747
|
-
|
|
748
|
-
|
|
749
|
-
|
|
750
|
-
|
|
751
|
-
|
|
752
|
-
|
|
753
|
-
|
|
754
|
-
|
|
755
|
-
|
|
756
|
-
|
|
757
|
-
|
|
758
|
-
|
|
759
|
-
|
|
760
|
-
|
|
761
|
-
|
|
762
|
-
|
|
763
|
-
|
|
764
|
-
|
|
765
|
-
|
|
662
|
+
case "Opaque":
|
|
663
|
+
return encodeOpaque(encoder, expression.name, [], env, mode);
|
|
664
|
+
case "Quant":
|
|
665
|
+
return wrapBool(encodeQuantifier(encoder, expression, env, mode));
|
|
666
|
+
case "Choose":
|
|
667
|
+
return encodeChoose(encoder, expression, env, mode);
|
|
668
|
+
case "SetSt":
|
|
669
|
+
return encodeSetSt(encoder, expression, env, mode);
|
|
670
|
+
case "SetOf":
|
|
671
|
+
return encodeSetOf(encoder, expression, env, mode);
|
|
672
|
+
case "SetEnum":
|
|
673
|
+
return wrapIdv(
|
|
674
|
+
call(
|
|
675
|
+
tla(`SetEnum_${expression.elements.length}`),
|
|
676
|
+
expression.elements.map((element) => encodeIdv(encoder, element, env, mode)),
|
|
677
|
+
),
|
|
678
|
+
);
|
|
679
|
+
case "Product":
|
|
680
|
+
return wrapIdv(
|
|
681
|
+
call(
|
|
682
|
+
tla(`Product_${expression.factors.length}`),
|
|
683
|
+
expression.factors.map((factor) => encodeIdv(encoder, factor, env, mode)),
|
|
684
|
+
),
|
|
685
|
+
);
|
|
686
|
+
case "Tuple":
|
|
687
|
+
return wrapIdv(
|
|
688
|
+
call(
|
|
689
|
+
tla(`Tuple_${expression.elements.length}`),
|
|
690
|
+
expression.elements.map((element) => encodeIdv(encoder, element, env, mode)),
|
|
691
|
+
),
|
|
692
|
+
);
|
|
693
|
+
case "Fcn":
|
|
694
|
+
return encodeFunction(encoder, expression, env, mode);
|
|
695
|
+
case "FcnApp": {
|
|
696
|
+
const encodedFunction = encodeIdv(encoder, expression.function, env, mode);
|
|
697
|
+
const args = expression.args.map((arg) => encodeIdv(encoder, arg, env, mode));
|
|
698
|
+
const argument = args.length === 1 ? args[0] : call(tla(`Tuple_${args.length}`), args);
|
|
699
|
+
return wrapIdv(`(${FUN_APP} ${encodedFunction} ${argument})`);
|
|
700
|
+
}
|
|
701
|
+
case "Arrow":
|
|
702
|
+
return wrapIdv(
|
|
703
|
+
call(FUN_SET, [
|
|
704
|
+
encodeIdv(encoder, expression.domain, env, mode),
|
|
705
|
+
encodeIdv(encoder, expression.range, env, mode),
|
|
706
|
+
]),
|
|
707
|
+
);
|
|
708
|
+
case "Record":
|
|
709
|
+
case "Rect": {
|
|
710
|
+
const names = expression.fields.map((field) => field.name);
|
|
711
|
+
const suffix = names.join("_");
|
|
712
|
+
encoder.recordFields.set(`Record_${suffix}`, names);
|
|
713
|
+
encoder.recordFields.set(`RecordSet_${suffix}`, names);
|
|
714
|
+
return wrapIdv(
|
|
715
|
+
call(
|
|
716
|
+
tla(`${expression.kind === "Record" ? "Record" : "RecordSet"}_${suffix}`),
|
|
717
|
+
expression.fields.map((field) => encodeIdv(encoder, field.value, env, mode)),
|
|
718
|
+
),
|
|
719
|
+
);
|
|
720
|
+
}
|
|
721
|
+
case "Except":
|
|
722
|
+
return wrapIdv(encodeExcept(encoder, expression, env, mode));
|
|
723
|
+
case "Dot":
|
|
724
|
+
return wrapIdv(
|
|
725
|
+
`(${FUN_APP} ${encodeIdv(encoder, expression.expression, env, mode)} ${tla(`StrLit_${expression.field}`)})`,
|
|
726
|
+
);
|
|
727
|
+
case "Case":
|
|
728
|
+
return encodeCase(encoder, expression, env, mode);
|
|
729
|
+
case "String":
|
|
730
|
+
return wrapIdv(tla(`StrLit_${expression.value}`));
|
|
731
|
+
case "Num":
|
|
732
|
+
if (expression.fraction !== "") throw new TlaUnsupportedError("a real number");
|
|
733
|
+
return {
|
|
734
|
+
isBool: false,
|
|
735
|
+
text: `(${CAST_INT} ${BigInt(expression.integer)})`,
|
|
736
|
+
integer: String(BigInt(expression.integer)),
|
|
737
|
+
};
|
|
738
|
+
case "At":
|
|
739
|
+
if (mode.at === undefined) throw new TlaUnsupportedError("@ outside EXCEPT");
|
|
740
|
+
return wrapIdv(mode.at);
|
|
741
|
+
case "Tquant":
|
|
742
|
+
case "Tsub":
|
|
743
|
+
case "Fair":
|
|
744
|
+
throw new TlaUnsupportedError("a temporal formula");
|
|
745
|
+
default:
|
|
746
|
+
throw new TlaUnsupportedError(`the expression ${expression.kind}`);
|
|
747
|
+
}
|
|
766
748
|
};
|
|
749
|
+
|
|
750
|
+
export const getEntries = (encoder: Encoder, line: string): Entry[] => [
|
|
751
|
+
...encoder.flattener.takeIntroduced(),
|
|
752
|
+
removeUnprimable(resolveTriggers(line, false)),
|
|
753
|
+
];
|
|
754
|
+
|
|
755
|
+
export const createEncoder = (session: EncodingSession): Encoder => ({
|
|
756
|
+
session,
|
|
757
|
+
flattener: createFlattener(),
|
|
758
|
+
anonymous: new Map(),
|
|
759
|
+
recordFields: new Map(),
|
|
760
|
+
context: createContext(),
|
|
761
|
+
declared: new Map(),
|
|
762
|
+
});
|