tla-ts 0.0.4-dev.7c70fed → 0.0.4-dev.8fefa42
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 +62 -70
- package/dist/deciders.cjs +366 -0
- package/dist/deciders.js +366 -0
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +35 -1
- package/dist/index.d.ts +35 -1
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -4
- package/dist/parallel-worker.js +1 -4
- package/dist/prove-worker.cjs +9 -0
- package/dist/prove-worker.d.cts +9 -0
- package/dist/prove-worker.d.ts +9 -0
- package/dist/prove-worker.js +9 -0
- package/dist/prove.cjs +515 -0
- package/dist/prove.js +515 -0
- package/dist/run-cli.cjs +30 -47
- package/dist/run-cli.js +30 -47
- package/dist/tlapm.cjs +10 -0
- package/dist/tlapm.js +10 -0
- package/dist/transfer.cjs +38 -44
- package/dist/transfer.js +38 -44
- package/dist/worker.cjs +21 -0
- package/dist/worker.js +21 -0
- package/package.json +21 -12
- package/src/check.ts +1 -0
- package/src/errors.ts +86 -0
- package/src/evaluate.ts +54 -19
- package/src/index.ts +10 -0
- package/src/{obligation-action.ts → obligations/action.ts} +258 -37
- package/src/{obligation-anon.ts → obligations/anon.ts} +13 -7
- package/src/obligations/ctx.ts +64 -0
- package/src/{obligation-deref.ts → obligations/deref.ts} +2 -2
- package/src/{obligation-expression.ts → obligations/expression.ts} +54 -8
- package/src/{obligation-generate.ts → obligations/generate.ts} +134 -61
- package/src/{obligations.ts → obligations/index.ts} +26 -12
- package/src/{obligation-levels.ts → obligations/levels.ts} +12 -2
- package/src/{obligation-module.ts → obligations/module.ts} +46 -20
- package/src/obligations/pickle.ts +100 -0
- package/src/obligations/pragma.ts +189 -0
- package/src/{obligation-printer.ts → obligations/printer.ts} +5 -59
- package/src/{obligation-proof.ts → obligations/proof.ts} +7 -1
- package/src/{obligation-source.ts → obligations/source.ts} +91 -35
- package/src/obligations/temporal.ts +319 -0
- package/src/{obligation-tuples.ts → obligations/tuples.ts} +1 -1
- package/src/parallel-worker.ts +2 -18
- package/src/parallel.ts +10 -43
- package/src/prove/decide-pool.ts +100 -0
- package/src/prove/deciders.ts +27 -0
- package/src/prove/isabelle/LICENSE +36 -0
- package/src/prove/isabelle/LICENSE-tlapm +26 -0
- package/src/prove/isabelle/decide.ts +47 -0
- package/src/prove/isabelle/encode.ts +477 -0
- package/src/prove/isabelle/isar/inner-syntax.ts +579 -0
- package/src/prove/isabelle/isar/method.ts +367 -0
- package/src/prove/isabelle/isar/proof.ts +28 -0
- package/src/prove/isabelle/isar/statement.ts +57 -0
- package/src/prove/isabelle/isar/theory.ts +192 -0
- package/src/prove/isabelle/isar/type-check.ts +278 -0
- package/src/prove/isabelle/provers/blast/blast.ts +258 -0
- package/src/prove/isabelle/provers/blast/branch.ts +322 -0
- package/src/prove/isabelle/provers/blast/prove.ts +347 -0
- package/src/prove/isabelle/provers/blast/rules.ts +330 -0
- package/src/prove/isabelle/provers/blast/state.ts +180 -0
- package/src/prove/isabelle/provers/blast/term.ts +547 -0
- package/src/prove/isabelle/provers/clasimp.ts +150 -0
- package/src/prove/isabelle/provers/classical.ts +389 -0
- package/src/prove/isabelle/provers/hypsubst.ts +441 -0
- package/src/prove/isabelle/pure/bicompose.ts +174 -0
- package/src/prove/isabelle/pure/consts.ts +32 -0
- package/src/prove/isabelle/pure/conv.ts +79 -0
- package/src/prove/isabelle/pure/drule.ts +264 -0
- package/src/prove/isabelle/pure/envir.ts +363 -0
- package/src/prove/isabelle/pure/goal.ts +53 -0
- package/src/prove/isabelle/pure/interrupt.ts +16 -0
- package/src/prove/isabelle/pure/list.ts +12 -0
- package/src/prove/isabelle/pure/logic.ts +402 -0
- package/src/prove/isabelle/pure/name.ts +110 -0
- package/src/prove/isabelle/pure/net.ts +262 -0
- package/src/prove/isabelle/pure/object-logic.ts +41 -0
- package/src/prove/isabelle/pure/pattern.ts +650 -0
- package/src/prove/isabelle/pure/raw-simplifier.ts +353 -0
- package/src/prove/isabelle/pure/rewriter.ts +602 -0
- package/src/prove/isabelle/pure/search.ts +68 -0
- package/src/prove/isabelle/pure/seq.ts +156 -0
- package/src/prove/isabelle/pure/simplifier.ts +112 -0
- package/src/prove/isabelle/pure/table.ts +208 -0
- package/src/prove/isabelle/pure/tactic.ts +276 -0
- package/src/prove/isabelle/pure/tactical.ts +347 -0
- package/src/prove/isabelle/pure/term-ord.ts +159 -0
- package/src/prove/isabelle/pure/term.ts +808 -0
- package/src/prove/isabelle/pure/thm.ts +806 -0
- package/src/prove/isabelle/pure/type.ts +133 -0
- package/src/prove/isabelle/pure/unify.ts +753 -0
- package/src/prove/isabelle/pure/variable.ts +25 -0
- package/src/prove/isabelle/tla/classical-setup.ts +101 -0
- package/src/prove/isabelle/tla/context.ts +74 -0
- package/src/prove/isabelle/tla/logic-data.ts +5 -0
- package/src/prove/isabelle/tla/logic.ts +215 -0
- package/src/prove/isabelle/tla/simpdata.ts +241 -0
- package/src/prove/isabelle/tools/intuitionistic.ts +132 -0
- package/src/prove/ocaml.ts +22 -0
- package/src/prove/prep/action.ts +520 -0
- package/src/prove/prep/defs.ts +27 -0
- package/src/prove/prep/elab.ts +156 -0
- package/src/prove/prep/enabled-axioms.ts +189 -0
- package/src/prove/prep/enabled.ts +43 -0
- package/src/prove/prep/fingerprint.ts +388 -0
- package/src/prove/prep/flatten.ts +70 -0
- package/src/prove/prep/level-comparison.ts +552 -0
- package/src/prove/prep/md5.ts +67 -0
- package/src/prove/prep/pragma.ts +221 -0
- package/src/prove/prep/trivial.ts +22 -0
- package/src/prove/prove-worker.ts +29 -0
- package/src/prove/prove.ts +417 -0
- package/src/prove/ptl/decide.ts +68 -0
- package/src/prove/ptl/encode.ts +256 -0
- package/src/prove/ptl/sat.ts +151 -0
- package/src/prove/ptl/tableau.ts +276 -0
- package/src/prove/smt/axiomatize.ts +69 -0
- package/src/prove/smt/axioms.ts +210 -0
- package/src/prove/smt/context.ts +108 -0
- package/src/prove/smt/data.ts +665 -0
- package/src/prove/smt/encode.ts +169 -0
- package/src/prove/smt/extensionality.ts +63 -0
- package/src/prove/smt/flatten.ts +127 -0
- package/src/prove/smt/format.ts +143 -0
- package/src/prove/smt/instances.ts +182 -0
- package/src/prove/smt/rewrite.ts +784 -0
- package/src/prove/smt/simplify.ts +57 -0
- package/src/prove/smt/solver/act-cache.ts +265 -0
- package/src/prove/smt/solver/arith-rewriter.ts +962 -0
- package/src/prove/smt/solver/array.ts +22 -0
- package/src/prove/smt/solver/asserted-formulas.ts +469 -0
- package/src/prove/smt/solver/ast-lt.ts +157 -0
- package/src/prove/smt/solver/ast-util.ts +147 -0
- package/src/prove/smt/solver/ast.ts +1315 -0
- package/src/prove/smt/solver/auf-solver.ts +572 -0
- package/src/prove/smt/solver/case-split-queue.ts +178 -0
- package/src/prove/smt/solver/cg-table.ts +175 -0
- package/src/prove/smt/solver/clause.ts +276 -0
- package/src/prove/smt/solver/conflict-resolution.ts +343 -0
- package/src/prove/smt/solver/context.ts +1292 -0
- package/src/prove/smt/solver/ctx-simplify.ts +334 -0
- package/src/prove/smt/solver/der.ts +224 -0
- package/src/prove/smt/solver/dyn-ack.ts +141 -0
- package/src/prove/smt/solver/e-matching.ts +659 -0
- package/src/prove/smt/solver/enode.ts +259 -0
- package/src/prove/smt/solver/expr-ref.ts +21 -0
- package/src/prove/smt/solver/expr-safe-replace.ts +172 -0
- package/src/prove/smt/solver/fingerprints.ts +92 -0
- package/src/prove/smt/solver/flat-literals.ts +51 -0
- package/src/prove/smt/solver/goal.ts +138 -0
- package/src/prove/smt/solver/hash.ts +173 -0
- package/src/prove/smt/solver/hashtable.ts +166 -0
- package/src/prove/smt/solver/internalizer.ts +1381 -0
- package/src/prove/smt/solver/lbool.ts +5 -0
- package/src/prove/smt/solver/literal.ts +24 -0
- package/src/prove/smt/solver/lp/bound-propagator.ts +391 -0
- package/src/prove/smt/solver/lp/constraints.ts +78 -0
- package/src/prove/smt/solver/lp/containers.ts +296 -0
- package/src/prove/smt/solver/lp/core-solver.ts +504 -0
- package/src/prove/smt/solver/lp/cross-nested.ts +224 -0
- package/src/prove/smt/solver/lp/dep-intervals.ts +656 -0
- package/src/prove/smt/solver/lp/dependency.ts +51 -0
- package/src/prove/smt/solver/lp/dioph-eq.ts +1181 -0
- package/src/prove/smt/solver/lp/explanation.ts +46 -0
- package/src/prove/smt/solver/lp/gomory.ts +255 -0
- package/src/prove/smt/solver/lp/hnf-cutter.ts +125 -0
- package/src/prove/smt/solver/lp/hnf.ts +281 -0
- package/src/prove/smt/solver/lp/int-cube.ts +295 -0
- package/src/prove/smt/solver/lp/int-solver.ts +514 -0
- package/src/prove/smt/solver/lp/lar-solver.ts +816 -0
- package/src/prove/smt/solver/lp/lar-term.ts +62 -0
- package/src/prove/smt/solver/lp/lp-settings.ts +91 -0
- package/src/prove/smt/solver/lp/maximize-term.ts +347 -0
- package/src/prove/smt/solver/lp/nex-creator.ts +381 -0
- package/src/prove/smt/solver/lp/nex.ts +120 -0
- package/src/prove/smt/solver/lp/nla-backoff.ts +43 -0
- package/src/prove/smt/solver/lp/nla-basics.ts +398 -0
- package/src/prove/smt/solver/lp/nla-core.ts +968 -0
- package/src/prove/smt/solver/lp/nla-divisions.ts +332 -0
- package/src/prove/smt/solver/lp/nla-emonics.ts +373 -0
- package/src/prove/smt/solver/lp/nla-factorization.ts +30 -0
- package/src/prove/smt/solver/lp/nla-grobner.ts +904 -0
- package/src/prove/smt/solver/lp/nla-horner.ts +126 -0
- package/src/prove/smt/solver/lp/nla-intervals.ts +265 -0
- package/src/prove/smt/solver/lp/nla-monomial-bounds.ts +715 -0
- package/src/prove/smt/solver/lp/nla-monotone.ts +59 -0
- package/src/prove/smt/solver/lp/nla-order.ts +307 -0
- package/src/prove/smt/solver/lp/nla-patcher.ts +112 -0
- package/src/prove/smt/solver/lp/nla-tangents.ts +251 -0
- package/src/prove/smt/solver/lp/nla-throttle.ts +85 -0
- package/src/prove/smt/solver/lp/nla-types.ts +124 -0
- package/src/prove/smt/solver/lp/nla-var-eqs.ts +141 -0
- package/src/prove/smt/solver/lp/nra-solver.ts +440 -0
- package/src/prove/smt/solver/lp/numeric-pair.ts +65 -0
- package/src/prove/smt/solver/lp/pdd-interval.ts +31 -0
- package/src/prove/smt/solver/lp/pdd-simplifier.ts +184 -0
- package/src/prove/smt/solver/lp/pdd-solver.ts +408 -0
- package/src/prove/smt/solver/lp/pdd.ts +971 -0
- package/src/prove/smt/solver/lp/random-updater.ts +138 -0
- package/src/prove/smt/solver/lp/static-matrix.ts +246 -0
- package/src/prove/smt/solver/lp/union-find.ts +96 -0
- package/src/prove/smt/solver/mam-compiler.ts +847 -0
- package/src/prove/smt/solver/mam-interpreter.ts +400 -0
- package/src/prove/smt/solver/maximize-ac-sharing.ts +118 -0
- package/src/prove/smt/solver/model-checker.ts +347 -0
- package/src/prove/smt/solver/model-evaluator.ts +262 -0
- package/src/prove/smt/solver/model-finder.ts +155 -0
- package/src/prove/smt/solver/model-generator.ts +97 -0
- package/src/prove/smt/solver/model-macro-solver.ts +728 -0
- package/src/prove/smt/solver/nlsat/algebraic.ts +1161 -0
- package/src/prove/smt/solver/nlsat/atoms.ts +238 -0
- package/src/prove/smt/solver/nlsat/evaluator.ts +303 -0
- package/src/prove/smt/solver/nlsat/explain.ts +607 -0
- package/src/prove/smt/solver/nlsat/interval-set.ts +351 -0
- package/src/prove/smt/solver/nlsat/levelwise.ts +740 -0
- package/src/prove/smt/solver/nlsat/mpbq.ts +161 -0
- package/src/prove/smt/solver/nlsat/polynomial.ts +1722 -0
- package/src/prove/smt/solver/nlsat/solver.ts +911 -0
- package/src/prove/smt/solver/nlsat/types.ts +43 -0
- package/src/prove/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
- package/src/prove/smt/solver/nlsat/upolynomial.ts +996 -0
- package/src/prove/smt/solver/nnf.ts +469 -0
- package/src/prove/smt/solver/pattern-inference.ts +351 -0
- package/src/prove/smt/solver/poly-rewriter.ts +477 -0
- package/src/prove/smt/solver/propagate-values.ts +83 -0
- package/src/prove/smt/solver/proto-model.ts +551 -0
- package/src/prove/smt/solver/pull-quant.ts +139 -0
- package/src/prove/smt/solver/qe-lite-der.ts +526 -0
- package/src/prove/smt/solver/qe-lite-fm.ts +576 -0
- package/src/prove/smt/solver/qe-lite.ts +381 -0
- package/src/prove/smt/solver/qi-queue.ts +362 -0
- package/src/prove/smt/solver/quant-tactics.ts +117 -0
- package/src/prove/smt/solver/quantifier-analyzer.ts +562 -0
- package/src/prove/smt/solver/quantifier-manager.ts +186 -0
- package/src/prove/smt/solver/random-gen.ts +10 -0
- package/src/prove/smt/solver/rational.ts +165 -0
- package/src/prove/smt/solver/ref-vector.ts +62 -0
- package/src/prove/smt/solver/relevancy.ts +247 -0
- package/src/prove/smt/solver/rewriter-tpl.ts +1159 -0
- package/src/prove/smt/solver/rewriter.ts +843 -0
- package/src/prove/smt/solver/rlimit.ts +79 -0
- package/src/prove/smt/solver/smtlib-parser.ts +526 -0
- package/src/prove/smt/solver/solver.ts +71 -0
- package/src/prove/smt/solver/sort.ts +35 -0
- package/src/prove/smt/solver/sticky-generations.ts +69 -0
- package/src/prove/smt/solver/theory-lra-axioms.ts +340 -0
- package/src/prove/smt/solver/theory-lra-bounds.ts +226 -0
- package/src/prove/smt/solver/theory-lra-final-check.ts +252 -0
- package/src/prove/smt/solver/theory-lra-internalize.ts +476 -0
- package/src/prove/smt/solver/theory-lra-model.ts +243 -0
- package/src/prove/smt/solver/theory-lra-propagate.ts +405 -0
- package/src/prove/smt/solver/theory-lra-state.ts +43 -0
- package/src/prove/smt/solver/theory-lra.ts +56 -0
- package/src/prove/smt/solver/var-subst.ts +258 -0
- package/src/prove/smt/solver/z3-license.txt +10 -0
- package/src/prove/smt/table.ts +170 -0
- package/src/prove/tlapm/tlapm.ts +96 -0
- package/src/prove/tlaps-module.ts +510 -0
- package/src/prove/verdict.ts +13 -0
- package/src/prove/zenon/LICENSE +32 -0
- package/src/prove/zenon/check/check.ts +105 -0
- package/src/prove/zenon/check/definitions.ts +144 -0
- package/src/prove/zenon/check/equality.ts +182 -0
- package/src/prove/zenon/check/functions.ts +62 -0
- package/src/prove/zenon/check/keys.ts +125 -0
- package/src/prove/zenon/check/propositional.ts +104 -0
- package/src/prove/zenon/check/records.ts +188 -0
- package/src/prove/zenon/check/relations.ts +121 -0
- package/src/prove/zenon/check/rewrites.ts +224 -0
- package/src/prove/zenon/check/sets.ts +302 -0
- package/src/prove/zenon/check/terms.ts +127 -0
- package/src/prove/zenon/check/tla.ts +126 -0
- package/src/prove/zenon/decide.ts +113 -0
- package/src/prove/zenon/encode.ts +444 -0
- package/src/prove/zenon/eqrel.ts +300 -0
- package/src/prove/zenon/equality-rules.ts +435 -0
- package/src/prove/zenon/expr.ts +551 -0
- package/src/prove/zenon/index-table.ts +350 -0
- package/src/prove/zenon/isar-case.ts +513 -0
- package/src/prove/zenon/isar.ts +1249 -0
- package/src/prove/zenon/limits.ts +15 -0
- package/src/prove/zenon/llproof.ts +173 -0
- package/src/prove/zenon/mltoll.ts +1566 -0
- package/src/prove/zenon/node.ts +297 -0
- package/src/prove/zenon/ocaml.ts +169 -0
- package/src/prove/zenon/parse.ts +247 -0
- package/src/prove/zenon/phrase.ts +191 -0
- package/src/prove/zenon/proof.ts +198 -0
- package/src/prove/zenon/propositional-rules.ts +387 -0
- package/src/prove/zenon/rules.ts +94 -0
- package/src/prove/zenon/search.ts +288 -0
- package/src/prove/zenon/tla/functions.ts +151 -0
- package/src/prove/zenon/tla/llproof.ts +480 -0
- package/src/prove/zenon/tla/records.ts +225 -0
- package/src/prove/zenon/tla/rewrites.ts +447 -0
- package/src/prove/zenon/tla/sets.ts +304 -0
- package/src/prove/zenon/tla/terms.ts +181 -0
- package/src/prove/zenon/tla/tla.ts +506 -0
- package/src/run-cli.ts +73 -20
- package/src/successors.ts +24 -5
- package/src/tlc-version.ts +8 -7
- package/src/values.ts +47 -4
- package/src/worker.ts +65 -0
- package/dist/parallel.cjs +0 -12
- package/dist/parallel.js +0 -12
- /package/src/{obligation-format.ts → obligations/format.ts} +0 -0
|
@@ -0,0 +1,477 @@
|
|
|
1
|
+
// Ported from tlapm's src/backend/isabelle.ml (BSD licensed, see LICENSE-tlapm).
|
|
2
|
+
// An obligation as the Isabelle/TLA+ theory tlapm writes for Isabelle to prove with a tactic.
|
|
3
|
+
|
|
4
|
+
import { TlapmBugError, TlaProverError, TlaUnsupportedError } from "../../errors";
|
|
5
|
+
import { createContext, getBoundName, popNames, pushName } from "../../obligations/ctx";
|
|
6
|
+
import {
|
|
7
|
+
shiftExpr,
|
|
8
|
+
type Bound,
|
|
9
|
+
type Builtin,
|
|
10
|
+
type Expr,
|
|
11
|
+
type Sequent,
|
|
12
|
+
} from "../../obligations/expression";
|
|
13
|
+
import { pickle } from "../../obligations/pickle";
|
|
14
|
+
|
|
15
|
+
const cook = (name: string) => `is${pickle(name)}`;
|
|
16
|
+
|
|
17
|
+
const ATOMS: Partial<Record<Builtin, string>> = {
|
|
18
|
+
TRUE: "TRUE",
|
|
19
|
+
FALSE: "FALSE",
|
|
20
|
+
STRING: "STRING",
|
|
21
|
+
BOOLEAN: "BOOLEAN",
|
|
22
|
+
Nat: "Nat",
|
|
23
|
+
Int: "Int",
|
|
24
|
+
Real: cook("Real"),
|
|
25
|
+
Infinity: cook("Infinity"),
|
|
26
|
+
Any: "Any",
|
|
27
|
+
};
|
|
28
|
+
|
|
29
|
+
const UNARY: Partial<Record<Builtin, string>> = {
|
|
30
|
+
Neg: "~",
|
|
31
|
+
DOMAIN: "DOMAIN",
|
|
32
|
+
SUBSET: "SUBSET",
|
|
33
|
+
UNION: "UNION",
|
|
34
|
+
};
|
|
35
|
+
|
|
36
|
+
const BINARY: Partial<Record<Builtin, string>> = {
|
|
37
|
+
Implies: "\\<Rightarrow>",
|
|
38
|
+
Equiv: "\\<Leftrightarrow>",
|
|
39
|
+
Conj: "\\<and>",
|
|
40
|
+
Disj: "\\<or>",
|
|
41
|
+
Eq: "=",
|
|
42
|
+
Neq: "\\<noteq>",
|
|
43
|
+
Subseteq: "\\<subseteq>",
|
|
44
|
+
Mem: "\\<in>",
|
|
45
|
+
Notmem: "\\<notin>",
|
|
46
|
+
Setminus: "\\\\",
|
|
47
|
+
Cap: "\\<inter>",
|
|
48
|
+
Cup: "\\<union>",
|
|
49
|
+
OneArg: ":>",
|
|
50
|
+
Extend: "@@",
|
|
51
|
+
};
|
|
52
|
+
|
|
53
|
+
const NONFIX: Partial<Record<Builtin, [string, number]>> = {
|
|
54
|
+
Plus: ["addint", 2],
|
|
55
|
+
Minus: ["subint", 2],
|
|
56
|
+
Uminus: ["minus", 1],
|
|
57
|
+
Times: ["mult", 2],
|
|
58
|
+
Ratio: [cook("/"), 2],
|
|
59
|
+
Quotient: [cook("\\div"), 2],
|
|
60
|
+
Remainder: [cook("%"), 2],
|
|
61
|
+
Exp: [cook("^"), 2],
|
|
62
|
+
Lteq: ["leq", 2],
|
|
63
|
+
Lt: ["less", 2],
|
|
64
|
+
Gteq: ["geq", 2],
|
|
65
|
+
Gt: ["greater", 2],
|
|
66
|
+
Range: ["intvl", 2],
|
|
67
|
+
Seq: ["Seq", 1],
|
|
68
|
+
Len: ["Len", 1],
|
|
69
|
+
BSeq: ["BSeq", 1],
|
|
70
|
+
Cat: [cook("\\circ"), 2],
|
|
71
|
+
Append: ["Append", 2],
|
|
72
|
+
Head: ["Head", 1],
|
|
73
|
+
Tail: ["Tail", 1],
|
|
74
|
+
SubSeq: ["SubSeq", 3],
|
|
75
|
+
SelectSeq: ["SelectSeq", 2],
|
|
76
|
+
Print: ["Print", 2],
|
|
77
|
+
PrintT: ["PrintT", 1],
|
|
78
|
+
Assert: ["Assert", 2],
|
|
79
|
+
JavaTime: ["JavaTime", 0],
|
|
80
|
+
TLCGet: ["TLCGet", 1],
|
|
81
|
+
TLCSet: ["TLCSet", 2],
|
|
82
|
+
Permutations: ["Permutations", 1],
|
|
83
|
+
SortSeq: ["SortSeq", 2],
|
|
84
|
+
RandomElement: ["RandomElement", 1],
|
|
85
|
+
ToString: ["ToString", 1],
|
|
86
|
+
};
|
|
87
|
+
|
|
88
|
+
// The temporal operators Isabelle/TLA+ has no counterpart for, by the name tlapm reports.
|
|
89
|
+
const TEMPORAL: Partial<Record<Builtin, [string, number]>> = {
|
|
90
|
+
Leadsto: ["Leadsto", 2],
|
|
91
|
+
ENABLED: ["ENABLED", 1],
|
|
92
|
+
Cdot: ["\\cdot", 2],
|
|
93
|
+
Actplus: ["-+->", 2],
|
|
94
|
+
BoxTrue: ["[]", 1],
|
|
95
|
+
BoxFalse: ["[]", 1],
|
|
96
|
+
Diamond: ["<>", 1],
|
|
97
|
+
};
|
|
98
|
+
|
|
99
|
+
// thy_header's tdoms_table: the operators the theory declares, with their arities.
|
|
100
|
+
const DECLARED: [string, number][] = [
|
|
101
|
+
["Real", 0],
|
|
102
|
+
["/", 2],
|
|
103
|
+
["\\div", 2],
|
|
104
|
+
["%", 2],
|
|
105
|
+
["..", 2],
|
|
106
|
+
["Infinity", 0],
|
|
107
|
+
["[]", 1],
|
|
108
|
+
["<>", 1],
|
|
109
|
+
];
|
|
110
|
+
|
|
111
|
+
const HEADER = [
|
|
112
|
+
"consts",
|
|
113
|
+
...DECLARED.map(
|
|
114
|
+
([name, arity]) =>
|
|
115
|
+
` "${cook(name)}" :: ${arity === 0 ? "c" : `"[${Array(arity).fill("c").join(",")}] => c"`}`,
|
|
116
|
+
),
|
|
117
|
+
"",
|
|
118
|
+
].join("\n");
|
|
119
|
+
|
|
120
|
+
// tlapm raises Unsupported for what Isabelle/TLA+ can't express, which omits a fact and fails the
|
|
121
|
+
// obligation anywhere else.
|
|
122
|
+
const unsupported = (message: string): never => {
|
|
123
|
+
throw new TlaUnsupportedError(message);
|
|
124
|
+
};
|
|
125
|
+
|
|
126
|
+
const getSuccessors = (integer: string) => {
|
|
127
|
+
const count = Number.parseInt(integer, 10);
|
|
128
|
+
return `${"succ[".repeat(count)}0${"]".repeat(count)}`;
|
|
129
|
+
};
|
|
130
|
+
|
|
131
|
+
// thy_temp: the theory tlapm writes for Isabelle to prove obligation id, after Backend.Prep has
|
|
132
|
+
// shipped it, with the tactic of the method that selects Isabelle.
|
|
133
|
+
export const encodeIsabelle = (
|
|
134
|
+
id: number,
|
|
135
|
+
sequent: Sequent,
|
|
136
|
+
tactic: string,
|
|
137
|
+
theoryName: string,
|
|
138
|
+
): string => {
|
|
139
|
+
const context = createContext();
|
|
140
|
+
const adjoin = (name: string) => pushName(context, pickle(name));
|
|
141
|
+
const bump = () => pushName(context, "");
|
|
142
|
+
const state = { isAssumed: false };
|
|
143
|
+
|
|
144
|
+
// A binder's name binds in what prints inside it.
|
|
145
|
+
const withBound = (name: string, print: (bound: string) => string) => {
|
|
146
|
+
const doc = print(adjoin(name));
|
|
147
|
+
popNames(context, 1);
|
|
148
|
+
return doc;
|
|
149
|
+
};
|
|
150
|
+
|
|
151
|
+
// pp_print_expr: every expression, apart from the obligation's sequent, prints in parentheses.
|
|
152
|
+
const printExpr = (expression: Expr) => `(${formatExpr(expression)})`;
|
|
153
|
+
const delimited = (args: Expr[]) => args.map(printExpr).join(", ");
|
|
154
|
+
const nonfix = (name: string, args: Expr[]) => `(${name} (${delimited(args)}))`;
|
|
155
|
+
|
|
156
|
+
const printInternal = (builtin: Builtin, args: Expr[]): string => {
|
|
157
|
+
const atom = ATOMS[builtin];
|
|
158
|
+
if (atom !== undefined && args.length === 0) return atom;
|
|
159
|
+
const unary = UNARY[builtin];
|
|
160
|
+
if (unary !== undefined && args.length === 1) return `(${unary} ${printExpr(args[0])})`;
|
|
161
|
+
const binary = BINARY[builtin];
|
|
162
|
+
if (binary !== undefined && args.length === 2)
|
|
163
|
+
return `(${printExpr(args[0])} ${binary} ${printExpr(args[1])})`;
|
|
164
|
+
const operator = NONFIX[builtin];
|
|
165
|
+
if (operator && operator[1] === args.length) return nonfix(operator[0], args);
|
|
166
|
+
if (builtin === "Unprimable" && args.length === 1) return printExpr(args[0]);
|
|
167
|
+
// tlapm prints an irregular expression as the hash of its TLA+ text, but never makes one.
|
|
168
|
+
if (builtin === "Irregular" && args.length === 1) return unsupported("Irregular");
|
|
169
|
+
const isFrontend = builtin === "Prime" || builtin === "StrongPrime" || builtin === "UNCHANGED";
|
|
170
|
+
if (isFrontend && args.length === 1) throw new TlapmBugError();
|
|
171
|
+
const temporal = TEMPORAL[builtin];
|
|
172
|
+
if (temporal && temporal[1] === args.length)
|
|
173
|
+
throw new TlaProverError(`Unsupported operator \`${temporal[0]}\`.\n`);
|
|
174
|
+
throw new TlaProverError("Backend.Isabelle.pp_apply");
|
|
175
|
+
};
|
|
176
|
+
|
|
177
|
+
const printApply = (operator: Expr, args: Expr[]): string => {
|
|
178
|
+
switch (operator.kind) {
|
|
179
|
+
case "Ix": {
|
|
180
|
+
const name = getBoundName(context, operator.index);
|
|
181
|
+
if (operator.index <= 0 || name === undefined) throw new TlapmBugError();
|
|
182
|
+
return args.length === 0 ? name : `(${name} (${delimited(args)}))`;
|
|
183
|
+
}
|
|
184
|
+
case "Opaque": {
|
|
185
|
+
const name = pickle(operator.name);
|
|
186
|
+
return args.length === 0 ? `(${name} :: c)` : `(${name} (${delimited(args)}) :: c)`;
|
|
187
|
+
}
|
|
188
|
+
case "Internal":
|
|
189
|
+
return printInternal(operator.builtin, args);
|
|
190
|
+
// tlapm prints a lambda without the arguments it's applied to.
|
|
191
|
+
case "Lambda": {
|
|
192
|
+
const names = operator.params.map((param) => `${adjoin(param.name)} `).join("");
|
|
193
|
+
const doc = `\\<lambda> ${names}. ${printExpr(operator.body)}`;
|
|
194
|
+
popNames(context, operator.params.length);
|
|
195
|
+
return doc;
|
|
196
|
+
}
|
|
197
|
+
default:
|
|
198
|
+
throw new TlapmBugError();
|
|
199
|
+
}
|
|
200
|
+
};
|
|
201
|
+
|
|
202
|
+
// The first bound binds around a quantifier over the others, which move under it.
|
|
203
|
+
const printQuant = (quantifier: "Forall" | "Exists", bounds: Bound[], body: Expr): string => {
|
|
204
|
+
const [bound, ...rest] = bounds;
|
|
205
|
+
if (!bound) return formatExpr(body);
|
|
206
|
+
const undittoed =
|
|
207
|
+
rest[0]?.domain.kind === "Ditto"
|
|
208
|
+
? [{ ...rest[0], domain: bound.domain }, ...rest.slice(1)]
|
|
209
|
+
: rest;
|
|
210
|
+
const inner: Expr =
|
|
211
|
+
undittoed.length === 0
|
|
212
|
+
? body
|
|
213
|
+
: {
|
|
214
|
+
kind: "Quant",
|
|
215
|
+
quantifier,
|
|
216
|
+
bounds: undittoed.map((other) =>
|
|
217
|
+
other.domain.kind === "Domain"
|
|
218
|
+
? {
|
|
219
|
+
...other,
|
|
220
|
+
domain: { kind: "Domain", expression: shiftExpr(1, other.domain.expression) },
|
|
221
|
+
}
|
|
222
|
+
: other,
|
|
223
|
+
),
|
|
224
|
+
body,
|
|
225
|
+
location: body.location,
|
|
226
|
+
};
|
|
227
|
+
const symbol = quantifier === "Forall" ? "\\<forall>" : "\\<exists>";
|
|
228
|
+
if (bound.domain.kind === "NoDomain")
|
|
229
|
+
return withBound(bound.name, (name) => `${symbol}${name} : ${printExpr(inner)}`);
|
|
230
|
+
if (bound.domain.kind !== "Domain") throw new TlapmBugError();
|
|
231
|
+
const domain = printExpr(bound.domain.expression);
|
|
232
|
+
return withBound(
|
|
233
|
+
bound.name,
|
|
234
|
+
(name) => `${symbol} ${name} \\<in> ${domain} : ${printExpr(inner)}`,
|
|
235
|
+
);
|
|
236
|
+
};
|
|
237
|
+
|
|
238
|
+
// pp_print_sequent_inner: a sequent inside an expression, as a meta-level implication.
|
|
239
|
+
const printNestedSequent = (sequent: Sequent): string => {
|
|
240
|
+
const [hyp, ...rest] = sequent.context;
|
|
241
|
+
if (!hyp) return printExpr(sequent.active);
|
|
242
|
+
const printRest = () => printNestedSequent({ context: rest, active: sequent.active });
|
|
243
|
+
switch (hyp.kind) {
|
|
244
|
+
case "Flex":
|
|
245
|
+
return withBound(hyp.name, (name) => `(\\<And> ${name} ${name}'.${printRest()})`);
|
|
246
|
+
case "Fresh": {
|
|
247
|
+
if (hyp.domain && hyp.domainVisibility === "Visible") {
|
|
248
|
+
const domain = printExpr(hyp.domain);
|
|
249
|
+
return withBound(
|
|
250
|
+
hyp.name,
|
|
251
|
+
(name) =>
|
|
252
|
+
`(\\<And> ${name} :: c. ${name} \\<in> ${domain} \\<Longrightarrow> ${printRest()})`,
|
|
253
|
+
);
|
|
254
|
+
}
|
|
255
|
+
const shape = `${"c => ".repeat(hyp.shape)}c`;
|
|
256
|
+
return withBound(hyp.name, (name) => `(\\<And> ${name} :: ${shape}. ${printRest()})`);
|
|
257
|
+
}
|
|
258
|
+
case "Fact": {
|
|
259
|
+
const fact = hyp.visibility === "Visible" ? printExpr(hyp.expression) : undefined;
|
|
260
|
+
bump();
|
|
261
|
+
const doc = fact ? `(${fact} \\<Longrightarrow> ${printRest()})` : printRest();
|
|
262
|
+
popNames(context, 1);
|
|
263
|
+
return doc;
|
|
264
|
+
}
|
|
265
|
+
case "Defn":
|
|
266
|
+
return unsupported("Inner definition");
|
|
267
|
+
}
|
|
268
|
+
};
|
|
269
|
+
|
|
270
|
+
const formatExpr = (expression: Expr): string => {
|
|
271
|
+
switch (expression.kind) {
|
|
272
|
+
case "Ix":
|
|
273
|
+
case "Internal":
|
|
274
|
+
case "Opaque":
|
|
275
|
+
case "Lambda":
|
|
276
|
+
return printApply(expression, []);
|
|
277
|
+
case "Apply":
|
|
278
|
+
return printApply(expression.operator, expression.args);
|
|
279
|
+
case "Bang":
|
|
280
|
+
throw new TlaProverError("Backend.Isabelle.module");
|
|
281
|
+
case "Sequent":
|
|
282
|
+
return printNestedSequent(expression.sequent);
|
|
283
|
+
case "With":
|
|
284
|
+
case "Parens":
|
|
285
|
+
return formatExpr(expression.expression);
|
|
286
|
+
case "Let":
|
|
287
|
+
return unsupported("LET");
|
|
288
|
+
case "List":
|
|
289
|
+
if (expression.bullet === "Refs" && expression.items.length === 0) return "TRUE";
|
|
290
|
+
if (expression.bullet === "Refs" && expression.items.length === 1)
|
|
291
|
+
return formatExpr(expression.items[0]);
|
|
292
|
+
return expression.items.map(printExpr).join(expression.bullet === "Or" ? " | " : " & ");
|
|
293
|
+
case "If":
|
|
294
|
+
return `cond(${printExpr(expression.condition)}, ${printExpr(expression.consequent)}, ${printExpr(expression.alternative)})`;
|
|
295
|
+
case "Quant":
|
|
296
|
+
return printQuant(expression.quantifier, expression.bounds, expression.body);
|
|
297
|
+
case "Tquant":
|
|
298
|
+
return unsupported(expression.quantifier === "Forall" ? "\\\\AA" : "\\\\EE");
|
|
299
|
+
case "Choose": {
|
|
300
|
+
const body = expression.body;
|
|
301
|
+
if (!expression.domain)
|
|
302
|
+
return withBound(expression.name, (name) => `Choice(%${name}. ${printExpr(body)})`);
|
|
303
|
+
const domain = printExpr(expression.domain);
|
|
304
|
+
return withBound(
|
|
305
|
+
expression.name,
|
|
306
|
+
(name) => `bChoice(${domain}, %${name}. ${printExpr(body)})`,
|
|
307
|
+
);
|
|
308
|
+
}
|
|
309
|
+
case "SetSt": {
|
|
310
|
+
const body = expression.body;
|
|
311
|
+
const domain = printExpr(expression.domain);
|
|
312
|
+
return withBound(
|
|
313
|
+
expression.name,
|
|
314
|
+
(name) => `subsetOf(${domain}, %${name}. ${printExpr(body)})`,
|
|
315
|
+
);
|
|
316
|
+
}
|
|
317
|
+
case "SetOf": {
|
|
318
|
+
const element = expression.element;
|
|
319
|
+
const [bound] = expression.bounds;
|
|
320
|
+
if (!bound) throw new TlapmBugError();
|
|
321
|
+
if (expression.bounds.length !== 1 || bound.domain.kind !== "Domain")
|
|
322
|
+
return unsupported("SetOf (multiple declared constants)");
|
|
323
|
+
const domain = printExpr(bound.domain.expression);
|
|
324
|
+
return withBound(
|
|
325
|
+
bound.name,
|
|
326
|
+
(name) => `setOfAll(${domain}, %${name}. ${printExpr(element)})`,
|
|
327
|
+
);
|
|
328
|
+
}
|
|
329
|
+
case "SetEnum":
|
|
330
|
+
return `{${delimited(expression.elements)}}`;
|
|
331
|
+
case "Fcn": {
|
|
332
|
+
const body = expression.body;
|
|
333
|
+
const [bound] = expression.bounds;
|
|
334
|
+
if (!bound || expression.bounds.length !== 1)
|
|
335
|
+
return unsupported("function (multiple declared constants)");
|
|
336
|
+
if (bound.domain.kind === "Ditto") throw new TlapmBugError();
|
|
337
|
+
const domain =
|
|
338
|
+
bound.domain.kind === "Domain" ? printExpr(bound.domain.expression) : undefined;
|
|
339
|
+
return withBound(bound.name, (name) => {
|
|
340
|
+
const printed = domain === undefined ? name : ` ${name} \\<in> ${domain} `;
|
|
341
|
+
return `[${printed} \\<mapsto> ${printExpr(body)}]`;
|
|
342
|
+
});
|
|
343
|
+
}
|
|
344
|
+
case "FcnApp": {
|
|
345
|
+
const fcn = printExpr(expression.function);
|
|
346
|
+
return expression.args.length === 1
|
|
347
|
+
? `fapply (${fcn}, ${printExpr(expression.args[0])})`
|
|
348
|
+
: `fapply (${fcn}, <<${delimited(expression.args)}>>)`;
|
|
349
|
+
}
|
|
350
|
+
case "Arrow":
|
|
351
|
+
return `[${printExpr(expression.domain)} \\<rightarrow> ${printExpr(expression.range)}]`;
|
|
352
|
+
case "Rect":
|
|
353
|
+
return `[${expression.fields.map((field) => `''${field.name}'' : ${printExpr(field.value)}`).join(", ")}]`;
|
|
354
|
+
case "Record":
|
|
355
|
+
return `(${expression.fields.map((field) => `(''${field.name}'' :> ${printExpr(field.value)})`).join(" @@ ")})`;
|
|
356
|
+
case "Except": {
|
|
357
|
+
const specs = expression.specs.map((spec) => {
|
|
358
|
+
const trail = spec.trail
|
|
359
|
+
.map((point) =>
|
|
360
|
+
point.kind === "Dot" ? `[''${point.field}'']` : `[${printExpr(point.expression)}]`,
|
|
361
|
+
)
|
|
362
|
+
.join("");
|
|
363
|
+
return `!${trail} = ${printExpr(spec.value)}`;
|
|
364
|
+
});
|
|
365
|
+
return `[${printExpr(expression.function)} EXCEPT ${specs.join(", ")}]`;
|
|
366
|
+
}
|
|
367
|
+
case "Dot":
|
|
368
|
+
return `fapply (${printExpr(expression.expression)}, (''${expression.field}''))`;
|
|
369
|
+
case "Tuple":
|
|
370
|
+
return `<<${delimited(expression.elements)}>>`;
|
|
371
|
+
case "Product":
|
|
372
|
+
return expression.factors.length === 2
|
|
373
|
+
? `(${printExpr(expression.factors[0])} \\<times> ${printExpr(expression.factors[1])})`
|
|
374
|
+
: `Product(\\<langle>${delimited(expression.factors)}\\<rangle>)`;
|
|
375
|
+
case "Sub":
|
|
376
|
+
case "Tsub": {
|
|
377
|
+
const suffix = expression.kind === "Sub" ? "sub" : "tsub";
|
|
378
|
+
const name = expression.modal === "Box" ? cook(`a'box'${suffix}`) : `a'dia'${suffix}`;
|
|
379
|
+
return `${name}(${printExpr(expression.action)},${printExpr(expression.subscript)})`;
|
|
380
|
+
}
|
|
381
|
+
case "Fair":
|
|
382
|
+
return `${cook(expression.fairness === "Weak" ? "a'wf" : "a'sf")}(${printExpr(expression.subscript)},${printExpr(expression.action)})`;
|
|
383
|
+
case "Case": {
|
|
384
|
+
const conditions = delimited(expression.arms.map((arm) => arm.condition));
|
|
385
|
+
const bodies = delimited(expression.arms.map((arm) => arm.body));
|
|
386
|
+
return expression.other
|
|
387
|
+
? `CaseOther(<<${conditions}>>,<<${bodies}>>,${printExpr(expression.other)})`
|
|
388
|
+
: `Case(<<${conditions}>>,<<${bodies}>>)`;
|
|
389
|
+
}
|
|
390
|
+
case "String":
|
|
391
|
+
return `''${expression.value}''`;
|
|
392
|
+
case "Num":
|
|
393
|
+
if (expression.fraction !== "") return unsupported("real constants");
|
|
394
|
+
return `(${getSuccessors(expression.integer)})`;
|
|
395
|
+
case "At":
|
|
396
|
+
throw new TlapmBugError();
|
|
397
|
+
}
|
|
398
|
+
};
|
|
399
|
+
|
|
400
|
+
// tlapm prints a fact to a formatter that drops its output first, to omit an unsupported one.
|
|
401
|
+
const getFact = (expression: Expr) => {
|
|
402
|
+
const depth = context.stack.length;
|
|
403
|
+
try {
|
|
404
|
+
return printExpr(expression);
|
|
405
|
+
} catch (error) {
|
|
406
|
+
if (!(error instanceof TlaUnsupportedError)) throw error;
|
|
407
|
+
popNames(context, context.stack.length - depth);
|
|
408
|
+
return error;
|
|
409
|
+
}
|
|
410
|
+
};
|
|
411
|
+
|
|
412
|
+
// pp_print_sequent_outer: the obligation's sequent as the fixes, assumes and shows of a lemma. A
|
|
413
|
+
// pragma's definition ends it, without the goal.
|
|
414
|
+
const printLemma = (sequent: Sequent) => {
|
|
415
|
+
const lines: string[] = [];
|
|
416
|
+
for (const hyp of sequent.context) {
|
|
417
|
+
switch (hyp.kind) {
|
|
418
|
+
case "Flex": {
|
|
419
|
+
const name = adjoin(hyp.name);
|
|
420
|
+
lines.push(`fixes ${name} ${name}'`);
|
|
421
|
+
break;
|
|
422
|
+
}
|
|
423
|
+
case "Fresh": {
|
|
424
|
+
const domain =
|
|
425
|
+
hyp.domain && hyp.domainVisibility === "Visible" ? printExpr(hyp.domain) : undefined;
|
|
426
|
+
const name = adjoin(hyp.name);
|
|
427
|
+
lines.push(`fixes ${name}`);
|
|
428
|
+
if (domain === undefined) break;
|
|
429
|
+
state.isAssumed = true;
|
|
430
|
+
lines.push(`assumes ${name}_in : "(${name} \\<in> ${domain})"`);
|
|
431
|
+
break;
|
|
432
|
+
}
|
|
433
|
+
case "Fact": {
|
|
434
|
+
const count = context.stack.length;
|
|
435
|
+
const fact = hyp.visibility === "Visible" ? getFact(hyp.expression) : undefined;
|
|
436
|
+
bump();
|
|
437
|
+
if (fact instanceof TlaUnsupportedError) {
|
|
438
|
+
lines.push(`(* omitted temporal assumption : ${fact.message} *)`);
|
|
439
|
+
break;
|
|
440
|
+
}
|
|
441
|
+
if (fact === undefined) break;
|
|
442
|
+
state.isAssumed = true;
|
|
443
|
+
lines.push(`assumes v'${count}: "${fact}"`);
|
|
444
|
+
break;
|
|
445
|
+
}
|
|
446
|
+
case "Defn":
|
|
447
|
+
if (hyp.definition.kind === "Bpragma") return lines.map((line) => `${line}\n`).join("");
|
|
448
|
+
lines.push(`(* usable definition ${hyp.definition.name} suppressed *)`);
|
|
449
|
+
adjoin(hyp.definition.name);
|
|
450
|
+
break;
|
|
451
|
+
}
|
|
452
|
+
}
|
|
453
|
+
return [...lines, `shows "${printExpr(sequent.active)}"`].join("\n");
|
|
454
|
+
};
|
|
455
|
+
|
|
456
|
+
const lemma = (() => {
|
|
457
|
+
try {
|
|
458
|
+
return printLemma(sequent);
|
|
459
|
+
} catch (error) {
|
|
460
|
+
if (!(error instanceof TlaUnsupportedError)) throw error;
|
|
461
|
+
throw new TlaProverError(`isabelle : unsupported operator ${error.message}`);
|
|
462
|
+
}
|
|
463
|
+
})();
|
|
464
|
+
return [
|
|
465
|
+
"(* automatically generated -- do not edit manually *)",
|
|
466
|
+
`theory ${theoryName} imports Constant Zenon begin`,
|
|
467
|
+
HEADER,
|
|
468
|
+
`lemma ob'${id}:`,
|
|
469
|
+
`${lemma}(is "PROP ?ob'${id}")`,
|
|
470
|
+
"proof -",
|
|
471
|
+
`show "PROP ?ob'${id}"`,
|
|
472
|
+
`${state.isAssumed ? "using assms " : ""}by ${tactic}`,
|
|
473
|
+
"qed",
|
|
474
|
+
"end",
|
|
475
|
+
"",
|
|
476
|
+
].join("\n");
|
|
477
|
+
};
|