tla-ts 0.0.4-dev.e9adbb1 → 0.0.4-dev.ee344a5

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.
Files changed (303) hide show
  1. package/README.md +45 -1
  2. package/dist/deciders.cjs +366 -0
  3. package/dist/deciders.js +366 -0
  4. package/dist/index.cjs +1 -1
  5. package/dist/index.d.cts +35 -1
  6. package/dist/index.d.ts +35 -1
  7. package/dist/index.js +1 -1
  8. package/dist/parallel-worker.cjs +1 -4
  9. package/dist/parallel-worker.js +1 -4
  10. package/dist/prove-worker.cjs +9 -0
  11. package/dist/prove-worker.d.cts +9 -0
  12. package/dist/prove-worker.d.ts +9 -0
  13. package/dist/prove-worker.js +9 -0
  14. package/dist/prove.cjs +515 -0
  15. package/dist/prove.js +515 -0
  16. package/dist/run-cli.cjs +30 -47
  17. package/dist/run-cli.js +30 -47
  18. package/dist/tlapm.cjs +10 -0
  19. package/dist/tlapm.js +10 -0
  20. package/dist/transfer.cjs +38 -44
  21. package/dist/transfer.js +38 -44
  22. package/dist/worker.cjs +21 -0
  23. package/dist/worker.js +21 -0
  24. package/package.json +21 -12
  25. package/src/errors.ts +86 -0
  26. package/src/index.ts +10 -0
  27. package/src/{obligation-action.ts → obligations/action.ts} +258 -37
  28. package/src/{obligation-anon.ts → obligations/anon.ts} +13 -7
  29. package/src/obligations/ctx.ts +64 -0
  30. package/src/{obligation-deref.ts → obligations/deref.ts} +2 -2
  31. package/src/{obligation-expression.ts → obligations/expression.ts} +54 -8
  32. package/src/{obligation-generate.ts → obligations/generate.ts} +134 -61
  33. package/src/{obligations.ts → obligations/index.ts} +26 -12
  34. package/src/{obligation-levels.ts → obligations/levels.ts} +12 -2
  35. package/src/{obligation-module.ts → obligations/module.ts} +46 -20
  36. package/src/obligations/pickle.ts +100 -0
  37. package/src/obligations/pragma.ts +189 -0
  38. package/src/{obligation-printer.ts → obligations/printer.ts} +5 -59
  39. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -1
  40. package/src/{obligation-source.ts → obligations/source.ts} +91 -35
  41. package/src/obligations/temporal.ts +319 -0
  42. package/src/{obligation-tuples.ts → obligations/tuples.ts} +1 -1
  43. package/src/parallel-worker.ts +2 -18
  44. package/src/parallel.ts +10 -43
  45. package/src/prove/decide-pool.ts +100 -0
  46. package/src/prove/deciders.ts +27 -0
  47. package/src/prove/isabelle/LICENSE +36 -0
  48. package/src/prove/isabelle/LICENSE-tlapm +26 -0
  49. package/src/prove/isabelle/decide.ts +47 -0
  50. package/src/prove/isabelle/encode.ts +477 -0
  51. package/src/prove/isabelle/isar/inner-syntax.ts +579 -0
  52. package/src/prove/isabelle/isar/method.ts +367 -0
  53. package/src/prove/isabelle/isar/proof.ts +28 -0
  54. package/src/prove/isabelle/isar/statement.ts +57 -0
  55. package/src/prove/isabelle/isar/theory.ts +192 -0
  56. package/src/prove/isabelle/isar/type-check.ts +278 -0
  57. package/src/prove/isabelle/provers/blast/blast.ts +258 -0
  58. package/src/prove/isabelle/provers/blast/branch.ts +322 -0
  59. package/src/prove/isabelle/provers/blast/prove.ts +347 -0
  60. package/src/prove/isabelle/provers/blast/rules.ts +330 -0
  61. package/src/prove/isabelle/provers/blast/state.ts +180 -0
  62. package/src/prove/isabelle/provers/blast/term.ts +547 -0
  63. package/src/prove/isabelle/provers/clasimp.ts +150 -0
  64. package/src/prove/isabelle/provers/classical.ts +389 -0
  65. package/src/prove/isabelle/provers/hypsubst.ts +441 -0
  66. package/src/prove/isabelle/pure/bicompose.ts +174 -0
  67. package/src/prove/isabelle/pure/consts.ts +32 -0
  68. package/src/prove/isabelle/pure/conv.ts +79 -0
  69. package/src/prove/isabelle/pure/drule.ts +264 -0
  70. package/src/prove/isabelle/pure/envir.ts +363 -0
  71. package/src/prove/isabelle/pure/goal.ts +53 -0
  72. package/src/prove/isabelle/pure/interrupt.ts +16 -0
  73. package/src/prove/isabelle/pure/list.ts +12 -0
  74. package/src/prove/isabelle/pure/logic.ts +402 -0
  75. package/src/prove/isabelle/pure/name.ts +110 -0
  76. package/src/prove/isabelle/pure/net.ts +262 -0
  77. package/src/prove/isabelle/pure/object-logic.ts +41 -0
  78. package/src/prove/isabelle/pure/pattern.ts +650 -0
  79. package/src/prove/isabelle/pure/raw-simplifier.ts +353 -0
  80. package/src/prove/isabelle/pure/rewriter.ts +602 -0
  81. package/src/prove/isabelle/pure/search.ts +68 -0
  82. package/src/prove/isabelle/pure/seq.ts +156 -0
  83. package/src/prove/isabelle/pure/simplifier.ts +112 -0
  84. package/src/prove/isabelle/pure/table.ts +208 -0
  85. package/src/prove/isabelle/pure/tactic.ts +276 -0
  86. package/src/prove/isabelle/pure/tactical.ts +347 -0
  87. package/src/prove/isabelle/pure/term-ord.ts +159 -0
  88. package/src/prove/isabelle/pure/term.ts +808 -0
  89. package/src/prove/isabelle/pure/thm.ts +806 -0
  90. package/src/prove/isabelle/pure/type.ts +133 -0
  91. package/src/prove/isabelle/pure/unify.ts +753 -0
  92. package/src/prove/isabelle/pure/variable.ts +25 -0
  93. package/src/prove/isabelle/tla/classical-setup.ts +101 -0
  94. package/src/prove/isabelle/tla/context.ts +74 -0
  95. package/src/prove/isabelle/tla/logic-data.ts +5 -0
  96. package/src/prove/isabelle/tla/logic.ts +215 -0
  97. package/src/prove/isabelle/tla/simpdata.ts +241 -0
  98. package/src/prove/isabelle/tools/intuitionistic.ts +132 -0
  99. package/src/prove/ocaml.ts +22 -0
  100. package/src/prove/prep/action.ts +520 -0
  101. package/src/prove/prep/defs.ts +27 -0
  102. package/src/prove/prep/elab.ts +156 -0
  103. package/src/prove/prep/enabled-axioms.ts +189 -0
  104. package/src/prove/prep/enabled.ts +43 -0
  105. package/src/prove/prep/fingerprint.ts +388 -0
  106. package/src/prove/prep/flatten.ts +70 -0
  107. package/src/prove/prep/level-comparison.ts +552 -0
  108. package/src/prove/prep/md5.ts +67 -0
  109. package/src/prove/prep/pragma.ts +221 -0
  110. package/src/prove/prep/trivial.ts +22 -0
  111. package/src/prove/prove-worker.ts +29 -0
  112. package/src/prove/prove.ts +417 -0
  113. package/src/prove/ptl/decide.ts +68 -0
  114. package/src/prove/ptl/encode.ts +256 -0
  115. package/src/prove/ptl/sat.ts +151 -0
  116. package/src/prove/ptl/tableau.ts +276 -0
  117. package/src/prove/smt/axiomatize.ts +69 -0
  118. package/src/prove/smt/axioms.ts +210 -0
  119. package/src/prove/smt/context.ts +108 -0
  120. package/src/prove/smt/data.ts +665 -0
  121. package/src/prove/smt/encode.ts +169 -0
  122. package/src/prove/smt/extensionality.ts +63 -0
  123. package/src/prove/smt/flatten.ts +127 -0
  124. package/src/prove/smt/format.ts +143 -0
  125. package/src/prove/smt/instances.ts +182 -0
  126. package/src/prove/smt/rewrite.ts +784 -0
  127. package/src/prove/smt/simplify.ts +57 -0
  128. package/src/prove/smt/solver/act-cache.ts +265 -0
  129. package/src/prove/smt/solver/arith-rewriter.ts +962 -0
  130. package/src/prove/smt/solver/array.ts +22 -0
  131. package/src/prove/smt/solver/asserted-formulas.ts +469 -0
  132. package/src/prove/smt/solver/ast-lt.ts +157 -0
  133. package/src/prove/smt/solver/ast-util.ts +147 -0
  134. package/src/prove/smt/solver/ast.ts +1315 -0
  135. package/src/prove/smt/solver/auf-solver.ts +572 -0
  136. package/src/prove/smt/solver/case-split-queue.ts +178 -0
  137. package/src/prove/smt/solver/cg-table.ts +175 -0
  138. package/src/prove/smt/solver/clause.ts +276 -0
  139. package/src/prove/smt/solver/conflict-resolution.ts +343 -0
  140. package/src/prove/smt/solver/context.ts +1292 -0
  141. package/src/prove/smt/solver/ctx-simplify.ts +334 -0
  142. package/src/prove/smt/solver/der.ts +224 -0
  143. package/src/prove/smt/solver/dyn-ack.ts +141 -0
  144. package/src/prove/smt/solver/e-matching.ts +659 -0
  145. package/src/prove/smt/solver/enode.ts +259 -0
  146. package/src/prove/smt/solver/expr-ref.ts +21 -0
  147. package/src/prove/smt/solver/expr-safe-replace.ts +172 -0
  148. package/src/prove/smt/solver/fingerprints.ts +92 -0
  149. package/src/prove/smt/solver/flat-literals.ts +51 -0
  150. package/src/prove/smt/solver/goal.ts +138 -0
  151. package/src/prove/smt/solver/hash.ts +173 -0
  152. package/src/prove/smt/solver/hashtable.ts +166 -0
  153. package/src/prove/smt/solver/internalizer.ts +1381 -0
  154. package/src/prove/smt/solver/lbool.ts +5 -0
  155. package/src/prove/smt/solver/literal.ts +24 -0
  156. package/src/prove/smt/solver/lp/bound-propagator.ts +391 -0
  157. package/src/prove/smt/solver/lp/constraints.ts +78 -0
  158. package/src/prove/smt/solver/lp/containers.ts +296 -0
  159. package/src/prove/smt/solver/lp/core-solver.ts +504 -0
  160. package/src/prove/smt/solver/lp/cross-nested.ts +224 -0
  161. package/src/prove/smt/solver/lp/dep-intervals.ts +656 -0
  162. package/src/prove/smt/solver/lp/dependency.ts +51 -0
  163. package/src/prove/smt/solver/lp/dioph-eq.ts +1181 -0
  164. package/src/prove/smt/solver/lp/explanation.ts +46 -0
  165. package/src/prove/smt/solver/lp/gomory.ts +255 -0
  166. package/src/prove/smt/solver/lp/hnf-cutter.ts +125 -0
  167. package/src/prove/smt/solver/lp/hnf.ts +281 -0
  168. package/src/prove/smt/solver/lp/int-cube.ts +295 -0
  169. package/src/prove/smt/solver/lp/int-solver.ts +514 -0
  170. package/src/prove/smt/solver/lp/lar-solver.ts +816 -0
  171. package/src/prove/smt/solver/lp/lar-term.ts +62 -0
  172. package/src/prove/smt/solver/lp/lp-settings.ts +91 -0
  173. package/src/prove/smt/solver/lp/maximize-term.ts +347 -0
  174. package/src/prove/smt/solver/lp/nex-creator.ts +381 -0
  175. package/src/prove/smt/solver/lp/nex.ts +120 -0
  176. package/src/prove/smt/solver/lp/nla-backoff.ts +43 -0
  177. package/src/prove/smt/solver/lp/nla-basics.ts +398 -0
  178. package/src/prove/smt/solver/lp/nla-core.ts +968 -0
  179. package/src/prove/smt/solver/lp/nla-divisions.ts +332 -0
  180. package/src/prove/smt/solver/lp/nla-emonics.ts +373 -0
  181. package/src/prove/smt/solver/lp/nla-factorization.ts +30 -0
  182. package/src/prove/smt/solver/lp/nla-grobner.ts +904 -0
  183. package/src/prove/smt/solver/lp/nla-horner.ts +126 -0
  184. package/src/prove/smt/solver/lp/nla-intervals.ts +265 -0
  185. package/src/prove/smt/solver/lp/nla-monomial-bounds.ts +715 -0
  186. package/src/prove/smt/solver/lp/nla-monotone.ts +59 -0
  187. package/src/prove/smt/solver/lp/nla-order.ts +307 -0
  188. package/src/prove/smt/solver/lp/nla-patcher.ts +112 -0
  189. package/src/prove/smt/solver/lp/nla-tangents.ts +251 -0
  190. package/src/prove/smt/solver/lp/nla-throttle.ts +85 -0
  191. package/src/prove/smt/solver/lp/nla-types.ts +124 -0
  192. package/src/prove/smt/solver/lp/nla-var-eqs.ts +141 -0
  193. package/src/prove/smt/solver/lp/nra-solver.ts +440 -0
  194. package/src/prove/smt/solver/lp/numeric-pair.ts +65 -0
  195. package/src/prove/smt/solver/lp/pdd-interval.ts +31 -0
  196. package/src/prove/smt/solver/lp/pdd-simplifier.ts +184 -0
  197. package/src/prove/smt/solver/lp/pdd-solver.ts +408 -0
  198. package/src/prove/smt/solver/lp/pdd.ts +971 -0
  199. package/src/prove/smt/solver/lp/random-updater.ts +138 -0
  200. package/src/prove/smt/solver/lp/static-matrix.ts +246 -0
  201. package/src/prove/smt/solver/lp/union-find.ts +96 -0
  202. package/src/prove/smt/solver/mam-compiler.ts +847 -0
  203. package/src/prove/smt/solver/mam-interpreter.ts +400 -0
  204. package/src/prove/smt/solver/maximize-ac-sharing.ts +118 -0
  205. package/src/prove/smt/solver/model-checker.ts +347 -0
  206. package/src/prove/smt/solver/model-evaluator.ts +262 -0
  207. package/src/prove/smt/solver/model-finder.ts +155 -0
  208. package/src/prove/smt/solver/model-generator.ts +97 -0
  209. package/src/prove/smt/solver/model-macro-solver.ts +728 -0
  210. package/src/prove/smt/solver/nlsat/algebraic.ts +1161 -0
  211. package/src/prove/smt/solver/nlsat/atoms.ts +238 -0
  212. package/src/prove/smt/solver/nlsat/evaluator.ts +303 -0
  213. package/src/prove/smt/solver/nlsat/explain.ts +607 -0
  214. package/src/prove/smt/solver/nlsat/interval-set.ts +351 -0
  215. package/src/prove/smt/solver/nlsat/levelwise.ts +740 -0
  216. package/src/prove/smt/solver/nlsat/mpbq.ts +161 -0
  217. package/src/prove/smt/solver/nlsat/polynomial.ts +1722 -0
  218. package/src/prove/smt/solver/nlsat/solver.ts +911 -0
  219. package/src/prove/smt/solver/nlsat/types.ts +43 -0
  220. package/src/prove/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
  221. package/src/prove/smt/solver/nlsat/upolynomial.ts +996 -0
  222. package/src/prove/smt/solver/nnf.ts +469 -0
  223. package/src/prove/smt/solver/pattern-inference.ts +351 -0
  224. package/src/prove/smt/solver/poly-rewriter.ts +477 -0
  225. package/src/prove/smt/solver/propagate-values.ts +83 -0
  226. package/src/prove/smt/solver/proto-model.ts +551 -0
  227. package/src/prove/smt/solver/pull-quant.ts +139 -0
  228. package/src/prove/smt/solver/qe-lite-der.ts +526 -0
  229. package/src/prove/smt/solver/qe-lite-fm.ts +576 -0
  230. package/src/prove/smt/solver/qe-lite.ts +381 -0
  231. package/src/prove/smt/solver/qi-queue.ts +362 -0
  232. package/src/prove/smt/solver/quant-tactics.ts +117 -0
  233. package/src/prove/smt/solver/quantifier-analyzer.ts +562 -0
  234. package/src/prove/smt/solver/quantifier-manager.ts +186 -0
  235. package/src/prove/smt/solver/random-gen.ts +10 -0
  236. package/src/prove/smt/solver/rational.ts +165 -0
  237. package/src/prove/smt/solver/ref-vector.ts +62 -0
  238. package/src/prove/smt/solver/relevancy.ts +247 -0
  239. package/src/prove/smt/solver/rewriter-tpl.ts +1159 -0
  240. package/src/prove/smt/solver/rewriter.ts +843 -0
  241. package/src/prove/smt/solver/rlimit.ts +79 -0
  242. package/src/prove/smt/solver/smtlib-parser.ts +526 -0
  243. package/src/prove/smt/solver/solver.ts +71 -0
  244. package/src/prove/smt/solver/sort.ts +35 -0
  245. package/src/prove/smt/solver/sticky-generations.ts +69 -0
  246. package/src/prove/smt/solver/theory-lra-axioms.ts +340 -0
  247. package/src/prove/smt/solver/theory-lra-bounds.ts +226 -0
  248. package/src/prove/smt/solver/theory-lra-final-check.ts +252 -0
  249. package/src/prove/smt/solver/theory-lra-internalize.ts +476 -0
  250. package/src/prove/smt/solver/theory-lra-model.ts +243 -0
  251. package/src/prove/smt/solver/theory-lra-propagate.ts +405 -0
  252. package/src/prove/smt/solver/theory-lra-state.ts +43 -0
  253. package/src/prove/smt/solver/theory-lra.ts +56 -0
  254. package/src/prove/smt/solver/var-subst.ts +258 -0
  255. package/src/prove/smt/solver/z3-license.txt +10 -0
  256. package/src/prove/smt/table.ts +170 -0
  257. package/src/prove/tlapm/tlapm.ts +96 -0
  258. package/src/prove/tlaps-module.ts +510 -0
  259. package/src/prove/verdict.ts +13 -0
  260. package/src/prove/zenon/LICENSE +32 -0
  261. package/src/prove/zenon/check/check.ts +105 -0
  262. package/src/prove/zenon/check/definitions.ts +144 -0
  263. package/src/prove/zenon/check/equality.ts +182 -0
  264. package/src/prove/zenon/check/functions.ts +62 -0
  265. package/src/prove/zenon/check/keys.ts +125 -0
  266. package/src/prove/zenon/check/propositional.ts +104 -0
  267. package/src/prove/zenon/check/records.ts +188 -0
  268. package/src/prove/zenon/check/relations.ts +121 -0
  269. package/src/prove/zenon/check/rewrites.ts +224 -0
  270. package/src/prove/zenon/check/sets.ts +302 -0
  271. package/src/prove/zenon/check/terms.ts +127 -0
  272. package/src/prove/zenon/check/tla.ts +126 -0
  273. package/src/prove/zenon/decide.ts +113 -0
  274. package/src/prove/zenon/encode.ts +444 -0
  275. package/src/prove/zenon/eqrel.ts +300 -0
  276. package/src/prove/zenon/equality-rules.ts +435 -0
  277. package/src/prove/zenon/expr.ts +551 -0
  278. package/src/prove/zenon/index-table.ts +350 -0
  279. package/src/prove/zenon/isar-case.ts +513 -0
  280. package/src/prove/zenon/isar.ts +1249 -0
  281. package/src/prove/zenon/limits.ts +15 -0
  282. package/src/prove/zenon/llproof.ts +173 -0
  283. package/src/prove/zenon/mltoll.ts +1566 -0
  284. package/src/prove/zenon/node.ts +297 -0
  285. package/src/prove/zenon/ocaml.ts +169 -0
  286. package/src/prove/zenon/parse.ts +247 -0
  287. package/src/prove/zenon/phrase.ts +191 -0
  288. package/src/prove/zenon/proof.ts +198 -0
  289. package/src/prove/zenon/propositional-rules.ts +387 -0
  290. package/src/prove/zenon/rules.ts +94 -0
  291. package/src/prove/zenon/search.ts +288 -0
  292. package/src/prove/zenon/tla/functions.ts +151 -0
  293. package/src/prove/zenon/tla/llproof.ts +480 -0
  294. package/src/prove/zenon/tla/records.ts +225 -0
  295. package/src/prove/zenon/tla/rewrites.ts +447 -0
  296. package/src/prove/zenon/tla/sets.ts +304 -0
  297. package/src/prove/zenon/tla/terms.ts +181 -0
  298. package/src/prove/zenon/tla/tla.ts +506 -0
  299. package/src/run-cli.ts +63 -10
  300. package/src/worker.ts +65 -0
  301. package/dist/parallel.cjs +0 -12
  302. package/dist/parallel.js +0 -12
  303. /package/src/{obligation-format.ts → obligations/format.ts} +0 -0
@@ -0,0 +1,278 @@
1
+ // Ported from Isabelle2025's Pure/type_infer_context.ML, Pure/type_infer.ML (fixate) and the
2
+ // abbreviation expansion of Pure/consts.ML. Copyright (c) 1986-2025 University of Cambridge,
3
+ // Technische Universitaet Muenchen, and contributors, see LICENSE.
4
+ //
5
+ // Resolves the names of parsed propositions and infers their types together, as
6
+ // Syntax.check_props does for the statement of a lemma: a free variable has one type across all
7
+ // of them, and type parameters that stay open become the type variables 'a, 'b, and so on.
8
+
9
+ import { TlaIsabelleError } from "../../../errors";
10
+ import { bumpString } from "../pure/name";
11
+ import {
12
+ betapplys,
13
+ foldAtyps,
14
+ foldTypes,
15
+ funT,
16
+ mkAbs,
17
+ mkApp,
18
+ mkBound,
19
+ mkConst,
20
+ mkFree,
21
+ mkTFree,
22
+ mkTVar,
23
+ mkType,
24
+ mapTypes,
25
+ stripComb,
26
+ type Term,
27
+ type Typ,
28
+ } from "../pure/term";
29
+ import type { ConstInfo } from "../tla/logic";
30
+ import type { Ast } from "./inner-syntax";
31
+
32
+ // The name a type parameter carries until it is fixed, as Type_Infer.param does.
33
+ const PARAM_NAME = "?'a";
34
+
35
+ export interface NameScope {
36
+ readonly consts: ReadonlyMap<string, ConstInfo>;
37
+ // The constant an unqualified name stands for.
38
+ readonly constNames: ReadonlyMap<string, string>;
39
+ }
40
+
41
+ export interface PropToCheck {
42
+ readonly ast: Ast;
43
+ // The variables fixed where the proposition appears.
44
+ readonly fixed: ReadonlySet<string>;
45
+ }
46
+
47
+ interface Inference {
48
+ readonly substitution: Map<number, Typ>;
49
+ readonly freeTypes: Map<string, Typ>;
50
+ nextParam: number;
51
+ }
52
+
53
+ const freshParam = (inference: Inference) => {
54
+ const param = mkTVar(PARAM_NAME, inference.nextParam);
55
+ inference.nextParam += 1;
56
+ return param;
57
+ };
58
+
59
+ const isParam = (type: Typ) => type.kind === "TVar" && type.name === PARAM_NAME;
60
+
61
+ const resolve = (inference: Inference, type: Typ): Typ => {
62
+ if (type.kind === "TVar" && isParam(type)) {
63
+ const bound = inference.substitution.get(type.index);
64
+ return bound === undefined ? type : resolve(inference, bound);
65
+ }
66
+ return type;
67
+ };
68
+
69
+ const normalize = (inference: Inference, type: Typ): Typ => {
70
+ const resolved = resolve(inference, type);
71
+ return resolved.kind === "Type"
72
+ ? mkType(
73
+ resolved.name,
74
+ resolved.args.map((arg) => normalize(inference, arg)),
75
+ )
76
+ : resolved;
77
+ };
78
+
79
+ const occurs = (inference: Inference, index: number, type: Typ): boolean => {
80
+ const resolved = resolve(inference, type);
81
+ if (resolved.kind === "TVar" && isParam(resolved)) return resolved.index === index;
82
+ return resolved.kind === "Type" && resolved.args.some((arg) => occurs(inference, index, arg));
83
+ };
84
+
85
+ const unify = (inference: Inference, left: Typ, right: Typ) => {
86
+ const resolvedLeft = resolve(inference, left);
87
+ const resolvedRight = resolve(inference, right);
88
+ if (resolvedLeft.kind === "TVar" && isParam(resolvedLeft)) {
89
+ if (
90
+ resolvedRight.kind === "TVar" &&
91
+ isParam(resolvedRight) &&
92
+ resolvedRight.index === resolvedLeft.index
93
+ )
94
+ return;
95
+ if (occurs(inference, resolvedLeft.index, resolvedRight))
96
+ throw new TlaIsabelleError("ERROR", "Type unification failed: occurs check");
97
+ inference.substitution.set(resolvedLeft.index, resolvedRight);
98
+ return;
99
+ }
100
+ if (resolvedRight.kind === "TVar" && isParam(resolvedRight)) {
101
+ unify(inference, resolvedRight, resolvedLeft);
102
+ return;
103
+ }
104
+ if (
105
+ resolvedLeft.kind === "Type" &&
106
+ resolvedRight.kind === "Type" &&
107
+ resolvedLeft.name === resolvedRight.name
108
+ ) {
109
+ resolvedLeft.args.forEach((arg, index) => unify(inference, arg, resolvedRight.args[index]));
110
+ return;
111
+ }
112
+ if (
113
+ resolvedLeft.kind === "TFree" &&
114
+ resolvedRight.kind === "TFree" &&
115
+ resolvedLeft.name === resolvedRight.name
116
+ )
117
+ return;
118
+ throw new TlaIsabelleError("ERROR", "Type unification failed");
119
+ };
120
+
121
+ // A constant's declared type with fresh parameters for its type variables.
122
+ const instantiateScheme = (inference: Inference, type: Typ) => {
123
+ const params = new Map<string, Typ>();
124
+ const instantiate = (current: Typ): Typ => {
125
+ if (current.kind === "Type") return mkType(current.name, current.args.map(instantiate));
126
+ const key = current.kind === "TFree" ? current.name : `${current.name}.${current.index}`;
127
+ const known = params.get(key);
128
+ if (known !== undefined) return known;
129
+ const param = freshParam(inference);
130
+ params.set(key, param);
131
+ return param;
132
+ };
133
+ return instantiate(type);
134
+ };
135
+
136
+ const constType = (scope: NameScope, name: string) => {
137
+ const info = scope.consts.get(name);
138
+ if (info === undefined) throw new TlaIsabelleError("ERROR", `Undeclared constant: ${name}`);
139
+ return info.type;
140
+ };
141
+
142
+ // Builds the term with parameter types and infers its type, constraining the parameters.
143
+ const elaborate = (
144
+ scope: NameScope,
145
+ inference: Inference,
146
+ fixed: ReadonlySet<string>,
147
+ bound: readonly { name: string; type: Typ }[],
148
+ ast: Ast,
149
+ ): [Term, Typ] => {
150
+ switch (ast.kind) {
151
+ case "name": {
152
+ const index = bound.findIndex((binder) => binder.name === ast.name);
153
+ if (index >= 0) return [mkBound(index), bound[index].type];
154
+ const constant = fixed.has(ast.name) ? undefined : scope.constNames.get(ast.name);
155
+ if (constant !== undefined) {
156
+ const type = instantiateScheme(inference, constType(scope, constant));
157
+ return [mkConst(constant, type), type];
158
+ }
159
+ const known = inference.freeTypes.get(ast.name);
160
+ const type = known ?? freshParam(inference);
161
+ if (known === undefined) inference.freeTypes.set(ast.name, type);
162
+ return [mkFree(ast.name, type), type];
163
+ }
164
+ case "const": {
165
+ const type = instantiateScheme(inference, constType(scope, ast.name));
166
+ return [mkConst(ast.name, type), type];
167
+ }
168
+ case "app": {
169
+ const [fun, funType] = elaborate(scope, inference, fixed, bound, ast.fun);
170
+ const [arg, argType] = elaborate(scope, inference, fixed, bound, ast.arg);
171
+ const result = freshParam(inference);
172
+ unify(inference, funType, funT(argType, result));
173
+ return [mkApp(fun, arg), result];
174
+ }
175
+ case "abs": {
176
+ const type = ast.type ?? freshParam(inference);
177
+ const [body, bodyType] = elaborate(
178
+ scope,
179
+ inference,
180
+ fixed,
181
+ [{ name: ast.name, type }, ...bound],
182
+ ast.body,
183
+ );
184
+ return [mkAbs(ast.name, type, body), funT(type, bodyType)];
185
+ }
186
+ case "constrain": {
187
+ const [term, type] = elaborate(scope, inference, fixed, bound, ast.term);
188
+ unify(inference, type, ast.type);
189
+ return [term, type];
190
+ }
191
+ }
192
+ };
193
+
194
+ const matchScheme = (pattern: Typ, object: Typ, instantiation: Map<string, Typ>) => {
195
+ if (pattern.kind === "Type") {
196
+ if (object.kind === "Type")
197
+ pattern.args.forEach((arg, index) => matchScheme(arg, object.args[index], instantiation));
198
+ return;
199
+ }
200
+ instantiation.set(
201
+ pattern.kind === "TFree" ? pattern.name : `${pattern.name}.${pattern.index}`,
202
+ object,
203
+ );
204
+ };
205
+
206
+ const instantiateMatched = (type: Typ, instantiation: ReadonlyMap<string, Typ>): Typ =>
207
+ type.kind === "Type"
208
+ ? mkType(
209
+ type.name,
210
+ type.args.map((arg) => instantiateMatched(arg, instantiation)),
211
+ )
212
+ : (instantiation.get(type.kind === "TFree" ? type.name : `${type.name}.${type.index}`) ?? type);
213
+
214
+ // Consts.certify with normalize: unfolds abbreviations and applies them to their arguments.
215
+ const expandAbbreviations = (scope: NameScope, term: Term): Term => {
216
+ const [head, args] = stripComb(term);
217
+ const expandedArgs = args.map((arg) => expandAbbreviations(scope, arg));
218
+ if (head.kind === "Abs")
219
+ return betapplys(
220
+ mkAbs(head.name, head.type, expandAbbreviations(scope, head.body)),
221
+ expandedArgs,
222
+ );
223
+ const info = head.kind === "Const" ? scope.consts.get(head.name) : undefined;
224
+ if (head.kind !== "Const" || info?.abbreviation === undefined)
225
+ return betapplys(head, expandedArgs);
226
+ const instantiation = new Map<string, Typ>();
227
+ matchScheme(info.type, head.type, instantiation);
228
+ return betapplys(
229
+ mapTypes((type) => instantiateMatched(type, instantiation), info.abbreviation),
230
+ expandedArgs,
231
+ );
232
+ };
233
+
234
+ export const checkProps = (scope: NameScope, props: readonly PropToCheck[]): Term[] => {
235
+ const inference: Inference = { substitution: new Map(), freeTypes: new Map(), nextParam: 0 };
236
+ const elaborated = props.map((prop) => {
237
+ const [term, type] = elaborate(scope, inference, prop.fixed, [], prop.ast);
238
+ unify(inference, type, mkType("prop"));
239
+ return term;
240
+ });
241
+ const expanded = elaborated.map((term) =>
242
+ expandAbbreviations(
243
+ scope,
244
+ mapTypes((type) => normalize(inference, type), term),
245
+ ),
246
+ );
247
+ // Type_Infer.fixate: the parameters left open become type variables named in order of their
248
+ // first appearance.
249
+ const params = expanded.reduce(
250
+ (result, term) =>
251
+ foldTypes(
252
+ (type, state: number[]) =>
253
+ foldAtyps(
254
+ (atom, current: number[]) =>
255
+ atom.kind === "TVar" && isParam(atom) && !current.includes(atom.index)
256
+ ? [...current, atom.index]
257
+ : current,
258
+ type,
259
+ state,
260
+ ),
261
+ term,
262
+ result,
263
+ ),
264
+ [] as number[],
265
+ );
266
+ const names = new Map<number, string>();
267
+ params.reduce((name, param) => {
268
+ names.set(param, name);
269
+ return bumpString(name);
270
+ }, "'a");
271
+ const fixType = (type: Typ): Typ =>
272
+ type.kind === "Type"
273
+ ? mkType(type.name, type.args.map(fixType))
274
+ : type.kind === "TVar" && isParam(type)
275
+ ? mkTFree(names.get(type.index) ?? "'a")
276
+ : type;
277
+ return expanded.map((term) => mapTypes(fixType, term));
278
+ };
@@ -0,0 +1,258 @@
1
+ // Ported from Isabelle2025's Provers/blast.ML. Copyright (c) 1986-2025 University of Cambridge,
2
+ // Technische Universitaet Muenchen, and contributors, see LICENSE.
3
+ //
4
+ // Paulson's generic tableau prover with proof reconstruction. It converts subgoal 1 to
5
+ // prototerms, Skolemizing its parameters, searches for a tableau proof with the claset's rules,
6
+ // and replays the proof with Isabelle tactics, so the kernel checks every result. Blast ignores
7
+ // the claset's wrappers and the elimination rules whose conclusion is not a formula variable.
8
+
9
+ import { TlaIsabelleError } from "../../../../errors";
10
+ import { selectGoal } from "../../pure/goal";
11
+ import { destImplies, stripParams } from "../../pure/logic";
12
+ import { makeNameContext } from "../../pure/name";
13
+ import { emptySeq, makeSeq, ofCell, type Cell, type Seq } from "../../pure/seq";
14
+ import { eqThm, orElse, thenTac, type GoalTactic, type Tactic } from "../../pure/tactical";
15
+ import { addFreeNames, stripComb, type Term } from "../../pure/term";
16
+ import { nprems, type Thm } from "../../pure/thm";
17
+ import { atomizePremsTac } from "../../pure/object-logic";
18
+ import { prove, type Continuation } from "./prove";
19
+ import {
20
+ backtrack,
21
+ gensym,
22
+ isBacktrackTo,
23
+ type BlastContext,
24
+ type BlastState,
25
+ type Branch,
26
+ } from "./state";
27
+ import {
28
+ FALSE_NAME,
29
+ GOAL_NAME,
30
+ addTermsVars,
31
+ blastSubstBound,
32
+ fromConst,
33
+ listBlastComb,
34
+ mkBlastAbs,
35
+ mkBlastBound,
36
+ mkBlastFree,
37
+ mkBlastSkolem,
38
+ mkBlastVar,
39
+ mkGoal,
40
+ stripBlastImpConcl,
41
+ stripBlastImpPrems,
42
+ type BlastTerm,
43
+ type VarEntry,
44
+ type VarRef,
45
+ } from "./term";
46
+
47
+ export type { BlastContext, BlastData } from "./state";
48
+
49
+ // Blast's depth_limit configuration option.
50
+ const DEPTH_LIMIT = 20;
51
+
52
+ // TRANS: the subgoal has no translation, such as one applying an unknown to a non-parameter.
53
+ class Trans extends Error {}
54
+
55
+ const isTermError = (error: unknown) =>
56
+ error instanceof TlaIsabelleError && error.exception === "TERM";
57
+
58
+ const initialize = (context: BlastContext, state: Thm): BlastState => {
59
+ for (const name of [GOAL_NAME, FALSE_NAME])
60
+ if (context.consts.has(name))
61
+ throw new TlaIsabelleError("ERROR", `blast: theory contains reserved constant "${name}"`);
62
+ return { context, names: new Map(makeNameContext(addFreeNames(state.prop, []))), trail: [] };
63
+ };
64
+
65
+ const discardForalls = (term: Term): Term =>
66
+ term.kind === "App" &&
67
+ term.fun.kind === "Const" &&
68
+ term.fun.name === "Pure.all" &&
69
+ term.arg.kind === "Abs"
70
+ ? discardForalls(term.arg.body)
71
+ : term;
72
+
73
+ interface SubgoalVar {
74
+ readonly key: string;
75
+ readonly ref: VarRef;
76
+ // The parameters the variable is applied to.
77
+ readonly bounds: readonly number[];
78
+ }
79
+
80
+ // Translates a subgoal, Skolemizing all its parameters.
81
+ const fromSubgoal = (state: BlastState, term: Term): BlastTerm => {
82
+ const vars: SubgoalVar[] = [];
83
+ const tvars: VarEntry[] = [];
84
+ const from = (level: number, current: Term): BlastTerm => {
85
+ const [head, args] = stripComb(current);
86
+ const apply = (blastHead: BlastTerm) =>
87
+ listBlastComb(
88
+ blastHead,
89
+ args.map((arg) => from(level, arg)),
90
+ );
91
+ const bounds = () =>
92
+ args.map((arg) => {
93
+ if (arg.kind !== "Bound")
94
+ throw new Trans("Function unknown's argument not a bound variable");
95
+ if (arg.index < level) throw new Trans("Function unknown's argument not a parameter");
96
+ return arg.index - level;
97
+ });
98
+ switch (head.kind) {
99
+ case "Const":
100
+ return apply(fromConst(state.context.consts, tvars, head.name, head.type));
101
+ case "Free":
102
+ return apply(mkBlastFree(head.name));
103
+ case "Bound":
104
+ return apply(mkBlastBound(head.index));
105
+ case "Var": {
106
+ const key = `${head.name}.${head.index}`;
107
+ const known = vars.find((entry) => entry.key === key);
108
+ if (known === undefined) {
109
+ const entry = { key, ref: { value: undefined }, bounds: bounds() };
110
+ vars.unshift(entry);
111
+ return mkBlastVar(entry.ref);
112
+ }
113
+ const argBounds = bounds();
114
+ if (
115
+ known.bounds.length === argBounds.length &&
116
+ known.bounds.every((bound, index) => bound === argBounds[index])
117
+ )
118
+ return mkBlastVar(known.ref);
119
+ throw new Trans(`Discrepancy among occurrences of ?${head.name}`);
120
+ }
121
+ case "Abs":
122
+ if (args.length > 0) throw new Trans("argument not in normal form");
123
+ return mkBlastAbs(head.name, from(level + 1, head.body));
124
+ case "App":
125
+ throw new Trans("strip_comb");
126
+ }
127
+ };
128
+ const npars = stripParams(term).length;
129
+ let result = from(0, discardForalls(term));
130
+ for (let index = 0; index < npars; index += 1) {
131
+ const args = vars.filter((entry) => !entry.bounds.includes(index)).map((entry) => entry.ref);
132
+ result = blastSubstBound(mkBlastSkolem(gensym(state, "T"), args), result);
133
+ }
134
+ return result;
135
+ };
136
+
137
+ interface EveryTrail {
138
+ readonly state: Thm;
139
+ readonly rest: Seq<Thm>;
140
+ readonly position: number;
141
+ readonly next: EveryTrail | undefined;
142
+ }
143
+
144
+ // EVERY, as a loop: Isabelle's EVY and evyBack call each other in tail position, so backtracking
145
+ // over a long reconstruction must not grow the stack.
146
+ const everyTac =
147
+ (tactics: readonly Tactic[]): Tactic =>
148
+ (start) => {
149
+ const advance = (
150
+ initialTrail: EveryTrail | undefined,
151
+ initialPosition: number,
152
+ initialState: Thm | undefined,
153
+ ): Cell<Thm> => {
154
+ let trail = initialTrail;
155
+ let position = initialPosition;
156
+ let state = initialState;
157
+ for (;;) {
158
+ if (state === undefined) {
159
+ if (trail === undefined) return undefined;
160
+ const cell = trail.rest.pull();
161
+ if (cell === undefined) trail = trail.next;
162
+ else if (eqThm(trail.state, cell[0])) trail = { ...trail, rest: cell[1] };
163
+ else {
164
+ trail = { state: cell[0], rest: cell[1], position: trail.position, next: trail.next };
165
+ position = trail.position;
166
+ state = cell[0];
167
+ }
168
+ } else if (position === tactics.length) {
169
+ const saved = trail;
170
+ return [state, makeSeq(() => advance(saved, 0, undefined))];
171
+ } else {
172
+ const cell = tactics[position](state).pull();
173
+ if (cell === undefined) state = undefined;
174
+ else {
175
+ trail = { state: cell[0], rest: cell[1], position: position + 1, next: trail };
176
+ position += 1;
177
+ state = cell[0];
178
+ }
179
+ }
180
+ }
181
+ };
182
+ return makeSeq(() => advance(undefined, 0, start));
183
+ };
184
+
185
+ const initBranch = (terms: readonly BlastTerm[], lim: number): Branch => ({
186
+ pairs: [{ safe: terms.map((term) => ({ term, md: true })), unsafe: [] }],
187
+ lits: [],
188
+ vars: addTermsVars(terms, []),
189
+ lim,
190
+ });
191
+
192
+ // The tableau engine and proof reconstruction on subgoal 1, with depth limit lim.
193
+ const rawBlast =
194
+ (context: BlastContext, lim: number): Tactic =>
195
+ (goalState) => {
196
+ const state = initialize(context, goalState);
197
+ const cont: Continuation = (tactics, choices) => {
198
+ const cell = (() => {
199
+ try {
200
+ const replay: Tactic[] = [];
201
+ for (let current = tactics; current !== undefined; current = current.tail)
202
+ replay.push(current.head(1));
203
+ return everyTac(replay.reverse())(goalState).pull();
204
+ } catch (error) {
205
+ if (isTermError(error)) return backtrack(choices);
206
+ throw error;
207
+ }
208
+ })();
209
+ return cell === undefined ? backtrack(choices) : ofCell(cell);
210
+ };
211
+ try {
212
+ const skoprem = fromSubgoal(state, destImplies(goalState.prop)[0]);
213
+ const trueprop = context.data.trueprop;
214
+ return prove(
215
+ state,
216
+ [
217
+ initBranch(
218
+ [
219
+ mkGoal(stripBlastImpConcl(trueprop, skoprem)),
220
+ ...stripBlastImpPrems(trueprop, skoprem),
221
+ ],
222
+ lim,
223
+ ),
224
+ ],
225
+ cont,
226
+ );
227
+ } catch (error) {
228
+ if (isBacktrackTo(error, undefined) || error instanceof Trans) return emptySeq;
229
+ throw error;
230
+ }
231
+ };
232
+
233
+ // Blast.depth_tac: blast with a fixed depth limit.
234
+ export const blastDepthTac =
235
+ (context: BlastContext, limit: number): GoalTactic =>
236
+ (index) =>
237
+ selectGoal(
238
+ thenTac(atomizePremsTac(context.limits, context.data.atomize)(1), rawBlast(context, limit)),
239
+ )(index);
240
+
241
+ // Search.DEEPEN (1, lim) from depth m on goal 1.
242
+ const deepen =
243
+ (context: BlastContext, limit: number, depth: number): Tactic =>
244
+ (state): Seq<Thm> =>
245
+ nprems(state) < 1 || depth > limit
246
+ ? emptySeq
247
+ : orElse(rawBlast(context, depth), deepen(context, limit, depth + 1))(state);
248
+
249
+ // Blast.blast_tac: iterative deepening up to the depth limit.
250
+ export const blastTac =
251
+ (context: BlastContext): GoalTactic =>
252
+ (index) =>
253
+ selectGoal(
254
+ thenTac(
255
+ atomizePremsTac(context.limits, context.data.atomize)(1),
256
+ deepen(context, DEPTH_LIMIT, 0),
257
+ ),
258
+ )(index);