tla-ts 0.0.9 → 0.0.10-dev.09e53c2a6
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +30 -1
- package/dist/compile.cjs +23 -0
- package/dist/compile.js +23 -0
- package/dist/deciders.cjs +41 -37
- package/dist/deciders.js +57 -53
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +109 -10
- package/dist/index.d.ts +109 -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 +2746 -410
- package/dist/prove.js +2745 -409
- package/dist/run.cjs +146 -31
- package/dist/run.js +146 -31
- package/dist/tlapm.cjs +2 -2
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +132 -104
- package/dist/transfer.js +132 -104
- package/dist/worker.cjs +6 -6
- package/dist/worker.js +6 -6
- package/package.json +3 -1
- package/src/ast.ts +45 -59
- 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 +797 -782
- 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 +433 -82
- package/src/cli/tlc-arguments.ts +652 -0
- package/src/cli/tlc-output.ts +687 -0
- package/src/cli/tlc-usage.ts +360 -0
- package/src/cli/tlc.ts +323 -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 +36 -54
- package/src/dfid.ts +618 -0
- package/src/environment-config.ts +315 -0
- package/src/environment.ts +178 -339
- package/src/errors.ts +100 -57
- package/src/evaluate.ts +598 -340
- package/src/exit-codes.ts +38 -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 +83 -101
- package/src/liveness-checker.ts +590 -311
- package/src/liveness.ts +180 -124
- package/src/obligations/action.ts +17 -44
- package/src/obligations/anonymize.ts +120 -95
- package/src/obligations/enabled-axioms.ts +218 -0
- package/src/obligations/equality.ts +1 -3
- package/src/obligations/expression.ts +37 -26
- package/src/obligations/format.ts +0 -10
- package/src/obligations/generate.ts +66 -64
- package/src/obligations/index.ts +38 -19
- package/src/obligations/levels.ts +27 -18
- package/src/obligations/module.ts +28 -55
- package/src/obligations/normalize.ts +30 -37
- package/src/obligations/operators.ts +0 -3
- package/src/obligations/pragma.ts +52 -24
- package/src/obligations/printer.ts +89 -58
- package/src/obligations/proof.ts +3 -6
- package/src/obligations/regroup.ts +0 -5
- package/src/obligations/simplify.ts +57 -63
- package/src/obligations/source.ts +119 -95
- package/src/obligations/subexpression.ts +49 -28
- package/src/obligations/substitution.ts +1 -5
- package/src/obligations/temporal.ts +12 -20
- package/src/obligations/tuples.ts +2 -10
- package/src/parallel-worker.ts +30 -60
- package/src/parallel.ts +59 -73
- package/src/parser.ts +1082 -399
- 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 +12 -13
- package/src/prover/first-order.ts +0 -11
- package/src/prover/isabelle/decide.ts +3 -31
- package/src/prover/isabelle/encode.ts +82 -64
- package/src/prover/isabelle/isar/attrib.ts +250 -0
- package/src/prover/isabelle/isar/context.ts +335 -0
- package/src/prover/isabelle/isar/induct.ts +382 -0
- package/src/prover/isabelle/isar/inner-syntax.ts +262 -117
- package/src/prover/isabelle/isar/method.ts +510 -226
- package/src/prover/isabelle/isar/proof.ts +570 -23
- package/src/prover/isabelle/isar/rule-cases.ts +224 -0
- package/src/prover/isabelle/isar/theory.ts +488 -88
- package/src/prover/isabelle/isar/toplevel.ts +331 -0
- package/src/prover/isabelle/isar/type-check.ts +99 -38
- package/src/prover/isabelle/provers/blast/blast.ts +16 -105
- package/src/prover/isabelle/provers/blast/branch.ts +0 -33
- package/src/prover/isabelle/provers/blast/prove.ts +0 -36
- package/src/prover/isabelle/provers/blast/rules.ts +5 -45
- package/src/prover/isabelle/provers/blast/state.ts +1 -29
- package/src/prover/isabelle/provers/blast/term.ts +8 -37
- package/src/prover/isabelle/provers/clasimp.ts +0 -14
- package/src/prover/isabelle/provers/classical.ts +58 -61
- package/src/prover/isabelle/provers/hypsubst.ts +27 -52
- package/src/prover/isabelle/pure/bicompose.ts +24 -39
- package/src/prover/isabelle/pure/consts.ts +0 -8
- package/src/prover/isabelle/pure/conv.ts +2 -18
- package/src/prover/isabelle/pure/drule.ts +95 -45
- package/src/prover/isabelle/pure/envir.ts +2 -53
- package/src/prover/isabelle/pure/goal.ts +1 -9
- package/src/prover/isabelle/pure/interrupt.ts +0 -5
- package/src/prover/isabelle/pure/list.ts +0 -3
- package/src/prover/isabelle/pure/logic.ts +1 -16
- package/src/prover/isabelle/pure/name.ts +1 -10
- package/src/prover/isabelle/pure/net.ts +2 -60
- package/src/prover/isabelle/pure/object-logic.ts +15 -16
- package/src/prover/isabelle/pure/pattern.ts +1 -20
- package/src/prover/isabelle/pure/raw-simplifier.ts +16 -63
- package/src/prover/isabelle/pure/rewriter.ts +31 -74
- package/src/prover/isabelle/pure/search.ts +2 -11
- package/src/prover/isabelle/pure/seq.ts +0 -11
- package/src/prover/isabelle/pure/simplifier.ts +27 -16
- package/src/prover/isabelle/pure/table.ts +2 -33
- package/src/prover/isabelle/pure/tactic.ts +11 -23
- package/src/prover/isabelle/pure/tactical.ts +47 -48
- package/src/prover/isabelle/pure/term-ord.ts +1 -7
- package/src/prover/isabelle/pure/term.ts +1 -44
- package/src/prover/isabelle/pure/thm.ts +26 -48
- package/src/prover/isabelle/pure/type.ts +1 -16
- package/src/prover/isabelle/pure/unify.ts +19 -31
- package/src/prover/isabelle/pure/variable.ts +2 -8
- package/src/prover/isabelle/tla/classical-setup.ts +17 -25
- package/src/prover/isabelle/tla/context.ts +65 -26
- package/src/prover/isabelle/tla/logic-data.ts +1 -1
- package/src/prover/isabelle/tla/logic.ts +53 -32
- package/src/prover/isabelle/tla/simpdata.ts +45 -44
- package/src/prover/isabelle/tools/intuitionistic.ts +28 -21
- package/src/prover/ocaml.ts +4 -7
- package/src/prover/prep/action.ts +33 -66
- package/src/prover/prep/enabled-axioms.ts +22 -20
- 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 +189 -86
- package/src/prover/prep/normalize.ts +42 -37
- package/src/prover/prove-worker.ts +0 -2
- package/src/prover/prove.ts +398 -133
- package/src/prover/ptl/decide.ts +96 -56
- package/src/prover/ptl/encode.ts +15 -38
- package/src/prover/ptl/sat.ts +24 -32
- package/src/prover/ptl/tableau.ts +40 -28
- package/src/prover/smt/arithmetic.ts +310 -0
- package/src/prover/smt/axioms.ts +12 -15
- package/src/prover/smt/context.ts +60 -32
- package/src/prover/smt/data.ts +517 -401
- package/src/prover/smt/encode.ts +155 -85
- package/src/prover/smt/extensionality.ts +5 -13
- package/src/prover/smt/flatten.ts +7 -28
- package/src/prover/smt/format.ts +33 -14
- package/src/prover/smt/instances.ts +7 -11
- package/src/prover/smt/layout.ts +91 -0
- package/src/prover/smt/rewrite.ts +1026 -658
- package/src/prover/smt/simplify.ts +441 -0
- package/src/prover/smt/solver/ackermannize-bv-tactic.ts +61 -0
- package/src/prover/smt/solver/ackr-helper.ts +179 -0
- package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
- package/src/prover/smt/solver/act-cache.ts +0 -16
- package/src/prover/smt/solver/add-bounds-tactic.ts +59 -0
- package/src/prover/smt/solver/aig-tactic.ts +52 -0
- package/src/prover/smt/solver/aig.ts +889 -0
- package/src/prover/smt/solver/arith-rewriter.ts +615 -53
- package/src/prover/smt/solver/arith-terms.ts +121 -0
- package/src/prover/smt/solver/array-decl-plugin.ts +175 -0
- package/src/prover/smt/solver/array-rewriter.ts +309 -0
- package/src/prover/smt/solver/array.ts +1 -3
- package/src/prover/smt/solver/asserted-formulas.ts +87 -58
- package/src/prover/smt/solver/ast-lt.ts +166 -22
- package/src/prover/smt/solver/ast-util.ts +160 -7
- package/src/prover/smt/solver/ast.ts +1424 -180
- package/src/prover/smt/solver/auf-solver.ts +7 -44
- package/src/prover/smt/solver/bit-blast-tactic.ts +582 -0
- package/src/prover/smt/solver/bit-blaster.ts +871 -0
- package/src/prover/smt/solver/bound-manager.ts +196 -0
- package/src/prover/smt/solver/bound-simplifier.ts +600 -0
- package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
- package/src/prover/smt/solver/bv-decl-plugin.ts +338 -0
- package/src/prover/smt/solver/bv-divrem-bounds.ts +95 -0
- package/src/prover/smt/solver/bv-rewriter.ts +1901 -0
- package/src/prover/smt/solver/bv1-blast.ts +214 -0
- package/src/prover/smt/solver/bv2fpa-converter.ts +174 -0
- package/src/prover/smt/solver/bv2int-rewriter.ts +544 -0
- package/src/prover/smt/solver/bv2real-rewriter.ts +533 -0
- package/src/prover/smt/solver/card2bv.ts +110 -0
- package/src/prover/smt/solver/case-split-queue.ts +0 -10
- package/src/prover/smt/solver/cg-table.ts +39 -42
- package/src/prover/smt/solver/check-logic.ts +330 -0
- package/src/prover/smt/solver/clause.ts +0 -27
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +278 -0
- package/src/prover/smt/solver/conflict-resolution.ts +78 -11
- package/src/prover/smt/solver/context.ts +519 -175
- package/src/prover/smt/solver/ctx-simplify.ts +33 -50
- package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
- package/src/prover/smt/solver/datatype-decl-plugin.ts +572 -0
- package/src/prover/smt/solver/datatype-rewriter.ts +82 -0
- package/src/prover/smt/solver/demodulator.ts +786 -0
- package/src/prover/smt/solver/dependent-expr-state.ts +81 -0
- package/src/prover/smt/solver/der.ts +39 -30
- package/src/prover/smt/solver/diff-neq.ts +206 -0
- package/src/prover/smt/solver/distribute-forall.ts +57 -0
- package/src/prover/smt/solver/dom-simplify.ts +511 -0
- package/src/prover/smt/solver/dt2bv-tactic.ts +260 -0
- package/src/prover/smt/solver/dyn-ack.ts +0 -11
- package/src/prover/smt/solver/e-matching.ts +9 -41
- package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
- package/src/prover/smt/solver/elim-uncnstr.ts +545 -0
- package/src/prover/smt/solver/enode.ts +100 -23
- package/src/prover/smt/solver/eq2bv-tactic.ts +218 -0
- package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
- package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
- package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
- package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
- package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
- package/src/prover/smt/solver/euf/array-solver.ts +306 -0
- package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
- package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
- package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
- package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
- package/src/prover/smt/solver/euf/egraph.ts +907 -0
- package/src/prover/smt/solver/euf/euf-solver.ts +1205 -0
- package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
- package/src/prover/smt/solver/euf/mam.ts +1050 -0
- package/src/prover/smt/solver/euf/q-ematch.ts +830 -0
- package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
- package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
- package/src/prover/smt/solver/euf/q-solver.ts +361 -0
- package/src/prover/smt/solver/euf/th-solver.ts +335 -0
- package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
- package/src/prover/smt/solver/expr-ref.ts +0 -5
- package/src/prover/smt/solver/expr-safe-replace.ts +26 -7
- package/src/prover/smt/solver/expr2polynomial.ts +146 -0
- package/src/prover/smt/solver/factor.ts +141 -0
- package/src/prover/smt/solver/fd-solver.ts +265 -0
- package/src/prover/smt/solver/fingerprints.ts +15 -26
- package/src/prover/smt/solver/fix-dl-var.ts +148 -0
- package/src/prover/smt/solver/flat-literals.ts +0 -9
- package/src/prover/smt/solver/fm-tactic.ts +884 -0
- package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
- package/src/prover/smt/solver/fpa-rewriter.ts +640 -0
- package/src/prover/smt/solver/fpa2bv-converter.ts +2249 -0
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +348 -0
- package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
- package/src/prover/smt/solver/goal.ts +176 -28
- package/src/prover/smt/solver/goal2nlsat.ts +189 -0
- package/src/prover/smt/solver/guard-set.ts +219 -0
- package/src/prover/smt/solver/hash.ts +0 -9
- package/src/prover/smt/solver/hashtable.ts +26 -23
- package/src/prover/smt/solver/inf-eps.ts +63 -0
- package/src/prover/smt/solver/inj-axiom.ts +101 -0
- package/src/prover/smt/solver/internalizer.ts +112 -132
- package/src/prover/smt/solver/lackr.ts +381 -0
- package/src/prover/smt/solver/lbool.ts +0 -2
- package/src/prover/smt/solver/lia2card.ts +268 -0
- package/src/prover/smt/solver/lia2pb.ts +154 -0
- package/src/prover/smt/solver/literal.ts +0 -4
- package/src/prover/smt/solver/logic-tactics.ts +345 -0
- package/src/prover/smt/solver/lp/bound-propagator.ts +7 -26
- package/src/prover/smt/solver/lp/constraints.ts +1 -8
- package/src/prover/smt/solver/lp/containers.ts +11 -30
- package/src/prover/smt/solver/lp/core-solver.ts +23 -29
- package/src/prover/smt/solver/lp/cross-nested.ts +5 -20
- package/src/prover/smt/solver/lp/dep-intervals.ts +6 -24
- package/src/prover/smt/solver/lp/dependency.ts +0 -5
- package/src/prover/smt/solver/lp/dioph-eq.ts +8 -103
- package/src/prover/smt/solver/lp/explanation.ts +0 -6
- package/src/prover/smt/solver/lp/gomory.ts +8 -22
- package/src/prover/smt/solver/lp/hnf-cutter.ts +16 -23
- package/src/prover/smt/solver/lp/hnf.ts +10 -28
- package/src/prover/smt/solver/lp/int-cube.ts +17 -39
- package/src/prover/smt/solver/lp/int-solver.ts +3 -35
- package/src/prover/smt/solver/lp/lar-solver.ts +69 -82
- package/src/prover/smt/solver/lp/lar-term.ts +0 -5
- package/src/prover/smt/solver/lp/lp-settings.ts +0 -14
- package/src/prover/smt/solver/lp/maximize-term.ts +76 -52
- package/src/prover/smt/solver/lp/nex-creator.ts +4 -28
- package/src/prover/smt/solver/lp/nex.ts +0 -6
- package/src/prover/smt/solver/lp/nla-backoff.ts +0 -5
- package/src/prover/smt/solver/lp/nla-basics.ts +48 -30
- package/src/prover/smt/solver/lp/nla-core.ts +91 -135
- package/src/prover/smt/solver/lp/nla-divisions.ts +31 -43
- package/src/prover/smt/solver/lp/nla-emonics.ts +3 -21
- package/src/prover/smt/solver/lp/nla-factorization.ts +0 -4
- package/src/prover/smt/solver/lp/nla-grobner.ts +22 -72
- package/src/prover/smt/solver/lp/nla-horner.ts +2 -12
- package/src/prover/smt/solver/lp/nla-intervals.ts +1 -12
- package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +15 -42
- package/src/prover/smt/solver/lp/nla-monotone.ts +1 -6
- package/src/prover/smt/solver/lp/nla-order.ts +0 -13
- package/src/prover/smt/solver/lp/nla-patcher.ts +3 -7
- package/src/prover/smt/solver/lp/nla-powers.ts +220 -0
- package/src/prover/smt/solver/lp/nla-tangents.ts +0 -10
- package/src/prover/smt/solver/lp/nla-throttle.ts +0 -6
- package/src/prover/smt/solver/lp/nla-transcendentals.ts +324 -0
- package/src/prover/smt/solver/lp/nla-types.ts +0 -12
- package/src/prover/smt/solver/lp/nla-var-eqs.ts +4 -26
- package/src/prover/smt/solver/lp/nra-solver.ts +123 -112
- package/src/prover/smt/solver/lp/numeric-pair.ts +0 -4
- package/src/prover/smt/solver/lp/pdd-interval.ts +0 -3
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +1 -14
- package/src/prover/smt/solver/lp/pdd-solver.ts +2 -33
- package/src/prover/smt/solver/lp/pdd.ts +7 -70
- package/src/prover/smt/solver/lp/random-updater.ts +0 -9
- package/src/prover/smt/solver/lp/static-matrix.ts +8 -19
- package/src/prover/smt/solver/lp/union-find.ts +5 -5
- package/src/prover/smt/solver/macro-finder.ts +530 -0
- package/src/prover/smt/solver/mam-compiler.ts +129 -139
- package/src/prover/smt/solver/mam-interpreter.ts +0 -21
- package/src/prover/smt/solver/max-bv-sharing-tactic.ts +17 -0
- package/src/prover/smt/solver/max-cliques.ts +105 -0
- package/src/prover/smt/solver/maxcore.ts +309 -0
- package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -21
- package/src/prover/smt/solver/maxlex.ts +115 -0
- package/src/prover/smt/solver/maxsmt-base.ts +105 -0
- package/src/prover/smt/solver/maxsmt.ts +92 -0
- package/src/prover/smt/solver/mbp/mbp-arith.ts +467 -0
- package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +101 -0
- package/src/prover/smt/solver/mbp/mbp-plugin.ts +287 -0
- package/src/prover/smt/solver/mbp/mbp-qel.ts +48 -0
- package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +271 -0
- package/src/prover/smt/solver/mbp/mbp-term-graph.ts +606 -0
- package/src/prover/smt/solver/model-based-opt.ts +844 -0
- package/src/prover/smt/solver/model-checker.ts +19 -62
- package/src/prover/smt/solver/model-evaluator.ts +190 -40
- package/src/prover/smt/solver/model-finder.ts +14 -32
- package/src/prover/smt/solver/model-generator.ts +56 -40
- package/src/prover/smt/solver/model-macro-solver.ts +60 -114
- package/src/prover/smt/solver/model-printer.ts +214 -0
- package/src/prover/smt/solver/mpf.ts +711 -0
- package/src/prover/smt/solver/mus.ts +51 -0
- package/src/prover/smt/solver/muz/dl-context.ts +404 -0
- package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +97 -0
- package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +167 -0
- package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +125 -0
- package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +299 -0
- package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +455 -0
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +340 -0
- package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +163 -0
- package/src/prover/smt/solver/muz/dl-rule-set.ts +273 -0
- package/src/prover/smt/solver/muz/dl-rule-transformer.ts +123 -0
- package/src/prover/smt/solver/muz/dl-rule.ts +496 -0
- package/src/prover/smt/solver/muz/hnf.ts +201 -0
- package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
- package/src/prover/smt/solver/muz/horn-tactic.ts +201 -0
- package/src/prover/smt/solver/muz/rule-properties.ts +337 -0
- package/src/prover/smt/solver/muz/spacer-context.ts +1406 -0
- package/src/prover/smt/solver/muz/spacer-dl-interface.ts +52 -0
- package/src/prover/smt/solver/muz/spacer-generalizers.ts +241 -0
- package/src/prover/smt/solver/muz/spacer-manager.ts +127 -0
- package/src/prover/smt/solver/muz/spacer-pdr.ts +218 -0
- package/src/prover/smt/solver/muz/spacer-prop-solver.ts +333 -0
- package/src/prover/smt/solver/muz/spacer-util.ts +282 -0
- package/src/prover/smt/solver/muz/substitution.ts +203 -0
- package/src/prover/smt/solver/nla2bv-tactic.ts +285 -0
- package/src/prover/smt/solver/nlqsat.ts +484 -0
- package/src/prover/smt/solver/nlsat/algebraic.ts +177 -160
- package/src/prover/smt/solver/nlsat/atoms.ts +24 -24
- package/src/prover/smt/solver/nlsat/evaluator.ts +16 -22
- package/src/prover/smt/solver/nlsat/explain.ts +65 -69
- package/src/prover/smt/solver/nlsat/interval-set.ts +9 -51
- package/src/prover/smt/solver/nlsat/levelwise.ts +48 -135
- package/src/prover/smt/solver/nlsat/mpbq.ts +47 -14
- package/src/prover/smt/solver/nlsat/polynomial.ts +29 -161
- package/src/prover/smt/solver/nlsat/solver.ts +241 -110
- package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
- package/src/prover/smt/solver/nlsat/transcendentals.ts +367 -0
- package/src/prover/smt/solver/nlsat/types.ts +0 -9
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +1 -47
- package/src/prover/smt/solver/nlsat/upolynomial.ts +10 -93
- package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
- package/src/prover/smt/solver/nnf.ts +107 -60
- package/src/prover/smt/solver/normalize-bounds.ts +53 -0
- package/src/prover/smt/solver/occf.ts +97 -0
- package/src/prover/smt/solver/opt-context.ts +787 -0
- package/src/prover/smt/solver/opt-nlsat.ts +375 -0
- package/src/prover/smt/solver/opt-pareto.ts +282 -0
- package/src/prover/smt/solver/opt-preprocess.ts +101 -0
- package/src/prover/smt/solver/opt-solver.ts +308 -0
- package/src/prover/smt/solver/opt-value.ts +55 -0
- package/src/prover/smt/solver/optsmt.ts +692 -0
- package/src/prover/smt/solver/parallel-tactic.ts +299 -0
- package/src/prover/smt/solver/pattern-inference.ts +21 -26
- package/src/prover/smt/solver/pb-rewriter.ts +284 -0
- package/src/prover/smt/solver/pb2bv-tactic.ts +540 -0
- package/src/prover/smt/solver/poly-rewriter.ts +204 -79
- package/src/prover/smt/solver/probes.ts +512 -0
- package/src/prover/smt/solver/propagate-values.ts +37 -30
- package/src/prover/smt/solver/proto-model.ts +650 -66
- package/src/prover/smt/solver/pull-quant.ts +28 -23
- package/src/prover/smt/solver/purify-arith.ts +632 -0
- package/src/prover/smt/solver/qe-arith-plugin.ts +1098 -0
- package/src/prover/smt/solver/qe-lite-der.ts +2 -31
- package/src/prover/smt/solver/qe-lite-fm.ts +4 -28
- package/src/prover/smt/solver/qe-lite.ts +39 -49
- package/src/prover/smt/solver/qe-mbp.ts +270 -0
- package/src/prover/smt/solver/qe.ts +1498 -0
- package/src/prover/smt/solver/qel.ts +25 -0
- package/src/prover/smt/solver/qi-queue.ts +0 -16
- package/src/prover/smt/solver/qsat.ts +814 -0
- package/src/prover/smt/solver/quant-hoist.ts +196 -0
- package/src/prover/smt/solver/quant-tactics.ts +17 -74
- package/src/prover/smt/solver/quantifier-analyzer.ts +26 -47
- package/src/prover/smt/solver/quantifier-manager.ts +8 -23
- package/src/prover/smt/solver/quasi-macros.ts +243 -0
- package/src/prover/smt/solver/random-gen.ts +0 -2
- package/src/prover/smt/solver/rational.ts +45 -8
- package/src/prover/smt/solver/recfun-decl-plugin.ts +261 -0
- package/src/prover/smt/solver/recfun-rewriter.ts +107 -0
- package/src/prover/smt/solver/reduce-args.ts +225 -0
- package/src/prover/smt/solver/reduce-bv-size.ts +119 -0
- package/src/prover/smt/solver/ref-vector.ts +0 -6
- package/src/prover/smt/solver/relevancy.ts +2 -16
- package/src/prover/smt/solver/rewriter-tpl.ts +52 -129
- package/src/prover/smt/solver/rewriter.ts +477 -120
- package/src/prover/smt/solver/rlimit.ts +39 -21
- package/src/prover/smt/solver/sat/asymm-branch.ts +325 -0
- package/src/prover/smt/solver/sat/big.ts +177 -0
- package/src/prover/smt/solver/sat/clause-use-list.ts +71 -0
- package/src/prover/smt/solver/sat/clause.ts +203 -0
- package/src/prover/smt/solver/sat/cleaner.ts +94 -0
- package/src/prover/smt/solver/sat/config.ts +122 -0
- package/src/prover/smt/solver/sat/consequences.ts +203 -0
- package/src/prover/smt/solver/sat/elim-eqs.ts +142 -0
- package/src/prover/smt/solver/sat/goal2sat.ts +526 -0
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +378 -0
- package/src/prover/smt/solver/sat/model-converter.ts +136 -0
- package/src/prover/smt/solver/sat/pb-constraint.ts +261 -0
- package/src/prover/smt/solver/sat/pb-solver.ts +1577 -0
- package/src/prover/smt/solver/sat/probing.ts +170 -0
- package/src/prover/smt/solver/sat/sat-tactic.ts +43 -0
- package/src/prover/smt/solver/sat/sat2goal.ts +165 -0
- package/src/prover/smt/solver/sat/scc.ts +142 -0
- package/src/prover/smt/solver/sat/simplifier.ts +1618 -0
- package/src/prover/smt/solver/sat/solver.ts +2127 -0
- package/src/prover/smt/solver/sat/var-queue.ts +117 -0
- package/src/prover/smt/solver/sat/watch-list.ts +140 -0
- package/src/prover/smt/solver/search-tree.ts +284 -0
- package/src/prover/smt/solver/seq-axioms.ts +1010 -0
- package/src/prover/smt/solver/seq-decl-plugin.ts +819 -0
- package/src/prover/smt/solver/seq-derive.ts +1301 -0
- package/src/prover/smt/solver/seq-eq-approx.ts +236 -0
- package/src/prover/smt/solver/seq-eq-solver.ts +439 -0
- package/src/prover/smt/solver/seq-factory.ts +89 -0
- package/src/prover/smt/solver/seq-monadic.ts +728 -0
- package/src/prover/smt/solver/seq-range-predicate.ts +235 -0
- package/src/prover/smt/solver/seq-re-rewriter.ts +1170 -0
- package/src/prover/smt/solver/seq-re-util.ts +758 -0
- package/src/prover/smt/solver/seq-regex-bisim.ts +144 -0
- package/src/prover/smt/solver/seq-regex-live.ts +200 -0
- package/src/prover/smt/solver/seq-rewriter.ts +2402 -0
- package/src/prover/smt/solver/seq-skolem.ts +317 -0
- package/src/prover/smt/solver/seq-subset.ts +165 -0
- package/src/prover/smt/solver/seq-view-witness.ts +353 -0
- package/src/prover/smt/solver/smt-consequences.ts +297 -0
- package/src/prover/smt/solver/smt-kernel.ts +83 -0
- package/src/prover/smt/solver/smt-logics.ts +66 -0
- package/src/prover/smt/solver/smt-setup.ts +496 -0
- package/src/prover/smt/solver/smt2-printer.ts +765 -0
- package/src/prover/smt/solver/smtlib-parser.ts +3140 -365
- package/src/prover/smt/solver/smtlib-script.ts +1631 -0
- package/src/prover/smt/solver/solve-eqs.ts +929 -0
- package/src/prover/smt/solver/solver.ts +119 -39
- package/src/prover/smt/solver/sort.ts +1 -5
- package/src/prover/smt/solver/static-features.ts +314 -0
- package/src/prover/smt/solver/sticky-generations.ts +0 -6
- package/src/prover/smt/solver/tactic.ts +1986 -0
- package/src/prover/smt/solver/term-enumeration.ts +205 -0
- package/src/prover/smt/solver/theory-array.ts +1240 -0
- package/src/prover/smt/solver/theory-bv.ts +1200 -0
- package/src/prover/smt/solver/theory-char.ts +355 -0
- package/src/prover/smt/solver/theory-datatype.ts +598 -0
- package/src/prover/smt/solver/theory-finite-set.ts +30 -0
- package/src/prover/smt/solver/theory-fpa.ts +389 -0
- package/src/prover/smt/solver/theory-lra-axioms.ts +55 -25
- package/src/prover/smt/solver/theory-lra-bounds.ts +31 -11
- package/src/prover/smt/solver/theory-lra-final-check.ts +59 -91
- package/src/prover/smt/solver/theory-lra-internalize.ts +94 -53
- package/src/prover/smt/solver/theory-lra-model.ts +23 -53
- package/src/prover/smt/solver/theory-lra-propagate.ts +24 -40
- package/src/prover/smt/solver/theory-lra-state.ts +6 -27
- package/src/prover/smt/solver/theory-lra.ts +188 -8
- package/src/prover/smt/solver/theory-pb.ts +934 -0
- package/src/prover/smt/solver/theory-polymorphism.ts +58 -0
- package/src/prover/smt/solver/theory-recfun.ts +307 -0
- package/src/prover/smt/solver/theory-seq-regex.ts +867 -0
- package/src/prover/smt/solver/theory-seq-solve.ts +1373 -0
- package/src/prover/smt/solver/theory-seq-state.ts +871 -0
- package/src/prover/smt/solver/theory-seq.ts +961 -0
- package/src/prover/smt/solver/theory.ts +189 -0
- package/src/prover/smt/solver/tseitin-cnf.ts +485 -0
- package/src/prover/smt/solver/var-subst.ts +37 -39
- package/src/prover/smt/table.ts +3 -10
- package/src/prover/smt/types.ts +146 -0
- package/src/prover/tlapm/cache.ts +67 -41
- package/src/prover/tlapm/ocaml-marshal.ts +19 -21
- package/src/prover/tlapm/tlapm.ts +21 -20
- package/src/prover/tlapm-library.ts +3208 -0
- package/src/prover/verdict.ts +9 -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 +10 -19
- package/src/prover/zenon/encode.ts +0 -9
- package/src/prover/zenon/eqrel.ts +2 -15
- package/src/prover/zenon/equality-rules.ts +0 -6
- package/src/prover/zenon/expr.ts +8 -28
- package/src/prover/zenon/index-table.ts +26 -59
- package/src/prover/zenon/isar-case.ts +8 -20
- package/src/prover/zenon/isar.ts +35 -65
- package/src/prover/zenon/limits.ts +0 -4
- package/src/prover/zenon/llproof.ts +2 -22
- package/src/prover/zenon/mltoll.ts +66 -106
- package/src/prover/zenon/node.ts +20 -15
- package/src/prover/zenon/ocaml.ts +1 -17
- package/src/prover/zenon/parse.ts +9 -13
- package/src/prover/zenon/phrase.ts +1 -13
- package/src/prover/zenon/proof.ts +0 -11
- package/src/prover/zenon/propositional-rules.ts +0 -7
- package/src/prover/zenon/rules.ts +2 -8
- package/src/prover/zenon/search.ts +11 -35
- package/src/prover/zenon/tla/functions.ts +59 -33
- package/src/prover/zenon/tla/llproof.ts +67 -78
- package/src/prover/zenon/tla/records.ts +57 -35
- package/src/prover/zenon/tla/rewrites.ts +12 -21
- package/src/prover/zenon/tla/sets.ts +88 -59
- package/src/prover/zenon/tla/terms.ts +0 -8
- package/src/prover/zenon/tla/tla.ts +66 -66
- package/src/randomization.ts +81 -35
- package/src/resolve.ts +67 -185
- package/src/runtime.ts +26 -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 +5 -35
- package/src/sany/lexer.ts +58 -77
- package/src/sany/linter.ts +0 -10
- 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 +671 -169
- package/src/simulate.ts +712 -0
- package/src/spec-description.ts +192 -100
- package/src/standard-definitions.ts +4 -4
- package/src/standard-modules.ts +264 -95
- package/src/state-graph.ts +52 -33
- package/src/subexpressions.ts +69 -52
- package/src/substitution-levels.ts +7 -7
- package/src/successors.ts +267 -100
- package/src/symmetry.ts +35 -27
- package/src/tableau.ts +29 -26
- package/src/tlc/fingerprint.ts +267 -79
- 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 +64 -60
- package/src/tlc/tlc-operators.ts +78 -44
- package/src/tlc/tlcext-operators.ts +171 -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/typed-tier.ts +6535 -0
- 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
- package/src/prover/isabelle/isar/statement.ts +0 -57
- package/src/prover/smt/solver/z3-license.txt +0 -10
- package/src/prover/tlaps-module.ts +0 -510
- package/src/prover/zenon/LICENSE +0 -32
|
@@ -1,19 +1,9 @@
|
|
|
1
|
-
|
|
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";
|
|
1
|
+
import { TlaError, TlaProverError, TlaUnsupportedError } from "../../errors";
|
|
6
2
|
import { normalizeApply, shiftExpr } from "../../obligations/substitution";
|
|
7
|
-
import {
|
|
3
|
+
import type { Bound, Builtin, Expr, Hyp, Sequent } from "../../obligations/expression";
|
|
4
|
+
import { getNumeral } from "./axioms";
|
|
8
5
|
import { createContext, type Identifier } from "./context";
|
|
9
|
-
import {
|
|
10
|
-
createFlattener,
|
|
11
|
-
getDepth,
|
|
12
|
-
getVariable,
|
|
13
|
-
removeUnprimable,
|
|
14
|
-
UNPRIMABLE,
|
|
15
|
-
type Entry,
|
|
16
|
-
} from "./flatten";
|
|
6
|
+
import { createFlattener, getDepth, removeUnprimable, UNPRIMABLE, type Entry } from "./flatten";
|
|
17
7
|
import {
|
|
18
8
|
BOOL_SET,
|
|
19
9
|
BUILTIN_SYMBOLS,
|
|
@@ -24,18 +14,21 @@ import {
|
|
|
24
14
|
disjoin,
|
|
25
15
|
FUN_APP,
|
|
26
16
|
FUN_EXCEPT,
|
|
17
|
+
FUN_ISAFCN,
|
|
27
18
|
FUN_SET,
|
|
28
19
|
getBinders,
|
|
20
|
+
getVariable,
|
|
21
|
+
getVariableSort,
|
|
29
22
|
INT_LTEQ,
|
|
30
23
|
INT_SET,
|
|
31
24
|
MEM,
|
|
32
25
|
NAT_SET,
|
|
26
|
+
PROJ_INT,
|
|
33
27
|
STR_SET,
|
|
34
28
|
SUBSET_EQ,
|
|
35
29
|
tla,
|
|
36
30
|
TT_IDV,
|
|
37
31
|
} from "./format";
|
|
38
|
-
import { getIntegers } from "./axioms";
|
|
39
32
|
import { getEquality, resolveTriggers, type Polarity } from "./extensionality";
|
|
40
33
|
import {
|
|
41
34
|
getChooseAxioms,
|
|
@@ -44,21 +37,39 @@ import {
|
|
|
44
37
|
getSetOfAxioms,
|
|
45
38
|
getSetStAxioms,
|
|
46
39
|
} from "./instances";
|
|
40
|
+
import {
|
|
41
|
+
BOOL,
|
|
42
|
+
getSort,
|
|
43
|
+
getTypeName,
|
|
44
|
+
IDV,
|
|
45
|
+
INT,
|
|
46
|
+
isSameType,
|
|
47
|
+
searchType,
|
|
48
|
+
STRING,
|
|
49
|
+
type Type,
|
|
50
|
+
} from "./types";
|
|
47
51
|
|
|
48
52
|
interface Term {
|
|
49
53
|
isBool: boolean;
|
|
50
54
|
text: string;
|
|
51
|
-
// Type.Synthesize: the Int-sorted form of a term that is an integer before it's cast to Idv.
|
|
52
55
|
integer?: string;
|
|
56
|
+
type?: Type;
|
|
53
57
|
}
|
|
54
58
|
|
|
55
|
-
// What tlapm keeps across the obligations of one run.
|
|
56
59
|
export interface EncodingSession {
|
|
57
60
|
caseErrors: number;
|
|
58
61
|
}
|
|
59
62
|
|
|
63
|
+
// The options of Smtlib.preprocess that tlapm's --debug flags set.
|
|
64
|
+
export interface SmtEncoding {
|
|
65
|
+
isArithmetic: boolean;
|
|
66
|
+
rewriteLevel: number;
|
|
67
|
+
isSetExtensional: boolean;
|
|
68
|
+
// Type level 2, which --debug smarter_types turns on.
|
|
69
|
+
isTyped: boolean;
|
|
70
|
+
}
|
|
71
|
+
|
|
60
72
|
export interface Mode {
|
|
61
|
-
// Whether the text encodes a fact that tlapm leaves out, which may declare operators.
|
|
62
73
|
isOmitted: boolean;
|
|
63
74
|
polarity: Polarity;
|
|
64
75
|
at: string | undefined;
|
|
@@ -66,8 +77,15 @@ export interface Mode {
|
|
|
66
77
|
}
|
|
67
78
|
|
|
68
79
|
export type Binding =
|
|
69
|
-
| { kind: "constant"; symbol: string }
|
|
70
|
-
| {
|
|
80
|
+
| { kind: "constant"; symbol: string; type?: Type }
|
|
81
|
+
| {
|
|
82
|
+
kind: "variable";
|
|
83
|
+
name: string;
|
|
84
|
+
symbol: string;
|
|
85
|
+
primed: string;
|
|
86
|
+
type?: Type;
|
|
87
|
+
primedType?: Type;
|
|
88
|
+
}
|
|
71
89
|
| { kind: "operator"; symbol: string; arity: number }
|
|
72
90
|
| { kind: "secondOrder"; name: string; shapes: number[] }
|
|
73
91
|
| { kind: "unsupported"; reason: string };
|
|
@@ -77,690 +95,1040 @@ export interface Env {
|
|
|
77
95
|
rest: Env | undefined;
|
|
78
96
|
}
|
|
79
97
|
|
|
80
|
-
|
|
81
|
-
|
|
98
|
+
export interface Encoder {
|
|
99
|
+
session: EncodingSession;
|
|
100
|
+
encoding: SmtEncoding;
|
|
101
|
+
flattener: ReturnType<typeof createFlattener>;
|
|
102
|
+
anonymous: Map<string, number>;
|
|
103
|
+
recordFields: Map<string, string[]>;
|
|
104
|
+
setTypes: Map<string, Type>;
|
|
105
|
+
context: ReturnType<typeof createContext>;
|
|
106
|
+
declared: Map<string, Identifier>;
|
|
107
|
+
}
|
|
108
|
+
|
|
82
109
|
interface NestedContext {
|
|
83
110
|
env: Env | undefined;
|
|
84
111
|
mode: Mode;
|
|
85
112
|
wrappers: ((body: string) => string)[];
|
|
86
113
|
}
|
|
87
114
|
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
|
|
102
|
-
term.isBool ? term.text : `(= ${resolveTriggers(term.text, true)} ${TT_IDV})`;
|
|
103
|
-
|
|
104
|
-
const toIdv = (term: Term) =>
|
|
105
|
-
term.isBool ? `(${CAST_BOOL} ${resolveTriggers(term.text, true)})` : term.text;
|
|
106
|
-
|
|
107
|
-
const bool = (text: string): Term => ({ isBool: true, text });
|
|
108
|
-
|
|
109
|
-
const idv = (text: string): Term => ({ isBool: false, text });
|
|
110
|
-
|
|
111
|
-
const getBinding = (env: Env | undefined, index: number): Binding => {
|
|
112
|
-
const found = Array.from({ length: index - 1 }).reduce<Env | undefined>(
|
|
113
|
-
(current) => current?.rest,
|
|
114
|
-
env,
|
|
115
|
-
);
|
|
116
|
-
if (!found) throw new TlaUnsupportedError("a reference outside the obligation");
|
|
117
|
-
return found.binding;
|
|
118
|
-
};
|
|
115
|
+
const UNSUPPORTED_OPERANDS = new Set<Builtin>([
|
|
116
|
+
"Prime",
|
|
117
|
+
"StrongPrime",
|
|
118
|
+
"Leadsto",
|
|
119
|
+
"ENABLED",
|
|
120
|
+
"UNCHANGED",
|
|
121
|
+
"Cdot",
|
|
122
|
+
"Actplus",
|
|
123
|
+
"BoxTrue",
|
|
124
|
+
"BoxFalse",
|
|
125
|
+
"Diamond",
|
|
126
|
+
"Divides",
|
|
127
|
+
"Irregular",
|
|
128
|
+
]);
|
|
119
129
|
|
|
120
|
-
|
|
130
|
+
const ARITHMETIC = new Set<Builtin>(["Plus", "Minus", "Times", "Uminus"]);
|
|
121
131
|
|
|
122
|
-
|
|
123
|
-
const getFree = (text: string, depth: number) =>
|
|
124
|
-
[...new Set(text.match(/[^\s()]+#\d+/g))]
|
|
125
|
-
.filter((variable) => getDepth(variable) < depth)
|
|
126
|
-
.toSorted((left, right) => getDepth(left) - getDepth(right));
|
|
132
|
+
const getSetType = (element: Type): Type => ({ kind: "Set", element });
|
|
127
133
|
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
const identifier = context.adjoin(name);
|
|
131
|
-
context.enter(identifier);
|
|
132
|
-
declared.set(identifier.name, identifier);
|
|
133
|
-
return identifier.name;
|
|
134
|
-
};
|
|
134
|
+
const getRecordFieldType = (type: Type, field: string) =>
|
|
135
|
+
type.kind === "Record" ? type.fields.find((entry) => entry.name === field)?.type : undefined;
|
|
135
136
|
|
|
136
|
-
|
|
137
|
+
const getFieldType = (type: Type, field: string) =>
|
|
138
|
+
type.kind === "Fun" && type.domain.kind === "String"
|
|
139
|
+
? type.range
|
|
140
|
+
: getRecordFieldType(type, field);
|
|
137
141
|
|
|
138
|
-
|
|
139
|
-
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
144
|
-
|
|
145
|
-
|
|
146
|
-
});
|
|
142
|
+
const getComponentType = (type: Type, args: Expr[]) => {
|
|
143
|
+
if (args.length !== 1) return undefined;
|
|
144
|
+
const arg = args[0];
|
|
145
|
+
if (arg.kind === "String") return getRecordFieldType(type, arg.value);
|
|
146
|
+
return arg.kind === "Num" && arg.fraction === "" && type.kind === "Product"
|
|
147
|
+
? type.items[Number(arg.integer) - 1]
|
|
148
|
+
: undefined;
|
|
149
|
+
};
|
|
147
150
|
|
|
148
|
-
|
|
149
|
-
|
|
150
|
-
|
|
151
|
-
|
|
152
|
-
|
|
153
|
-
|
|
154
|
-
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
|
|
158
|
-
.
|
|
159
|
-
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
|
|
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
|
-
};
|
|
151
|
+
const getBuiltinType = (builtin: Builtin, types: Type[]): Type | undefined => {
|
|
152
|
+
const first = types[0];
|
|
153
|
+
switch (builtin) {
|
|
154
|
+
case "Range":
|
|
155
|
+
return getSetType(INT);
|
|
156
|
+
case "Cup":
|
|
157
|
+
case "Cap":
|
|
158
|
+
case "Setminus":
|
|
159
|
+
return first.kind === "Set" && isSameType(first, types[1]) ? first : undefined;
|
|
160
|
+
case "UNION":
|
|
161
|
+
return first.kind === "Set" && first.element.kind === "Set" ? first.element : undefined;
|
|
162
|
+
case "SUBSET":
|
|
163
|
+
return first.kind === "Set" ? getSetType(first) : undefined;
|
|
164
|
+
case "DOMAIN":
|
|
165
|
+
if (first.kind === "Fun") return getSetType(first.domain);
|
|
166
|
+
if (first.kind === "Product") return getSetType(INT);
|
|
167
|
+
return first.kind === "Record" ? getSetType(STRING) : undefined;
|
|
168
|
+
default:
|
|
169
|
+
return undefined;
|
|
170
|
+
}
|
|
171
|
+
};
|
|
179
172
|
|
|
180
|
-
|
|
181
|
-
|
|
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
|
-
};
|
|
173
|
+
const toBool = (term: Term) =>
|
|
174
|
+
term.isBool ? term.text : `(= ${resolveTriggers(term.text, true)} ${TT_IDV})`;
|
|
199
175
|
|
|
200
|
-
|
|
201
|
-
|
|
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
|
-
};
|
|
176
|
+
const toIdv = (term: Term) =>
|
|
177
|
+
term.isBool ? `(${CAST_BOOL} ${resolveTriggers(term.text, true)})` : term.text;
|
|
218
178
|
|
|
219
|
-
|
|
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
|
-
};
|
|
179
|
+
const wrapBool = (text: string): Term => ({ isBool: true, text });
|
|
242
180
|
|
|
243
|
-
|
|
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
|
-
};
|
|
181
|
+
const wrapIdv = (text: string, type?: Type): Term => ({ isBool: false, text, type });
|
|
276
182
|
|
|
277
|
-
|
|
278
|
-
|
|
279
|
-
|
|
280
|
-
|
|
281
|
-
|
|
282
|
-
|
|
283
|
-
|
|
284
|
-
|
|
285
|
-
|
|
286
|
-
|
|
287
|
-
|
|
288
|
-
|
|
289
|
-
|
|
290
|
-
|
|
291
|
-
|
|
292
|
-
|
|
293
|
-
|
|
294
|
-
|
|
295
|
-
|
|
296
|
-
|
|
297
|
-
|
|
298
|
-
};
|
|
183
|
+
const wrapInteger = (text: string): Term => ({
|
|
184
|
+
isBool: false,
|
|
185
|
+
text: `(${CAST_INT} ${text})`,
|
|
186
|
+
integer: text,
|
|
187
|
+
});
|
|
188
|
+
|
|
189
|
+
const getTypedOnly = (encoder: Encoder, type: Type | undefined) =>
|
|
190
|
+
encoder.encoding.isTyped ? type : undefined;
|
|
191
|
+
|
|
192
|
+
const getType = (term: Term) =>
|
|
193
|
+
term.isBool ? BOOL : term.integer === undefined ? (term.type ?? IDV) : INT;
|
|
194
|
+
|
|
195
|
+
const getTyped = (symbol: string, type: Type | undefined) => {
|
|
196
|
+
if (type?.kind === "Int") return wrapInteger(symbol);
|
|
197
|
+
return type?.kind === "Bool" ? wrapBool(symbol) : wrapIdv(symbol, type);
|
|
198
|
+
};
|
|
199
|
+
|
|
200
|
+
// Type.Synthesize marks a component of a tuple or record as projected into its type, and only
|
|
201
|
+
// Int has a projection at type level 2. tlapm leaves a Bool component an Idv it then uses as a
|
|
202
|
+
// Bool, so it stays an individual here.
|
|
203
|
+
const project = (text: string, type: Type) => {
|
|
204
|
+
if (type.kind === "Int") return { isBool: false, text, integer: `(${PROJ_INT} ${text})` };
|
|
205
|
+
return wrapIdv(text, type.kind === "Bool" ? undefined : type);
|
|
206
|
+
};
|
|
207
|
+
|
|
208
|
+
const getElementType = (term: Term) => {
|
|
209
|
+
const type = getType(term);
|
|
210
|
+
return type.kind === "Set" ? type.element : undefined;
|
|
211
|
+
};
|
|
212
|
+
|
|
213
|
+
const getBinding = (env: Env | undefined, index: number): Binding => {
|
|
214
|
+
const found = Array.from({ length: index - 1 }).reduce<Env | undefined>(
|
|
215
|
+
(current) => current?.rest,
|
|
216
|
+
env,
|
|
217
|
+
);
|
|
218
|
+
if (!found) throw new TlaUnsupportedError("a reference outside the obligation");
|
|
219
|
+
return found.binding;
|
|
220
|
+
};
|
|
221
|
+
|
|
222
|
+
export const push = (env: Env | undefined, binding: Binding): Env => ({ binding, rest: env });
|
|
299
223
|
|
|
300
|
-
|
|
301
|
-
|
|
302
|
-
|
|
303
|
-
|
|
304
|
-
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
|
|
224
|
+
const inferType = (
|
|
225
|
+
encoder: Encoder,
|
|
226
|
+
expression: Expr,
|
|
227
|
+
env: Env | undefined,
|
|
228
|
+
mode: Mode,
|
|
229
|
+
depth: number,
|
|
230
|
+
) => {
|
|
231
|
+
const inner = Array.from({ length: depth }).reduce<Env | undefined>(
|
|
232
|
+
(current) => push(current, { kind: "unsupported", reason: "a declaration without a type" }),
|
|
233
|
+
env,
|
|
234
|
+
);
|
|
235
|
+
try {
|
|
236
|
+
return getType(
|
|
237
|
+
encode(
|
|
238
|
+
createEncoder({ caseErrors: encoder.session.caseErrors }, encoder.encoding),
|
|
239
|
+
expression,
|
|
240
|
+
inner,
|
|
241
|
+
mode,
|
|
242
|
+
),
|
|
308
243
|
);
|
|
244
|
+
} catch (error) {
|
|
245
|
+
if (error instanceof TlaError) return undefined;
|
|
246
|
+
throw error;
|
|
247
|
+
}
|
|
248
|
+
};
|
|
249
|
+
|
|
250
|
+
// The type a later hypothesis gives a declaration with no domain, which the env doesn't bind yet.
|
|
251
|
+
// A primed variable has no index of its own, so the hypotheses name it.
|
|
252
|
+
export const searchDeclarationType = (
|
|
253
|
+
encoder: Encoder,
|
|
254
|
+
expression: Expr,
|
|
255
|
+
isPositive: boolean,
|
|
256
|
+
env: Env | undefined,
|
|
257
|
+
mode: Mode,
|
|
258
|
+
primed?: string,
|
|
259
|
+
) =>
|
|
260
|
+
encoder.encoding.isTyped
|
|
261
|
+
? searchType(
|
|
262
|
+
{
|
|
263
|
+
infer: (inner, depth) =>
|
|
264
|
+
inferType(encoder, inner, env, mode, primed === undefined ? depth + 1 : depth),
|
|
265
|
+
isTarget: (inner, depth) =>
|
|
266
|
+
primed === undefined
|
|
267
|
+
? inner.kind === "Ix" && inner.index === depth + 1
|
|
268
|
+
: inner.kind === "Opaque" && inner.name === primed,
|
|
269
|
+
},
|
|
270
|
+
isPositive,
|
|
271
|
+
expression,
|
|
272
|
+
)
|
|
273
|
+
: undefined;
|
|
274
|
+
|
|
275
|
+
const getFree = (text: string, depth: number) =>
|
|
276
|
+
[...new Set(text.match(/[^\s()]+#\d+/g))]
|
|
277
|
+
.filter((variable) => getDepth(variable) < depth)
|
|
278
|
+
.toSorted((left, right) => getDepth(left) - getDepth(right));
|
|
279
|
+
|
|
280
|
+
export const getUniqueName = (encoder: Encoder, name: string) => {
|
|
281
|
+
const identifier = encoder.context.adjoin(name);
|
|
282
|
+
encoder.context.enter(identifier);
|
|
283
|
+
encoder.declared.set(identifier.name, identifier);
|
|
284
|
+
return identifier.name;
|
|
285
|
+
};
|
|
309
286
|
|
|
310
|
-
|
|
311
|
-
|
|
312
|
-
|
|
313
|
-
|
|
314
|
-
|
|
315
|
-
|
|
316
|
-
|
|
317
|
-
|
|
318
|
-
|
|
319
|
-
|
|
320
|
-
|
|
321
|
-
|
|
322
|
-
|
|
287
|
+
const clearPolarity = (mode: Mode): Mode => ({ ...mode, polarity: "Neither" });
|
|
288
|
+
|
|
289
|
+
const invert = (mode: Mode): Mode => ({
|
|
290
|
+
...mode,
|
|
291
|
+
polarity:
|
|
292
|
+
mode.polarity === "Positive"
|
|
293
|
+
? "Negative"
|
|
294
|
+
: mode.polarity === "Negative"
|
|
295
|
+
? "Positive"
|
|
296
|
+
: "Neither",
|
|
297
|
+
});
|
|
298
|
+
|
|
299
|
+
export const encodeIdv = (encoder: Encoder, expression: Expr, env: Env | undefined, mode: Mode) =>
|
|
300
|
+
toIdv(encode(encoder, expression, env, clearPolarity(mode)));
|
|
301
|
+
|
|
302
|
+
export const encodeBool = (encoder: Encoder, expression: Expr, env: Env | undefined, mode: Mode) =>
|
|
303
|
+
toBool(encode(encoder, expression, env, mode));
|
|
304
|
+
|
|
305
|
+
// tlapm's Rewrite encodes each Ditto's copy of a domain, so each copy flattens again.
|
|
306
|
+
const encodeDomains = (encoder: Encoder, bounds: Bound[], env: Env | undefined, mode: Mode) =>
|
|
307
|
+
bounds
|
|
308
|
+
.reduce<(Expr | undefined)[]>((domains, bound) => {
|
|
309
|
+
if (bound.domain.kind === "Ditto") return [...domains, domains.at(-1)];
|
|
310
|
+
if (bound.domain.kind === "NoDomain") return [...domains, undefined];
|
|
311
|
+
return [...domains, bound.domain.expression];
|
|
312
|
+
}, [])
|
|
313
|
+
.map((domain) =>
|
|
314
|
+
domain === undefined ? undefined : encode(encoder, domain, env, clearPolarity(mode)),
|
|
323
315
|
);
|
|
324
|
-
return { body, variable: bound.variables[0] };
|
|
325
|
-
};
|
|
326
316
|
|
|
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
|
-
|
|
317
|
+
const getDomains = (
|
|
318
|
+
encoder: Encoder,
|
|
319
|
+
bounds: Bound[],
|
|
320
|
+
env: Env | undefined,
|
|
321
|
+
mode: Mode,
|
|
322
|
+
construct: string,
|
|
323
|
+
) =>
|
|
324
|
+
encodeDomains(encoder, bounds, env, mode).map((domain) => {
|
|
325
|
+
if (domain === undefined) throw new TlaUnsupportedError(`${construct} without a domain`);
|
|
326
|
+
return domain;
|
|
327
|
+
});
|
|
328
|
+
|
|
329
|
+
const getSetResult = (encoder: Encoder, domains: Term[], getResult: (elements: Type[]) => Type) => {
|
|
330
|
+
const elements = domains.map(getElementType);
|
|
331
|
+
return encoder.encoding.isTyped && elements.every((element) => element !== undefined)
|
|
332
|
+
? getResult(elements.filter((element) => element !== undefined))
|
|
333
|
+
: undefined;
|
|
334
|
+
};
|
|
335
|
+
|
|
336
|
+
const bindVariables = (
|
|
337
|
+
names: string[],
|
|
338
|
+
env: Env | undefined,
|
|
339
|
+
mode: Mode,
|
|
340
|
+
types: (Type | undefined)[] = [],
|
|
341
|
+
) => {
|
|
342
|
+
const variables = names.map((name, index) =>
|
|
343
|
+
getVariable(name, mode.depth + index, getSort(types[index])),
|
|
344
|
+
);
|
|
345
|
+
const inner = variables.reduce<Env | undefined>(
|
|
346
|
+
(current, symbol, index) => push(current, { kind: "constant", symbol, type: types[index] }),
|
|
347
|
+
env,
|
|
348
|
+
);
|
|
349
|
+
return { variables, env: inner, mode: { ...mode, depth: mode.depth + names.length } };
|
|
350
|
+
};
|
|
351
|
+
|
|
352
|
+
// Type.Synthesize types a variable bounded by a set of type Set(t) as a t. A Ditto has the
|
|
353
|
+
// previous domain, though tlapm types it without a cast in its membership, or as Set(t) itself
|
|
354
|
+
// when t isn't atomic, so Z3 rejects either. A variable with no domain gets the type a hypothesis
|
|
355
|
+
// in the rest of the quantifier gives it.
|
|
356
|
+
const getBoundTypes = (
|
|
357
|
+
encoder: Encoder,
|
|
358
|
+
expression: Extract<Expr, { kind: "Quant" }>,
|
|
359
|
+
domains: (Term | undefined)[],
|
|
360
|
+
env: Env | undefined,
|
|
361
|
+
mode: Mode,
|
|
362
|
+
) =>
|
|
363
|
+
expression.bounds.reduce<{ types: (Type | undefined)[]; last: Type | undefined }>(
|
|
364
|
+
(state, bound, index) => {
|
|
365
|
+
const domain = domains[index];
|
|
366
|
+
const next = (type: Type | undefined) => ({ types: [...state.types, type], last: type });
|
|
367
|
+
if (bound.domain.kind === "Domain" && domain !== undefined)
|
|
368
|
+
return next(getElementType(domain));
|
|
369
|
+
if (bound.domain.kind === "Ditto" && state.last !== undefined) return next(state.last);
|
|
370
|
+
const rest = expression.bounds.slice(index + 1);
|
|
371
|
+
const scope = rest.length === 0 ? expression.body : { ...expression, bounds: rest };
|
|
372
|
+
const names = expression.bounds.slice(0, index).map((innerBound) => innerBound.name);
|
|
373
|
+
const outer = bindVariables(names, env, mode, state.types);
|
|
374
|
+
return next(
|
|
375
|
+
searchDeclarationType(
|
|
376
|
+
encoder,
|
|
377
|
+
scope,
|
|
378
|
+
expression.quantifier === "Forall",
|
|
379
|
+
outer.env,
|
|
380
|
+
outer.mode,
|
|
381
|
+
),
|
|
382
|
+
);
|
|
383
|
+
},
|
|
384
|
+
{ types: [], last: undefined },
|
|
385
|
+
).types;
|
|
386
|
+
|
|
387
|
+
const encodeQuantifier = (
|
|
388
|
+
encoder: Encoder,
|
|
389
|
+
expression: Extract<Expr, { kind: "Quant" }>,
|
|
390
|
+
env: Env | undefined,
|
|
391
|
+
mode: Mode,
|
|
392
|
+
) => {
|
|
393
|
+
const domains = encodeDomains(encoder, expression.bounds, env, mode);
|
|
394
|
+
const types = encoder.encoding.isTyped
|
|
395
|
+
? getBoundTypes(encoder, expression, domains, env, mode)
|
|
396
|
+
: [];
|
|
397
|
+
const bound = bindVariables(
|
|
398
|
+
expression.bounds.map((innerBound) => innerBound.name),
|
|
399
|
+
env,
|
|
400
|
+
mode,
|
|
401
|
+
types,
|
|
402
|
+
);
|
|
403
|
+
const body = encodeBool(encoder, expression.body, bound.env, bound.mode);
|
|
404
|
+
const guards = bound.variables.flatMap((variable, index) => {
|
|
405
|
+
const domain = domains[index];
|
|
406
|
+
if (domain === undefined) return [];
|
|
407
|
+
return [`(${MEM} ${toIdv(getTyped(variable, types[index]))} ${toIdv(domain)})`];
|
|
408
|
+
});
|
|
409
|
+
return expression.quantifier === "Forall"
|
|
410
|
+
? `(forall (${getBinders(bound.variables)}) ${guards.length === 0 ? body : `(=> ${conjoin(guards)} ${body})`})`
|
|
411
|
+
: `(exists (${getBinders(bound.variables)}) ${conjoin([...guards, body])})`;
|
|
412
|
+
};
|
|
413
|
+
|
|
414
|
+
const getSorts = (count: number, free: string[]) => [
|
|
415
|
+
...Array.from({ length: count }, () => "Idv"),
|
|
416
|
+
...free.map((variable) => getVariableSort(variable) ?? "Idv"),
|
|
417
|
+
];
|
|
418
|
+
|
|
419
|
+
const encodeSetSt = (
|
|
420
|
+
encoder: Encoder,
|
|
421
|
+
expression: Extract<Expr, { kind: "SetSt" }>,
|
|
422
|
+
env: Env | undefined,
|
|
423
|
+
mode: Mode,
|
|
424
|
+
) => {
|
|
425
|
+
const domain = encode(encoder, expression.domain, env, clearPolarity(mode));
|
|
426
|
+
const bound = bindVariables([expression.name], env, clearPolarity(mode));
|
|
427
|
+
const body = encodeBool(encoder, expression.body, bound.env, bound.mode);
|
|
428
|
+
const free = getFree(body, mode.depth);
|
|
429
|
+
const symbol = encoder.flattener.flatten(
|
|
430
|
+
"SetSt",
|
|
431
|
+
body,
|
|
432
|
+
mode,
|
|
433
|
+
(name) => getSetStAxioms(name, free, body, bound.variables[0]),
|
|
434
|
+
getSorts(1, free),
|
|
435
|
+
);
|
|
436
|
+
return wrapIdv(
|
|
437
|
+
call(symbol, [toIdv(domain), ...free]),
|
|
438
|
+
getSetResult(encoder, [domain], (elements) => getSetType(elements[0])),
|
|
439
|
+
);
|
|
440
|
+
};
|
|
441
|
+
|
|
442
|
+
// At type level 2 tlapm also gives a set of values the types Standardize rejects, so it encodes
|
|
443
|
+
// none.
|
|
444
|
+
const encodeSetOf = (
|
|
445
|
+
encoder: Encoder,
|
|
446
|
+
expression: Extract<Expr, { kind: "SetOf" }>,
|
|
447
|
+
env: Env | undefined,
|
|
448
|
+
mode: Mode,
|
|
449
|
+
) => {
|
|
450
|
+
const domains = getDomains(encoder, expression.bounds, env, mode, "a set of values");
|
|
451
|
+
const bound = bindVariables(
|
|
452
|
+
expression.bounds.map((innerBound) => innerBound.name),
|
|
453
|
+
env,
|
|
454
|
+
clearPolarity(mode),
|
|
455
|
+
);
|
|
456
|
+
const element = encode(encoder, expression.element, bound.env, clearPolarity(bound.mode));
|
|
457
|
+
const text = toIdv(element);
|
|
458
|
+
const free = getFree(text, mode.depth);
|
|
459
|
+
const count = domains.length;
|
|
460
|
+
const symbol = encoder.flattener.flatten(
|
|
461
|
+
`SetOf_${count}`,
|
|
462
|
+
text,
|
|
463
|
+
mode,
|
|
464
|
+
(name) => getSetOfAxioms(name, free, text, bound.variables),
|
|
465
|
+
getSorts(count, free),
|
|
466
|
+
);
|
|
467
|
+
return wrapIdv(
|
|
468
|
+
call(symbol, [...domains.map(toIdv), ...free]),
|
|
469
|
+
getSetResult(encoder, domains, () => getSetType(getType(element))),
|
|
470
|
+
);
|
|
471
|
+
};
|
|
472
|
+
|
|
473
|
+
// tlapm binds the components of a function of several arguments in a LET. It builds every
|
|
474
|
+
// component from Ix 1, which inside the LET is the previous component, doesn't shift the body past
|
|
475
|
+
// the tuple, and indexes the tuple with untyped numbers that no axiom relates to the tuple's, so
|
|
476
|
+
// this binds each component to its typed index.
|
|
477
|
+
const encodeFunction = (
|
|
478
|
+
encoder: Encoder,
|
|
479
|
+
expression: Extract<Expr, { kind: "Fcn" }>,
|
|
480
|
+
env: Env | undefined,
|
|
481
|
+
mode: Mode,
|
|
482
|
+
) => {
|
|
483
|
+
const terms = getDomains(encoder, expression.bounds, env, mode, "a function");
|
|
484
|
+
const domains = terms.map(toIdv);
|
|
485
|
+
const domain =
|
|
486
|
+
domains.length === 1 ? domains[0] : call(tla(`Product_${domains.length}`), domains);
|
|
487
|
+
const variable = getVariable(domains.length === 1 ? expression.bounds[0].name : "x", mode.depth);
|
|
488
|
+
const inner = { ...clearPolarity(mode), depth: mode.depth + 1 };
|
|
489
|
+
const components = bindVariables(
|
|
490
|
+
domains.length === 1 ? [] : expression.bounds.map((bound) => bound.name),
|
|
491
|
+
env,
|
|
492
|
+
inner,
|
|
493
|
+
);
|
|
494
|
+
const term = encode(
|
|
495
|
+
encoder,
|
|
496
|
+
expression.body,
|
|
497
|
+
domains.length === 1 ? push(env, { kind: "constant", symbol: variable }) : components.env,
|
|
498
|
+
clearPolarity(components.mode),
|
|
499
|
+
);
|
|
500
|
+
const body = toIdv(term);
|
|
501
|
+
const definitions = components.variables.map(
|
|
502
|
+
(component, index) =>
|
|
503
|
+
`(${component} (${FUN_APP} ${variable} ${getNumeral(index + 1, encoder.encoding.isArithmetic)}))`,
|
|
504
|
+
);
|
|
505
|
+
// Smtlib prints the definitions of a LET last first, and N_axiomatize visits them in order.
|
|
506
|
+
const value =
|
|
507
|
+
domains.length === 1 ? body : `(let (${definitions.toReversed().join(" ")}) ${body})`;
|
|
508
|
+
const free = getFree(value, mode.depth);
|
|
509
|
+
const symbol = encoder.flattener.flatten(
|
|
510
|
+
"FunFcn",
|
|
511
|
+
domains.length === 1 ? body : `(let (${definitions.join(" ")}) ${body})`,
|
|
512
|
+
mode,
|
|
513
|
+
(name, axioms) => getFunctionAxioms(name, free, value, variable, axioms),
|
|
514
|
+
getSorts(1, free),
|
|
515
|
+
);
|
|
516
|
+
return wrapIdv(
|
|
517
|
+
call(symbol, [domain, ...free]),
|
|
518
|
+
getSetResult(encoder, terms, (elements) => ({
|
|
519
|
+
kind: "Fun",
|
|
520
|
+
domain: elements.length === 1 ? elements[0] : { kind: "Product", items: elements },
|
|
521
|
+
range: getType(term),
|
|
522
|
+
})),
|
|
523
|
+
);
|
|
524
|
+
};
|
|
525
|
+
|
|
526
|
+
// At type level 2 tlapm sorts the variable of a CHOOSE over a set of type Set(Int) as an Int in
|
|
527
|
+
// its body but an Idv in ChooseDef, which Z3 rejects, so it stays an Idv.
|
|
528
|
+
const encodeChoose = (
|
|
529
|
+
encoder: Encoder,
|
|
530
|
+
expression: Extract<Expr, { kind: "Choose" }>,
|
|
531
|
+
env: Env | undefined,
|
|
532
|
+
mode: Mode,
|
|
533
|
+
) => {
|
|
534
|
+
const bound = bindVariables([expression.name], env, clearPolarity(mode));
|
|
535
|
+
const variable = bound.variables[0];
|
|
536
|
+
const domain =
|
|
537
|
+
expression.domain && `(${MEM} ${variable} ${encodeIdv(encoder, expression.domain, env, mode)})`;
|
|
538
|
+
const predicate = encodeBool(encoder, expression.body, bound.env, bound.mode);
|
|
539
|
+
const body = domain === undefined ? predicate : conjoin([domain, predicate]);
|
|
540
|
+
const free = getFree(body, mode.depth);
|
|
541
|
+
const symbol = encoder.flattener.flatten(
|
|
542
|
+
"Choose",
|
|
543
|
+
body,
|
|
544
|
+
mode,
|
|
545
|
+
(name) => getChooseAxioms(name, free, body, variable),
|
|
546
|
+
getSorts(0, free),
|
|
547
|
+
);
|
|
548
|
+
return wrapIdv(call(symbol, free));
|
|
549
|
+
};
|
|
550
|
+
|
|
551
|
+
// Type.Synthesize compares values of the same type in their own sort only above type level 1,
|
|
552
|
+
// and Standardize triggers set extensionality on any equality of two sets of one type.
|
|
553
|
+
const encodeEquality = (
|
|
554
|
+
encoder: Encoder,
|
|
555
|
+
args: Expr[],
|
|
556
|
+
env: Env | undefined,
|
|
557
|
+
mode: Mode,
|
|
558
|
+
isNegated: boolean,
|
|
559
|
+
) => {
|
|
560
|
+
const left = encode(encoder, args[0], env, clearPolarity(mode));
|
|
561
|
+
const right = encode(encoder, args[1], env, clearPolarity(mode));
|
|
562
|
+
const type = getType(left);
|
|
563
|
+
const polarity = encoder.encoding.isSetExtensional ? mode.polarity : undefined;
|
|
564
|
+
if (!encoder.encoding.isTyped || !isSameType(type, getType(right)))
|
|
565
|
+
return getEquality(toIdv(left), toIdv(right), polarity, isNegated);
|
|
566
|
+
if (type.kind === "Int" || type.kind === "Bool") {
|
|
567
|
+
const operands = [left, right].map((term) => term.integer ?? term.text).join(" ");
|
|
568
|
+
return isNegated ? `(distinct ${operands})` : `(= ${operands})`;
|
|
569
|
+
}
|
|
570
|
+
if (type.kind !== "Set") return getEquality(left.text, right.text, polarity, isNegated);
|
|
571
|
+
const name = `TrigEq_${getTypeName(type)}`;
|
|
572
|
+
encoder.setTypes.set(name, type);
|
|
573
|
+
return getEquality(left.text, right.text, polarity, isNegated, tla(name));
|
|
574
|
+
};
|
|
575
|
+
|
|
576
|
+
const getSelectionTest = (encoder: Encoder, test: Expr, env: Env | undefined, mode: Mode) => {
|
|
577
|
+
const lambda = test.kind === "Lambda" && test.params.length === 1 ? test : undefined;
|
|
578
|
+
const bound = bindVariables([lambda?.params[0].name ?? "x1"], env, clearPolarity(mode));
|
|
579
|
+
const body = encodeBool(
|
|
580
|
+
encoder,
|
|
581
|
+
lambda?.body ?? {
|
|
582
|
+
kind: "Apply",
|
|
583
|
+
operator: shiftExpr(1, test),
|
|
584
|
+
args: [{ kind: "Ix", index: 1 }],
|
|
585
|
+
},
|
|
586
|
+
bound.env,
|
|
587
|
+
bound.mode,
|
|
588
|
+
);
|
|
589
|
+
return { body, variable: bound.variables[0] };
|
|
590
|
+
};
|
|
591
|
+
|
|
592
|
+
const encodeBuiltin = (
|
|
593
|
+
encoder: Encoder,
|
|
594
|
+
builtin: Builtin,
|
|
595
|
+
args: Expr[],
|
|
596
|
+
env: Env | undefined,
|
|
597
|
+
mode: Mode,
|
|
598
|
+
): Term => {
|
|
599
|
+
const getTerms = () => args.map((arg) => encode(encoder, arg, env, clearPolarity(mode)));
|
|
600
|
+
const encodeArgs = () => getTerms().map(toIdv);
|
|
601
|
+
switch (builtin) {
|
|
602
|
+
case "Conj":
|
|
603
|
+
return wrapBool(conjoin(args.map((arg) => encodeBool(encoder, arg, env, mode))));
|
|
604
|
+
case "Disj":
|
|
605
|
+
return wrapBool(disjoin(args.map((arg) => encodeBool(encoder, arg, env, mode))));
|
|
606
|
+
case "Implies":
|
|
607
|
+
return wrapBool(
|
|
608
|
+
`(=> ${encodeBool(encoder, args[0], env, invert(mode))} ${encodeBool(encoder, args[1], env, mode)})`,
|
|
609
|
+
);
|
|
610
|
+
case "Equiv":
|
|
611
|
+
return wrapBool(
|
|
612
|
+
`(= ${args.map((arg) => encodeBool(encoder, arg, env, clearPolarity(mode))).join(" ")})`,
|
|
613
|
+
);
|
|
614
|
+
case "Neg":
|
|
615
|
+
return wrapBool(`(not ${encodeBool(encoder, args[0], env, invert(mode))})`);
|
|
616
|
+
case "Eq":
|
|
617
|
+
return wrapBool(encodeEquality(encoder, args, env, mode, false));
|
|
618
|
+
case "Neq":
|
|
619
|
+
return wrapBool(encodeEquality(encoder, args, env, mode, true));
|
|
620
|
+
case "Mem":
|
|
621
|
+
return wrapBool(call(MEM, encodeArgs()));
|
|
622
|
+
case "Notmem":
|
|
623
|
+
return wrapBool(`(not ${call(MEM, encodeArgs())})`);
|
|
624
|
+
case "Subseteq":
|
|
625
|
+
return wrapBool(call(SUBSET_EQ, encodeArgs()));
|
|
626
|
+
case "Lteq":
|
|
627
|
+
case "Gteq":
|
|
628
|
+
case "Lt":
|
|
629
|
+
case "Gt": {
|
|
630
|
+
const terms = getTerms();
|
|
631
|
+
const integers = terms.flatMap((term) => (term.integer === undefined ? [] : [term.integer]));
|
|
632
|
+
if (encoder.encoding.isTyped && integers.length === 2)
|
|
633
|
+
return wrapBool(call(tla(`TInt${builtin}`), integers));
|
|
634
|
+
const order = (operands: string[]) =>
|
|
635
|
+
builtin === "Lteq" || builtin === "Lt" ? operands : operands.toReversed();
|
|
636
|
+
const operands = order(terms.map(toIdv));
|
|
637
|
+
if (builtin === "Lteq" || builtin === "Gteq") return wrapBool(call(INT_LTEQ, operands));
|
|
638
|
+
// Rewrite copies the operands before Flatten, which flattens each copy again.
|
|
639
|
+
return wrapBool(
|
|
640
|
+
`(and ${call(INT_LTEQ, operands)} (distinct ${order(encodeArgs()).join(" ")}))`,
|
|
641
|
+
);
|
|
642
|
+
}
|
|
643
|
+
case "SelectSeq": {
|
|
644
|
+
const test = getSelectionTest(encoder, args[1], env, mode);
|
|
645
|
+
const free = getFree(test.body, mode.depth);
|
|
646
|
+
const symbol = encoder.flattener.flatten(
|
|
647
|
+
"SelectSeq",
|
|
648
|
+
test.body,
|
|
649
|
+
mode,
|
|
650
|
+
(name) =>
|
|
651
|
+
getSelectSeqAxioms(name, free, test.body, test.variable, encoder.encoding.isArithmetic),
|
|
652
|
+
getSorts(1, free),
|
|
653
|
+
);
|
|
654
|
+
return wrapIdv(call(symbol, [encodeIdv(encoder, args[0], env, mode), ...free]));
|
|
655
|
+
}
|
|
656
|
+
case "Unprimable": {
|
|
657
|
+
const term = encode(encoder, args[0], env, clearPolarity(mode));
|
|
658
|
+
return { ...term, text: `(${UNPRIMABLE} ${term.text})` };
|
|
659
|
+
}
|
|
660
|
+
default: {
|
|
661
|
+
const symbol = BUILTIN_SYMBOLS[builtin];
|
|
662
|
+
if (symbol === undefined)
|
|
663
|
+
throw new TlaProverError(
|
|
664
|
+
UNSUPPORTED_OPERANDS.has(builtin)
|
|
665
|
+
? `Type.Synthesize: Unsupported builtin ${builtin.startsWith("Box") ? "Box" : builtin}`
|
|
666
|
+
: "Type.Synthesize: Unexpected left operand",
|
|
379
667
|
);
|
|
380
|
-
|
|
381
|
-
|
|
382
|
-
|
|
383
|
-
|
|
384
|
-
return
|
|
385
|
-
|
|
386
|
-
default: {
|
|
387
|
-
const symbol = BUILTIN_SYMBOLS[builtin];
|
|
388
|
-
if (symbol === undefined) throw new TlaUnsupportedError(`the operator ${builtin}`);
|
|
389
|
-
return idv(call(symbol, idvs()));
|
|
390
|
-
}
|
|
668
|
+
const terms = getTerms();
|
|
669
|
+
if (!encoder.encoding.isTyped) return wrapIdv(call(symbol, terms.map(toIdv)));
|
|
670
|
+
const integers = terms.flatMap((term) => (term.integer === undefined ? [] : [term.integer]));
|
|
671
|
+
if (ARITHMETIC.has(builtin) && integers.length === terms.length)
|
|
672
|
+
return wrapInteger(call(tla(`TInt${builtin}`), integers));
|
|
673
|
+
return wrapIdv(call(symbol, terms.map(toIdv)), getBuiltinType(builtin, terms.map(getType)));
|
|
391
674
|
}
|
|
392
|
-
}
|
|
675
|
+
}
|
|
676
|
+
};
|
|
393
677
|
|
|
394
|
-
|
|
395
|
-
|
|
396
|
-
|
|
397
|
-
|
|
398
|
-
|
|
399
|
-
|
|
400
|
-
|
|
401
|
-
|
|
402
|
-
|
|
403
|
-
|
|
404
|
-
|
|
405
|
-
|
|
406
|
-
|
|
407
|
-
|
|
408
|
-
|
|
409
|
-
|
|
410
|
-
|
|
411
|
-
|
|
412
|
-
|
|
413
|
-
|
|
414
|
-
|
|
415
|
-
|
|
416
|
-
|
|
417
|
-
|
|
418
|
-
|
|
419
|
-
|
|
420
|
-
|
|
421
|
-
|
|
422
|
-
|
|
423
|
-
|
|
424
|
-
|
|
425
|
-
|
|
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")
|
|
678
|
+
const encodeReference = (
|
|
679
|
+
encoder: Encoder,
|
|
680
|
+
binding: Binding,
|
|
681
|
+
args: Expr[],
|
|
682
|
+
env: Env | undefined,
|
|
683
|
+
mode: Mode,
|
|
684
|
+
): Term => {
|
|
685
|
+
switch (binding.kind) {
|
|
686
|
+
case "constant":
|
|
687
|
+
case "variable":
|
|
688
|
+
if (args.length > 0) throw new TlaUnsupportedError(`an applied ${binding.kind}`);
|
|
689
|
+
return getTyped(binding.symbol, binding.type);
|
|
690
|
+
case "operator":
|
|
691
|
+
if (args.length === 0 && binding.arity > 0)
|
|
692
|
+
throw new TlaProverError("Type.Synthesize: Impossible operator conversion");
|
|
693
|
+
if (args.length !== binding.arity)
|
|
694
|
+
throw new TlaUnsupportedError("an operator applied to the wrong number of arguments");
|
|
695
|
+
return wrapIdv(
|
|
696
|
+
call(
|
|
697
|
+
binding.symbol,
|
|
698
|
+
args.map((arg) => encodeIdv(encoder, arg, env, mode)),
|
|
699
|
+
),
|
|
700
|
+
);
|
|
701
|
+
case "secondOrder": {
|
|
702
|
+
if (args.length !== binding.shapes.length)
|
|
703
|
+
throw new TlaUnsupportedError("an operator applied to the wrong number of arguments");
|
|
704
|
+
const operands = args.map((arg, index) => {
|
|
705
|
+
if (binding.shapes[index] === 0)
|
|
706
|
+
return { isFirstOrder: true, text: encodeIdv(encoder, arg, env, mode) };
|
|
707
|
+
if (arg.kind === "Ix") {
|
|
708
|
+
const argument = getBinding(env, arg.index);
|
|
709
|
+
if (argument.kind !== "operator")
|
|
431
710
|
throw new TlaUnsupportedError("an operator argument that isn't a LAMBDA");
|
|
432
|
-
|
|
433
|
-
|
|
434
|
-
|
|
435
|
-
|
|
436
|
-
|
|
437
|
-
|
|
438
|
-
|
|
439
|
-
|
|
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,
|
|
711
|
+
return { isFirstOrder: false, text: argument.symbol };
|
|
712
|
+
}
|
|
713
|
+
if (arg.kind !== "Lambda")
|
|
714
|
+
throw new TlaUnsupportedError("an operator argument that isn't a LAMBDA");
|
|
715
|
+
const bound = bindVariables(
|
|
716
|
+
arg.params.map((param) => param.name),
|
|
717
|
+
env,
|
|
718
|
+
clearPolarity(mode),
|
|
453
719
|
);
|
|
454
|
-
return
|
|
455
|
-
}
|
|
456
|
-
|
|
457
|
-
|
|
720
|
+
return { isFirstOrder: false, text: encodeIdv(encoder, arg.body, bound.env, bound.mode) };
|
|
721
|
+
});
|
|
722
|
+
const firstOrder = operands.flatMap((operand) =>
|
|
723
|
+
operand.isFirstOrder ? [operand.text] : [],
|
|
724
|
+
);
|
|
725
|
+
const higherOrder = operands.flatMap((operand) =>
|
|
726
|
+
operand.isFirstOrder ? [] : [operand.text],
|
|
727
|
+
);
|
|
728
|
+
const free = getFree(higherOrder.join(" "), mode.depth);
|
|
729
|
+
const symbol = encoder.flattener.flatten(
|
|
730
|
+
"",
|
|
731
|
+
higherOrder.join(" "),
|
|
732
|
+
mode,
|
|
733
|
+
() => [],
|
|
734
|
+
getSorts(firstOrder.length, free),
|
|
735
|
+
binding.name,
|
|
736
|
+
);
|
|
737
|
+
return wrapIdv(call(symbol, [...firstOrder, ...free]));
|
|
458
738
|
}
|
|
459
|
-
|
|
739
|
+
case "unsupported":
|
|
740
|
+
throw new TlaUnsupportedError(binding.reason);
|
|
741
|
+
}
|
|
742
|
+
};
|
|
460
743
|
|
|
461
|
-
|
|
462
|
-
|
|
463
|
-
const
|
|
464
|
-
|
|
465
|
-
|
|
466
|
-
|
|
467
|
-
|
|
468
|
-
: getPrimed(env.rest, name);
|
|
469
|
-
};
|
|
744
|
+
const getPrimed = (env: Env | undefined, name: string): Term => {
|
|
745
|
+
if (!env) throw new TlaUnsupportedError(`a primed declaration that isn't a variable`);
|
|
746
|
+
const binding = env.binding;
|
|
747
|
+
return binding.kind === "variable" && binding.name === name
|
|
748
|
+
? getTyped(binding.primed, binding.primedType)
|
|
749
|
+
: getPrimed(env.rest, name);
|
|
750
|
+
};
|
|
470
751
|
|
|
471
|
-
|
|
472
|
-
|
|
473
|
-
|
|
474
|
-
|
|
475
|
-
|
|
476
|
-
|
|
477
|
-
|
|
478
|
-
|
|
479
|
-
|
|
480
|
-
|
|
481
|
-
|
|
482
|
-
|
|
483
|
-
|
|
484
|
-
|
|
752
|
+
const encodeOpaque = (
|
|
753
|
+
encoder: Encoder,
|
|
754
|
+
name: string,
|
|
755
|
+
args: Expr[],
|
|
756
|
+
env: Env | undefined,
|
|
757
|
+
mode: Mode,
|
|
758
|
+
): Term => {
|
|
759
|
+
// Rewrite.simplify_sets writes IsAFcn for the functions in a set of functions.
|
|
760
|
+
if (name === "IsAFcn" && args.length === 1)
|
|
761
|
+
return wrapBool(`(${FUN_ISAFCN} ${encodeIdv(encoder, args[0], env, mode)})`);
|
|
762
|
+
if (args.length === 0 && name.endsWith("#prime"))
|
|
763
|
+
return getPrimed(env, name.slice(0, -"#prime".length));
|
|
764
|
+
const anonymousName = args.length === 0 ? `Anon_OPAQUE_${name}` : `Anon_${name}`;
|
|
765
|
+
encoder.anonymous.set(anonymousName, args.length);
|
|
766
|
+
return wrapIdv(
|
|
767
|
+
call(
|
|
768
|
+
tla(anonymousName),
|
|
769
|
+
args.map((arg) => encodeIdv(encoder, arg, env, mode)),
|
|
770
|
+
),
|
|
771
|
+
);
|
|
772
|
+
};
|
|
485
773
|
|
|
486
|
-
|
|
487
|
-
|
|
488
|
-
|
|
489
|
-
|
|
490
|
-
|
|
491
|
-
|
|
492
|
-
|
|
493
|
-
|
|
494
|
-
|
|
495
|
-
|
|
496
|
-
|
|
497
|
-
|
|
498
|
-
|
|
499
|
-
|
|
500
|
-
|
|
501
|
-
|
|
502
|
-
|
|
503
|
-
|
|
504
|
-
|
|
505
|
-
|
|
506
|
-
|
|
507
|
-
|
|
508
|
-
|
|
509
|
-
|
|
510
|
-
|
|
511
|
-
|
|
512
|
-
|
|
774
|
+
const encodeExcept = (
|
|
775
|
+
encoder: Encoder,
|
|
776
|
+
expression: Extract<Expr, { kind: "Except" }>,
|
|
777
|
+
env: Env | undefined,
|
|
778
|
+
mode: Mode,
|
|
779
|
+
) =>
|
|
780
|
+
expression.specs.reduce(
|
|
781
|
+
(base, spec) => {
|
|
782
|
+
const update = (value: string, trail: typeof spec.trail): string => {
|
|
783
|
+
if (trail.length === 0) return encodeIdv(encoder, spec.value, env, { ...mode, at: value });
|
|
784
|
+
const point = trail[0];
|
|
785
|
+
const encodeKey = () =>
|
|
786
|
+
point.kind === "Dot"
|
|
787
|
+
? tla(`StrLit_${point.field}`)
|
|
788
|
+
: encodeIdv(encoder, point.expression, env, mode);
|
|
789
|
+
const key = encodeKey();
|
|
790
|
+
// Elab.desugar repeats the key in the value it updates, and Flatten counts both.
|
|
791
|
+
const inner = update(
|
|
792
|
+
`(${FUN_APP} ${value} ${trail.length > 1 ? encodeKey() : key})`,
|
|
793
|
+
trail.slice(1),
|
|
794
|
+
);
|
|
795
|
+
return `(${FUN_EXCEPT} ${value} ${key} ${inner})`;
|
|
796
|
+
};
|
|
797
|
+
return update(base, spec.trail);
|
|
798
|
+
},
|
|
799
|
+
encodeIdv(encoder, expression.function, env, mode),
|
|
800
|
+
);
|
|
513
801
|
|
|
514
|
-
|
|
515
|
-
|
|
516
|
-
|
|
517
|
-
|
|
518
|
-
|
|
519
|
-
|
|
520
|
-
};
|
|
802
|
+
const getCaseError = (encoder: Encoder) => {
|
|
803
|
+
encoder.session.caseErrors++;
|
|
804
|
+
const name = `Anon_incomplete_case_error_${encoder.session.caseErrors}`;
|
|
805
|
+
encoder.anonymous.set(name, 0);
|
|
806
|
+
return tla(name);
|
|
807
|
+
};
|
|
521
808
|
|
|
522
|
-
|
|
523
|
-
|
|
524
|
-
|
|
525
|
-
|
|
526
|
-
|
|
527
|
-
|
|
528
|
-
|
|
529
|
-
|
|
530
|
-
|
|
531
|
-
|
|
532
|
-
|
|
533
|
-
|
|
534
|
-
|
|
535
|
-
|
|
536
|
-
|
|
537
|
-
(rest, arm, index) =>
|
|
538
|
-
`(ite ${encodeBool(arm.condition, env, neither(mode))} ${bodies[index].integer} ${rest})`,
|
|
539
|
-
other.integer ?? "",
|
|
540
|
-
);
|
|
541
|
-
return { isBool: false, text: `(${CAST_INT} ${integer})`, integer };
|
|
542
|
-
}
|
|
543
|
-
const convert = (term: Term) => (isBool ? term.text : toIdv(term));
|
|
544
|
-
const text = expression.arms.reduceRight(
|
|
809
|
+
const encodeCase = (
|
|
810
|
+
encoder: Encoder,
|
|
811
|
+
expression: Extract<Expr, { kind: "Case" }>,
|
|
812
|
+
env: Env | undefined,
|
|
813
|
+
mode: Mode,
|
|
814
|
+
): Term => {
|
|
815
|
+
const bodies = expression.arms.map((arm) => encode(encoder, arm.body, env, mode));
|
|
816
|
+
const other: Term = expression.other
|
|
817
|
+
? encode(encoder, expression.other, env, mode)
|
|
818
|
+
: wrapIdv(getCaseError(encoder));
|
|
819
|
+
const type = getType(other);
|
|
820
|
+
const isUniform = bodies.every((body) => isSameType(getType(body), type));
|
|
821
|
+
const isBool = isUniform && type.kind === "Bool";
|
|
822
|
+
if (isUniform && type.kind === "Int") {
|
|
823
|
+
const integer = expression.arms.reduceRight(
|
|
545
824
|
(rest, arm, index) =>
|
|
546
|
-
`(ite ${encodeBool(arm.condition, env, mode)} ${
|
|
547
|
-
|
|
825
|
+
`(ite ${encodeBool(encoder, arm.condition, env, clearPolarity(mode))} ${bodies[index].integer} ${rest})`,
|
|
826
|
+
other.integer ?? "",
|
|
548
827
|
);
|
|
549
|
-
return { isBool, text };
|
|
828
|
+
return { isBool: false, text: `(${CAST_INT} ${integer})`, integer };
|
|
829
|
+
}
|
|
830
|
+
const convert = (term: Term) => (isBool ? term.text : toIdv(term));
|
|
831
|
+
const text = expression.arms.reduceRight(
|
|
832
|
+
(rest, arm, index) =>
|
|
833
|
+
`(ite ${encodeBool(encoder, arm.condition, env, mode)} ${convert(bodies[index])} ${rest})`,
|
|
834
|
+
convert(other),
|
|
835
|
+
);
|
|
836
|
+
return { isBool, text, type: isUniform ? other.type : undefined };
|
|
837
|
+
};
|
|
838
|
+
|
|
839
|
+
// Type.Synthesize types a NEW constant by its visible domain, or else by a hypothesis in the rest
|
|
840
|
+
// of the sequent. The guard is its membership in the domain the encoding asserts.
|
|
841
|
+
export const declareConstant = (
|
|
842
|
+
encoder: Encoder,
|
|
843
|
+
hyp: Extract<Hyp, { kind: "Fresh" }>,
|
|
844
|
+
guarded: Expr | undefined,
|
|
845
|
+
rest: Sequent,
|
|
846
|
+
env: Env | undefined,
|
|
847
|
+
mode: Mode,
|
|
848
|
+
) => {
|
|
849
|
+
const domain = guarded && encode(encoder, guarded, env, clearPolarity(mode));
|
|
850
|
+
const type =
|
|
851
|
+
domain !== undefined && hyp.domainVisibility === "Visible"
|
|
852
|
+
? getElementType(domain)
|
|
853
|
+
: searchDeclarationType(encoder, { kind: "Sequent", sequent: rest }, true, env, mode);
|
|
854
|
+
return {
|
|
855
|
+
type,
|
|
856
|
+
getGuard: (symbol: string) =>
|
|
857
|
+
domain && `(${MEM} ${toIdv(getTyped(symbol, type))} ${toIdv(domain)})`,
|
|
550
858
|
};
|
|
859
|
+
};
|
|
551
860
|
|
|
552
|
-
|
|
553
|
-
|
|
554
|
-
|
|
555
|
-
|
|
556
|
-
|
|
557
|
-
|
|
558
|
-
|
|
559
|
-
|
|
560
|
-
|
|
561
|
-
|
|
562
|
-
|
|
563
|
-
|
|
564
|
-
|
|
565
|
-
}
|
|
566
|
-
if (hyp.level !== "Constant")
|
|
567
|
-
throw new TlaUnsupportedError("a NEW declaration that isn't constant");
|
|
568
|
-
const domain = hyp.domain && encodeIdv(hyp.domain, state.env, state.mode);
|
|
569
|
-
const bound = bindVariables([hyp.name], state.env, state.mode);
|
|
570
|
-
const variable = bound.variables[0];
|
|
571
|
-
const guard = domain && `(${MEM} ${variable} ${domain})`;
|
|
572
|
-
return {
|
|
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;
|
|
861
|
+
const encodeSequent = (
|
|
862
|
+
encoder: Encoder,
|
|
863
|
+
sequent: Sequent,
|
|
864
|
+
env: Env | undefined,
|
|
865
|
+
mode: Mode,
|
|
866
|
+
): string => {
|
|
867
|
+
const steps = sequent.context.reduce<NestedContext>(
|
|
868
|
+
(state, hyp, index) => {
|
|
869
|
+
switch (hyp.kind) {
|
|
870
|
+
case "Fresh": {
|
|
871
|
+
if (hyp.shape > 0) {
|
|
872
|
+
if (!state.mode.isOmitted) throw new TlaUnsupportedError("a second-order ASSUME");
|
|
873
|
+
const variable = getVariable(hyp.name, state.mode.depth);
|
|
586
874
|
return {
|
|
587
|
-
env: push(state.env, { kind: "
|
|
588
|
-
mode: state.mode,
|
|
589
|
-
wrappers:
|
|
590
|
-
? [...state.wrappers, (body) => `(=> ${fact} ${body})`]
|
|
591
|
-
: state.wrappers,
|
|
875
|
+
env: push(state.env, { kind: "operator", symbol: variable, arity: hyp.shape }),
|
|
876
|
+
mode: { ...state.mode, depth: state.mode.depth + 1 },
|
|
877
|
+
wrappers: [...state.wrappers, (body) => `(forall ((${variable} Idv)) ${body})`],
|
|
592
878
|
};
|
|
593
879
|
}
|
|
594
|
-
|
|
595
|
-
throw new TlaUnsupportedError(
|
|
880
|
+
if (hyp.level !== "Constant")
|
|
881
|
+
throw new TlaUnsupportedError("a NEW declaration that isn't constant");
|
|
882
|
+
const rest = { context: sequent.context.slice(index + 1), active: sequent.active };
|
|
883
|
+
const declared = declareConstant(encoder, hyp, hyp.domain, rest, state.env, state.mode);
|
|
884
|
+
const bound = bindVariables([hyp.name], state.env, state.mode, [declared.type]);
|
|
885
|
+
const variable = bound.variables[0];
|
|
886
|
+
const guard = declared.getGuard(variable);
|
|
887
|
+
return {
|
|
888
|
+
env: bound.env,
|
|
889
|
+
mode: bound.mode,
|
|
890
|
+
wrappers: [
|
|
891
|
+
...state.wrappers,
|
|
892
|
+
(body) =>
|
|
893
|
+
`(forall (${getBinders([variable])}) ${guard ? `(=> ${guard} ${body})` : body})`,
|
|
894
|
+
],
|
|
895
|
+
};
|
|
596
896
|
}
|
|
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}`);
|
|
626
|
-
}
|
|
627
|
-
case "Apply": {
|
|
628
|
-
const operator = expression.operator;
|
|
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 };
|
|
897
|
+
case "Fact": {
|
|
898
|
+
const fact =
|
|
899
|
+
hyp.visibility === "Visible"
|
|
900
|
+
? encodeBool(encoder, hyp.expression, state.env, invert(state.mode))
|
|
901
|
+
: undefined;
|
|
902
|
+
return {
|
|
903
|
+
env: push(state.env, { kind: "unsupported", reason: "a reference to a fact" }),
|
|
904
|
+
mode: state.mode,
|
|
905
|
+
wrappers: fact ? [...state.wrappers, (body) => `(=> ${fact} ${body})`] : state.wrappers,
|
|
906
|
+
};
|
|
651
907
|
}
|
|
652
|
-
|
|
653
|
-
|
|
654
|
-
: idv(`(ite ${condition} ${toIdv(consequent)} ${toIdv(alternative)})`);
|
|
908
|
+
default:
|
|
909
|
+
throw new TlaUnsupportedError(`a ${hyp.kind} in a nested ASSUME`);
|
|
655
910
|
}
|
|
656
|
-
|
|
657
|
-
|
|
658
|
-
|
|
659
|
-
|
|
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
|
-
|
|
692
|
-
|
|
693
|
-
|
|
694
|
-
|
|
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})`);
|
|
911
|
+
},
|
|
912
|
+
{ env, mode, wrappers: [] },
|
|
913
|
+
);
|
|
914
|
+
return steps.wrappers.reduceRight(
|
|
915
|
+
(body, wrap) => wrap(body),
|
|
916
|
+
encodeBool(encoder, sequent.active, steps.env, steps.mode),
|
|
917
|
+
);
|
|
918
|
+
};
|
|
919
|
+
|
|
920
|
+
export const encode = (
|
|
921
|
+
encoder: Encoder,
|
|
922
|
+
expression: Expr,
|
|
923
|
+
env: Env | undefined,
|
|
924
|
+
mode: Mode,
|
|
925
|
+
): Term => {
|
|
926
|
+
switch (expression.kind) {
|
|
927
|
+
case "Ix":
|
|
928
|
+
return encodeReference(encoder, getBinding(env, expression.index), [], env, mode);
|
|
929
|
+
case "Internal":
|
|
930
|
+
switch (expression.builtin) {
|
|
931
|
+
case "TRUE":
|
|
932
|
+
return wrapBool("true");
|
|
933
|
+
case "FALSE":
|
|
934
|
+
return wrapBool("false");
|
|
935
|
+
case "BOOLEAN":
|
|
936
|
+
return wrapIdv(BOOL_SET, getTypedOnly(encoder, getSetType(BOOL)));
|
|
937
|
+
case "STRING":
|
|
938
|
+
return wrapIdv(STR_SET, getTypedOnly(encoder, getSetType(STRING)));
|
|
939
|
+
case "Nat":
|
|
940
|
+
return wrapIdv(NAT_SET, getTypedOnly(encoder, getSetType(INT)));
|
|
941
|
+
case "Int":
|
|
942
|
+
return wrapIdv(INT_SET, getTypedOnly(encoder, getSetType(INT)));
|
|
943
|
+
case "Real":
|
|
944
|
+
case "Infinity":
|
|
945
|
+
throw new TlaProverError(
|
|
946
|
+
`Encode.Standardize: Unexpected builtin '${expression.builtin}'`,
|
|
947
|
+
);
|
|
948
|
+
default:
|
|
949
|
+
throw new TlaProverError("Type.Synthesize: Unexpected builtin");
|
|
699
950
|
}
|
|
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
|
-
),
|
|
951
|
+
case "Apply": {
|
|
952
|
+
const operator = expression.operator;
|
|
953
|
+
if (operator.kind === "Internal")
|
|
954
|
+
return encodeBuiltin(encoder, operator.builtin, expression.args, env, mode);
|
|
955
|
+
if (operator.kind === "Ix")
|
|
956
|
+
return encodeReference(
|
|
957
|
+
encoder,
|
|
958
|
+
getBinding(env, operator.index),
|
|
959
|
+
expression.args,
|
|
960
|
+
env,
|
|
961
|
+
mode,
|
|
718
962
|
);
|
|
963
|
+
if (operator.kind === "Opaque")
|
|
964
|
+
return encodeOpaque(encoder, operator.name, expression.args, env, mode);
|
|
965
|
+
if (operator.kind === "Lambda")
|
|
966
|
+
return encode(encoder, normalizeApply(operator, expression.args), env, mode);
|
|
967
|
+
throw new TlaUnsupportedError(`an application of ${operator.kind}`);
|
|
968
|
+
}
|
|
969
|
+
case "Sequent":
|
|
970
|
+
return wrapBool(encodeSequent(encoder, expression.sequent, env, mode));
|
|
971
|
+
case "With":
|
|
972
|
+
case "Parens":
|
|
973
|
+
return encode(encoder, expression.expression, env, mode);
|
|
974
|
+
case "If": {
|
|
975
|
+
const condition = encodeBool(encoder, expression.condition, env, mode);
|
|
976
|
+
const consequent = encode(encoder, expression.consequent, env, mode);
|
|
977
|
+
const alternative = encode(encoder, expression.alternative, env, mode);
|
|
978
|
+
if (consequent.integer !== undefined && alternative.integer !== undefined) {
|
|
979
|
+
const integer = `(ite ${resolveTriggers(condition, true)} ${consequent.integer} ${alternative.integer})`;
|
|
980
|
+
return { isBool: false, text: `(${CAST_INT} ${integer})`, integer };
|
|
719
981
|
}
|
|
720
|
-
|
|
721
|
-
return
|
|
722
|
-
|
|
723
|
-
|
|
724
|
-
|
|
725
|
-
|
|
726
|
-
case "Case":
|
|
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}`);
|
|
982
|
+
if (consequent.isBool && alternative.isBool)
|
|
983
|
+
return wrapBool(`(ite ${condition} ${consequent.text} ${alternative.text})`);
|
|
984
|
+
return wrapIdv(
|
|
985
|
+
`(ite ${condition} ${toIdv(consequent)} ${toIdv(alternative)})`,
|
|
986
|
+
isSameType(getType(consequent), getType(alternative)) ? consequent.type : undefined,
|
|
987
|
+
);
|
|
746
988
|
}
|
|
747
|
-
|
|
989
|
+
case "List": {
|
|
990
|
+
const items = expression.items.map((item) => encodeBool(encoder, item, env, mode));
|
|
991
|
+
return wrapBool(expression.bullet === "Or" ? disjoin(items) : conjoin(items));
|
|
992
|
+
}
|
|
993
|
+
case "Opaque":
|
|
994
|
+
return encodeOpaque(encoder, expression.name, [], env, mode);
|
|
995
|
+
case "Quant":
|
|
996
|
+
return wrapBool(encodeQuantifier(encoder, expression, env, mode));
|
|
997
|
+
case "Choose":
|
|
998
|
+
return encodeChoose(encoder, expression, env, mode);
|
|
999
|
+
case "SetSt":
|
|
1000
|
+
return encodeSetSt(encoder, expression, env, mode);
|
|
1001
|
+
case "SetOf":
|
|
1002
|
+
return encodeSetOf(encoder, expression, env, mode);
|
|
1003
|
+
case "SetEnum": {
|
|
1004
|
+
const elements = expression.elements.map((element) =>
|
|
1005
|
+
encode(encoder, element, env, clearPolarity(mode)),
|
|
1006
|
+
);
|
|
1007
|
+
const types = elements.map(getType);
|
|
1008
|
+
return wrapIdv(
|
|
1009
|
+
call(tla(`SetEnum_${elements.length}`), elements.map(toIdv)),
|
|
1010
|
+
getTypedOnly(
|
|
1011
|
+
encoder,
|
|
1012
|
+
types.every((type) => isSameType(type, types[0] ?? IDV))
|
|
1013
|
+
? getSetType(types[0] ?? IDV)
|
|
1014
|
+
: undefined,
|
|
1015
|
+
),
|
|
1016
|
+
);
|
|
1017
|
+
}
|
|
1018
|
+
case "Product": {
|
|
1019
|
+
const factors = expression.factors.map((factor) =>
|
|
1020
|
+
encode(encoder, factor, env, clearPolarity(mode)),
|
|
1021
|
+
);
|
|
1022
|
+
return wrapIdv(
|
|
1023
|
+
call(tla(`Product_${factors.length}`), factors.map(toIdv)),
|
|
1024
|
+
getSetResult(encoder, factors, (items) => getSetType({ kind: "Product", items })),
|
|
1025
|
+
);
|
|
1026
|
+
}
|
|
1027
|
+
case "Tuple": {
|
|
1028
|
+
const elements = expression.elements.map((element) =>
|
|
1029
|
+
encode(encoder, element, env, clearPolarity(mode)),
|
|
1030
|
+
);
|
|
1031
|
+
return wrapIdv(
|
|
1032
|
+
call(tla(`Tuple_${elements.length}`), elements.map(toIdv)),
|
|
1033
|
+
getTypedOnly(encoder, { kind: "Product", items: elements.map(getType) }),
|
|
1034
|
+
);
|
|
1035
|
+
}
|
|
1036
|
+
case "Fcn":
|
|
1037
|
+
return encodeFunction(encoder, expression, env, mode);
|
|
1038
|
+
case "FcnApp": {
|
|
1039
|
+
const encodedFunction = encode(encoder, expression.function, env, clearPolarity(mode));
|
|
1040
|
+
const args = expression.args.map((arg) => encodeIdv(encoder, arg, env, mode));
|
|
1041
|
+
const argument = args.length === 1 ? args[0] : call(tla(`Tuple_${args.length}`), args);
|
|
1042
|
+
const text = `(${FUN_APP} ${toIdv(encodedFunction)} ${argument})`;
|
|
1043
|
+
const component = getTypedOnly(
|
|
1044
|
+
encoder,
|
|
1045
|
+
getComponentType(getType(encodedFunction), expression.args),
|
|
1046
|
+
);
|
|
1047
|
+
return component === undefined ? wrapIdv(text) : project(text, component);
|
|
1048
|
+
}
|
|
1049
|
+
case "Arrow": {
|
|
1050
|
+
const sets = [expression.domain, expression.range].map((set) =>
|
|
1051
|
+
encode(encoder, set, env, clearPolarity(mode)),
|
|
1052
|
+
);
|
|
1053
|
+
return wrapIdv(
|
|
1054
|
+
call(FUN_SET, sets.map(toIdv)),
|
|
1055
|
+
getSetResult(encoder, sets, (elements) =>
|
|
1056
|
+
getSetType({ kind: "Fun", domain: elements[0], range: elements[1] }),
|
|
1057
|
+
),
|
|
1058
|
+
);
|
|
1059
|
+
}
|
|
1060
|
+
case "Record":
|
|
1061
|
+
case "Rect": {
|
|
1062
|
+
const names = expression.fields.map((field) => field.name);
|
|
1063
|
+
const suffix = names.join("_");
|
|
1064
|
+
encoder.recordFields.set(`Record_${suffix}`, names);
|
|
1065
|
+
encoder.recordFields.set(`RecordSet_${suffix}`, names);
|
|
1066
|
+
const values = expression.fields.map((field) =>
|
|
1067
|
+
encode(encoder, field.value, env, clearPolarity(mode)),
|
|
1068
|
+
);
|
|
1069
|
+
// Type.Synthesize types a set of records only at type level 3.
|
|
1070
|
+
const type: Type = {
|
|
1071
|
+
kind: "Record",
|
|
1072
|
+
fields: names.map((name, index) => ({ name, type: getType(values[index]) })),
|
|
1073
|
+
};
|
|
1074
|
+
return wrapIdv(
|
|
1075
|
+
call(
|
|
1076
|
+
tla(`${expression.kind === "Record" ? "Record" : "RecordSet"}_${suffix}`),
|
|
1077
|
+
values.map(toIdv),
|
|
1078
|
+
),
|
|
1079
|
+
expression.kind === "Record" ? getTypedOnly(encoder, type) : undefined,
|
|
1080
|
+
);
|
|
1081
|
+
}
|
|
1082
|
+
case "Except":
|
|
1083
|
+
return wrapIdv(encodeExcept(encoder, expression, env, mode));
|
|
1084
|
+
case "Dot": {
|
|
1085
|
+
const record = encode(encoder, expression.expression, env, clearPolarity(mode));
|
|
1086
|
+
const text = `(${FUN_APP} ${toIdv(record)} ${tla(`StrLit_${expression.field}`)})`;
|
|
1087
|
+
const component = getTypedOnly(encoder, getFieldType(getType(record), expression.field));
|
|
1088
|
+
return component === undefined ? wrapIdv(text) : project(text, component);
|
|
1089
|
+
}
|
|
1090
|
+
case "Case":
|
|
1091
|
+
return encodeCase(encoder, expression, env, mode);
|
|
1092
|
+
case "String":
|
|
1093
|
+
return wrapIdv(tla(`StrLit_${expression.value}`), getTypedOnly(encoder, STRING));
|
|
1094
|
+
case "Num":
|
|
1095
|
+
if (expression.fraction !== "") throw new TlaUnsupportedError("a real number");
|
|
1096
|
+
// Deviation from tlapm: its int_of_string fails the obligation for a literal above 2^62 - 1.
|
|
1097
|
+
// Type.Synthesize gives a number no type when arithmetic is off.
|
|
1098
|
+
if (!encoder.encoding.isArithmetic)
|
|
1099
|
+
return wrapIdv(tla(`IntLit_${BigInt(expression.integer)}`));
|
|
1100
|
+
return {
|
|
1101
|
+
isBool: false,
|
|
1102
|
+
text: `(${CAST_INT} ${BigInt(expression.integer)})`,
|
|
1103
|
+
integer: String(BigInt(expression.integer)),
|
|
1104
|
+
};
|
|
1105
|
+
case "At":
|
|
1106
|
+
if (mode.at === undefined) throw new TlaUnsupportedError("@ outside EXCEPT");
|
|
1107
|
+
return wrapIdv(mode.at);
|
|
1108
|
+
case "Tquant":
|
|
1109
|
+
case "Tsub":
|
|
1110
|
+
case "Fair":
|
|
1111
|
+
throw new TlaProverError("Backend.Smtlib: Unsupported expression");
|
|
1112
|
+
case "Lambda":
|
|
1113
|
+
case "Bang":
|
|
1114
|
+
throw new TlaProverError(`Type.Synthesize: Unexpected ${expression.kind} constructor`);
|
|
1115
|
+
default:
|
|
1116
|
+
throw new TlaUnsupportedError(`the expression ${expression.kind}`);
|
|
1117
|
+
}
|
|
1118
|
+
};
|
|
748
1119
|
|
|
749
|
-
|
|
750
|
-
|
|
751
|
-
|
|
752
|
-
|
|
753
|
-
];
|
|
1120
|
+
export const getEntries = (encoder: Encoder, line: string): Entry[] => [
|
|
1121
|
+
...encoder.flattener.takeIntroduced(),
|
|
1122
|
+
removeUnprimable(resolveTriggers(line, false)),
|
|
1123
|
+
];
|
|
754
1124
|
|
|
755
|
-
|
|
756
|
-
|
|
757
|
-
|
|
758
|
-
|
|
759
|
-
|
|
760
|
-
|
|
761
|
-
|
|
762
|
-
|
|
763
|
-
|
|
764
|
-
|
|
765
|
-
};
|
|
766
|
-
};
|
|
1125
|
+
export const createEncoder = (session: EncodingSession, encoding: SmtEncoding): Encoder => ({
|
|
1126
|
+
session,
|
|
1127
|
+
encoding,
|
|
1128
|
+
flattener: createFlattener(),
|
|
1129
|
+
anonymous: new Map(),
|
|
1130
|
+
recordFields: new Map(),
|
|
1131
|
+
setTypes: new Map(),
|
|
1132
|
+
context: createContext(),
|
|
1133
|
+
declared: new Map(),
|
|
1134
|
+
});
|