tla-ts 0.0.3 → 0.0.4-dev.2a873ee
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 +46 -115
- package/dist/cli.cjs +1 -1
- package/dist/cli.js +1 -1
- package/dist/deciders.cjs +366 -0
- package/dist/deciders.js +366 -0
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +194 -8
- package/dist/index.d.ts +194 -8
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -4
- package/dist/parallel-worker.js +1 -4
- package/dist/prove-worker.cjs +9 -0
- package/dist/prove-worker.d.cts +9 -0
- package/dist/prove-worker.d.ts +9 -0
- package/dist/prove-worker.js +9 -0
- package/dist/prove.cjs +996 -0
- package/dist/prove.js +996 -0
- package/dist/run-cli.cjs +37 -20
- package/dist/run-cli.js +37 -20
- package/dist/tlapm.cjs +10 -0
- package/dist/tlapm.js +10 -0
- package/dist/transfer.cjs +1387 -18
- package/dist/transfer.js +1387 -18
- package/dist/worker.cjs +21 -0
- package/dist/worker.js +21 -0
- package/package.json +24 -11
- package/src/ast.ts +149 -8
- package/src/bags.ts +4 -7
- package/src/builtins.ts +29 -11
- package/src/bundled-modules.ts +3 -3
- package/src/canonical.ts +4 -3
- package/src/check.ts +1540 -235
- package/src/cli-options.ts +12 -6
- package/src/cli.ts +8 -1
- package/src/codegen.ts +98 -39
- package/src/config.ts +254 -181
- package/src/dependencies.ts +2 -2
- package/src/environment.ts +540 -140
- package/src/errors.ts +284 -4
- package/src/evaluate.ts +1043 -293
- package/src/exit-codes.ts +22 -43
- package/src/fingerprints.ts +46 -11
- package/src/index.ts +11 -0
- package/src/instances.ts +19 -16
- package/src/java-overrides.ts +104 -25
- package/src/levels.ts +191 -45
- package/src/lexer.ts +127 -30
- package/src/live-check.ts +867 -0
- package/src/liveness.ts +218 -572
- package/src/{obligation-action.ts → obligations/action.ts} +247 -69
- package/src/{obligation-anon.ts → obligations/anon.ts} +49 -47
- package/src/obligations/ctx.ts +64 -0
- package/src/{obligation-deref.ts → obligations/deref.ts} +51 -92
- package/src/{obligation-expression.ts → obligations/expression.ts} +117 -57
- package/src/{obligation-format.ts → obligations/format.ts} +7 -8
- package/src/{obligation-generate.ts → obligations/generate.ts} +170 -192
- package/src/{obligations.ts → obligations/index.ts} +32 -16
- package/src/{obligation-levels.ts → obligations/levels.ts} +26 -28
- package/src/{obligation-module.ts → obligations/module.ts} +113 -121
- package/src/obligations/pickle.ts +98 -0
- package/src/obligations/pragma.ts +189 -0
- package/src/{obligation-printer.ts → obligations/printer.ts} +22 -80
- package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
- package/src/{obligation-source.ts → obligations/source.ts} +156 -99
- package/src/obligations/temporal.ts +321 -0
- package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
- package/src/ocaml-marshal.ts +166 -0
- package/src/parallel-worker.ts +169 -224
- package/src/parallel.ts +140 -81
- package/src/parser.ts +456 -147
- package/src/pcal-ast.ts +770 -0
- package/src/pcal-parse.ts +1523 -0
- package/src/pcal-tokenize.ts +516 -0
- package/src/pcal-translate.ts +1230 -0
- package/src/pcal-validate.ts +454 -0
- package/src/prove/decide-pool.ts +95 -0
- package/src/prove/deciders.ts +33 -0
- package/src/prove/first-order.ts +78 -0
- package/src/prove/isabelle/LICENSE +36 -0
- package/src/prove/isabelle/LICENSE-tlapm +26 -0
- package/src/prove/isabelle/decide.ts +47 -0
- package/src/prove/isabelle/encode.ts +446 -0
- package/src/prove/isabelle/isar/inner-syntax.ts +579 -0
- package/src/prove/isabelle/isar/method.ts +367 -0
- package/src/prove/isabelle/isar/proof.ts +28 -0
- package/src/prove/isabelle/isar/statement.ts +57 -0
- package/src/prove/isabelle/isar/theory.ts +192 -0
- package/src/prove/isabelle/isar/type-check.ts +278 -0
- package/src/prove/isabelle/provers/blast/blast.ts +258 -0
- package/src/prove/isabelle/provers/blast/branch.ts +322 -0
- package/src/prove/isabelle/provers/blast/prove.ts +347 -0
- package/src/prove/isabelle/provers/blast/rules.ts +330 -0
- package/src/prove/isabelle/provers/blast/state.ts +180 -0
- package/src/prove/isabelle/provers/blast/term.ts +546 -0
- package/src/prove/isabelle/provers/clasimp.ts +150 -0
- package/src/prove/isabelle/provers/classical.ts +389 -0
- package/src/prove/isabelle/provers/hypsubst.ts +433 -0
- package/src/prove/isabelle/pure/bicompose.ts +174 -0
- package/src/prove/isabelle/pure/consts.ts +32 -0
- package/src/prove/isabelle/pure/conv.ts +79 -0
- package/src/prove/isabelle/pure/drule.ts +264 -0
- package/src/prove/isabelle/pure/envir.ts +331 -0
- package/src/prove/isabelle/pure/goal.ts +53 -0
- package/src/prove/isabelle/pure/interrupt.ts +16 -0
- package/src/prove/isabelle/pure/list.ts +12 -0
- package/src/prove/isabelle/pure/logic.ts +330 -0
- package/src/prove/isabelle/pure/name.ts +98 -0
- package/src/prove/isabelle/pure/net.ts +215 -0
- package/src/prove/isabelle/pure/object-logic.ts +41 -0
- package/src/prove/isabelle/pure/pattern.ts +631 -0
- package/src/prove/isabelle/pure/raw-simplifier.ts +338 -0
- package/src/prove/isabelle/pure/rewriter.ts +602 -0
- package/src/prove/isabelle/pure/search.ts +68 -0
- package/src/prove/isabelle/pure/seq.ts +133 -0
- package/src/prove/isabelle/pure/simplifier.ts +106 -0
- package/src/prove/isabelle/pure/table.ts +201 -0
- package/src/prove/isabelle/pure/tactic.ts +168 -0
- package/src/prove/isabelle/pure/tactical.ts +264 -0
- package/src/prove/isabelle/pure/term-ord.ts +105 -0
- package/src/prove/isabelle/pure/term.ts +688 -0
- package/src/prove/isabelle/pure/thm.ts +783 -0
- package/src/prove/isabelle/pure/type.ts +121 -0
- package/src/prove/isabelle/pure/unify.ts +753 -0
- package/src/prove/isabelle/pure/variable.ts +25 -0
- package/src/prove/isabelle/tla/classical-setup.ts +101 -0
- package/src/prove/isabelle/tla/context.ts +74 -0
- package/src/prove/isabelle/tla/logic-data.ts +5 -0
- package/src/prove/isabelle/tla/logic.ts +215 -0
- package/src/prove/isabelle/tla/simpdata.ts +241 -0
- package/src/prove/isabelle/tools/intuitionistic.ts +132 -0
- package/src/prove/ocaml.ts +22 -0
- package/src/prove/prep/action.ts +508 -0
- package/src/prove/prep/defs.ts +33 -0
- package/src/prove/prep/elab.ts +156 -0
- package/src/prove/prep/enabled-axioms.ts +189 -0
- package/src/prove/prep/enabled.ts +43 -0
- package/src/prove/prep/fingerprint.ts +388 -0
- package/src/prove/prep/flatten.ts +70 -0
- package/src/prove/prep/level-comparison.ts +529 -0
- package/src/prove/prep/md5.ts +67 -0
- package/src/prove/prep/pragma.ts +221 -0
- package/src/prove/prep/trivial.ts +22 -0
- package/src/prove/prove-worker.ts +22 -0
- package/src/prove/prove.ts +498 -0
- package/src/prove/ptl/decide.ts +68 -0
- package/src/prove/ptl/encode.ts +255 -0
- package/src/prove/ptl/sat.ts +151 -0
- package/src/prove/ptl/tableau.ts +276 -0
- package/src/prove/smt/axiomatize.ts +69 -0
- package/src/prove/smt/axioms.ts +209 -0
- package/src/prove/smt/context.ts +108 -0
- package/src/prove/smt/data.ts +636 -0
- package/src/prove/smt/encode.ts +164 -0
- package/src/prove/smt/extensionality.ts +65 -0
- package/src/prove/smt/flatten.ts +112 -0
- package/src/prove/smt/format.ts +154 -0
- package/src/prove/smt/instances.ts +181 -0
- package/src/prove/smt/rewrite.ts +772 -0
- package/src/prove/smt/simplify.ts +57 -0
- package/src/prove/smt/solver/act-cache.ts +265 -0
- package/src/prove/smt/solver/arith-rewriter.ts +962 -0
- package/src/prove/smt/solver/array.ts +22 -0
- package/src/prove/smt/solver/asserted-formulas.ts +469 -0
- package/src/prove/smt/solver/ast-lt.ts +157 -0
- package/src/prove/smt/solver/ast-util.ts +91 -0
- package/src/prove/smt/solver/ast.ts +1315 -0
- package/src/prove/smt/solver/auf-solver.ts +572 -0
- package/src/prove/smt/solver/case-split-queue.ts +178 -0
- package/src/prove/smt/solver/cg-table.ts +175 -0
- package/src/prove/smt/solver/clause.ts +276 -0
- package/src/prove/smt/solver/conflict-resolution.ts +343 -0
- package/src/prove/smt/solver/context.ts +1292 -0
- package/src/prove/smt/solver/ctx-simplify.ts +334 -0
- package/src/prove/smt/solver/der.ts +224 -0
- package/src/prove/smt/solver/dyn-ack.ts +141 -0
- package/src/prove/smt/solver/e-matching.ts +659 -0
- package/src/prove/smt/solver/enode.ts +259 -0
- package/src/prove/smt/solver/expr-ref.ts +21 -0
- package/src/prove/smt/solver/expr-safe-replace.ts +172 -0
- package/src/prove/smt/solver/fingerprints.ts +92 -0
- package/src/prove/smt/solver/flat-literals.ts +51 -0
- package/src/prove/smt/solver/goal.ts +138 -0
- package/src/prove/smt/solver/hash.ts +173 -0
- package/src/prove/smt/solver/hashtable.ts +166 -0
- package/src/prove/smt/solver/internalizer.ts +1381 -0
- package/src/prove/smt/solver/lbool.ts +5 -0
- package/src/prove/smt/solver/literal.ts +24 -0
- package/src/prove/smt/solver/lp/bound-propagator.ts +391 -0
- package/src/prove/smt/solver/lp/constraints.ts +78 -0
- package/src/prove/smt/solver/lp/containers.ts +296 -0
- package/src/prove/smt/solver/lp/core-solver.ts +504 -0
- package/src/prove/smt/solver/lp/cross-nested.ts +224 -0
- package/src/prove/smt/solver/lp/dep-intervals.ts +642 -0
- package/src/prove/smt/solver/lp/dependency.ts +51 -0
- package/src/prove/smt/solver/lp/dioph-eq.ts +1181 -0
- package/src/prove/smt/solver/lp/explanation.ts +46 -0
- package/src/prove/smt/solver/lp/gomory.ts +255 -0
- package/src/prove/smt/solver/lp/hnf-cutter.ts +125 -0
- package/src/prove/smt/solver/lp/hnf.ts +281 -0
- package/src/prove/smt/solver/lp/int-cube.ts +295 -0
- package/src/prove/smt/solver/lp/int-solver.ts +514 -0
- package/src/prove/smt/solver/lp/lar-solver.ts +816 -0
- package/src/prove/smt/solver/lp/lar-term.ts +62 -0
- package/src/prove/smt/solver/lp/lp-settings.ts +91 -0
- package/src/prove/smt/solver/lp/maximize-term.ts +347 -0
- package/src/prove/smt/solver/lp/nex-creator.ts +381 -0
- package/src/prove/smt/solver/lp/nex.ts +120 -0
- package/src/prove/smt/solver/lp/nla-backoff.ts +43 -0
- package/src/prove/smt/solver/lp/nla-basics.ts +398 -0
- package/src/prove/smt/solver/lp/nla-core.ts +968 -0
- package/src/prove/smt/solver/lp/nla-divisions.ts +332 -0
- package/src/prove/smt/solver/lp/nla-emonics.ts +373 -0
- package/src/prove/smt/solver/lp/nla-factorization.ts +30 -0
- package/src/prove/smt/solver/lp/nla-grobner.ts +904 -0
- package/src/prove/smt/solver/lp/nla-horner.ts +126 -0
- package/src/prove/smt/solver/lp/nla-intervals.ts +265 -0
- package/src/prove/smt/solver/lp/nla-monomial-bounds.ts +715 -0
- package/src/prove/smt/solver/lp/nla-monotone.ts +59 -0
- package/src/prove/smt/solver/lp/nla-order.ts +307 -0
- package/src/prove/smt/solver/lp/nla-patcher.ts +112 -0
- package/src/prove/smt/solver/lp/nla-tangents.ts +251 -0
- package/src/prove/smt/solver/lp/nla-throttle.ts +85 -0
- package/src/prove/smt/solver/lp/nla-types.ts +124 -0
- package/src/prove/smt/solver/lp/nla-var-eqs.ts +141 -0
- package/src/prove/smt/solver/lp/nra-solver.ts +440 -0
- package/src/prove/smt/solver/lp/numeric-pair.ts +65 -0
- package/src/prove/smt/solver/lp/pdd-interval.ts +31 -0
- package/src/prove/smt/solver/lp/pdd-simplifier.ts +184 -0
- package/src/prove/smt/solver/lp/pdd-solver.ts +408 -0
- package/src/prove/smt/solver/lp/pdd.ts +971 -0
- package/src/prove/smt/solver/lp/random-updater.ts +138 -0
- package/src/prove/smt/solver/lp/static-matrix.ts +246 -0
- package/src/prove/smt/solver/lp/union-find.ts +96 -0
- package/src/prove/smt/solver/mam-compiler.ts +847 -0
- package/src/prove/smt/solver/mam-interpreter.ts +400 -0
- package/src/prove/smt/solver/maximize-ac-sharing.ts +118 -0
- package/src/prove/smt/solver/model-checker.ts +347 -0
- package/src/prove/smt/solver/model-evaluator.ts +262 -0
- package/src/prove/smt/solver/model-finder.ts +155 -0
- package/src/prove/smt/solver/model-generator.ts +97 -0
- package/src/prove/smt/solver/model-macro-solver.ts +728 -0
- package/src/prove/smt/solver/nlsat/algebraic.ts +1161 -0
- package/src/prove/smt/solver/nlsat/atoms.ts +238 -0
- package/src/prove/smt/solver/nlsat/evaluator.ts +303 -0
- package/src/prove/smt/solver/nlsat/explain.ts +607 -0
- package/src/prove/smt/solver/nlsat/interval-set.ts +351 -0
- package/src/prove/smt/solver/nlsat/levelwise.ts +737 -0
- package/src/prove/smt/solver/nlsat/mpbq.ts +161 -0
- package/src/prove/smt/solver/nlsat/polynomial.ts +1722 -0
- package/src/prove/smt/solver/nlsat/solver.ts +911 -0
- package/src/prove/smt/solver/nlsat/types.ts +43 -0
- package/src/prove/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
- package/src/prove/smt/solver/nlsat/upolynomial.ts +996 -0
- package/src/prove/smt/solver/nnf.ts +469 -0
- package/src/prove/smt/solver/pattern-inference.ts +351 -0
- package/src/prove/smt/solver/poly-rewriter.ts +477 -0
- package/src/prove/smt/solver/propagate-values.ts +83 -0
- package/src/prove/smt/solver/proto-model.ts +551 -0
- package/src/prove/smt/solver/pull-quant.ts +139 -0
- package/src/prove/smt/solver/qe-lite-der.ts +526 -0
- package/src/prove/smt/solver/qe-lite-fm.ts +576 -0
- package/src/prove/smt/solver/qe-lite.ts +381 -0
- package/src/prove/smt/solver/qi-queue.ts +362 -0
- package/src/prove/smt/solver/quant-tactics.ts +117 -0
- package/src/prove/smt/solver/quantifier-analyzer.ts +562 -0
- package/src/prove/smt/solver/quantifier-manager.ts +186 -0
- package/src/prove/smt/solver/random-gen.ts +10 -0
- package/src/prove/smt/solver/rational.ts +165 -0
- package/src/prove/smt/solver/ref-vector.ts +62 -0
- package/src/prove/smt/solver/relevancy.ts +247 -0
- package/src/prove/smt/solver/rewriter-tpl.ts +1159 -0
- package/src/prove/smt/solver/rewriter.ts +843 -0
- package/src/prove/smt/solver/rlimit.ts +79 -0
- package/src/prove/smt/solver/smtlib-parser.ts +526 -0
- package/src/prove/smt/solver/solver.ts +71 -0
- package/src/prove/smt/solver/sort.ts +35 -0
- package/src/prove/smt/solver/sticky-generations.ts +69 -0
- package/src/prove/smt/solver/theory-lra-axioms.ts +340 -0
- package/src/prove/smt/solver/theory-lra-bounds.ts +226 -0
- package/src/prove/smt/solver/theory-lra-final-check.ts +252 -0
- package/src/prove/smt/solver/theory-lra-internalize.ts +476 -0
- package/src/prove/smt/solver/theory-lra-model.ts +243 -0
- package/src/prove/smt/solver/theory-lra-propagate.ts +405 -0
- package/src/prove/smt/solver/theory-lra-state.ts +43 -0
- package/src/prove/smt/solver/theory-lra.ts +56 -0
- package/src/prove/smt/solver/var-subst.ts +258 -0
- package/src/prove/smt/solver/z3-license.txt +10 -0
- package/src/prove/smt/table.ts +170 -0
- package/src/prove/tlapm/tlapm.ts +96 -0
- package/src/prove/tlaps-module.ts +510 -0
- package/src/prove/verdict.ts +18 -0
- package/src/prove/zenon/LICENSE +32 -0
- package/src/prove/zenon/check/check.ts +105 -0
- package/src/prove/zenon/check/definitions.ts +144 -0
- package/src/prove/zenon/check/equality.ts +182 -0
- package/src/prove/zenon/check/functions.ts +62 -0
- package/src/prove/zenon/check/keys.ts +125 -0
- package/src/prove/zenon/check/propositional.ts +104 -0
- package/src/prove/zenon/check/records.ts +188 -0
- package/src/prove/zenon/check/relations.ts +121 -0
- package/src/prove/zenon/check/rewrites.ts +224 -0
- package/src/prove/zenon/check/sets.ts +302 -0
- package/src/prove/zenon/check/terms.ts +127 -0
- package/src/prove/zenon/check/tla.ts +126 -0
- package/src/prove/zenon/decide.ts +113 -0
- package/src/prove/zenon/encode.ts +379 -0
- package/src/prove/zenon/eqrel.ts +300 -0
- package/src/prove/zenon/equality-rules.ts +435 -0
- package/src/prove/zenon/expr.ts +551 -0
- package/src/prove/zenon/index-table.ts +350 -0
- package/src/prove/zenon/isar-case.ts +513 -0
- package/src/prove/zenon/isar.ts +1249 -0
- package/src/prove/zenon/limits.ts +15 -0
- package/src/prove/zenon/llproof.ts +173 -0
- package/src/prove/zenon/mltoll.ts +1566 -0
- package/src/prove/zenon/node.ts +297 -0
- package/src/prove/zenon/ocaml.ts +169 -0
- package/src/prove/zenon/parse.ts +247 -0
- package/src/prove/zenon/phrase.ts +191 -0
- package/src/prove/zenon/proof.ts +198 -0
- package/src/prove/zenon/propositional-rules.ts +387 -0
- package/src/prove/zenon/rules.ts +94 -0
- package/src/prove/zenon/search.ts +288 -0
- package/src/prove/zenon/tla/functions.ts +151 -0
- package/src/prove/zenon/tla/llproof.ts +480 -0
- package/src/prove/zenon/tla/records.ts +225 -0
- package/src/prove/zenon/tla/rewrites.ts +447 -0
- package/src/prove/zenon/tla/sets.ts +304 -0
- package/src/prove/zenon/tla/terms.ts +162 -0
- package/src/prove/zenon/tla/tla.ts +506 -0
- package/src/randomization.ts +24 -7
- package/src/resolve.ts +1481 -426
- package/src/run-cli.ts +1483 -212
- package/src/runtime.ts +19 -1
- package/src/sany-builtins.ts +147 -0
- package/src/sany-generator.ts +3128 -0
- package/src/sany-levels.ts +1208 -0
- package/src/sany-lexer.ts +545 -0
- package/src/sany-linter.ts +122 -0
- package/src/sany-modules.ts +1398 -0
- package/src/sany-nodes.ts +463 -0
- package/src/sany-parse-error.ts +2161 -0
- package/src/sany-report.ts +356 -0
- package/src/sany-selectors.ts +738 -0
- package/src/sany-source.ts +248 -0
- package/src/sany-xml.ts +1017 -0
- package/src/spec-description.ts +42 -11
- package/src/standard-modules.ts +203 -148
- package/src/standard-ranges.ts +116 -0
- package/src/state-graph.ts +180 -0
- package/src/subexpressions.ts +231 -171
- package/src/substitution-levels.ts +38 -17
- package/src/successors.ts +241 -110
- package/src/symmetry.ts +194 -54
- package/src/tableau.ts +54 -25
- package/src/tlapm-cache.ts +236 -0
- package/src/tlc-ext.ts +42 -29
- package/src/tlc-messages.ts +329 -0
- package/src/tlc-module.ts +52 -43
- package/src/tlc-modules.ts +4 -0
- package/src/tlc-order.ts +78 -10
- package/src/tlc-random.ts +84 -33
- package/src/tlc-replay.ts +655 -0
- package/src/tlc-summary.ts +20 -5
- package/src/tlc-version.ts +19 -0
- package/src/transfer.ts +15 -3
- package/src/values.ts +787 -190
- package/src/worker.ts +65 -0
- package/dist/parallel.cjs +0 -12
- package/dist/parallel.js +0 -12
|
@@ -0,0 +1,772 @@
|
|
|
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
|
+
import { TlaUnsupportedError } from "../../errors";
|
|
6
|
+
import {
|
|
7
|
+
normalizeApply,
|
|
8
|
+
shiftExpr,
|
|
9
|
+
type Bound,
|
|
10
|
+
type Builtin,
|
|
11
|
+
type Expr,
|
|
12
|
+
type Sequent,
|
|
13
|
+
} from "../../obligations/expression";
|
|
14
|
+
import { createContext, type Identifier } from "./context";
|
|
15
|
+
import {
|
|
16
|
+
createFlattener,
|
|
17
|
+
getDepth,
|
|
18
|
+
getVariable,
|
|
19
|
+
removeUnprimable,
|
|
20
|
+
UNPRIMABLE,
|
|
21
|
+
type Entry,
|
|
22
|
+
} from "./flatten";
|
|
23
|
+
import {
|
|
24
|
+
BOOL_SET,
|
|
25
|
+
BUILTIN_SYMBOLS,
|
|
26
|
+
call,
|
|
27
|
+
CAST_BOOL,
|
|
28
|
+
CAST_INT,
|
|
29
|
+
conjoin,
|
|
30
|
+
disjoin,
|
|
31
|
+
FUN_APP,
|
|
32
|
+
FUN_EXCEPT,
|
|
33
|
+
FUN_SET,
|
|
34
|
+
getBinders,
|
|
35
|
+
INT_LTEQ,
|
|
36
|
+
INT_SET,
|
|
37
|
+
MEM,
|
|
38
|
+
NAT_SET,
|
|
39
|
+
STR_SET,
|
|
40
|
+
SUBSET_EQ,
|
|
41
|
+
tla,
|
|
42
|
+
TT_IDV,
|
|
43
|
+
} from "./format";
|
|
44
|
+
import { getIntegers } from "./axioms";
|
|
45
|
+
import { getEquality, resolveTriggers, type Polarity } from "./extensionality";
|
|
46
|
+
import {
|
|
47
|
+
getChooseAxioms,
|
|
48
|
+
getFunctionAxioms,
|
|
49
|
+
getSelectSeqAxioms,
|
|
50
|
+
getSetOfAxioms,
|
|
51
|
+
getSetStAxioms,
|
|
52
|
+
} from "./instances";
|
|
53
|
+
|
|
54
|
+
interface Term {
|
|
55
|
+
isBool: boolean;
|
|
56
|
+
text: string;
|
|
57
|
+
// Type.Synthesize: the Int-sorted form of a term that is an integer before it's cast to Idv.
|
|
58
|
+
integer?: string;
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
// What tlapm keeps across the obligations of one run.
|
|
62
|
+
export interface EncodingSession {
|
|
63
|
+
caseErrors: number;
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
export interface Mode {
|
|
67
|
+
// Whether the text encodes a fact that tlapm leaves out, which may declare operators.
|
|
68
|
+
isOmitted: boolean;
|
|
69
|
+
polarity: Polarity;
|
|
70
|
+
at: string | undefined;
|
|
71
|
+
depth: number;
|
|
72
|
+
}
|
|
73
|
+
|
|
74
|
+
export type Binding =
|
|
75
|
+
| { kind: "constant"; symbol: string }
|
|
76
|
+
| { kind: "variable"; name: string; symbol: string; primed: string }
|
|
77
|
+
| { kind: "operator"; symbol: string; arity: number }
|
|
78
|
+
| { kind: "secondOrder"; name: string; shapes: number[] }
|
|
79
|
+
| { kind: "unsupported"; reason: string };
|
|
80
|
+
|
|
81
|
+
export interface Env {
|
|
82
|
+
binding: Binding;
|
|
83
|
+
rest: Env | undefined;
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
// A nested ASSUME's declarations and facts so far: each wraps the goal in a quantifier or an
|
|
87
|
+
// implication.
|
|
88
|
+
interface NestedContext {
|
|
89
|
+
env: Env | undefined;
|
|
90
|
+
mode: Mode;
|
|
91
|
+
wrappers: ((body: string) => string)[];
|
|
92
|
+
}
|
|
93
|
+
|
|
94
|
+
export const createEncoder = (session: EncodingSession) => {
|
|
95
|
+
const flattener = createFlattener();
|
|
96
|
+
const flatten = flattener.flatten;
|
|
97
|
+
// The arity of each anonymous operator Coalesce introduces.
|
|
98
|
+
const anonymous = new Map<string, number>();
|
|
99
|
+
// The fields of each record symbol.
|
|
100
|
+
const recordFields = new Map<string, string[]>();
|
|
101
|
+
const context = createContext();
|
|
102
|
+
// The salted name of each declared user symbol, for the printer's context.
|
|
103
|
+
const declared = new Map<string, Identifier>();
|
|
104
|
+
|
|
105
|
+
// Standardize wraps a cast term in an application, and set_extensionality_visitor visits the
|
|
106
|
+
// arguments of an application with neither polarity, so a cast triggers every set equality in it.
|
|
107
|
+
const toBool = (term: Term) =>
|
|
108
|
+
term.isBool ? term.text : `(= ${resolveTriggers(term.text, true)} ${TT_IDV})`;
|
|
109
|
+
|
|
110
|
+
const toIdv = (term: Term) =>
|
|
111
|
+
term.isBool ? `(${CAST_BOOL} ${resolveTriggers(term.text, true)})` : term.text;
|
|
112
|
+
|
|
113
|
+
const bool = (text: string): Term => ({ isBool: true, text });
|
|
114
|
+
|
|
115
|
+
const idv = (text: string): Term => ({ isBool: false, text });
|
|
116
|
+
|
|
117
|
+
const getBinding = (env: Env | undefined, index: number): Binding => {
|
|
118
|
+
const found = Array.from({ length: index - 1 }).reduce<Env | undefined>(
|
|
119
|
+
(current) => current?.rest,
|
|
120
|
+
env,
|
|
121
|
+
);
|
|
122
|
+
if (!found) throw new TlaUnsupportedError("a reference outside the obligation");
|
|
123
|
+
return found.binding;
|
|
124
|
+
};
|
|
125
|
+
|
|
126
|
+
const push = (env: Env | undefined, binding: Binding): Env => ({ binding, rest: env });
|
|
127
|
+
|
|
128
|
+
// The variables bound outside depth that text uses, outermost first.
|
|
129
|
+
const getFree = (text: string, depth: number) =>
|
|
130
|
+
[...new Set(text.match(/[^\s()]+#\d+/g))]
|
|
131
|
+
.filter((variable) => getDepth(variable) < depth)
|
|
132
|
+
.toSorted((left, right) => getDepth(left) - getDepth(right));
|
|
133
|
+
|
|
134
|
+
// Smtlib.adj: the Action frontend's name, salted while it's taken.
|
|
135
|
+
const getUniqueName = (name: string) => {
|
|
136
|
+
const identifier = context.adjoin(name);
|
|
137
|
+
context.enter(identifier);
|
|
138
|
+
declared.set(identifier.name, identifier);
|
|
139
|
+
return identifier.name;
|
|
140
|
+
};
|
|
141
|
+
|
|
142
|
+
const neither = (mode: Mode): Mode => ({ ...mode, polarity: "Neither" });
|
|
143
|
+
|
|
144
|
+
const invert = (mode: Mode): Mode => ({
|
|
145
|
+
...mode,
|
|
146
|
+
polarity:
|
|
147
|
+
mode.polarity === "Positive"
|
|
148
|
+
? "Negative"
|
|
149
|
+
: mode.polarity === "Negative"
|
|
150
|
+
? "Positive"
|
|
151
|
+
: "Neither",
|
|
152
|
+
});
|
|
153
|
+
|
|
154
|
+
const encodeIdv = (expression: Expr, env: Env | undefined, mode: Mode) =>
|
|
155
|
+
toIdv(encode(expression, env, neither(mode)));
|
|
156
|
+
|
|
157
|
+
const encodeBool = (expression: Expr, env: Env | undefined, mode: Mode) =>
|
|
158
|
+
toBool(encode(expression, env, mode));
|
|
159
|
+
|
|
160
|
+
// The domains of bounds, each in the scope outside them. A Ditto copies the last domain, and
|
|
161
|
+
// tlapm's Rewrite encodes each copy, so each one flattens again.
|
|
162
|
+
const encodeDomains = (bounds: Bound[], env: Env | undefined, mode: Mode) =>
|
|
163
|
+
bounds
|
|
164
|
+
.reduce<(Expr | undefined)[]>((domains, bound) => {
|
|
165
|
+
if (bound.domain.kind === "Ditto") return [...domains, domains.at(-1)];
|
|
166
|
+
if (bound.domain.kind === "NoDomain") return [...domains, undefined];
|
|
167
|
+
return [...domains, bound.domain.expression];
|
|
168
|
+
}, [])
|
|
169
|
+
.map((domain) => (domain === undefined ? undefined : encodeIdv(domain, env, mode)));
|
|
170
|
+
|
|
171
|
+
const getDomains = (bounds: Bound[], env: Env | undefined, mode: Mode, construct: string) =>
|
|
172
|
+
encodeDomains(bounds, env, mode).map((domain) => {
|
|
173
|
+
if (domain === undefined) throw new TlaUnsupportedError(`${construct} without a domain`);
|
|
174
|
+
return domain;
|
|
175
|
+
});
|
|
176
|
+
|
|
177
|
+
const bindVariables = (names: string[], env: Env | undefined, mode: Mode) => {
|
|
178
|
+
const variables = names.map((name, index) => getVariable(name, mode.depth + index));
|
|
179
|
+
const inner = variables.reduce<Env | undefined>(
|
|
180
|
+
(current, symbol) => push(current, { kind: "constant", symbol }),
|
|
181
|
+
env,
|
|
182
|
+
);
|
|
183
|
+
return { variables, env: inner, mode: { ...mode, depth: mode.depth + names.length } };
|
|
184
|
+
};
|
|
185
|
+
|
|
186
|
+
const encodeQuantifier = (
|
|
187
|
+
expression: Extract<Expr, { kind: "Quant" }>,
|
|
188
|
+
env: Env | undefined,
|
|
189
|
+
mode: Mode,
|
|
190
|
+
) => {
|
|
191
|
+
const domains = encodeDomains(expression.bounds, env, mode);
|
|
192
|
+
const bound = bindVariables(
|
|
193
|
+
expression.bounds.map((innerBound) => innerBound.name),
|
|
194
|
+
env,
|
|
195
|
+
mode,
|
|
196
|
+
);
|
|
197
|
+
const body = encodeBool(expression.body, bound.env, bound.mode);
|
|
198
|
+
const guards = bound.variables.flatMap((variable, index) =>
|
|
199
|
+
domains[index] === undefined ? [] : [`(${MEM} ${variable} ${domains[index]})`],
|
|
200
|
+
);
|
|
201
|
+
return expression.quantifier === "Forall"
|
|
202
|
+
? `(forall (${getBinders(bound.variables)}) ${guards.length === 0 ? body : `(=> ${conjoin(guards)} ${body})`})`
|
|
203
|
+
: `(exists (${getBinders(bound.variables)}) ${conjoin([...guards, body])})`;
|
|
204
|
+
};
|
|
205
|
+
|
|
206
|
+
const encodeSetSt = (
|
|
207
|
+
expression: Extract<Expr, { kind: "SetSt" }>,
|
|
208
|
+
env: Env | undefined,
|
|
209
|
+
mode: Mode,
|
|
210
|
+
) => {
|
|
211
|
+
const domain = encodeIdv(expression.domain, env, mode);
|
|
212
|
+
const bound = bindVariables([expression.name], env, neither(mode));
|
|
213
|
+
const body = encodeBool(expression.body, bound.env, bound.mode);
|
|
214
|
+
const free = getFree(body, mode.depth);
|
|
215
|
+
const symbol = flatten(
|
|
216
|
+
"SetSt",
|
|
217
|
+
body,
|
|
218
|
+
mode,
|
|
219
|
+
(name) => getSetStAxioms(name, free, body, bound.variables[0]),
|
|
220
|
+
free.length + 1,
|
|
221
|
+
);
|
|
222
|
+
return idv(call(symbol, [domain, ...free]));
|
|
223
|
+
};
|
|
224
|
+
|
|
225
|
+
const encodeSetOf = (
|
|
226
|
+
expression: Extract<Expr, { kind: "SetOf" }>,
|
|
227
|
+
env: Env | undefined,
|
|
228
|
+
mode: Mode,
|
|
229
|
+
) => {
|
|
230
|
+
const domains = getDomains(expression.bounds, env, mode, "a set of values");
|
|
231
|
+
const bound = bindVariables(
|
|
232
|
+
expression.bounds.map((innerBound) => innerBound.name),
|
|
233
|
+
env,
|
|
234
|
+
neither(mode),
|
|
235
|
+
);
|
|
236
|
+
const element = encodeIdv(expression.element, bound.env, bound.mode);
|
|
237
|
+
const free = getFree(element, mode.depth);
|
|
238
|
+
const count = domains.length;
|
|
239
|
+
const symbol = flatten(
|
|
240
|
+
`SetOf_${count}`,
|
|
241
|
+
element,
|
|
242
|
+
mode,
|
|
243
|
+
(name) => getSetOfAxioms(name, free, element, bound.variables),
|
|
244
|
+
count + free.length,
|
|
245
|
+
);
|
|
246
|
+
return idv(call(symbol, [...domains, ...free]));
|
|
247
|
+
};
|
|
248
|
+
|
|
249
|
+
// Rewrite.elim_multiarg: a function of several arguments is a function of a tuple.
|
|
250
|
+
const encodeFunction = (
|
|
251
|
+
expression: Extract<Expr, { kind: "Fcn" }>,
|
|
252
|
+
env: Env | undefined,
|
|
253
|
+
mode: Mode,
|
|
254
|
+
) => {
|
|
255
|
+
const domains = getDomains(expression.bounds, env, mode, "a function");
|
|
256
|
+
const domain =
|
|
257
|
+
domains.length === 1 ? domains[0] : call(tla(`Product_${domains.length}`), domains);
|
|
258
|
+
const variable = getVariable(
|
|
259
|
+
domains.length === 1 ? expression.bounds[0].name : "x",
|
|
260
|
+
mode.depth,
|
|
261
|
+
);
|
|
262
|
+
const inner = { ...neither(mode), depth: mode.depth + 1 };
|
|
263
|
+
const bodyEnv =
|
|
264
|
+
domains.length === 1
|
|
265
|
+
? push(env, { kind: "constant", symbol: variable })
|
|
266
|
+
: getIntegers(domains.length).reduce<Env | undefined>(
|
|
267
|
+
(current, key) =>
|
|
268
|
+
push(current, { kind: "constant", symbol: `(${FUN_APP} ${variable} ${key})` }),
|
|
269
|
+
env,
|
|
270
|
+
);
|
|
271
|
+
const body = encodeIdv(expression.body, bodyEnv, inner);
|
|
272
|
+
const free = getFree(body, mode.depth);
|
|
273
|
+
const symbol = flatten(
|
|
274
|
+
"FunFcn",
|
|
275
|
+
body,
|
|
276
|
+
mode,
|
|
277
|
+
(name, axioms) => getFunctionAxioms(name, free, body, variable, axioms),
|
|
278
|
+
free.length + 1,
|
|
279
|
+
);
|
|
280
|
+
return idv(call(symbol, [domain, ...free]));
|
|
281
|
+
};
|
|
282
|
+
|
|
283
|
+
// Elab: CHOOSE x \in S : P is CHOOSE x : x \in S /\ P.
|
|
284
|
+
const encodeChoose = (
|
|
285
|
+
expression: Extract<Expr, { kind: "Choose" }>,
|
|
286
|
+
env: Env | undefined,
|
|
287
|
+
mode: Mode,
|
|
288
|
+
) => {
|
|
289
|
+
const bound = bindVariables([expression.name], env, neither(mode));
|
|
290
|
+
const variable = bound.variables[0];
|
|
291
|
+
const domain =
|
|
292
|
+
expression.domain && `(${MEM} ${variable} ${encodeIdv(expression.domain, env, mode)})`;
|
|
293
|
+
const predicate = encodeBool(expression.body, bound.env, bound.mode);
|
|
294
|
+
const body = domain === undefined ? predicate : conjoin([domain, predicate]);
|
|
295
|
+
const free = getFree(body, mode.depth);
|
|
296
|
+
const symbol = flatten(
|
|
297
|
+
"Choose",
|
|
298
|
+
body,
|
|
299
|
+
mode,
|
|
300
|
+
(name) => getChooseAxioms(name, free, body, variable),
|
|
301
|
+
free.length,
|
|
302
|
+
);
|
|
303
|
+
return idv(call(symbol, free));
|
|
304
|
+
};
|
|
305
|
+
|
|
306
|
+
// Type.Synthesize compares values of the same sort only above type level 1, so two formulas are
|
|
307
|
+
// compared as values.
|
|
308
|
+
const encodeEquality = (args: Expr[], env: Env | undefined, mode: Mode, isNegated: boolean) =>
|
|
309
|
+
getEquality(
|
|
310
|
+
encodeIdv(args[0], env, mode),
|
|
311
|
+
encodeIdv(args[1], env, mode),
|
|
312
|
+
mode.polarity,
|
|
313
|
+
isNegated,
|
|
314
|
+
);
|
|
315
|
+
|
|
316
|
+
// Type.Synthesize: SelectSeq's test becomes the predicate LAMBDA x1 : Test(x1), its body the
|
|
317
|
+
// text Flatten compares.
|
|
318
|
+
const getSelectionTest = (test: Expr, env: Env | undefined, mode: Mode) => {
|
|
319
|
+
const lambda = test.kind === "Lambda" && test.params.length === 1 ? test : undefined;
|
|
320
|
+
const bound = bindVariables([lambda?.params[0].name ?? "x1"], env, neither(mode));
|
|
321
|
+
const body = encodeBool(
|
|
322
|
+
lambda?.body ?? {
|
|
323
|
+
kind: "Apply",
|
|
324
|
+
operator: shiftExpr(1, test),
|
|
325
|
+
args: [{ kind: "Ix", index: 1 }],
|
|
326
|
+
},
|
|
327
|
+
bound.env,
|
|
328
|
+
bound.mode,
|
|
329
|
+
);
|
|
330
|
+
return { body, variable: bound.variables[0] };
|
|
331
|
+
};
|
|
332
|
+
|
|
333
|
+
const encodeBuiltin = (
|
|
334
|
+
builtin: Builtin,
|
|
335
|
+
args: Expr[],
|
|
336
|
+
env: Env | undefined,
|
|
337
|
+
mode: Mode,
|
|
338
|
+
): Term => {
|
|
339
|
+
const idvs = () => args.map((arg) => encodeIdv(arg, env, mode));
|
|
340
|
+
switch (builtin) {
|
|
341
|
+
case "Conj":
|
|
342
|
+
return bool(conjoin(args.map((arg) => encodeBool(arg, env, mode))));
|
|
343
|
+
case "Disj":
|
|
344
|
+
return bool(disjoin(args.map((arg) => encodeBool(arg, env, mode))));
|
|
345
|
+
case "Implies":
|
|
346
|
+
return bool(
|
|
347
|
+
`(=> ${encodeBool(args[0], env, invert(mode))} ${encodeBool(args[1], env, mode)})`,
|
|
348
|
+
);
|
|
349
|
+
case "Equiv":
|
|
350
|
+
return bool(`(= ${args.map((arg) => encodeBool(arg, env, neither(mode))).join(" ")})`);
|
|
351
|
+
case "Neg":
|
|
352
|
+
return bool(`(not ${encodeBool(args[0], env, invert(mode))})`);
|
|
353
|
+
case "Eq":
|
|
354
|
+
return bool(encodeEquality(args, env, mode, false));
|
|
355
|
+
case "Neq":
|
|
356
|
+
return bool(encodeEquality(args, env, mode, true));
|
|
357
|
+
case "Mem":
|
|
358
|
+
return bool(call(MEM, idvs()));
|
|
359
|
+
// Rewrite.elim_notmem: a \notin S is ~(a \in S).
|
|
360
|
+
case "Notmem":
|
|
361
|
+
return bool(`(not ${call(MEM, idvs())})`);
|
|
362
|
+
case "Subseteq":
|
|
363
|
+
return bool(call(SUBSET_EQ, idvs()));
|
|
364
|
+
// Rewrite.elim_compare: a < b is a <= b /\ a # b, and a > b is b < a.
|
|
365
|
+
case "Lteq":
|
|
366
|
+
return bool(call(INT_LTEQ, idvs()));
|
|
367
|
+
case "Gteq":
|
|
368
|
+
return bool(call(INT_LTEQ, idvs().toReversed()));
|
|
369
|
+
case "Lt":
|
|
370
|
+
case "Gt": {
|
|
371
|
+
// Rewrite copies the operands before Flatten, which flattens each copy again.
|
|
372
|
+
const getOperands = () => (builtin === "Lt" ? idvs() : idvs().toReversed());
|
|
373
|
+
return bool(`(and ${call(INT_LTEQ, getOperands())} (distinct ${getOperands().join(" ")}))`);
|
|
374
|
+
}
|
|
375
|
+
// Flatten: SelectSeq(s, Test) is a fresh operator of s and the bound variables Test uses.
|
|
376
|
+
case "SelectSeq": {
|
|
377
|
+
const test = getSelectionTest(args[1], env, mode);
|
|
378
|
+
const free = getFree(test.body, mode.depth);
|
|
379
|
+
const symbol = flatten(
|
|
380
|
+
"SelectSeq",
|
|
381
|
+
test.body,
|
|
382
|
+
mode,
|
|
383
|
+
(name) => getSelectSeqAxioms(name, free, test.body, test.variable),
|
|
384
|
+
free.length + 1,
|
|
385
|
+
);
|
|
386
|
+
return idv(call(symbol, [encodeIdv(args[0], env, mode), ...free]));
|
|
387
|
+
}
|
|
388
|
+
case "Unprimable": {
|
|
389
|
+
const term = encode(args[0], env, neither(mode));
|
|
390
|
+
return { ...term, text: `(${UNPRIMABLE} ${term.text})` };
|
|
391
|
+
}
|
|
392
|
+
default: {
|
|
393
|
+
const symbol = BUILTIN_SYMBOLS[builtin];
|
|
394
|
+
if (symbol === undefined) throw new TlaUnsupportedError(`the operator ${builtin}`);
|
|
395
|
+
return idv(call(symbol, idvs()));
|
|
396
|
+
}
|
|
397
|
+
}
|
|
398
|
+
};
|
|
399
|
+
|
|
400
|
+
const encodeReference = (
|
|
401
|
+
binding: Binding,
|
|
402
|
+
args: Expr[],
|
|
403
|
+
env: Env | undefined,
|
|
404
|
+
mode: Mode,
|
|
405
|
+
): Term => {
|
|
406
|
+
switch (binding.kind) {
|
|
407
|
+
case "constant":
|
|
408
|
+
case "variable":
|
|
409
|
+
if (args.length > 0) throw new TlaUnsupportedError(`an applied ${binding.kind}`);
|
|
410
|
+
return idv(binding.symbol);
|
|
411
|
+
case "operator":
|
|
412
|
+
if (args.length !== binding.arity)
|
|
413
|
+
throw new TlaUnsupportedError("an operator applied to the wrong number of arguments");
|
|
414
|
+
return idv(
|
|
415
|
+
call(
|
|
416
|
+
binding.symbol,
|
|
417
|
+
args.map((arg) => encodeIdv(arg, env, mode)),
|
|
418
|
+
),
|
|
419
|
+
);
|
|
420
|
+
// Flatten: an application of a second-order operator, which has no axioms, is a fresh
|
|
421
|
+
// operator of its first-order arguments and the bound variables its others use.
|
|
422
|
+
case "secondOrder": {
|
|
423
|
+
if (args.length !== binding.shapes.length)
|
|
424
|
+
throw new TlaUnsupportedError("an operator applied to the wrong number of arguments");
|
|
425
|
+
const operands = args.map((arg, index) => {
|
|
426
|
+
if (binding.shapes[index] === 0)
|
|
427
|
+
return { isFirstOrder: true, text: encodeIdv(arg, env, mode) };
|
|
428
|
+
// An operator's name as the argument stands for the operator, which compare_expr
|
|
429
|
+
// matches by name.
|
|
430
|
+
if (arg.kind === "Ix") {
|
|
431
|
+
const argument = getBinding(env, arg.index);
|
|
432
|
+
if (argument.kind !== "operator")
|
|
433
|
+
throw new TlaUnsupportedError("an operator argument that isn't a LAMBDA");
|
|
434
|
+
return { isFirstOrder: false, text: argument.symbol };
|
|
435
|
+
}
|
|
436
|
+
if (arg.kind !== "Lambda")
|
|
437
|
+
throw new TlaUnsupportedError("an operator argument that isn't a LAMBDA");
|
|
438
|
+
const bound = bindVariables(
|
|
439
|
+
arg.params.map((param) => param.name),
|
|
440
|
+
env,
|
|
441
|
+
neither(mode),
|
|
442
|
+
);
|
|
443
|
+
return { isFirstOrder: false, text: encodeIdv(arg.body, bound.env, bound.mode) };
|
|
444
|
+
});
|
|
445
|
+
const firstOrder = operands.flatMap((operand) =>
|
|
446
|
+
operand.isFirstOrder ? [operand.text] : [],
|
|
447
|
+
);
|
|
448
|
+
const higherOrder = operands.flatMap((operand) =>
|
|
449
|
+
operand.isFirstOrder ? [] : [operand.text],
|
|
450
|
+
);
|
|
451
|
+
const free = getFree(higherOrder.join(" "), mode.depth);
|
|
452
|
+
const symbol = flatten(
|
|
453
|
+
"",
|
|
454
|
+
higherOrder.join(" "),
|
|
455
|
+
mode,
|
|
456
|
+
() => [],
|
|
457
|
+
firstOrder.length + free.length,
|
|
458
|
+
binding.name,
|
|
459
|
+
);
|
|
460
|
+
return idv(call(symbol, [...firstOrder, ...free]));
|
|
461
|
+
}
|
|
462
|
+
case "unsupported":
|
|
463
|
+
throw new TlaUnsupportedError(binding.reason);
|
|
464
|
+
}
|
|
465
|
+
};
|
|
466
|
+
|
|
467
|
+
// Rewrite.elim_flex: the Action frontend's name#prime is the primed copy of the variable it
|
|
468
|
+
// names, which tlapm finds by name.
|
|
469
|
+
const getPrimed = (env: Env | undefined, name: string): string => {
|
|
470
|
+
if (!env) throw new TlaUnsupportedError(`a primed declaration that isn't a variable`);
|
|
471
|
+
const binding = env.binding;
|
|
472
|
+
return binding.kind === "variable" && binding.name === name
|
|
473
|
+
? binding.primed
|
|
474
|
+
: getPrimed(env.rest, name);
|
|
475
|
+
};
|
|
476
|
+
|
|
477
|
+
// Standardize: an opaque name the Action frontend introduces is an anonymous operator, named
|
|
478
|
+
// OPAQUE_ when it has no arguments.
|
|
479
|
+
const encodeOpaque = (name: string, args: Expr[], env: Env | undefined, mode: Mode) => {
|
|
480
|
+
if (args.length === 0 && name.endsWith("#prime"))
|
|
481
|
+
return idv(getPrimed(env, name.slice(0, -"#prime".length)));
|
|
482
|
+
const anonymousName = args.length === 0 ? `Anon_OPAQUE_${name}` : `Anon_${name}`;
|
|
483
|
+
anonymous.set(anonymousName, args.length);
|
|
484
|
+
return idv(
|
|
485
|
+
call(
|
|
486
|
+
tla(anonymousName),
|
|
487
|
+
args.map((arg) => encodeIdv(arg, env, mode)),
|
|
488
|
+
),
|
|
489
|
+
);
|
|
490
|
+
};
|
|
491
|
+
|
|
492
|
+
const encodeExcept = (
|
|
493
|
+
expression: Extract<Expr, { kind: "Except" }>,
|
|
494
|
+
env: Env | undefined,
|
|
495
|
+
mode: Mode,
|
|
496
|
+
) =>
|
|
497
|
+
expression.specs.reduce(
|
|
498
|
+
(base, spec) => {
|
|
499
|
+
// Elab.desugar: @ is the value at the whole trail.
|
|
500
|
+
const update = (value: string, trail: typeof spec.trail): string => {
|
|
501
|
+
if (trail.length === 0) return encodeIdv(spec.value, env, { ...mode, at: value });
|
|
502
|
+
const point = trail[0];
|
|
503
|
+
const encodeKey = () =>
|
|
504
|
+
point.kind === "Dot"
|
|
505
|
+
? tla(`StrLit_${point.field}`)
|
|
506
|
+
: encodeIdv(point.expression, env, mode);
|
|
507
|
+
const key = encodeKey();
|
|
508
|
+
// Elab.desugar repeats the key in the value it updates, and Flatten counts both.
|
|
509
|
+
const inner = update(
|
|
510
|
+
`(${FUN_APP} ${value} ${trail.length > 1 ? encodeKey() : key})`,
|
|
511
|
+
trail.slice(1),
|
|
512
|
+
);
|
|
513
|
+
return `(${FUN_EXCEPT} ${value} ${key} ${inner})`;
|
|
514
|
+
};
|
|
515
|
+
return update(base, spec.trail);
|
|
516
|
+
},
|
|
517
|
+
encodeIdv(expression.function, env, mode),
|
|
518
|
+
);
|
|
519
|
+
|
|
520
|
+
// Standardize names each CASE with no OTHER by a count that tlapm never resets.
|
|
521
|
+
const getCaseError = () => {
|
|
522
|
+
session.caseErrors++;
|
|
523
|
+
const name = `Anon_incomplete_case_error_${session.caseErrors}`;
|
|
524
|
+
anonymous.set(name, 0);
|
|
525
|
+
return tla(name);
|
|
526
|
+
};
|
|
527
|
+
|
|
528
|
+
const encodeCase = (
|
|
529
|
+
expression: Extract<Expr, { kind: "Case" }>,
|
|
530
|
+
env: Env | undefined,
|
|
531
|
+
mode: Mode,
|
|
532
|
+
): Term => {
|
|
533
|
+
const bodies = expression.arms.map((arm) => encode(arm.body, env, mode));
|
|
534
|
+
// Standardize: a CASE with no OTHER ends in an unknown value.
|
|
535
|
+
const other: Term = expression.other
|
|
536
|
+
? encode(expression.other, env, mode)
|
|
537
|
+
: idv(getCaseError());
|
|
538
|
+
const isBool = other.isBool && bodies.every((body) => body.isBool);
|
|
539
|
+
const isInteger =
|
|
540
|
+
other.integer !== undefined && bodies.every((body) => body.integer !== undefined);
|
|
541
|
+
if (isInteger) {
|
|
542
|
+
const integer = expression.arms.reduceRight(
|
|
543
|
+
(rest, arm, index) =>
|
|
544
|
+
`(ite ${encodeBool(arm.condition, env, neither(mode))} ${bodies[index].integer} ${rest})`,
|
|
545
|
+
other.integer ?? "",
|
|
546
|
+
);
|
|
547
|
+
return { isBool: false, text: `(${CAST_INT} ${integer})`, integer };
|
|
548
|
+
}
|
|
549
|
+
const convert = (term: Term) => (isBool ? term.text : toIdv(term));
|
|
550
|
+
const text = expression.arms.reduceRight(
|
|
551
|
+
(rest, arm, index) =>
|
|
552
|
+
`(ite ${encodeBool(arm.condition, env, mode)} ${convert(bodies[index])} ${rest})`,
|
|
553
|
+
convert(other),
|
|
554
|
+
);
|
|
555
|
+
return { isBool, text };
|
|
556
|
+
};
|
|
557
|
+
|
|
558
|
+
const encodeSequent = (sequent: Sequent, env: Env | undefined, mode: Mode): string => {
|
|
559
|
+
const steps = sequent.context.reduce<NestedContext>(
|
|
560
|
+
(state, hyp) => {
|
|
561
|
+
switch (hyp.kind) {
|
|
562
|
+
case "Fresh": {
|
|
563
|
+
if (hyp.shape > 0) {
|
|
564
|
+
if (!state.mode.isOmitted) throw new TlaUnsupportedError("a second-order ASSUME");
|
|
565
|
+
const variable = getVariable(hyp.name, state.mode.depth);
|
|
566
|
+
return {
|
|
567
|
+
env: push(state.env, { kind: "operator", symbol: variable, arity: hyp.shape }),
|
|
568
|
+
mode: { ...state.mode, depth: state.mode.depth + 1 },
|
|
569
|
+
wrappers: [...state.wrappers, (body) => `(forall ((${variable} Idv)) ${body})`],
|
|
570
|
+
};
|
|
571
|
+
}
|
|
572
|
+
if (hyp.level !== "Constant")
|
|
573
|
+
throw new TlaUnsupportedError("a NEW declaration that isn't constant");
|
|
574
|
+
const domain = hyp.domain && encodeIdv(hyp.domain, state.env, state.mode);
|
|
575
|
+
const bound = bindVariables([hyp.name], state.env, state.mode);
|
|
576
|
+
const variable = bound.variables[0];
|
|
577
|
+
const guard = domain && `(${MEM} ${variable} ${domain})`;
|
|
578
|
+
return {
|
|
579
|
+
env: bound.env,
|
|
580
|
+
mode: bound.mode,
|
|
581
|
+
wrappers: [
|
|
582
|
+
...state.wrappers,
|
|
583
|
+
(body) => `(forall ((${variable} Idv)) ${guard ? `(=> ${guard} ${body})` : body})`,
|
|
584
|
+
],
|
|
585
|
+
};
|
|
586
|
+
}
|
|
587
|
+
case "Fact": {
|
|
588
|
+
const fact =
|
|
589
|
+
hyp.visibility === "Visible"
|
|
590
|
+
? encodeBool(hyp.expression, state.env, invert(state.mode))
|
|
591
|
+
: undefined;
|
|
592
|
+
return {
|
|
593
|
+
env: push(state.env, { kind: "unsupported", reason: "a reference to a fact" }),
|
|
594
|
+
mode: state.mode,
|
|
595
|
+
wrappers: fact
|
|
596
|
+
? [...state.wrappers, (body) => `(=> ${fact} ${body})`]
|
|
597
|
+
: state.wrappers,
|
|
598
|
+
};
|
|
599
|
+
}
|
|
600
|
+
default:
|
|
601
|
+
throw new TlaUnsupportedError(`a ${hyp.kind} in a nested ASSUME`);
|
|
602
|
+
}
|
|
603
|
+
},
|
|
604
|
+
{ env, mode, wrappers: [] },
|
|
605
|
+
);
|
|
606
|
+
return steps.wrappers.reduceRight(
|
|
607
|
+
(body, wrap) => wrap(body),
|
|
608
|
+
encodeBool(sequent.active, steps.env, steps.mode),
|
|
609
|
+
);
|
|
610
|
+
};
|
|
611
|
+
|
|
612
|
+
const encode = (expression: Expr, env: Env | undefined, mode: Mode): Term => {
|
|
613
|
+
switch (expression.kind) {
|
|
614
|
+
case "Ix":
|
|
615
|
+
return encodeReference(getBinding(env, expression.index), [], env, mode);
|
|
616
|
+
case "Internal":
|
|
617
|
+
switch (expression.builtin) {
|
|
618
|
+
case "TRUE":
|
|
619
|
+
return bool("true");
|
|
620
|
+
case "FALSE":
|
|
621
|
+
return bool("false");
|
|
622
|
+
case "BOOLEAN":
|
|
623
|
+
return idv(BOOL_SET);
|
|
624
|
+
case "STRING":
|
|
625
|
+
return idv(STR_SET);
|
|
626
|
+
case "Nat":
|
|
627
|
+
return idv(NAT_SET);
|
|
628
|
+
case "Int":
|
|
629
|
+
return idv(INT_SET);
|
|
630
|
+
default:
|
|
631
|
+
throw new TlaUnsupportedError(`the operator ${expression.builtin}`);
|
|
632
|
+
}
|
|
633
|
+
case "Apply": {
|
|
634
|
+
const operator = expression.operator;
|
|
635
|
+
if (operator.kind === "Internal")
|
|
636
|
+
return encodeBuiltin(operator.builtin, expression.args, env, mode);
|
|
637
|
+
if (operator.kind === "Ix")
|
|
638
|
+
return encodeReference(getBinding(env, operator.index), expression.args, env, mode);
|
|
639
|
+
if (operator.kind === "Opaque")
|
|
640
|
+
return encodeOpaque(operator.name, expression.args, env, mode);
|
|
641
|
+
if (operator.kind === "Lambda")
|
|
642
|
+
return encode(normalizeApply(operator, expression.args), env, mode);
|
|
643
|
+
throw new TlaUnsupportedError(`an application of ${operator.kind}`);
|
|
644
|
+
}
|
|
645
|
+
case "Sequent":
|
|
646
|
+
return bool(encodeSequent(expression.sequent, env, mode));
|
|
647
|
+
case "With":
|
|
648
|
+
case "Parens":
|
|
649
|
+
return encode(expression.expression, env, mode);
|
|
650
|
+
case "If": {
|
|
651
|
+
const condition = encodeBool(expression.condition, env, mode);
|
|
652
|
+
const consequent = encode(expression.consequent, env, mode);
|
|
653
|
+
const alternative = encode(expression.alternative, env, mode);
|
|
654
|
+
if (consequent.integer !== undefined && alternative.integer !== undefined) {
|
|
655
|
+
const integer = `(ite ${resolveTriggers(condition, true)} ${consequent.integer} ${alternative.integer})`;
|
|
656
|
+
return { isBool: false, text: `(${CAST_INT} ${integer})`, integer };
|
|
657
|
+
}
|
|
658
|
+
return consequent.isBool && alternative.isBool
|
|
659
|
+
? bool(`(ite ${condition} ${consequent.text} ${alternative.text})`)
|
|
660
|
+
: idv(`(ite ${condition} ${toIdv(consequent)} ${toIdv(alternative)})`);
|
|
661
|
+
}
|
|
662
|
+
case "List": {
|
|
663
|
+
const items = expression.items.map((item) => encodeBool(item, env, mode));
|
|
664
|
+
return bool(expression.bullet === "Or" ? disjoin(items) : conjoin(items));
|
|
665
|
+
}
|
|
666
|
+
case "Opaque":
|
|
667
|
+
return encodeOpaque(expression.name, [], env, mode);
|
|
668
|
+
case "Quant":
|
|
669
|
+
return bool(encodeQuantifier(expression, env, mode));
|
|
670
|
+
case "Choose":
|
|
671
|
+
return encodeChoose(expression, env, mode);
|
|
672
|
+
case "SetSt":
|
|
673
|
+
return encodeSetSt(expression, env, mode);
|
|
674
|
+
case "SetOf":
|
|
675
|
+
return encodeSetOf(expression, env, mode);
|
|
676
|
+
case "SetEnum":
|
|
677
|
+
return idv(
|
|
678
|
+
call(
|
|
679
|
+
tla(`SetEnum_${expression.elements.length}`),
|
|
680
|
+
expression.elements.map((element) => encodeIdv(element, env, mode)),
|
|
681
|
+
),
|
|
682
|
+
);
|
|
683
|
+
case "Product":
|
|
684
|
+
return idv(
|
|
685
|
+
call(
|
|
686
|
+
tla(`Product_${expression.factors.length}`),
|
|
687
|
+
expression.factors.map((factor) => encodeIdv(factor, env, mode)),
|
|
688
|
+
),
|
|
689
|
+
);
|
|
690
|
+
case "Tuple":
|
|
691
|
+
return idv(
|
|
692
|
+
call(
|
|
693
|
+
tla(`Tuple_${expression.elements.length}`),
|
|
694
|
+
expression.elements.map((element) => encodeIdv(element, env, mode)),
|
|
695
|
+
),
|
|
696
|
+
);
|
|
697
|
+
case "Fcn":
|
|
698
|
+
return encodeFunction(expression, env, mode);
|
|
699
|
+
// Rewrite.elim_multiarg: f[a, b] applies f to the tuple <<a, b>>.
|
|
700
|
+
case "FcnApp": {
|
|
701
|
+
const fn = encodeIdv(expression.function, env, mode);
|
|
702
|
+
const args = expression.args.map((arg) => encodeIdv(arg, env, mode));
|
|
703
|
+
const argument = args.length === 1 ? args[0] : call(tla(`Tuple_${args.length}`), args);
|
|
704
|
+
return idv(`(${FUN_APP} ${fn} ${argument})`);
|
|
705
|
+
}
|
|
706
|
+
case "Arrow":
|
|
707
|
+
return idv(
|
|
708
|
+
call(FUN_SET, [
|
|
709
|
+
encodeIdv(expression.domain, env, mode),
|
|
710
|
+
encodeIdv(expression.range, env, mode),
|
|
711
|
+
]),
|
|
712
|
+
);
|
|
713
|
+
case "Record":
|
|
714
|
+
case "Rect": {
|
|
715
|
+
const names = expression.fields.map((field) => field.name);
|
|
716
|
+
const suffix = names.join("_");
|
|
717
|
+
recordFields.set(`Record_${suffix}`, names);
|
|
718
|
+
recordFields.set(`RecordSet_${suffix}`, names);
|
|
719
|
+
return idv(
|
|
720
|
+
call(
|
|
721
|
+
tla(`${expression.kind === "Record" ? "Record" : "RecordSet"}_${suffix}`),
|
|
722
|
+
expression.fields.map((field) => encodeIdv(field.value, env, mode)),
|
|
723
|
+
),
|
|
724
|
+
);
|
|
725
|
+
}
|
|
726
|
+
case "Except":
|
|
727
|
+
return idv(encodeExcept(expression, env, mode));
|
|
728
|
+
case "Dot":
|
|
729
|
+
return idv(
|
|
730
|
+
`(${FUN_APP} ${encodeIdv(expression.expression, env, mode)} ${tla(`StrLit_${expression.field}`)})`,
|
|
731
|
+
);
|
|
732
|
+
case "Case":
|
|
733
|
+
return encodeCase(expression, env, mode);
|
|
734
|
+
case "String":
|
|
735
|
+
return idv(tla(`StrLit_${expression.value}`));
|
|
736
|
+
case "Num":
|
|
737
|
+
if (expression.fraction !== "") throw new TlaUnsupportedError("a real number");
|
|
738
|
+
return {
|
|
739
|
+
isBool: false,
|
|
740
|
+
text: `(${CAST_INT} ${BigInt(expression.integer)})`,
|
|
741
|
+
integer: String(BigInt(expression.integer)),
|
|
742
|
+
};
|
|
743
|
+
case "At":
|
|
744
|
+
if (mode.at === undefined) throw new TlaUnsupportedError("@ outside EXCEPT");
|
|
745
|
+
return idv(mode.at);
|
|
746
|
+
case "Tquant":
|
|
747
|
+
case "Tsub":
|
|
748
|
+
case "Fair":
|
|
749
|
+
throw new TlaUnsupportedError("a temporal formula");
|
|
750
|
+
default:
|
|
751
|
+
throw new TlaUnsupportedError(`the expression ${expression.kind}`);
|
|
752
|
+
}
|
|
753
|
+
};
|
|
754
|
+
|
|
755
|
+
// One fact or the goal, after the declarations of the symbols it flattens.
|
|
756
|
+
const getEntries = (line: string): Entry[] => [
|
|
757
|
+
...flattener.takeIntroduced(),
|
|
758
|
+
removeUnprimable(resolveTriggers(line, false)),
|
|
759
|
+
];
|
|
760
|
+
|
|
761
|
+
return {
|
|
762
|
+
encodeIdv,
|
|
763
|
+
encodeBool,
|
|
764
|
+
push,
|
|
765
|
+
getEntries,
|
|
766
|
+
getUniqueName,
|
|
767
|
+
flattened: flattener.flattened,
|
|
768
|
+
anonymous,
|
|
769
|
+
recordFields,
|
|
770
|
+
declared,
|
|
771
|
+
};
|
|
772
|
+
};
|