tla-ts 0.0.9 → 0.0.10-dev.63a6693bd

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 (400) hide show
  1. package/README.md +29 -1
  2. package/dist/compile.cjs +23 -0
  3. package/dist/compile.js +23 -0
  4. package/dist/deciders.cjs +29 -29
  5. package/dist/deciders.js +42 -42
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +106 -10
  8. package/dist/index.d.ts +106 -10
  9. package/dist/index.js +1 -1
  10. package/dist/parallel-worker.cjs +1 -1
  11. package/dist/parallel-worker.js +1 -1
  12. package/dist/prove-worker.cjs +1 -1
  13. package/dist/prove-worker.js +1 -1
  14. package/dist/prove.cjs +117 -37
  15. package/dist/prove.js +116 -36
  16. package/dist/run.cjs +143 -31
  17. package/dist/run.js +143 -31
  18. package/dist/tlapm.cjs +2 -2
  19. package/dist/tlapm.js +2 -2
  20. package/dist/transfer.cjs +129 -104
  21. package/dist/transfer.js +129 -104
  22. package/dist/worker.cjs +7 -7
  23. package/dist/worker.js +7 -7
  24. package/package.json +3 -1
  25. package/src/ast.ts +48 -62
  26. package/src/bags.ts +99 -102
  27. package/src/builtins.ts +28 -75
  28. package/src/bundled-modules.ts +1 -8
  29. package/src/check-failure.ts +116 -0
  30. package/src/check-trace.ts +282 -0
  31. package/src/check.ts +599 -754
  32. package/src/cli/options.ts +12 -32
  33. package/src/cli/run.ts +0 -2
  34. package/src/cli/runtime-invariants.ts +136 -0
  35. package/src/cli/shared.ts +19 -12
  36. package/src/cli/tlapm.ts +14 -25
  37. package/src/cli/tlc-arguments.ts +652 -0
  38. package/src/cli/tlc-output.ts +687 -0
  39. package/src/cli/tlc-usage.ts +361 -0
  40. package/src/cli/tlc.ts +309 -658
  41. package/src/cli/typescript.ts +23 -0
  42. package/src/cli/xml-exporter.ts +27 -49
  43. package/src/cli.ts +0 -1
  44. package/src/codegen.ts +196 -74
  45. package/src/config.ts +140 -109
  46. package/src/coverage.ts +830 -0
  47. package/src/dependencies.ts +14 -53
  48. package/src/dfid.ts +618 -0
  49. package/src/environment-config.ts +315 -0
  50. package/src/environment.ts +169 -335
  51. package/src/errors.ts +71 -55
  52. package/src/evaluate.ts +598 -340
  53. package/src/exit-codes.ts +37 -3
  54. package/src/fingerprints.ts +75 -11
  55. package/src/index.ts +3 -0
  56. package/src/instances.ts +126 -21
  57. package/src/java-hash.ts +7 -0
  58. package/src/java-overrides.ts +4 -19
  59. package/src/json-reader.ts +455 -0
  60. package/src/json.ts +252 -139
  61. package/src/levels.ts +46 -58
  62. package/src/lexer.ts +80 -100
  63. package/src/liveness-checker.ts +103 -153
  64. package/src/liveness.ts +150 -109
  65. package/src/obligations/action.ts +8 -39
  66. package/src/obligations/anonymize.ts +88 -82
  67. package/src/obligations/equality.ts +1 -1
  68. package/src/obligations/expression.ts +20 -21
  69. package/src/obligations/format.ts +1 -9
  70. package/src/obligations/generate.ts +46 -49
  71. package/src/obligations/index.ts +2 -13
  72. package/src/obligations/levels.ts +4 -8
  73. package/src/obligations/module.ts +28 -53
  74. package/src/obligations/normalize.ts +7 -25
  75. package/src/obligations/operators.ts +1 -2
  76. package/src/obligations/pragma.ts +1 -10
  77. package/src/obligations/printer.ts +47 -46
  78. package/src/obligations/proof.ts +1 -5
  79. package/src/obligations/regroup.ts +1 -4
  80. package/src/obligations/simplify.ts +42 -58
  81. package/src/obligations/source.ts +48 -78
  82. package/src/obligations/subexpression.ts +5 -11
  83. package/src/obligations/substitution.ts +1 -3
  84. package/src/obligations/temporal.ts +13 -19
  85. package/src/obligations/tuples.ts +3 -9
  86. package/src/parallel-worker.ts +30 -60
  87. package/src/parallel.ts +57 -71
  88. package/src/parser.ts +584 -316
  89. package/src/pcal/ast.ts +53 -86
  90. package/src/pcal/parse.ts +144 -219
  91. package/src/pcal/tokenize.ts +91 -131
  92. package/src/pcal/translate.ts +83 -130
  93. package/src/pcal/validate.ts +48 -68
  94. package/src/pretty-print.ts +7 -8
  95. package/src/prover/decide-pool.ts +8 -13
  96. package/src/prover/deciders.ts +3 -7
  97. package/src/prover/first-order.ts +0 -11
  98. package/src/prover/isabelle/decide.ts +0 -6
  99. package/src/prover/isabelle/encode.ts +11 -23
  100. package/src/prover/isabelle/isar/inner-syntax.ts +114 -115
  101. package/src/prover/isabelle/isar/method.ts +29 -53
  102. package/src/prover/isabelle/isar/proof.ts +1 -10
  103. package/src/prover/isabelle/isar/statement.ts +1 -6
  104. package/src/prover/isabelle/isar/theory.ts +26 -36
  105. package/src/prover/isabelle/isar/type-check.ts +17 -31
  106. package/src/prover/isabelle/provers/blast/blast.ts +17 -104
  107. package/src/prover/isabelle/provers/blast/branch.ts +1 -32
  108. package/src/prover/isabelle/provers/blast/prove.ts +1 -35
  109. package/src/prover/isabelle/provers/blast/rules.ts +6 -44
  110. package/src/prover/isabelle/provers/blast/state.ts +2 -28
  111. package/src/prover/isabelle/provers/blast/term.ts +9 -36
  112. package/src/prover/isabelle/provers/clasimp.ts +1 -13
  113. package/src/prover/isabelle/provers/classical.ts +14 -42
  114. package/src/prover/isabelle/provers/hypsubst.ts +28 -51
  115. package/src/prover/isabelle/pure/bicompose.ts +25 -38
  116. package/src/prover/isabelle/pure/consts.ts +1 -7
  117. package/src/prover/isabelle/pure/conv.ts +3 -17
  118. package/src/prover/isabelle/pure/drule.ts +33 -42
  119. package/src/prover/isabelle/pure/envir.ts +3 -52
  120. package/src/prover/isabelle/pure/goal.ts +1 -7
  121. package/src/prover/isabelle/pure/interrupt.ts +0 -5
  122. package/src/prover/isabelle/pure/list.ts +0 -3
  123. package/src/prover/isabelle/pure/logic.ts +2 -15
  124. package/src/prover/isabelle/pure/name.ts +2 -9
  125. package/src/prover/isabelle/pure/net.ts +3 -59
  126. package/src/prover/isabelle/pure/object-logic.ts +3 -10
  127. package/src/prover/isabelle/pure/pattern.ts +2 -19
  128. package/src/prover/isabelle/pure/raw-simplifier.ts +17 -62
  129. package/src/prover/isabelle/pure/rewriter.ts +31 -67
  130. package/src/prover/isabelle/pure/search.ts +3 -10
  131. package/src/prover/isabelle/pure/seq.ts +1 -10
  132. package/src/prover/isabelle/pure/simplifier.ts +4 -12
  133. package/src/prover/isabelle/pure/table.ts +3 -32
  134. package/src/prover/isabelle/pure/tactic.ts +12 -22
  135. package/src/prover/isabelle/pure/tactical.ts +48 -47
  136. package/src/prover/isabelle/pure/term-ord.ts +2 -6
  137. package/src/prover/isabelle/pure/term.ts +2 -43
  138. package/src/prover/isabelle/pure/thm.ts +27 -47
  139. package/src/prover/isabelle/pure/type.ts +2 -15
  140. package/src/prover/isabelle/pure/unify.ts +20 -30
  141. package/src/prover/isabelle/pure/variable.ts +3 -7
  142. package/src/prover/isabelle/tla/classical-setup.ts +17 -24
  143. package/src/prover/isabelle/tla/context.ts +15 -18
  144. package/src/prover/isabelle/tla/logic.ts +14 -32
  145. package/src/prover/isabelle/tla/simpdata.ts +46 -43
  146. package/src/prover/isabelle/tools/intuitionistic.ts +1 -10
  147. package/src/prover/ocaml.ts +0 -6
  148. package/src/prover/prep/action.ts +14 -54
  149. package/src/prover/prep/enabled-axioms.ts +12 -19
  150. package/src/prover/prep/fingerprint.ts +2 -21
  151. package/src/prover/prep/level-comparison.ts +8 -12
  152. package/src/prover/prep/md5.ts +0 -2
  153. package/src/prover/prep/methods.ts +33 -39
  154. package/src/prover/prep/normalize.ts +4 -28
  155. package/src/prover/prove-worker.ts +0 -2
  156. package/src/prover/prove.ts +87 -100
  157. package/src/prover/ptl/decide.ts +7 -12
  158. package/src/prover/ptl/encode.ts +14 -36
  159. package/src/prover/ptl/sat.ts +24 -32
  160. package/src/prover/ptl/tableau.ts +12 -26
  161. package/src/prover/smt/axioms.ts +0 -7
  162. package/src/prover/smt/context.ts +20 -28
  163. package/src/prover/smt/data.ts +433 -424
  164. package/src/prover/smt/encode.ts +43 -52
  165. package/src/prover/smt/extensionality.ts +0 -10
  166. package/src/prover/smt/flatten.ts +3 -22
  167. package/src/prover/smt/format.ts +5 -10
  168. package/src/prover/smt/instances.ts +0 -10
  169. package/src/prover/smt/rewrite.ts +663 -667
  170. package/src/prover/smt/solver/act-cache.ts +0 -15
  171. package/src/prover/smt/solver/arith-rewriter.ts +3 -48
  172. package/src/prover/smt/solver/array.ts +1 -3
  173. package/src/prover/smt/solver/asserted-formulas.ts +1 -43
  174. package/src/prover/smt/solver/ast-lt.ts +1 -11
  175. package/src/prover/smt/solver/ast-util.ts +1 -6
  176. package/src/prover/smt/solver/ast.ts +1 -165
  177. package/src/prover/smt/solver/auf-solver.ts +8 -44
  178. package/src/prover/smt/solver/case-split-queue.ts +1 -9
  179. package/src/prover/smt/solver/cg-table.ts +1 -18
  180. package/src/prover/smt/solver/clause.ts +1 -27
  181. package/src/prover/smt/solver/conflict-resolution.ts +0 -9
  182. package/src/prover/smt/solver/context.ts +7 -64
  183. package/src/prover/smt/solver/ctx-simplify.ts +14 -41
  184. package/src/prover/smt/solver/der.ts +2 -21
  185. package/src/prover/smt/solver/dyn-ack.ts +1 -11
  186. package/src/prover/smt/solver/e-matching.ts +4 -35
  187. package/src/prover/smt/solver/enode.ts +1 -21
  188. package/src/prover/smt/solver/expr-ref.ts +1 -5
  189. package/src/prover/smt/solver/expr-safe-replace.ts +1 -6
  190. package/src/prover/smt/solver/fingerprints.ts +1 -12
  191. package/src/prover/smt/solver/flat-literals.ts +1 -9
  192. package/src/prover/smt/solver/goal.ts +2 -14
  193. package/src/prover/smt/solver/hash.ts +0 -8
  194. package/src/prover/smt/solver/hashtable.ts +1 -12
  195. package/src/prover/smt/solver/internalizer.ts +7 -100
  196. package/src/prover/smt/solver/lbool.ts +1 -2
  197. package/src/prover/smt/solver/literal.ts +0 -3
  198. package/src/prover/smt/solver/lp/bound-propagator.ts +8 -26
  199. package/src/prover/smt/solver/lp/constraints.ts +2 -8
  200. package/src/prover/smt/solver/lp/containers.ts +12 -30
  201. package/src/prover/smt/solver/lp/core-solver.ts +10 -31
  202. package/src/prover/smt/solver/lp/cross-nested.ts +6 -20
  203. package/src/prover/smt/solver/lp/dep-intervals.ts +7 -22
  204. package/src/prover/smt/solver/lp/dependency.ts +1 -4
  205. package/src/prover/smt/solver/lp/dioph-eq.ts +9 -102
  206. package/src/prover/smt/solver/lp/explanation.ts +1 -6
  207. package/src/prover/smt/solver/lp/gomory.ts +9 -22
  208. package/src/prover/smt/solver/lp/hnf-cutter.ts +17 -23
  209. package/src/prover/smt/solver/lp/hnf.ts +11 -26
  210. package/src/prover/smt/solver/lp/int-cube.ts +15 -36
  211. package/src/prover/smt/solver/lp/int-solver.ts +4 -34
  212. package/src/prover/smt/solver/lp/lar-solver.ts +32 -81
  213. package/src/prover/smt/solver/lp/lar-term.ts +1 -5
  214. package/src/prover/smt/solver/lp/lp-settings.ts +1 -14
  215. package/src/prover/smt/solver/lp/maximize-term.ts +20 -45
  216. package/src/prover/smt/solver/lp/nex-creator.ts +5 -28
  217. package/src/prover/smt/solver/lp/nex.ts +1 -6
  218. package/src/prover/smt/solver/lp/nla-backoff.ts +1 -4
  219. package/src/prover/smt/solver/lp/nla-basics.ts +5 -30
  220. package/src/prover/smt/solver/lp/nla-core.ts +36 -135
  221. package/src/prover/smt/solver/lp/nla-divisions.ts +32 -42
  222. package/src/prover/smt/solver/lp/nla-emonics.ts +4 -21
  223. package/src/prover/smt/solver/lp/nla-factorization.ts +1 -4
  224. package/src/prover/smt/solver/lp/nla-grobner.ts +15 -69
  225. package/src/prover/smt/solver/lp/nla-horner.ts +3 -11
  226. package/src/prover/smt/solver/lp/nla-intervals.ts +2 -12
  227. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +16 -41
  228. package/src/prover/smt/solver/lp/nla-monotone.ts +2 -6
  229. package/src/prover/smt/solver/lp/nla-order.ts +2 -13
  230. package/src/prover/smt/solver/lp/nla-patcher.ts +4 -7
  231. package/src/prover/smt/solver/lp/nla-tangents.ts +1 -9
  232. package/src/prover/smt/solver/lp/nla-throttle.ts +1 -6
  233. package/src/prover/smt/solver/lp/nla-types.ts +1 -11
  234. package/src/prover/smt/solver/lp/nla-var-eqs.ts +4 -25
  235. package/src/prover/smt/solver/lp/nra-solver.ts +5 -52
  236. package/src/prover/smt/solver/lp/numeric-pair.ts +1 -4
  237. package/src/prover/smt/solver/lp/pdd-interval.ts +1 -3
  238. package/src/prover/smt/solver/lp/pdd-simplifier.ts +2 -14
  239. package/src/prover/smt/solver/lp/pdd-solver.ts +4 -33
  240. package/src/prover/smt/solver/lp/pdd.ts +7 -70
  241. package/src/prover/smt/solver/lp/random-updater.ts +1 -8
  242. package/src/prover/smt/solver/lp/static-matrix.ts +9 -19
  243. package/src/prover/smt/solver/lp/union-find.ts +1 -6
  244. package/src/prover/smt/solver/mam-compiler.ts +18 -58
  245. package/src/prover/smt/solver/mam-interpreter.ts +1 -21
  246. package/src/prover/smt/solver/maximize-ac-sharing.ts +2 -17
  247. package/src/prover/smt/solver/model-checker.ts +3 -37
  248. package/src/prover/smt/solver/model-evaluator.ts +3 -29
  249. package/src/prover/smt/solver/model-finder.ts +15 -32
  250. package/src/prover/smt/solver/model-generator.ts +1 -12
  251. package/src/prover/smt/solver/model-macro-solver.ts +23 -88
  252. package/src/prover/smt/solver/nlsat/algebraic.ts +63 -159
  253. package/src/prover/smt/solver/nlsat/atoms.ts +25 -23
  254. package/src/prover/smt/solver/nlsat/evaluator.ts +17 -22
  255. package/src/prover/smt/solver/nlsat/explain.ts +10 -69
  256. package/src/prover/smt/solver/nlsat/interval-set.ts +9 -50
  257. package/src/prover/smt/solver/nlsat/levelwise.ts +49 -135
  258. package/src/prover/smt/solver/nlsat/mpbq.ts +3 -14
  259. package/src/prover/smt/solver/nlsat/polynomial.ts +29 -159
  260. package/src/prover/smt/solver/nlsat/solver.ts +18 -90
  261. package/src/prover/smt/solver/nlsat/types.ts +1 -8
  262. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +2 -45
  263. package/src/prover/smt/solver/nlsat/upolynomial.ts +11 -92
  264. package/src/prover/smt/solver/nnf.ts +3 -38
  265. package/src/prover/smt/solver/pattern-inference.ts +2 -15
  266. package/src/prover/smt/solver/poly-rewriter.ts +3 -23
  267. package/src/prover/smt/solver/propagate-values.ts +1 -10
  268. package/src/prover/smt/solver/proto-model.ts +3 -52
  269. package/src/prover/smt/solver/pull-quant.ts +1 -12
  270. package/src/prover/smt/solver/qe-lite-der.ts +1 -29
  271. package/src/prover/smt/solver/qe-lite-fm.ts +2 -25
  272. package/src/prover/smt/solver/qe-lite.ts +3 -33
  273. package/src/prover/smt/solver/qi-queue.ts +1 -16
  274. package/src/prover/smt/solver/quant-tactics.ts +5 -22
  275. package/src/prover/smt/solver/quantifier-analyzer.ts +27 -47
  276. package/src/prover/smt/solver/quantifier-manager.ts +2 -13
  277. package/src/prover/smt/solver/random-gen.ts +1 -2
  278. package/src/prover/smt/solver/rational.ts +1 -8
  279. package/src/prover/smt/solver/ref-vector.ts +1 -6
  280. package/src/prover/smt/solver/relevancy.ts +2 -15
  281. package/src/prover/smt/solver/rewriter-tpl.ts +3 -147
  282. package/src/prover/smt/solver/rewriter.ts +3 -85
  283. package/src/prover/smt/solver/rlimit.ts +2 -20
  284. package/src/prover/smt/solver/smtlib-parser.ts +80 -131
  285. package/src/prover/smt/solver/solver.ts +23 -34
  286. package/src/prover/smt/solver/sort.ts +1 -5
  287. package/src/prover/smt/solver/sticky-generations.ts +0 -5
  288. package/src/prover/smt/solver/theory-lra-axioms.ts +3 -24
  289. package/src/prover/smt/solver/theory-lra-bounds.ts +1 -7
  290. package/src/prover/smt/solver/theory-lra-final-check.ts +4 -22
  291. package/src/prover/smt/solver/theory-lra-internalize.ts +6 -43
  292. package/src/prover/smt/solver/theory-lra-model.ts +4 -19
  293. package/src/prover/smt/solver/theory-lra-propagate.ts +1 -15
  294. package/src/prover/smt/solver/theory-lra-state.ts +3 -8
  295. package/src/prover/smt/solver/theory-lra.ts +1 -8
  296. package/src/prover/smt/solver/var-subst.ts +2 -26
  297. package/src/prover/smt/table.ts +0 -8
  298. package/src/prover/tlapm/cache.ts +45 -40
  299. package/src/prover/tlapm/ocaml-marshal.ts +19 -21
  300. package/src/prover/tlapm/tlapm.ts +21 -20
  301. package/src/prover/verdict.ts +7 -2
  302. package/src/prover/zenon/check/check.ts +1 -11
  303. package/src/prover/zenon/check/definitions.ts +5 -15
  304. package/src/prover/zenon/check/equality.ts +0 -8
  305. package/src/prover/zenon/check/functions.ts +0 -4
  306. package/src/prover/zenon/check/keys.ts +0 -7
  307. package/src/prover/zenon/check/propositional.ts +0 -3
  308. package/src/prover/zenon/check/records.ts +1 -6
  309. package/src/prover/zenon/check/relations.ts +2 -14
  310. package/src/prover/zenon/check/rewrites.ts +2 -21
  311. package/src/prover/zenon/check/sets.ts +40 -61
  312. package/src/prover/zenon/check/terms.ts +1 -19
  313. package/src/prover/zenon/check/tla.ts +0 -6
  314. package/src/prover/zenon/decide.ts +0 -12
  315. package/src/prover/zenon/encode.ts +1 -8
  316. package/src/prover/zenon/eqrel.ts +2 -13
  317. package/src/prover/zenon/equality-rules.ts +0 -4
  318. package/src/prover/zenon/expr.ts +8 -26
  319. package/src/prover/zenon/index-table.ts +26 -57
  320. package/src/prover/zenon/isar-case.ts +9 -19
  321. package/src/prover/zenon/isar.ts +36 -64
  322. package/src/prover/zenon/limits.ts +0 -4
  323. package/src/prover/zenon/llproof.ts +2 -20
  324. package/src/prover/zenon/mltoll.ts +66 -104
  325. package/src/prover/zenon/node.ts +1 -11
  326. package/src/prover/zenon/ocaml.ts +1 -17
  327. package/src/prover/zenon/parse.ts +4 -12
  328. package/src/prover/zenon/phrase.ts +1 -11
  329. package/src/prover/zenon/proof.ts +0 -9
  330. package/src/prover/zenon/propositional-rules.ts +0 -5
  331. package/src/prover/zenon/rules.ts +2 -6
  332. package/src/prover/zenon/search.ts +5 -31
  333. package/src/prover/zenon/tla/functions.ts +59 -31
  334. package/src/prover/zenon/tla/llproof.ts +67 -76
  335. package/src/prover/zenon/tla/records.ts +57 -33
  336. package/src/prover/zenon/tla/rewrites.ts +12 -19
  337. package/src/prover/zenon/tla/sets.ts +83 -53
  338. package/src/prover/zenon/tla/terms.ts +0 -6
  339. package/src/prover/zenon/tla/tla.ts +66 -64
  340. package/src/randomization.ts +81 -35
  341. package/src/resolve.ts +67 -184
  342. package/src/runtime.ts +22 -22
  343. package/src/sany/builtins.ts +2 -5
  344. package/src/sany/generation.ts +394 -0
  345. package/src/sany/generator-def-entries.ts +210 -0
  346. package/src/sany/generator-definitions.ts +686 -0
  347. package/src/sany/generator-expressions.ts +1100 -0
  348. package/src/sany/generator-proofs.ts +662 -0
  349. package/src/sany/generator.ts +191 -2764
  350. package/src/sany/levels.ts +6 -34
  351. package/src/sany/lexer.ts +58 -77
  352. package/src/sany/linter.ts +1 -9
  353. package/src/sany/modules.ts +1 -5
  354. package/src/sany/nodes.ts +5 -43
  355. package/src/sany/parse-error.ts +39 -117
  356. package/src/sany/report.ts +32 -69
  357. package/src/sany/selectors.ts +49 -76
  358. package/src/sany/source.ts +1 -17
  359. package/src/sany/xml.ts +35 -117
  360. package/src/search.ts +541 -163
  361. package/src/simulate.ts +709 -0
  362. package/src/spec-description.ts +192 -100
  363. package/src/standard-definitions.ts +0 -4
  364. package/src/standard-modules.ts +264 -95
  365. package/src/state-graph.ts +52 -31
  366. package/src/subexpressions.ts +69 -52
  367. package/src/substitution-levels.ts +7 -7
  368. package/src/successors.ts +266 -99
  369. package/src/symmetry.ts +33 -25
  370. package/src/tableau.ts +27 -24
  371. package/src/tlc/fingerprint.ts +183 -67
  372. package/src/tlc/jar-data.ts +112 -6
  373. package/src/tlc/messages.ts +125 -54
  374. package/src/tlc/order.ts +39 -69
  375. package/src/tlc/random.ts +37 -49
  376. package/src/tlc/replay.ts +553 -228
  377. package/src/tlc/summary.ts +36 -47
  378. package/src/tlc/tlc-operators.ts +78 -44
  379. package/src/tlc/tlcext-operators.ts +139 -122
  380. package/src/tlc/trace-spec.ts +249 -0
  381. package/src/tlc/value-stream.ts +139 -0
  382. package/src/tlc/version.ts +1 -4
  383. package/src/transfer.ts +22 -25
  384. package/src/typescript/actions.ts +479 -0
  385. package/src/typescript/collections.ts +614 -0
  386. package/src/typescript/compile.ts +63 -0
  387. package/src/typescript/context.ts +94 -0
  388. package/src/typescript/emit.ts +121 -0
  389. package/src/typescript/expressions.ts +496 -0
  390. package/src/typescript/formula.ts +154 -0
  391. package/src/typescript/functions.ts +284 -0
  392. package/src/typescript/model.ts +162 -0
  393. package/src/typescript/names.ts +114 -0
  394. package/src/typescript/program.ts +48 -0
  395. package/src/typescript/properties.ts +139 -0
  396. package/src/typescript/scope.ts +112 -0
  397. package/src/typescript/steps.ts +167 -0
  398. package/src/typescript/types.ts +171 -0
  399. package/src/values.ts +832 -484
  400. package/src/worker.ts +7 -8
@@ -1,14 +1,10 @@
1
1
  // Ported from Zenon's ext_tla.ml, as shipped in tlapm. Copyright 2008 INRIA, see LICENSE.
2
- //
3
- // Zenon's to_llproof for the TLA+ extension: each rule becomes an extension rule of the low-level
4
- // proof, named after the lemma in Zenon.thy that justifies it.
5
2
 
6
3
  import { TlaZenonError } from "../../../errors";
7
4
  import { difference, union, type Expr, type Expressions } from "../expr";
8
- import { connect, type Lemma, type LlProof, type LlRule } from "../llproof";
5
+ import type { Lemma, LlProof, LlRule } from "../llproof";
9
6
  import type { MlProof, Translated } from "../mltoll";
10
7
 
11
- // The lemma's name, the terms it's instantiated with, the conclusions it uses and its branches.
12
8
  type LlArgs = [string, Expr[], Expr[], Expr[][]];
13
9
 
14
10
  type Shape = (name: string, args: Expr[]) => LlArgs;
@@ -72,7 +68,6 @@ const binbeta: Shape = (name, args) => {
72
68
  return [`zenon_${name}`, rest, [first, second], [[hypothesisA], [hypothesisB]]];
73
69
  };
74
70
 
75
- // A conclusion, two terms and then the hypotheses, in one branch or one branch each.
76
71
  const withTerms =
77
72
  (isSplit: boolean): Shape =>
78
73
  (name, args) => {
@@ -86,7 +81,6 @@ const withTerms =
86
81
  ];
87
82
  };
88
83
 
89
- // A conclusion and then the hypotheses, in one branch or one branch each.
90
84
  const withoutTerms =
91
85
  (isSplit: boolean): Shape =>
92
86
  (name, args) => {
@@ -107,7 +101,6 @@ const getCaseBranches = (args: Expr[]): Expr[][] =>
107
101
  : [args]
108
102
  : [args.slice(0, 2), ...getCaseBranches(args.slice(2))];
109
103
 
110
- // Zenon's to_llargs, by rule name. The rules missing here take one hypothesis.
111
104
  const SHAPES: Record<string, Shape> = {
112
105
  in_emptyset: (name, args) => [`zenon_${name}`, args.slice(1), args.slice(0, 1), []],
113
106
  in_nat_0: close,
@@ -128,11 +121,7 @@ const SHAPES: Record<string, Shape> = {
128
121
  if (third === undefined) throw getShapeError(name);
129
122
  return [`zenon_${name}`, rest, [conclusion], [[first, second, third]]];
130
123
  },
131
- except_notin_funcset: (name, args) => {
132
- const [conclusion, first, second, ...rest] = args;
133
- if (second === undefined) throw getShapeError(name);
134
- return [`zenon_${name}`, rest, [conclusion], [[first], [second]]];
135
- },
124
+ except_notin_funcset: beta,
136
125
  notin_funcset: (name, args) => {
137
126
  const [conclusion, first, second, third, ...rest] = args;
138
127
  if (third === undefined) throw getShapeError(name);
@@ -194,14 +183,12 @@ const SHAPES: Record<string, Shape> = {
194
183
  record_notisafcn: close,
195
184
  };
196
185
 
197
- // Zenon's Ext_tla.to_llproof, for a rule of the extension and its translated subproofs.
198
186
  export const getTlaLlProof = (
199
187
  translateExpr: (expression: Expr) => Expr,
200
188
  exprs: Expressions,
201
189
  proof: MlProof,
202
190
  subproofs: Translated[],
203
191
  ): Translated => {
204
- const tr = translateExpr;
205
192
  const rule = proof.rule;
206
193
  const member = (element: Expr, set: Expr) => exprs.eapp("TLA.in", [element, set]);
207
194
  const equal = (left: Expr, right: Expr) => exprs.eapp("=", [left, right]);
@@ -213,18 +200,24 @@ export const getTlaLlProof = (
213
200
  branches: Expr[][],
214
201
  nodeSubproofs: LlProof[],
215
202
  ): LlProof => ({
216
- conclusions: conclusions.map(tr),
203
+ conclusions: conclusions.map(translateExpr),
217
204
  rule: {
218
205
  kind: "extension",
219
206
  name,
220
- args: args.map(tr),
221
- conclusions: ruleConclusions.map(tr),
222
- branches: branches.map((branch) => branch.map(tr)),
207
+ args: args.map(translateExpr),
208
+ conclusions: ruleConclusions.map(translateExpr),
209
+ branches: branches.map((branch) => branch.map(translateExpr)),
223
210
  },
224
211
  subproofs: nodeSubproofs,
225
212
  });
226
213
 
227
- // The membership in an enumerated set, one element at a time.
214
+ const splitSet = (set: Expr, isSetOf: boolean) =>
215
+ set.kind === "app" &&
216
+ set.symbol === (isSetOf ? "TLA.set" : "TLA.addElt") &&
217
+ set.args.length >= (isSetOf ? 1 : 2)
218
+ ? [set.args[0], isSetOf ? exprs.eapp("TLA.set", set.args.slice(1)) : set.args[1]]
219
+ : undefined;
220
+
228
221
  const getMembership = (
229
222
  element: Expr,
230
223
  set: Expr,
@@ -240,12 +233,7 @@ export const getTlaLlProof = (
240
233
  extension(conclusions, "zenon_in_emptyset", [element], [member(element, set)], [], []),
241
234
  [],
242
235
  ];
243
- const split =
244
- set.kind === "app" &&
245
- set.symbol === (isSetOf ? "TLA.set" : "TLA.addElt") &&
246
- set.args.length >= (isSetOf ? 1 : 2)
247
- ? [set.args[0], isSetOf ? exprs.eapp("TLA.set", set.args.slice(1)) : set.args[1]]
248
- : undefined;
236
+ const split = splitSet(set, isSetOf);
249
237
  const first = remaining[0];
250
238
  if (split === undefined || first === undefined) {
251
239
  if (!isSetOf && remaining.length === 1) return remaining[0];
@@ -254,13 +242,13 @@ export const getTlaLlProof = (
254
242
  const value = split[0];
255
243
  const rest = split[1];
256
244
  const conclusion = member(element, set);
257
- const isValue = equal(element, value);
258
- const isInRest = member(element, rest);
245
+ const valueEquality = equal(element, value);
246
+ const restMembership = member(element, rest);
259
247
  const next = getMembership(
260
248
  element,
261
249
  rest,
262
250
  remaining.slice(1),
263
- [isInRest, ...conclusions],
251
+ [restMembership, ...conclusions],
264
252
  isSetOf,
265
253
  );
266
254
  const extras = difference(union(first[1], next[1]), conclusions);
@@ -270,14 +258,13 @@ export const getTlaLlProof = (
270
258
  "zenon_in_addElt",
271
259
  [element, value, rest],
272
260
  [conclusion],
273
- [[isValue], [isInRest]],
261
+ [[valueEquality], [restMembership]],
274
262
  [first[0], next[0]],
275
263
  ),
276
264
  extras,
277
265
  ];
278
266
  };
279
267
 
280
- // The non-membership in an enumerated set, one element at a time.
281
268
  const getNonMembership = (
282
269
  element: Expr,
283
270
  set: Expr,
@@ -285,23 +272,18 @@ export const getTlaLlProof = (
285
272
  conclusions: Expr[],
286
273
  isSetOf: boolean,
287
274
  ): Translated => {
288
- const split =
289
- set.kind === "app" &&
290
- set.symbol === (isSetOf ? "TLA.set" : "TLA.addElt") &&
291
- set.args.length >= (isSetOf ? 1 : 2)
292
- ? [set.args[0], isSetOf ? exprs.eapp("TLA.set", set.args.slice(1)) : set.args[1]]
293
- : undefined;
275
+ const split = splitSet(set, isSetOf);
294
276
  if (split === undefined) return sub;
295
277
  const value = split[0];
296
278
  const rest = split[1];
297
279
  const conclusion = exprs.enot(member(element, set));
298
- const isNotValue = exprs.enot(equal(element, value));
299
- const isNotInRest = exprs.enot(member(element, rest));
280
+ const valueInequality = exprs.enot(equal(element, value));
281
+ const restNonMembership = exprs.enot(member(element, rest));
300
282
  const next = getNonMembership(
301
283
  element,
302
284
  rest,
303
285
  sub,
304
- [isNotValue, isNotInRest, ...conclusions],
286
+ [valueInequality, restNonMembership, ...conclusions],
305
287
  isSetOf,
306
288
  );
307
289
  const extras = difference(next[1], conclusions);
@@ -311,7 +293,7 @@ export const getTlaLlProof = (
311
293
  "zenon_notin_addElt",
312
294
  [element, value, rest],
313
295
  [conclusion],
314
- [[isNotValue, isNotInRest]],
296
+ [[valueInequality, restNonMembership]],
315
297
  [next[0]],
316
298
  ),
317
299
  extras,
@@ -367,10 +349,9 @@ export const getTlaLlProof = (
367
349
  }
368
350
  };
369
351
 
370
- // Zenon's Ext_tla.postprocess: the lemmas with each $notequiv written as a negated equivalence.
371
352
  export const postprocessTla = (exprs: Expressions, lemmas: Lemma[]): Lemma[] => {
372
353
  const cache = new Map<Expr, Expr>();
373
- const pp = (expression: Expr): Expr => {
354
+ const postprocess = (expression: Expr): Expr => {
374
355
  const cached = cache.get(expression);
375
356
  if (cached !== undefined) return cached;
376
357
  const result = ((): Expr => {
@@ -383,35 +364,37 @@ export const postprocessTla = (exprs: Expressions, lemmas: Lemma[]): Lemma[] =>
383
364
  throw new TlaZenonError("Zenon: a metavariable in a low-level proof");
384
365
  case "app": {
385
366
  if (expression.symbol !== "$notequiv")
386
- return exprs.eapp(expression.symbol, expression.args.map(pp));
367
+ return exprs.eapp(expression.symbol, expression.args.map(postprocess));
387
368
  if (expression.args.length !== 2)
388
369
  throw new TlaZenonError("Zenon: $notequiv without two arguments");
389
- const right = pp(expression.args[1]);
390
- return exprs.enot(exprs.eequiv(pp(expression.args[0]), right));
370
+ const right = postprocess(expression.args[1]);
371
+ return exprs.enot(exprs.eequiv(postprocess(expression.args[0]), right));
391
372
  }
392
373
  case "not":
393
- return exprs.enot(pp(expression.args[0]));
374
+ return exprs.enot(postprocess(expression.args[0]));
394
375
  case "and":
395
376
  case "or":
396
377
  case "imply":
397
378
  case "equiv": {
398
- const right = pp(expression.args[1]);
399
- return connect(exprs, expression.kind, pp(expression.args[0]), right);
379
+ const right = postprocess(expression.args[1]);
380
+ return exprs.binary(expression.kind, postprocess(expression.args[0]), right);
400
381
  }
401
382
  case "all":
402
- return exprs.eall(expression.args[0], expression.symbol, pp(expression.args[1]));
403
383
  case "ex":
404
- return exprs.eex(expression.args[0], expression.symbol, pp(expression.args[1]));
405
384
  case "tau":
406
- return exprs.etau(expression.args[0], expression.symbol, pp(expression.args[1]));
407
385
  case "lam":
408
- return exprs.elam(expression.args[0], expression.symbol, pp(expression.args[1]));
386
+ return exprs.binder(
387
+ expression.kind,
388
+ expression.args[0],
389
+ expression.symbol,
390
+ postprocess(expression.args[1]),
391
+ );
409
392
  }
410
393
  })();
411
394
  cache.set(expression, result);
412
395
  return result;
413
396
  };
414
- const ppRule = (rule: LlRule): LlRule => {
397
+ const postprocessRule = (rule: LlRule): LlRule => {
415
398
  switch (rule.kind) {
416
399
  case "false":
417
400
  case "nottrue":
@@ -419,62 +402,70 @@ export const postprocessTla = (exprs: Expressions, lemmas: Lemma[]): Lemma[] =>
419
402
  case "axiom":
420
403
  case "cut":
421
404
  case "notnot":
422
- return { kind: rule.kind, formula: pp(rule.formula) };
405
+ return { kind: rule.kind, formula: postprocess(rule.formula) };
423
406
  case "noteq":
424
- return { kind: "noteq", term: pp(rule.term) };
407
+ return { kind: "noteq", term: postprocess(rule.term) };
425
408
  case "eqsym":
426
409
  case "notequal":
427
- return { kind: rule.kind, left: pp(rule.left), right: pp(rule.right) };
410
+ return { kind: rule.kind, left: postprocess(rule.left), right: postprocess(rule.right) };
428
411
  case "connect":
429
412
  case "notconnect":
430
413
  return {
431
414
  kind: rule.kind,
432
415
  connective: rule.connective,
433
- left: pp(rule.left),
434
- right: pp(rule.right),
416
+ left: postprocess(rule.left),
417
+ right: postprocess(rule.right),
435
418
  };
436
419
  case "ex":
437
420
  case "all":
438
421
  case "notex":
439
422
  case "notall":
440
- return { kind: rule.kind, quantified: pp(rule.quantified), term: pp(rule.term) };
423
+ return {
424
+ kind: rule.kind,
425
+ quantified: postprocess(rule.quantified),
426
+ term: postprocess(rule.term),
427
+ };
441
428
  case "pnotp":
442
- return { kind: "pnotp", positive: pp(rule.positive), negative: pp(rule.negative) };
429
+ return {
430
+ kind: "pnotp",
431
+ positive: postprocess(rule.positive),
432
+ negative: postprocess(rule.negative),
433
+ };
443
434
  case "congruencelr":
444
435
  case "congruencerl":
445
436
  return {
446
437
  kind: rule.kind,
447
- context: pp(rule.context),
448
- left: pp(rule.left),
449
- right: pp(rule.right),
438
+ context: postprocess(rule.context),
439
+ left: postprocess(rule.left),
440
+ right: postprocess(rule.right),
450
441
  };
451
442
  case "definition":
452
443
  return {
453
444
  kind: "definition",
454
445
  name: rule.name,
455
- folded: pp(rule.folded),
456
- unfolded: pp(rule.unfolded),
446
+ folded: postprocess(rule.folded),
447
+ unfolded: postprocess(rule.unfolded),
457
448
  };
458
449
  case "extension":
459
450
  return {
460
451
  kind: "extension",
461
452
  name: rule.name,
462
- args: rule.args.map(pp),
463
- conclusions: rule.conclusions.map(pp),
464
- branches: rule.branches.map((branch) => branch.map(pp)),
453
+ args: rule.args.map(postprocess),
454
+ conclusions: rule.conclusions.map(postprocess),
455
+ branches: rule.branches.map((branch) => branch.map(postprocess)),
465
456
  };
466
457
  case "lemma":
467
- return { kind: "lemma", name: rule.name, args: rule.args.map(pp) };
458
+ return { kind: "lemma", name: rule.name, args: rule.args.map(postprocess) };
468
459
  }
469
460
  };
470
- const ppTree = (tree: LlProof): LlProof => ({
471
- conclusions: tree.conclusions.map(pp),
472
- rule: ppRule(tree.rule),
473
- subproofs: tree.subproofs.map(ppTree),
461
+ const postprocessTree = (tree: LlProof): LlProof => ({
462
+ conclusions: tree.conclusions.map(postprocess),
463
+ rule: postprocessRule(tree.rule),
464
+ subproofs: tree.subproofs.map(postprocessTree),
474
465
  });
475
466
  return lemmas.map((lemma) => ({
476
467
  name: lemma.name,
477
- params: lemma.params.map((param): [string, Expr] => [param[0], pp(param[1])]),
478
- proof: ppTree(lemma.proof),
468
+ params: lemma.params.map((param): [string, Expr] => [param[0], postprocess(param[1])]),
469
+ proof: postprocessTree(lemma.proof),
479
470
  }));
480
471
  };
@@ -1,11 +1,8 @@
1
1
  // Ported from Zenon's ext_tla.ml, as shipped in tlapm. Copyright 2008 INRIA, see LICENSE.
2
- //
3
- // The rules for tuples and records.
4
2
 
5
- import { compareExprs, isApp, type Expr } from "../expr";
3
+ import { compareExprs, getStringName, isApp, type Expr } from "../expr";
6
4
  import { stableSort } from "../ocaml";
7
- import type { Priority } from "../node";
8
- import { makeRule, type Rule } from "../proof";
5
+ import { makeRule } from "../proof";
9
6
  import {
10
7
  domain,
11
8
  equal,
@@ -20,12 +17,6 @@ import {
20
17
  type Literal,
21
18
  } from "./terms";
22
19
 
23
- const getStringName = (expression: Expr) =>
24
- isApp(expression, "$string", 1) && expression.args[0].kind === "var"
25
- ? expression.args[0].symbol
26
- : undefined;
27
-
28
- // Zenon's check_record_labels on sorted fields: false for Invalid_record, a repeated label.
29
20
  const hasDistinctLabels = (pairs: [Expr, Expr][]) => {
30
21
  for (let index = 0; index + 1 < pairs.length; index++) {
31
22
  const left = pairs[index][0];
@@ -56,10 +47,8 @@ export const getTupleNodes = (literal: Literal): Item[] | undefined => {
56
47
  const isNegated = literal.isNegated;
57
48
  const atom = literal.atom;
58
49
  const relation = literal.relation;
59
- const node = (priority: Priority, rule: Rule, branches: Expr[][]) =>
60
- makeExtensionNode(literal, priority, rule, branches);
61
50
  if (isNegated && isApp(atom, "TLA.isASeq", 1) && isApp(atom.args[0], "TLA.tuple"))
62
- return node("prop", makeRule("tuple_notisaseq", [formula]), []);
51
+ return makeExtensionNode(literal, "prop", makeRule("tuple_notisaseq", [formula]), []);
63
52
  if (relation === undefined) return undefined;
64
53
  const left = relation.args[0];
65
54
  const right = relation.args[1];
@@ -67,11 +56,21 @@ export const getTupleNodes = (literal: Literal): Item[] | undefined => {
67
56
  const isMembership = relation.symbol === "TLA.in";
68
57
  if (!isNegated && isEquality && isApp(left, "TLA.tuple") && isApp(right, "TLA.tuple")) {
69
58
  if (left.args.length !== right.args.length)
70
- return node("prop", makeRule("tuple_eq_mismatch", [formula, formula]), []);
59
+ return makeExtensionNode(
60
+ literal,
61
+ "prop",
62
+ makeRule("tuple_eq_mismatch", [formula, formula]),
63
+ [],
64
+ );
71
65
  const equalities = left.args.map((inner, position) =>
72
66
  equal(exprs, inner, right.args[position]),
73
67
  );
74
- return node("prop", makeRule("tuple_eq_match", [formula, ...equalities]), [equalities]);
68
+ return makeExtensionNode(
69
+ literal,
70
+ "prop",
71
+ makeRule("tuple_eq_match", [formula, ...equalities]),
72
+ [equalities],
73
+ );
75
74
  }
76
75
  if (isMembership && isApp(right, "TLA.Product", 1) && isApp(right.args[0], "TLA.tuple")) {
77
76
  const element = left;
@@ -80,16 +79,24 @@ export const getTupleNodes = (literal: Literal): Item[] | undefined => {
80
79
  const components = tuple.args.map((inner, position) =>
81
80
  member(exprs, fapply(exprs, element, makeNatural(exprs, position + 1)), inner),
82
81
  );
83
- const isSequence = exprs.eapp("TLA.isASeq", [element]);
84
- const hasLength = equal(
82
+ const sequenceFormula = exprs.eapp("TLA.isASeq", [element]);
83
+ const lengthFormula = equal(
85
84
  exprs,
86
85
  exprs.eapp("TLA.Len", [element]),
87
86
  makeNatural(exprs, tuple.args.length),
88
87
  );
89
- return node(
88
+ return makeExtensionNode(
89
+ literal,
90
90
  "prop",
91
- makeRule("in_product", [formula, element, tuple, isSequence, hasLength, ...components]),
92
- [[isSequence, hasLength, ...components]],
91
+ makeRule("in_product", [
92
+ formula,
93
+ element,
94
+ tuple,
95
+ sequenceFormula,
96
+ lengthFormula,
97
+ ...components,
98
+ ]),
99
+ [[sequenceFormula, lengthFormula, ...components]],
93
100
  );
94
101
  }
95
102
  if (
@@ -108,7 +115,8 @@ export const getTupleNodes = (literal: Literal): Item[] | undefined => {
108
115
  ),
109
116
  ...components,
110
117
  ];
111
- return node(
118
+ return makeExtensionNode(
119
+ literal,
112
120
  "prop",
113
121
  makeRule("notin_product", [formula, element, tuple, ...formulas]),
114
122
  getBranches(formulas),
@@ -123,10 +131,8 @@ export const getRecordNodes = (literal: Literal): Item[] | undefined => {
123
131
  const isNegated = literal.isNegated;
124
132
  const atom = literal.atom;
125
133
  const relation = literal.relation;
126
- const node = (priority: Priority, rule: Rule, branches: Expr[][]) =>
127
- makeExtensionNode(literal, priority, rule, branches);
128
134
  if (isNegated && isApp(atom, "TLA.isAFcn", 1) && isApp(atom.args[0], "TLA.record"))
129
- return node("prop", makeRule("record_notisafcn", [formula]), []);
135
+ return makeExtensionNode(literal, "prop", makeRule("record_notisafcn", [formula]), []);
130
136
  if (relation === undefined) return undefined;
131
137
  const left = relation.args[0];
132
138
  const right = relation.args[1];
@@ -140,14 +146,27 @@ export const getRecordNodes = (literal: Literal): Item[] | undefined => {
140
146
  leftFields.length === rightFields.length &&
141
147
  leftFields.every((field, position) => field[0] === rightFields[position][0]);
142
148
  if (!isMatch)
143
- return isNegated ? [] : node("prop", makeRule("record_eq_mismatch", [formula, formula]), []);
149
+ return isNegated
150
+ ? []
151
+ : makeExtensionNode(
152
+ literal,
153
+ "prop",
154
+ makeRule("record_eq_mismatch", [formula, formula]),
155
+ [],
156
+ );
144
157
  const equalities = leftFields.map((field, position) =>
145
158
  equal(exprs, field[1], rightFields[position][1]),
146
159
  );
147
160
  if (!isNegated)
148
- return node("prop", makeRule("record_eq_match", [formula, ...equalities]), [equalities]);
161
+ return makeExtensionNode(
162
+ literal,
163
+ "prop",
164
+ makeRule("record_eq_match", [formula, ...equalities]),
165
+ [equalities],
166
+ );
149
167
  const inequalities = equalities.map((inner) => exprs.enot(inner));
150
- return node(
168
+ return makeExtensionNode(
169
+ literal,
151
170
  "prop",
152
171
  makeRule("record_neq_match", [formula, ...inequalities]),
153
172
  getBranches(inequalities),
@@ -171,7 +190,8 @@ export const getRecordNodes = (literal: Literal): Item[] | undefined => {
171
190
  ),
172
191
  ...pairs.map((pair) => exprs.enot(equal(exprs, fapply(exprs, other, pair[0]), pair[1]))),
173
192
  ];
174
- return node(
193
+ return makeExtensionNode(
194
+ literal,
175
195
  "prop",
176
196
  makeRule(record === right ? "neq_record" : "record_neq", [
177
197
  formula,
@@ -194,9 +214,12 @@ export const getRecordNodes = (literal: Literal): Item[] | undefined => {
194
214
  equal(exprs, domain(exprs, left), labels),
195
215
  ...pairs.map((pair) => member(exprs, fapply(exprs, left, pair[0]), pair[1])),
196
216
  ];
197
- return node("prop", makeRule("in_recordset", [formula, left, right, ...formulas]), [
198
- formulas,
199
- ]);
217
+ return makeExtensionNode(
218
+ literal,
219
+ "prop",
220
+ makeRule("in_recordset", [formula, left, right, ...formulas]),
221
+ [formulas],
222
+ );
200
223
  }
201
224
  if (isApp(left, "TLA.record")) {
202
225
  const leftLabels = getSortedLabels(left.args);
@@ -215,7 +238,8 @@ export const getRecordNodes = (literal: Literal): Item[] | undefined => {
215
238
  exprs.enot(equal(exprs, domain(exprs, left), labels)),
216
239
  ...pairs.map((pair) => exprs.enot(member(exprs, fapply(exprs, left, pair[0]), pair[1]))),
217
240
  ];
218
- return node(
241
+ return makeExtensionNode(
242
+ literal,
219
243
  "prop",
220
244
  makeRule("notin_recordset", [formula, left, right, ...formulas]),
221
245
  getBranches(formulas),
@@ -1,7 +1,4 @@
1
1
  // Ported from Zenon's ext_tla.ml, as shipped in tlapm. Copyright 2008 INRIA, see LICENSE.
2
- //
3
- // Rewriting a subterm: unfolding a definition, evaluating a function application, IF, CASE or a
4
- // formula used as a term, or replacing the subterm with an equal one from the branch.
5
2
 
6
3
  import { TlaZenonError } from "../../../errors";
7
4
  import {
@@ -29,8 +26,7 @@ import {
29
26
  type TlaContext,
30
27
  } from "./terms";
31
28
 
32
- // OCaml's int_of_string, for the numerals that tlapm writes as variables.
33
- const parseInteger = (text: string) =>
29
+ const parseOcamlInteger = (text: string) =>
34
30
  /^[-+]?(0[xX][0-9a-fA-F_]+|0[oO][0-7_]+|0[bB][01_]+|0[uU][0-9_]+|[0-9][0-9_]*)$/.test(text)
35
31
  ? Number(text.replace(/_/g, "").replace(/^([-+]?)0[uU]/, "$1"))
36
32
  : undefined;
@@ -43,7 +39,7 @@ const getNaturalConstant = (expression: Expr): number | undefined => {
43
39
  current = current.args[1];
44
40
  }
45
41
  if (current.kind !== "var") return undefined;
46
- const value = parseInteger(current.symbol);
42
+ const value = parseOcamlInteger(current.symbol);
47
43
  return value === undefined ? undefined : accumulator + value;
48
44
  };
49
45
 
@@ -100,20 +96,19 @@ const getRewrites = (
100
96
  const lambda = exprs.elam(hole, "", frame);
101
97
  const fill = (inner: Expr) => exprs.substitute([[hole, inner]], frame);
102
98
  const makeBoolCase = (getRule: (prefix: [Expr, Expr, Expr, Expr, Expr, Expr]) => Rule) => {
103
- const isTrue = equal(exprs, term, TRUE);
99
+ const trueEquality = equal(exprs, term, TRUE);
104
100
  const whenTrue = fill(TRUE);
105
- const isFalse = equal(exprs, term, FALSE);
101
+ const falseEquality = equal(exprs, term, FALSE);
106
102
  const whenFalse = fill(FALSE);
107
103
  return make(
108
- getRule([fill(term), isTrue, whenTrue, isFalse, whenFalse, lambda]),
104
+ getRule([fill(term), trueEquality, whenTrue, falseEquality, whenFalse, lambda]),
109
105
  [],
110
106
  [
111
- [isTrue, whenTrue],
112
- [isFalse, whenFalse],
107
+ [trueEquality, whenTrue],
108
+ [falseEquality, whenFalse],
113
109
  ],
114
110
  );
115
111
  };
116
- // Rewrites the term with the equalities on the branch whose other side has one of these heads.
117
112
  const makeEqualityRewrites = (wrapped: Expr, heads: string[], subterm: Expr) => {
118
113
  const hasGoodHead = (other: Expr) =>
119
114
  (other.kind === "app" || other.kind === "var") &&
@@ -199,19 +194,19 @@ const getRewrites = (
199
194
  const point = fcn.args[1];
200
195
  const value = fcn.args[2];
201
196
  const inDomain = member(exprs, argument, domain(exprs, base));
202
- const isPoint = equal(exprs, point, argument);
197
+ const pointEquality = equal(exprs, point, argument);
203
198
  const changed = fill(value);
204
- const isOther = exprs.enot(equal(exprs, point, argument));
199
+ const pointInequality = exprs.enot(equal(exprs, point, argument));
205
200
  const unchanged = fill(fapply(exprs, base, argument));
206
201
  const outside = exprs.enot(inDomain);
207
202
  return make(
208
203
  makeRule("fapplyexcept", [
209
204
  fill(term),
210
205
  inDomain,
211
- isPoint,
206
+ pointEquality,
212
207
  changed,
213
208
  inDomain,
214
- isOther,
209
+ pointInequality,
215
210
  unchanged,
216
211
  outside,
217
212
  lambda,
@@ -221,7 +216,7 @@ const getRewrites = (
221
216
  argument,
222
217
  ]),
223
218
  [],
224
- [[inDomain, isPoint, changed], [inDomain, isOther, unchanged], [outside]],
219
+ [[inDomain, pointEquality, changed], [inDomain, pointInequality, unchanged], [outside]],
225
220
  );
226
221
  }
227
222
  if (isApp(fcn, "TLA.tuple") && isInOneTo(argument, fcn.args.length)) {
@@ -394,8 +389,6 @@ const hasExistential = (exprs: Expressions, index: Index, choice: BinderExpr) =>
394
389
  return index.isMember(exprs.eex(choice.args[0], choice.symbol, body));
395
390
  };
396
391
 
397
- // Zenon's find_rewrites: the rewrites of the outermost subterm that has some, looking through
398
- // applications and negations.
399
392
  const findRewrites = (
400
393
  context: TlaContext,
401
394
  isInTerm: boolean,