tla-ts 0.0.4-dev.6dec595 → 0.0.4-dev.7b5087a

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 (307) hide show
  1. package/README.md +27 -141
  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 +996 -0
  15. package/dist/prove.js +996 -0
  16. package/dist/run-cli.cjs +517 -47
  17. package/dist/run-cli.js +517 -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/evaluate.ts +28 -7
  27. package/src/index.ts +10 -0
  28. package/src/{obligation-action.ts → obligations/action.ts} +258 -37
  29. package/src/{obligation-anon.ts → obligations/anon.ts} +13 -7
  30. package/src/obligations/ctx.ts +64 -0
  31. package/src/{obligation-deref.ts → obligations/deref.ts} +2 -2
  32. package/src/{obligation-expression.ts → obligations/expression.ts} +54 -8
  33. package/src/{obligation-format.ts → obligations/format.ts} +6 -5
  34. package/src/{obligation-generate.ts → obligations/generate.ts} +134 -61
  35. package/src/{obligations.ts → obligations/index.ts} +28 -12
  36. package/src/{obligation-levels.ts → obligations/levels.ts} +12 -2
  37. package/src/{obligation-module.ts → obligations/module.ts} +46 -20
  38. package/src/obligations/pickle.ts +100 -0
  39. package/src/obligations/pragma.ts +189 -0
  40. package/src/{obligation-printer.ts → obligations/printer.ts} +9 -63
  41. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -1
  42. package/src/{obligation-source.ts → obligations/source.ts} +91 -35
  43. package/src/obligations/temporal.ts +319 -0
  44. package/src/{obligation-tuples.ts → obligations/tuples.ts} +1 -1
  45. package/src/ocaml-marshal.ts +172 -0
  46. package/src/parallel-worker.ts +2 -18
  47. package/src/parallel.ts +10 -43
  48. package/src/prove/decide-pool.ts +100 -0
  49. package/src/prove/deciders.ts +33 -0
  50. package/src/prove/isabelle/LICENSE +36 -0
  51. package/src/prove/isabelle/LICENSE-tlapm +26 -0
  52. package/src/prove/isabelle/decide.ts +47 -0
  53. package/src/prove/isabelle/encode.ts +512 -0
  54. package/src/prove/isabelle/isar/inner-syntax.ts +579 -0
  55. package/src/prove/isabelle/isar/method.ts +367 -0
  56. package/src/prove/isabelle/isar/proof.ts +28 -0
  57. package/src/prove/isabelle/isar/statement.ts +57 -0
  58. package/src/prove/isabelle/isar/theory.ts +192 -0
  59. package/src/prove/isabelle/isar/type-check.ts +278 -0
  60. package/src/prove/isabelle/provers/blast/blast.ts +258 -0
  61. package/src/prove/isabelle/provers/blast/branch.ts +322 -0
  62. package/src/prove/isabelle/provers/blast/prove.ts +347 -0
  63. package/src/prove/isabelle/provers/blast/rules.ts +330 -0
  64. package/src/prove/isabelle/provers/blast/state.ts +180 -0
  65. package/src/prove/isabelle/provers/blast/term.ts +547 -0
  66. package/src/prove/isabelle/provers/clasimp.ts +150 -0
  67. package/src/prove/isabelle/provers/classical.ts +389 -0
  68. package/src/prove/isabelle/provers/hypsubst.ts +441 -0
  69. package/src/prove/isabelle/pure/bicompose.ts +174 -0
  70. package/src/prove/isabelle/pure/consts.ts +32 -0
  71. package/src/prove/isabelle/pure/conv.ts +79 -0
  72. package/src/prove/isabelle/pure/drule.ts +264 -0
  73. package/src/prove/isabelle/pure/envir.ts +363 -0
  74. package/src/prove/isabelle/pure/goal.ts +53 -0
  75. package/src/prove/isabelle/pure/interrupt.ts +16 -0
  76. package/src/prove/isabelle/pure/list.ts +12 -0
  77. package/src/prove/isabelle/pure/logic.ts +402 -0
  78. package/src/prove/isabelle/pure/name.ts +110 -0
  79. package/src/prove/isabelle/pure/net.ts +262 -0
  80. package/src/prove/isabelle/pure/object-logic.ts +41 -0
  81. package/src/prove/isabelle/pure/pattern.ts +650 -0
  82. package/src/prove/isabelle/pure/raw-simplifier.ts +353 -0
  83. package/src/prove/isabelle/pure/rewriter.ts +602 -0
  84. package/src/prove/isabelle/pure/search.ts +68 -0
  85. package/src/prove/isabelle/pure/seq.ts +156 -0
  86. package/src/prove/isabelle/pure/simplifier.ts +112 -0
  87. package/src/prove/isabelle/pure/table.ts +208 -0
  88. package/src/prove/isabelle/pure/tactic.ts +276 -0
  89. package/src/prove/isabelle/pure/tactical.ts +347 -0
  90. package/src/prove/isabelle/pure/term-ord.ts +159 -0
  91. package/src/prove/isabelle/pure/term.ts +808 -0
  92. package/src/prove/isabelle/pure/thm.ts +806 -0
  93. package/src/prove/isabelle/pure/type.ts +133 -0
  94. package/src/prove/isabelle/pure/unify.ts +753 -0
  95. package/src/prove/isabelle/pure/variable.ts +25 -0
  96. package/src/prove/isabelle/tla/classical-setup.ts +101 -0
  97. package/src/prove/isabelle/tla/context.ts +74 -0
  98. package/src/prove/isabelle/tla/logic-data.ts +5 -0
  99. package/src/prove/isabelle/tla/logic.ts +215 -0
  100. package/src/prove/isabelle/tla/simpdata.ts +241 -0
  101. package/src/prove/isabelle/tools/intuitionistic.ts +132 -0
  102. package/src/prove/ocaml.ts +22 -0
  103. package/src/prove/prep/action.ts +520 -0
  104. package/src/prove/prep/defs.ts +33 -0
  105. package/src/prove/prep/elab.ts +156 -0
  106. package/src/prove/prep/enabled-axioms.ts +189 -0
  107. package/src/prove/prep/enabled.ts +43 -0
  108. package/src/prove/prep/fingerprint.ts +388 -0
  109. package/src/prove/prep/flatten.ts +70 -0
  110. package/src/prove/prep/level-comparison.ts +552 -0
  111. package/src/prove/prep/md5.ts +67 -0
  112. package/src/prove/prep/pragma.ts +221 -0
  113. package/src/prove/prep/trivial.ts +22 -0
  114. package/src/prove/prove-worker.ts +27 -0
  115. package/src/prove/prove.ts +528 -0
  116. package/src/prove/ptl/decide.ts +68 -0
  117. package/src/prove/ptl/encode.ts +256 -0
  118. package/src/prove/ptl/sat.ts +151 -0
  119. package/src/prove/ptl/tableau.ts +276 -0
  120. package/src/prove/smt/axiomatize.ts +69 -0
  121. package/src/prove/smt/axioms.ts +210 -0
  122. package/src/prove/smt/context.ts +108 -0
  123. package/src/prove/smt/data.ts +665 -0
  124. package/src/prove/smt/encode.ts +169 -0
  125. package/src/prove/smt/extensionality.ts +63 -0
  126. package/src/prove/smt/flatten.ts +127 -0
  127. package/src/prove/smt/format.ts +143 -0
  128. package/src/prove/smt/instances.ts +182 -0
  129. package/src/prove/smt/rewrite.ts +784 -0
  130. package/src/prove/smt/simplify.ts +57 -0
  131. package/src/prove/smt/solver/act-cache.ts +265 -0
  132. package/src/prove/smt/solver/arith-rewriter.ts +962 -0
  133. package/src/prove/smt/solver/array.ts +22 -0
  134. package/src/prove/smt/solver/asserted-formulas.ts +469 -0
  135. package/src/prove/smt/solver/ast-lt.ts +157 -0
  136. package/src/prove/smt/solver/ast-util.ts +147 -0
  137. package/src/prove/smt/solver/ast.ts +1315 -0
  138. package/src/prove/smt/solver/auf-solver.ts +572 -0
  139. package/src/prove/smt/solver/case-split-queue.ts +178 -0
  140. package/src/prove/smt/solver/cg-table.ts +175 -0
  141. package/src/prove/smt/solver/clause.ts +276 -0
  142. package/src/prove/smt/solver/conflict-resolution.ts +343 -0
  143. package/src/prove/smt/solver/context.ts +1292 -0
  144. package/src/prove/smt/solver/ctx-simplify.ts +334 -0
  145. package/src/prove/smt/solver/der.ts +224 -0
  146. package/src/prove/smt/solver/dyn-ack.ts +141 -0
  147. package/src/prove/smt/solver/e-matching.ts +659 -0
  148. package/src/prove/smt/solver/enode.ts +259 -0
  149. package/src/prove/smt/solver/expr-ref.ts +21 -0
  150. package/src/prove/smt/solver/expr-safe-replace.ts +172 -0
  151. package/src/prove/smt/solver/fingerprints.ts +92 -0
  152. package/src/prove/smt/solver/flat-literals.ts +51 -0
  153. package/src/prove/smt/solver/goal.ts +138 -0
  154. package/src/prove/smt/solver/hash.ts +173 -0
  155. package/src/prove/smt/solver/hashtable.ts +166 -0
  156. package/src/prove/smt/solver/internalizer.ts +1381 -0
  157. package/src/prove/smt/solver/lbool.ts +5 -0
  158. package/src/prove/smt/solver/literal.ts +24 -0
  159. package/src/prove/smt/solver/lp/bound-propagator.ts +391 -0
  160. package/src/prove/smt/solver/lp/constraints.ts +78 -0
  161. package/src/prove/smt/solver/lp/containers.ts +296 -0
  162. package/src/prove/smt/solver/lp/core-solver.ts +504 -0
  163. package/src/prove/smt/solver/lp/cross-nested.ts +224 -0
  164. package/src/prove/smt/solver/lp/dep-intervals.ts +656 -0
  165. package/src/prove/smt/solver/lp/dependency.ts +51 -0
  166. package/src/prove/smt/solver/lp/dioph-eq.ts +1181 -0
  167. package/src/prove/smt/solver/lp/explanation.ts +46 -0
  168. package/src/prove/smt/solver/lp/gomory.ts +255 -0
  169. package/src/prove/smt/solver/lp/hnf-cutter.ts +125 -0
  170. package/src/prove/smt/solver/lp/hnf.ts +281 -0
  171. package/src/prove/smt/solver/lp/int-cube.ts +295 -0
  172. package/src/prove/smt/solver/lp/int-solver.ts +514 -0
  173. package/src/prove/smt/solver/lp/lar-solver.ts +816 -0
  174. package/src/prove/smt/solver/lp/lar-term.ts +62 -0
  175. package/src/prove/smt/solver/lp/lp-settings.ts +91 -0
  176. package/src/prove/smt/solver/lp/maximize-term.ts +347 -0
  177. package/src/prove/smt/solver/lp/nex-creator.ts +381 -0
  178. package/src/prove/smt/solver/lp/nex.ts +120 -0
  179. package/src/prove/smt/solver/lp/nla-backoff.ts +43 -0
  180. package/src/prove/smt/solver/lp/nla-basics.ts +398 -0
  181. package/src/prove/smt/solver/lp/nla-core.ts +968 -0
  182. package/src/prove/smt/solver/lp/nla-divisions.ts +332 -0
  183. package/src/prove/smt/solver/lp/nla-emonics.ts +373 -0
  184. package/src/prove/smt/solver/lp/nla-factorization.ts +30 -0
  185. package/src/prove/smt/solver/lp/nla-grobner.ts +904 -0
  186. package/src/prove/smt/solver/lp/nla-horner.ts +126 -0
  187. package/src/prove/smt/solver/lp/nla-intervals.ts +265 -0
  188. package/src/prove/smt/solver/lp/nla-monomial-bounds.ts +715 -0
  189. package/src/prove/smt/solver/lp/nla-monotone.ts +59 -0
  190. package/src/prove/smt/solver/lp/nla-order.ts +307 -0
  191. package/src/prove/smt/solver/lp/nla-patcher.ts +112 -0
  192. package/src/prove/smt/solver/lp/nla-tangents.ts +251 -0
  193. package/src/prove/smt/solver/lp/nla-throttle.ts +85 -0
  194. package/src/prove/smt/solver/lp/nla-types.ts +124 -0
  195. package/src/prove/smt/solver/lp/nla-var-eqs.ts +141 -0
  196. package/src/prove/smt/solver/lp/nra-solver.ts +440 -0
  197. package/src/prove/smt/solver/lp/numeric-pair.ts +65 -0
  198. package/src/prove/smt/solver/lp/pdd-interval.ts +31 -0
  199. package/src/prove/smt/solver/lp/pdd-simplifier.ts +184 -0
  200. package/src/prove/smt/solver/lp/pdd-solver.ts +408 -0
  201. package/src/prove/smt/solver/lp/pdd.ts +971 -0
  202. package/src/prove/smt/solver/lp/random-updater.ts +138 -0
  203. package/src/prove/smt/solver/lp/static-matrix.ts +246 -0
  204. package/src/prove/smt/solver/lp/union-find.ts +96 -0
  205. package/src/prove/smt/solver/mam-compiler.ts +847 -0
  206. package/src/prove/smt/solver/mam-interpreter.ts +400 -0
  207. package/src/prove/smt/solver/maximize-ac-sharing.ts +118 -0
  208. package/src/prove/smt/solver/model-checker.ts +347 -0
  209. package/src/prove/smt/solver/model-evaluator.ts +262 -0
  210. package/src/prove/smt/solver/model-finder.ts +155 -0
  211. package/src/prove/smt/solver/model-generator.ts +97 -0
  212. package/src/prove/smt/solver/model-macro-solver.ts +728 -0
  213. package/src/prove/smt/solver/nlsat/algebraic.ts +1161 -0
  214. package/src/prove/smt/solver/nlsat/atoms.ts +238 -0
  215. package/src/prove/smt/solver/nlsat/evaluator.ts +303 -0
  216. package/src/prove/smt/solver/nlsat/explain.ts +607 -0
  217. package/src/prove/smt/solver/nlsat/interval-set.ts +351 -0
  218. package/src/prove/smt/solver/nlsat/levelwise.ts +740 -0
  219. package/src/prove/smt/solver/nlsat/mpbq.ts +161 -0
  220. package/src/prove/smt/solver/nlsat/polynomial.ts +1722 -0
  221. package/src/prove/smt/solver/nlsat/solver.ts +911 -0
  222. package/src/prove/smt/solver/nlsat/types.ts +43 -0
  223. package/src/prove/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
  224. package/src/prove/smt/solver/nlsat/upolynomial.ts +996 -0
  225. package/src/prove/smt/solver/nnf.ts +469 -0
  226. package/src/prove/smt/solver/pattern-inference.ts +351 -0
  227. package/src/prove/smt/solver/poly-rewriter.ts +477 -0
  228. package/src/prove/smt/solver/propagate-values.ts +83 -0
  229. package/src/prove/smt/solver/proto-model.ts +551 -0
  230. package/src/prove/smt/solver/pull-quant.ts +139 -0
  231. package/src/prove/smt/solver/qe-lite-der.ts +526 -0
  232. package/src/prove/smt/solver/qe-lite-fm.ts +576 -0
  233. package/src/prove/smt/solver/qe-lite.ts +381 -0
  234. package/src/prove/smt/solver/qi-queue.ts +362 -0
  235. package/src/prove/smt/solver/quant-tactics.ts +117 -0
  236. package/src/prove/smt/solver/quantifier-analyzer.ts +562 -0
  237. package/src/prove/smt/solver/quantifier-manager.ts +186 -0
  238. package/src/prove/smt/solver/random-gen.ts +10 -0
  239. package/src/prove/smt/solver/rational.ts +165 -0
  240. package/src/prove/smt/solver/ref-vector.ts +62 -0
  241. package/src/prove/smt/solver/relevancy.ts +247 -0
  242. package/src/prove/smt/solver/rewriter-tpl.ts +1159 -0
  243. package/src/prove/smt/solver/rewriter.ts +843 -0
  244. package/src/prove/smt/solver/rlimit.ts +79 -0
  245. package/src/prove/smt/solver/smtlib-parser.ts +526 -0
  246. package/src/prove/smt/solver/solver.ts +71 -0
  247. package/src/prove/smt/solver/sort.ts +35 -0
  248. package/src/prove/smt/solver/sticky-generations.ts +69 -0
  249. package/src/prove/smt/solver/theory-lra-axioms.ts +340 -0
  250. package/src/prove/smt/solver/theory-lra-bounds.ts +226 -0
  251. package/src/prove/smt/solver/theory-lra-final-check.ts +252 -0
  252. package/src/prove/smt/solver/theory-lra-internalize.ts +476 -0
  253. package/src/prove/smt/solver/theory-lra-model.ts +243 -0
  254. package/src/prove/smt/solver/theory-lra-propagate.ts +405 -0
  255. package/src/prove/smt/solver/theory-lra-state.ts +43 -0
  256. package/src/prove/smt/solver/theory-lra.ts +56 -0
  257. package/src/prove/smt/solver/var-subst.ts +258 -0
  258. package/src/prove/smt/solver/z3-license.txt +10 -0
  259. package/src/prove/smt/table.ts +170 -0
  260. package/src/prove/tlapm/tlapm.ts +97 -0
  261. package/src/prove/tlaps-module.ts +510 -0
  262. package/src/prove/verdict.ts +19 -0
  263. package/src/prove/zenon/LICENSE +32 -0
  264. package/src/prove/zenon/check/check.ts +105 -0
  265. package/src/prove/zenon/check/definitions.ts +144 -0
  266. package/src/prove/zenon/check/equality.ts +182 -0
  267. package/src/prove/zenon/check/functions.ts +62 -0
  268. package/src/prove/zenon/check/keys.ts +125 -0
  269. package/src/prove/zenon/check/propositional.ts +104 -0
  270. package/src/prove/zenon/check/records.ts +188 -0
  271. package/src/prove/zenon/check/relations.ts +121 -0
  272. package/src/prove/zenon/check/rewrites.ts +224 -0
  273. package/src/prove/zenon/check/sets.ts +302 -0
  274. package/src/prove/zenon/check/terms.ts +127 -0
  275. package/src/prove/zenon/check/tla.ts +126 -0
  276. package/src/prove/zenon/decide.ts +113 -0
  277. package/src/prove/zenon/encode.ts +444 -0
  278. package/src/prove/zenon/eqrel.ts +300 -0
  279. package/src/prove/zenon/equality-rules.ts +435 -0
  280. package/src/prove/zenon/expr.ts +551 -0
  281. package/src/prove/zenon/index-table.ts +350 -0
  282. package/src/prove/zenon/isar-case.ts +513 -0
  283. package/src/prove/zenon/isar.ts +1249 -0
  284. package/src/prove/zenon/limits.ts +15 -0
  285. package/src/prove/zenon/llproof.ts +173 -0
  286. package/src/prove/zenon/mltoll.ts +1566 -0
  287. package/src/prove/zenon/node.ts +297 -0
  288. package/src/prove/zenon/ocaml.ts +169 -0
  289. package/src/prove/zenon/parse.ts +247 -0
  290. package/src/prove/zenon/phrase.ts +191 -0
  291. package/src/prove/zenon/proof.ts +198 -0
  292. package/src/prove/zenon/propositional-rules.ts +387 -0
  293. package/src/prove/zenon/rules.ts +94 -0
  294. package/src/prove/zenon/search.ts +288 -0
  295. package/src/prove/zenon/tla/functions.ts +151 -0
  296. package/src/prove/zenon/tla/llproof.ts +480 -0
  297. package/src/prove/zenon/tla/records.ts +225 -0
  298. package/src/prove/zenon/tla/rewrites.ts +447 -0
  299. package/src/prove/zenon/tla/sets.ts +304 -0
  300. package/src/prove/zenon/tla/terms.ts +181 -0
  301. package/src/prove/zenon/tla/tla.ts +506 -0
  302. package/src/run-cli.ts +338 -52
  303. package/src/tlapm-cache.ts +250 -0
  304. package/src/values.ts +8 -3
  305. package/src/worker.ts +65 -0
  306. package/dist/parallel.cjs +0 -12
  307. package/dist/parallel.js +0 -12
@@ -0,0 +1,247 @@
1
+ // Ported from Zenon's lexzen.mll and parsezen.mly, as shipped in tlapm. Copyright 2005 INRIA, see
2
+ // LICENSE.
3
+ //
4
+ // Reads Zenon's native input format, the .znn files that tlapm writes.
5
+
6
+ import { TlaZenonError } from "../../errors";
7
+ import {
8
+ FALSE,
9
+ GOAL_NAME,
10
+ TRUE,
11
+ UNIVERSE,
12
+ type Expr,
13
+ type Expressions,
14
+ type VarExpr,
15
+ } from "./expr";
16
+
17
+ export type Definition =
18
+ | { kind: "real"; name: string; symbol: string; params: Expr[]; body: Expr }
19
+ | { kind: "pseudo"; origin: Expr; goalness: number; symbol: string; params: Expr[]; body: Expr };
20
+
21
+ export type Phrase =
22
+ | { kind: "hyp"; name: string; formula: Expr; goalness: number }
23
+ | { kind: "def"; definition: Definition };
24
+
25
+ type TokenKind = "open" | "close" | "ident" | "string" | "int" | "keyword" | "operator" | "end";
26
+
27
+ interface Token {
28
+ kind: TokenKind;
29
+ text: string;
30
+ line: number;
31
+ }
32
+
33
+ const OPERATORS = ["<=>", "-.", "/\\", "\\/", "=>", "<=", "="];
34
+
35
+ const DOTTED_KEYWORDS = new Set(["T.", "F.", "A.", "E.", "t."]);
36
+
37
+ const KEYWORDS = [
38
+ "$fixpoint",
39
+ "$include",
40
+ "$indprop",
41
+ "$indset",
42
+ "$match",
43
+ "$goal",
44
+ "$self",
45
+ "$def",
46
+ "$fix",
47
+ "$hyp",
48
+ "$let",
49
+ "$sig",
50
+ ];
51
+
52
+ const IDENT_START = /[A-Za-z_0-9]/;
53
+ const IDENT_CHAR = /[A-Za-z0-9_'.]/;
54
+ const STRING_ESCAPE = /^\\([abfnrtv'"\\?]|x[0-9A-Fa-f]{2})/;
55
+
56
+ const tokenize = (text: string) => {
57
+ const tokens: Token[] = [];
58
+ let line = 1;
59
+ let index = 0;
60
+ while (index < text.length) {
61
+ const char = text[index];
62
+ if (char === "\n" || char === "\r") {
63
+ line += char === "\r" && text[index + 1] === "\n" ? 0 : 1;
64
+ index++;
65
+ } else if (char === " " || char === "\t" || char === "\f") index++;
66
+ else if (char === "#" || char === ";") {
67
+ while (index < text.length && text[index] !== "\n" && text[index] !== "\r") index++;
68
+ } else if (char === "(" || char === ")") {
69
+ tokens.push({ kind: char === "(" ? "open" : "close", text: char, line });
70
+ index++;
71
+ } else if (char === "$") {
72
+ const digits = /^\$[0-9]+/.exec(text.slice(index, index + 32));
73
+ const keyword = KEYWORDS.find((candidate) => text.startsWith(candidate, index));
74
+ if (digits !== null) {
75
+ tokens.push({ kind: "int", text: digits[0].slice(1), line });
76
+ index += digits[0].length;
77
+ } else if (keyword !== undefined) {
78
+ tokens.push({ kind: "keyword", text: keyword, line });
79
+ index += keyword.length;
80
+ } else throw new TlaZenonError(`Zenon: line ${line}: bad character '$'`);
81
+ } else if (char === '"') {
82
+ let end = index + 1;
83
+ while (end < text.length && text[end] !== '"') {
84
+ const escape = text[end] === "\\" ? STRING_ESCAPE.exec(text.slice(end, end + 4)) : null;
85
+ if (text[end] === "\\" && escape === null)
86
+ throw new TlaZenonError(`Zenon: line ${line}: bad escape in string`);
87
+ if (escape === null && (text.charCodeAt(end) < 32 || text.charCodeAt(end) >= 127))
88
+ throw new TlaZenonError(`Zenon: line ${line}: bad character in string`);
89
+ end += escape === null ? 1 : escape[0].length;
90
+ }
91
+ if (end >= text.length) throw new TlaZenonError(`Zenon: line ${line}: unterminated string`);
92
+ tokens.push({ kind: "string", text: text.slice(index + 1, end), line });
93
+ index = end + 1;
94
+ } else if (IDENT_START.test(char)) {
95
+ let end = index + 1;
96
+ while (end < text.length && IDENT_CHAR.test(text[end])) end++;
97
+ const word = text.slice(index, end);
98
+ tokens.push({ kind: DOTTED_KEYWORDS.has(word) ? "keyword" : "ident", text: word, line });
99
+ index = end;
100
+ } else {
101
+ const operator = OPERATORS.find((candidate) => text.startsWith(candidate, index));
102
+ if (operator === undefined)
103
+ throw new TlaZenonError(`Zenon: line ${line}: bad character '${char}'`);
104
+ tokens.push({ kind: "operator", text: operator, line });
105
+ index += operator.length;
106
+ }
107
+ }
108
+ tokens.push({ kind: "end", text: "", line });
109
+ return tokens;
110
+ };
111
+
112
+ // Zenon's myfold: an n-ary connective nests to the right.
113
+ const foldRight = (combine: (left: Expr, right: Expr) => Expr, first: Expr, rest: Expr[]): Expr =>
114
+ rest.length === 0 ? first : combine(first, foldRight(combine, rest[0], rest.slice(1)));
115
+
116
+ export const parseZenon = (exprs: Expressions, text: string): Phrase[] => {
117
+ const binders: Record<string, (variable: VarExpr, type: string, body: Expr) => Expr> = {
118
+ "A.": exprs.eall,
119
+ "E.": exprs.eex,
120
+ };
121
+ const connectives: Record<string, (left: Expr, right: Expr) => Expr> = {
122
+ "/\\": exprs.eand,
123
+ "\\/": exprs.eor,
124
+ "=>": exprs.eimply,
125
+ "<=": (left, right) => exprs.eimply(right, left),
126
+ "<=>": exprs.eequiv,
127
+ };
128
+ const tokens = tokenize(text);
129
+ let position = 0;
130
+ const peek = (offset = 0) => tokens[position + offset];
131
+ const next = () => tokens[position++];
132
+ const expect = (kind: TokenKind, value?: string) => {
133
+ const token = next();
134
+ if (token.kind !== kind || (value !== undefined && token.text !== value))
135
+ throw new TlaZenonError(`Zenon: line ${token.line}: syntax error`);
136
+ return token;
137
+ };
138
+ const isAt = (kind: TokenKind, value?: string) =>
139
+ peek().kind === kind && (value === undefined || peek().text === value);
140
+
141
+ // A lambda after its first parenthesis: ((x y "type") body).
142
+ const parseLambda = () => {
143
+ expect("open");
144
+ const names: string[] = [];
145
+ while (isAt("ident")) names.push(next().text);
146
+ const type = isAt("string") ? next().text : UNIVERSE;
147
+ expect("close");
148
+ const body = parseExpr();
149
+ expect("close");
150
+ return { names, type, body };
151
+ };
152
+
153
+ const bindAll = (
154
+ bind: (variable: VarExpr, type: string, body: Expr) => Expr,
155
+ lambda: { names: string[]; type: string; body: Expr },
156
+ ) =>
157
+ lambda.names.reduceRight(
158
+ (body, name) => bind(exprs.evar(name), lambda.type, body),
159
+ lambda.body,
160
+ );
161
+
162
+ const parseList = () => {
163
+ const expressions: Expr[] = [];
164
+ while (!isAt("close")) expressions.push(parseExpr());
165
+ return expressions;
166
+ };
167
+
168
+ const parseExpr = (): Expr => {
169
+ const token = next();
170
+ if (token.kind === "ident") return exprs.evar(token.text);
171
+ if (token.kind === "string") return exprs.eapp("$string", [exprs.evar(`"${token.text}"`)]);
172
+ if (token.kind === "keyword" && token.text === "T.") return TRUE;
173
+ if (token.kind === "keyword" && token.text === "F.") return FALSE;
174
+ if (token.kind !== "open") throw new TlaZenonError(`Zenon: line ${token.line}: syntax error`);
175
+ const head = next();
176
+ if (head.kind === "open") {
177
+ position--;
178
+ return bindAll(exprs.elam, parseLambda());
179
+ }
180
+ if (head.kind === "ident") {
181
+ const args = parseList();
182
+ expect("close");
183
+ return exprs.eapp(head.text, args);
184
+ }
185
+ if (head.kind === "operator" && head.text === "-.") {
186
+ const operand = parseExpr();
187
+ expect("close");
188
+ return exprs.enot(operand);
189
+ }
190
+ if (head.kind === "operator" && head.text === "=") {
191
+ const left = parseExpr();
192
+ const right = parseExpr();
193
+ expect("close");
194
+ return exprs.eapp("=", [left, right]);
195
+ }
196
+ if (head.kind === "operator") {
197
+ const first = parseExpr();
198
+ const rest = parseList();
199
+ expect("close");
200
+ return foldRight(connectives[head.text], first, rest);
201
+ }
202
+ if (head.kind === "keyword" && (head.text === "T." || head.text === "F.")) {
203
+ expect("close");
204
+ return head.text === "T." ? TRUE : FALSE;
205
+ }
206
+ if (head.kind === "keyword" && head.text in binders) {
207
+ expect("open");
208
+ const lambda = parseLambda();
209
+ expect("close");
210
+ return bindAll(binders[head.text], lambda);
211
+ }
212
+ if (head.kind === "keyword" && head.text === "t.") {
213
+ expect("open");
214
+ const lambda = parseLambda();
215
+ expect("close");
216
+ if (lambda.names.length !== 1)
217
+ throw new TlaZenonError(`Zenon: line ${head.line}: syntax error`);
218
+ return exprs.etau(exprs.evar(lambda.names[0]), lambda.type, lambda.body);
219
+ }
220
+ throw new TlaZenonError(`Zenon: line ${head.line}: unsupported construct ${head.text}`);
221
+ };
222
+
223
+ const phrases: Phrase[] = [];
224
+ while (!isAt("end")) {
225
+ const token = next();
226
+ if (token.kind === "keyword" && token.text === "$hyp") {
227
+ const goalness = isAt("int") ? Number(next().text) : 1;
228
+ const name = expect("string").text;
229
+ phrases.push({ kind: "hyp", name, formula: parseExpr(), goalness });
230
+ } else if (token.kind === "keyword" && token.text === "$goal") {
231
+ phrases.push({ kind: "hyp", name: GOAL_NAME, formula: exprs.enot(parseExpr()), goalness: 0 });
232
+ } else if (token.kind === "keyword" && token.text === "$def") {
233
+ const name = expect("string").text;
234
+ expect("open");
235
+ const symbol = expect("ident").text;
236
+ const params: Expr[] = [];
237
+ while (isAt("ident")) params.push(exprs.evar(next().text));
238
+ expect("close");
239
+ const body = parseExpr();
240
+ phrases.push({
241
+ kind: "def",
242
+ definition: { kind: "real", name, symbol, params, body },
243
+ });
244
+ } else throw new TlaZenonError(`Zenon: line ${token.line}: unsupported phrase ${token.text}`);
245
+ }
246
+ return phrases;
247
+ };
@@ -0,0 +1,191 @@
1
+ // Ported from Zenon's phrase.ml, as shipped in tlapm. Copyright 2004 INRIA, see LICENSE.
2
+ //
3
+ // Splits the input into definitions and hypotheses. A hypothesis that defines a symbol, such as
4
+ // x = e or \A a, b : f(a, b) <=> e, becomes a definition that the prover unfolds.
5
+
6
+ import type { Expr } from "./expr";
7
+ import type { Definition, Phrase } from "./parse";
8
+
9
+ export interface Hypothesis {
10
+ formula: Expr;
11
+ goalness: number;
12
+ }
13
+
14
+ const hasName = (env: Expr[], name: string) => env.some((variable) => variable.symbol === name);
15
+
16
+ // Zenon's check_args: the arguments are variables, and exactly the quantified ones.
17
+ const isParameterList = (env: Expr[], args: Expr[]) => {
18
+ if (!args.every((arg) => arg.kind === "var")) return false;
19
+ const envNames = env.map((variable) => variable.symbol).sort();
20
+ const argNames = args.map((arg) => arg.symbol).sort();
21
+ return (
22
+ envNames.length === argNames.length &&
23
+ envNames.every((name, index) => name === argNames[index]) &&
24
+ envNames.every((name, index) => index === 0 || name !== envNames[index - 1])
25
+ );
26
+ };
27
+
28
+ const isBodyOf = (env: Expr[], symbol: string, expression: Expr): boolean => {
29
+ switch (expression.kind) {
30
+ case "var":
31
+ return expression.symbol !== symbol || hasName(env, expression.symbol);
32
+ case "app":
33
+ return (
34
+ expression.symbol !== symbol &&
35
+ expression.args.every((inner) => isBodyOf(env, symbol, inner))
36
+ );
37
+ case "all":
38
+ case "ex":
39
+ case "tau":
40
+ case "lam":
41
+ return isBodyOf([expression.args[0], ...env], symbol, expression.args[1]);
42
+ default:
43
+ return expression.args.every((inner) => isBodyOf(env, symbol, inner));
44
+ }
45
+ };
46
+
47
+ interface Shape {
48
+ symbol: string;
49
+ params: Expr[] | undefined;
50
+ body: Expr;
51
+ }
52
+
53
+ // The ways a formula can define a symbol, in the order Zenon tries them: a definiendum that is an
54
+ // application with its parameters, or a constant.
55
+ const getShapes = (expression: Expr): Shape[] => {
56
+ const sides =
57
+ expression.kind === "equiv" || (expression.kind === "app" && expression.symbol === "=")
58
+ ? expression.args
59
+ : undefined;
60
+ if (sides === undefined || sides.length !== 2) return [];
61
+ const left = sides[0];
62
+ const right = sides[1];
63
+ const toShape = (definiendum: Expr, body: Expr): Shape[] =>
64
+ definiendum.kind === "app"
65
+ ? [{ symbol: definiendum.symbol, params: definiendum.args, body }]
66
+ : definiendum.kind === "var"
67
+ ? [{ symbol: definiendum.symbol, params: undefined, body }]
68
+ : [];
69
+ const shapes = [...toShape(left, right), ...toShape(right, left)];
70
+ const applications = shapes.filter((shape) => shape.params !== undefined);
71
+ const constants = shapes.filter((shape) => shape.params === undefined);
72
+ return expression.kind === "equiv"
73
+ ? [...applications, ...constants]
74
+ : [...constants, ...applications];
75
+ };
76
+
77
+ const stripForall = (expression: Expr, env: Expr[]): { env: Expr[]; body: Expr } =>
78
+ expression.kind === "all"
79
+ ? stripForall(expression.args[1], [expression.args[0], ...env])
80
+ : { env, body: expression };
81
+
82
+ // Zenon's is_def, then make_def. The two try the shapes with different conditions, so the shape
83
+ // that defines the symbol can differ from the one that qualifies the formula.
84
+ const getDefinition = (
85
+ predefined: string[],
86
+ hypothesis: Hypothesis,
87
+ ): Extract<Definition, { kind: "pseudo" }> | undefined => {
88
+ const stripped = stripForall(hypothesis.formula, []);
89
+ const shapes = getShapes(stripped.body);
90
+ const qualifying = shapes.find((candidate) => !predefined.includes(candidate.symbol));
91
+ if (qualifying === undefined) return undefined;
92
+ const areParamsValid =
93
+ qualifying.params === undefined
94
+ ? stripped.env.length === 0
95
+ : isParameterList(stripped.env, qualifying.params);
96
+ if (!areParamsValid || !isBodyOf([], qualifying.symbol, qualifying.body)) return undefined;
97
+ const shape = shapes.find(
98
+ (candidate) =>
99
+ !predefined.includes(candidate.symbol) &&
100
+ (candidate.params === undefined || isParameterList(stripped.env, candidate.params)),
101
+ );
102
+ return (
103
+ shape && {
104
+ kind: "pseudo",
105
+ origin: hypothesis.formula,
106
+ goalness: hypothesis.goalness,
107
+ symbol: shape.symbol,
108
+ params: shape.params ?? [],
109
+ body: shape.body,
110
+ }
111
+ );
112
+ };
113
+
114
+ const getFreeSymbols = (env: Expr[], accumulator: string[], expression: Expr): string[] => {
115
+ switch (expression.kind) {
116
+ case "var":
117
+ return hasName(env, expression.symbol) ? accumulator : [expression.symbol, ...accumulator];
118
+ case "app":
119
+ return expression.args.reduce(
120
+ (symbols, inner) => getFreeSymbols(env, symbols, inner),
121
+ [expression.symbol, ...accumulator],
122
+ );
123
+ case "all":
124
+ case "ex":
125
+ case "tau":
126
+ case "lam":
127
+ return getFreeSymbols([expression.args[0], ...env], accumulator, expression.args[1]);
128
+ default:
129
+ return expression.args.reduce(
130
+ (symbols, inner) => getFreeSymbols(env, symbols, inner),
131
+ accumulator,
132
+ );
133
+ }
134
+ };
135
+
136
+ type Dependency = [string, string[]];
137
+
138
+ const followDependencies = (symbols: string[], dependencies: Dependency[]): string[] =>
139
+ symbols.flatMap(
140
+ (symbol) => dependencies.find((dependency) => dependency[0] === symbol)?.[1] ?? [],
141
+ );
142
+
143
+ const isLooping = (symbol: string, symbols: string[], dependencies: Dependency[]): boolean =>
144
+ symbols.length > 0 &&
145
+ (symbols.includes(symbol) ||
146
+ isLooping(symbol, followDependencies(symbols, dependencies), dependencies));
147
+
148
+ // Zenon's separate. Definitions come before hypotheses, each in input order, except where a
149
+ // symbol is defined twice: then neither formula defines it.
150
+ export const separate = (predefined: string[], phrases: Phrase[]) => {
151
+ let dependencies: Dependency[] = [];
152
+ const multiple: string[] = [];
153
+ let definitions: Definition[] = [];
154
+ const hypotheses: Hypothesis[] = [];
155
+ for (const phrase of phrases) {
156
+ if (phrase.kind === "def") {
157
+ definitions.unshift(phrase.definition);
158
+ continue;
159
+ }
160
+ const hypothesis = { formula: phrase.formula, goalness: phrase.goalness };
161
+ const definition = getDefinition(predefined, hypothesis);
162
+ if (definition === undefined) {
163
+ hypotheses.unshift(hypothesis);
164
+ continue;
165
+ }
166
+ const symbol = definition.symbol;
167
+ const dependency: Dependency = [symbol, getFreeSymbols(definition.params, [], definition.body)];
168
+ // The lists are reversed, as in Zenon, so a definition's index 0 is the latest.
169
+ const previous = definitions.findIndex(
170
+ (existing) => existing.kind === "pseudo" && existing.symbol === symbol,
171
+ );
172
+ const removed = definitions[previous];
173
+ if (multiple.includes(symbol) || isLooping(symbol, dependency[1], dependencies)) {
174
+ hypotheses.unshift(hypothesis);
175
+ } else if (removed?.kind === "pseudo") {
176
+ // Zenon's remove_def reverses the definitions after the old one.
177
+ definitions = [
178
+ ...definitions.slice(0, previous).reverse(),
179
+ ...definitions.slice(previous + 1),
180
+ ];
181
+ const dependencyIndex = dependencies.findIndex((candidate) => candidate[0] === symbol);
182
+ dependencies = dependencies.filter((_, position) => position !== dependencyIndex);
183
+ multiple.unshift(symbol);
184
+ hypotheses.unshift(hypothesis, { formula: removed.origin, goalness: removed.goalness });
185
+ } else {
186
+ dependencies.unshift(dependency);
187
+ definitions.unshift(definition);
188
+ }
189
+ }
190
+ return { definitions: definitions.reverse(), hypotheses: hypotheses.reverse() };
191
+ };
@@ -0,0 +1,198 @@
1
+ // Ported from Zenon's mlproof.ml, as shipped in tlapm. Copyright 2004 INRIA, see LICENSE.
2
+ //
3
+ // The proofs that the search builds and the checker reads. Each rule takes a fixed number of
4
+ // arguments, or at least a fixed number, so a rule application can't have the wrong arity. The
5
+ // rules of the TLA+ extension, Zenon's Ext, sit beside the core rules: their names don't clash.
6
+
7
+ import type { Expr } from "./expr";
8
+ import type { Definition } from "./parse";
9
+
10
+ type Two<Term> = [Term, Term];
11
+ type Three<Term> = [Term, Term, Term];
12
+ type Four<Term> = [Term, Term, Term, Term];
13
+ type Five<Term> = [Term, Term, Term, Term, Term];
14
+ type Six<Term> = [Term, Term, Term, Term, Term, Term];
15
+ type Seven<Term> = [Term, Term, Term, Term, Term, Term, Term];
16
+
17
+ // The arguments of each rule that names neither a relation nor a definition.
18
+ interface PlainRuleArgs<Term> {
19
+ close: [Term];
20
+ false: [];
21
+ not_true: [];
22
+ conj_tree: [Term];
23
+ disj_tree: [Term];
24
+ and: Two<Term>;
25
+ not_not: [Term];
26
+ not_or: Two<Term>;
27
+ not_impl: Two<Term>;
28
+ or: Two<Term>;
29
+ impl: Two<Term>;
30
+ equiv: Two<Term>;
31
+ not_and: Two<Term>;
32
+ not_equiv: Two<Term>;
33
+ ex: [Term];
34
+ not_all_ex: [Term];
35
+ all: Two<Term>;
36
+ not_ex: Two<Term>;
37
+ not_equal: Two<Term>;
38
+ p_not_p: Two<Term>;
39
+ trans: Two<Term>;
40
+ trans_sym: Two<Term>;
41
+ trans_eq: Three<Term>;
42
+ trans_eq_sym: Three<Term>;
43
+ trans_eq2: Three<Term>;
44
+ cut: [Term];
45
+ congruence_lr: Three<Term>;
46
+ congruence_rl: Three<Term>;
47
+ stringequal: Two<Term>;
48
+ stringdiffll: Four<Term>;
49
+ stringdifflr: Four<Term>;
50
+ stringdiffrl: Four<Term>;
51
+ stringdiffrr: Four<Term>;
52
+ eq_x_true: Three<Term>;
53
+ eq_true_x: Three<Term>;
54
+ noteq_x_true: Three<Term>;
55
+ noteq_true_x: Three<Term>;
56
+ eq_x_false: Three<Term>;
57
+ eq_false_x: Three<Term>;
58
+ in_emptyset: Two<Term>;
59
+ in_upair: Six<Term>;
60
+ notin_upair: Six<Term>;
61
+ in_addElt: Three<Term>;
62
+ notin_addElt: Three<Term>;
63
+ in_set: Three<Term>;
64
+ notin_set: Three<Term>;
65
+ in_SUBSET: Four<Term>;
66
+ notin_SUBSET: Four<Term>;
67
+ in_UNION: Four<Term>;
68
+ notin_UNION: Four<Term>;
69
+ in_cup: Six<Term>;
70
+ notin_cup: Six<Term>;
71
+ in_cap: Six<Term>;
72
+ notin_cap: Six<Term>;
73
+ in_setminus: Six<Term>;
74
+ notin_setminus: Six<Term>;
75
+ in_subsetof: Six<Term>;
76
+ notin_subsetof: Six<Term>;
77
+ in_setofall: Five<Term>;
78
+ notin_setofall: Five<Term>;
79
+ in_funcset: Seven<Term>;
80
+ notin_funcset: Seven<Term>;
81
+ except_notin_funcset: [Term, Term, Term, Term, Term, Term, Term, Term];
82
+ setequalempty: Three<Term>;
83
+ setemptyequal: Three<Term>;
84
+ setequal: Four<Term>;
85
+ notsetequal: Four<Term>;
86
+ notisafcn_fcn: Three<Term>;
87
+ notisafcn_except: Four<Term>;
88
+ notisafcn_onearg: Three<Term>;
89
+ notisafcn_extend: Three<Term>;
90
+ funequal: Four<Term>;
91
+ notfunequal: Four<Term>;
92
+ choose_diff_choose: Four<Term>;
93
+ notequivdef: [];
94
+ notequalchoose: Five<Term>;
95
+ in_nat_0: [Term];
96
+ in_nat_succ: Three<Term>;
97
+ box_p: Two<Term>;
98
+ tuple_eq_match: [Term, ...Term[]];
99
+ tuple_eq_mismatch: Two<Term>;
100
+ in_product: [Term, Term, Term, Term, Term, ...Term[]];
101
+ notin_product: [Term, Term, Term, ...Term[]];
102
+ tuple_notisaseq: [Term];
103
+ record_eq_match: [Term, ...Term[]];
104
+ record_eq_mismatch: Two<Term>;
105
+ record_neq_match: [Term, ...Term[]];
106
+ neq_record: [Term, Term, Term, ...Term[]];
107
+ record_neq: [Term, Term, Term, ...Term[]];
108
+ in_recordset: [Term, Term, Term, ...Term[]];
109
+ notin_recordset: [Term, Term, Term, ...Term[]];
110
+ record_notisafcn: [Term];
111
+ cup_subseteq: Three<Term>;
112
+ not_cup_subseteq: Three<Term>;
113
+ subseteq_cap: Three<Term>;
114
+ not_subseteq_cap: Three<Term>;
115
+ all_in: Five<Term>;
116
+ notex_in: Five<Term>;
117
+ p_eq_l: Seven<Term>;
118
+ p_eq_r: Seven<Term>;
119
+ np_eq_l: Seven<Term>;
120
+ np_eq_r: Seven<Term>;
121
+ trueistrue: Five<Term>;
122
+ fapplyfcn: Seven<Term>;
123
+ fapplyexcept: [Term, Term, Term, Term, Term, Term, Term, Term, Term, Term, Term, Term, Term];
124
+ tuple_access: Five<Term>;
125
+ record_access: Five<Term>;
126
+ domain_fcn: Five<Term>;
127
+ domain_except: Six<Term>;
128
+ record_domain: Five<Term>;
129
+ boolcase_not: Seven<Term>;
130
+ boolcase_and: [Term, Term, Term, Term, Term, Term, Term, Term];
131
+ boolcase_or: [Term, Term, Term, Term, Term, Term, Term, Term];
132
+ boolcase_imply: [Term, Term, Term, Term, Term, Term, Term, Term];
133
+ boolcase_equiv: [Term, Term, Term, Term, Term, Term, Term, Term];
134
+ boolcase_equal: [Term, Term, Term, Term, Term, Term, Term, Term];
135
+ boolcase_all: Seven<Term>;
136
+ boolcase_ex: Seven<Term>;
137
+ iftrue: Five<Term>;
138
+ iffalse: Five<Term>;
139
+ ifthenelse: [Term, Term, Term, Term, Term, Term, Term, Term, Term];
140
+ case: [Term, Term, ...Term[]];
141
+ tuple_len: Five<Term>;
142
+ }
143
+
144
+ // The rules that hold for any relation that the hypotheses make reflexive or symmetric.
145
+ interface RelationRuleArgs<Term> {
146
+ close_refl: [Term];
147
+ close_sym: Two<Term>;
148
+ refl: Two<Term>;
149
+ p_not_p_sym: Two<Term>;
150
+ }
151
+
152
+ export type PlainRuleName = keyof PlainRuleArgs<Expr>;
153
+
154
+ export type RelationRuleName = keyof RelationRuleArgs<Expr>;
155
+
156
+ export type RuleArgs<Name extends PlainRuleName, Term = Expr> = PlainRuleArgs<Term>[Name];
157
+
158
+ type PlainRules<Term> = {
159
+ [Name in keyof PlainRuleArgs<Term>]: { name: Name; args: PlainRuleArgs<Term>[Name] };
160
+ };
161
+
162
+ type RelationRules<Term> = {
163
+ [Name in keyof RelationRuleArgs<Term>]: {
164
+ name: Name;
165
+ relation: string;
166
+ args: RelationRuleArgs<Term>[Name];
167
+ };
168
+ };
169
+
170
+ // A rule application, as in Zenon's Mlproof.rule. "definition" unfolds `definition`.
171
+ export type Rule<Term = Expr> =
172
+ | PlainRules<Term>[PlainRuleName]
173
+ | RelationRules<Term>[RelationRuleName]
174
+ | { name: "definition"; definition: Definition; args: Two<Term> };
175
+
176
+ // A proof of the formulas in `conclusions`: the node's rule applied to `uses`, with a subproof for
177
+ // each of its branches.
178
+ export interface Proof<Term = Expr> {
179
+ conclusions: Term[];
180
+ rule: Rule<Term>;
181
+ uses: Term[];
182
+ subproofs: Proof<Term>[];
183
+ }
184
+
185
+ export const makeRule = <Name extends PlainRuleName>(
186
+ name: Name,
187
+ args: PlainRuleArgs<Expr>[Name],
188
+ ): { name: Name; args: PlainRuleArgs<Expr>[Name] } => ({ name, args });
189
+
190
+ export const makeRelationRule = <Name extends RelationRuleName>(
191
+ name: Name,
192
+ relation: string,
193
+ args: RelationRuleArgs<Expr>[Name],
194
+ ): { name: Name; relation: string; args: RelationRuleArgs<Expr>[Name] } => ({
195
+ name,
196
+ relation,
197
+ args,
198
+ });