tla-ts 0.0.4-dev.a297123 → 0.0.4-dev.c4929d7

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 (313) 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 +37 -47
  17. package/dist/run-cli.js +37 -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/check.ts +1 -0
  26. package/src/codegen.ts +5 -3
  27. package/src/errors.ts +86 -0
  28. package/src/evaluate.ts +54 -19
  29. package/src/index.ts +10 -0
  30. package/src/{obligation-action.ts → obligations/action.ts} +265 -55
  31. package/src/{obligation-anon.ts → obligations/anon.ts} +47 -37
  32. package/src/obligations/ctx.ts +64 -0
  33. package/src/{obligation-deref.ts → obligations/deref.ts} +38 -61
  34. package/src/{obligation-expression.ts → obligations/expression.ts} +78 -45
  35. package/src/{obligation-format.ts → obligations/format.ts} +7 -8
  36. package/src/{obligation-generate.ts → obligations/generate.ts} +147 -74
  37. package/src/{obligations.ts → obligations/index.ts} +29 -13
  38. package/src/{obligation-levels.ts → obligations/levels.ts} +14 -5
  39. package/src/{obligation-module.ts → obligations/module.ts} +56 -33
  40. package/src/obligations/pickle.ts +98 -0
  41. package/src/obligations/pragma.ts +189 -0
  42. package/src/{obligation-printer.ts → obligations/printer.ts} +22 -80
  43. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -1
  44. package/src/{obligation-source.ts → obligations/source.ts} +159 -97
  45. package/src/obligations/temporal.ts +319 -0
  46. package/src/{obligation-tuples.ts → obligations/tuples.ts} +1 -1
  47. package/src/ocaml-marshal.ts +166 -0
  48. package/src/parallel-worker.ts +2 -18
  49. package/src/parallel.ts +10 -43
  50. package/src/prove/decide-pool.ts +100 -0
  51. package/src/prove/deciders.ts +33 -0
  52. package/src/prove/isabelle/LICENSE +36 -0
  53. package/src/prove/isabelle/LICENSE-tlapm +26 -0
  54. package/src/prove/isabelle/decide.ts +47 -0
  55. package/src/prove/isabelle/encode.ts +503 -0
  56. package/src/prove/isabelle/isar/inner-syntax.ts +579 -0
  57. package/src/prove/isabelle/isar/method.ts +367 -0
  58. package/src/prove/isabelle/isar/proof.ts +28 -0
  59. package/src/prove/isabelle/isar/statement.ts +57 -0
  60. package/src/prove/isabelle/isar/theory.ts +192 -0
  61. package/src/prove/isabelle/isar/type-check.ts +278 -0
  62. package/src/prove/isabelle/provers/blast/blast.ts +258 -0
  63. package/src/prove/isabelle/provers/blast/branch.ts +322 -0
  64. package/src/prove/isabelle/provers/blast/prove.ts +347 -0
  65. package/src/prove/isabelle/provers/blast/rules.ts +330 -0
  66. package/src/prove/isabelle/provers/blast/state.ts +180 -0
  67. package/src/prove/isabelle/provers/blast/term.ts +547 -0
  68. package/src/prove/isabelle/provers/clasimp.ts +150 -0
  69. package/src/prove/isabelle/provers/classical.ts +389 -0
  70. package/src/prove/isabelle/provers/hypsubst.ts +441 -0
  71. package/src/prove/isabelle/pure/bicompose.ts +174 -0
  72. package/src/prove/isabelle/pure/consts.ts +32 -0
  73. package/src/prove/isabelle/pure/conv.ts +79 -0
  74. package/src/prove/isabelle/pure/drule.ts +264 -0
  75. package/src/prove/isabelle/pure/envir.ts +363 -0
  76. package/src/prove/isabelle/pure/goal.ts +53 -0
  77. package/src/prove/isabelle/pure/interrupt.ts +16 -0
  78. package/src/prove/isabelle/pure/list.ts +12 -0
  79. package/src/prove/isabelle/pure/logic.ts +402 -0
  80. package/src/prove/isabelle/pure/name.ts +110 -0
  81. package/src/prove/isabelle/pure/net.ts +262 -0
  82. package/src/prove/isabelle/pure/object-logic.ts +41 -0
  83. package/src/prove/isabelle/pure/pattern.ts +650 -0
  84. package/src/prove/isabelle/pure/raw-simplifier.ts +353 -0
  85. package/src/prove/isabelle/pure/rewriter.ts +602 -0
  86. package/src/prove/isabelle/pure/search.ts +68 -0
  87. package/src/prove/isabelle/pure/seq.ts +156 -0
  88. package/src/prove/isabelle/pure/simplifier.ts +112 -0
  89. package/src/prove/isabelle/pure/table.ts +208 -0
  90. package/src/prove/isabelle/pure/tactic.ts +276 -0
  91. package/src/prove/isabelle/pure/tactical.ts +347 -0
  92. package/src/prove/isabelle/pure/term-ord.ts +159 -0
  93. package/src/prove/isabelle/pure/term.ts +808 -0
  94. package/src/prove/isabelle/pure/thm.ts +806 -0
  95. package/src/prove/isabelle/pure/type.ts +133 -0
  96. package/src/prove/isabelle/pure/unify.ts +753 -0
  97. package/src/prove/isabelle/pure/variable.ts +25 -0
  98. package/src/prove/isabelle/tla/classical-setup.ts +101 -0
  99. package/src/prove/isabelle/tla/context.ts +74 -0
  100. package/src/prove/isabelle/tla/logic-data.ts +5 -0
  101. package/src/prove/isabelle/tla/logic.ts +215 -0
  102. package/src/prove/isabelle/tla/simpdata.ts +241 -0
  103. package/src/prove/isabelle/tools/intuitionistic.ts +132 -0
  104. package/src/prove/ocaml.ts +22 -0
  105. package/src/prove/prep/action.ts +521 -0
  106. package/src/prove/prep/defs.ts +33 -0
  107. package/src/prove/prep/elab.ts +156 -0
  108. package/src/prove/prep/enabled-axioms.ts +189 -0
  109. package/src/prove/prep/enabled.ts +43 -0
  110. package/src/prove/prep/fingerprint.ts +388 -0
  111. package/src/prove/prep/flatten.ts +70 -0
  112. package/src/prove/prep/level-comparison.ts +557 -0
  113. package/src/prove/prep/md5.ts +67 -0
  114. package/src/prove/prep/pragma.ts +221 -0
  115. package/src/prove/prep/trivial.ts +22 -0
  116. package/src/prove/prove-worker.ts +25 -0
  117. package/src/prove/prove.ts +505 -0
  118. package/src/prove/ptl/decide.ts +68 -0
  119. package/src/prove/ptl/encode.ts +256 -0
  120. package/src/prove/ptl/sat.ts +151 -0
  121. package/src/prove/ptl/tableau.ts +276 -0
  122. package/src/prove/smt/axiomatize.ts +69 -0
  123. package/src/prove/smt/axioms.ts +222 -0
  124. package/src/prove/smt/context.ts +108 -0
  125. package/src/prove/smt/data.ts +636 -0
  126. package/src/prove/smt/encode.ts +166 -0
  127. package/src/prove/smt/extensionality.ts +65 -0
  128. package/src/prove/smt/flatten.ts +112 -0
  129. package/src/prove/smt/format.ts +154 -0
  130. package/src/prove/smt/instances.ts +182 -0
  131. package/src/prove/smt/rewrite.ts +773 -0
  132. package/src/prove/smt/simplify.ts +57 -0
  133. package/src/prove/smt/solver/act-cache.ts +265 -0
  134. package/src/prove/smt/solver/arith-rewriter.ts +962 -0
  135. package/src/prove/smt/solver/array.ts +22 -0
  136. package/src/prove/smt/solver/asserted-formulas.ts +469 -0
  137. package/src/prove/smt/solver/ast-lt.ts +157 -0
  138. package/src/prove/smt/solver/ast-util.ts +147 -0
  139. package/src/prove/smt/solver/ast.ts +1315 -0
  140. package/src/prove/smt/solver/auf-solver.ts +572 -0
  141. package/src/prove/smt/solver/case-split-queue.ts +178 -0
  142. package/src/prove/smt/solver/cg-table.ts +175 -0
  143. package/src/prove/smt/solver/clause.ts +276 -0
  144. package/src/prove/smt/solver/conflict-resolution.ts +343 -0
  145. package/src/prove/smt/solver/context.ts +1292 -0
  146. package/src/prove/smt/solver/ctx-simplify.ts +334 -0
  147. package/src/prove/smt/solver/der.ts +224 -0
  148. package/src/prove/smt/solver/dyn-ack.ts +141 -0
  149. package/src/prove/smt/solver/e-matching.ts +659 -0
  150. package/src/prove/smt/solver/enode.ts +259 -0
  151. package/src/prove/smt/solver/expr-ref.ts +21 -0
  152. package/src/prove/smt/solver/expr-safe-replace.ts +172 -0
  153. package/src/prove/smt/solver/fingerprints.ts +92 -0
  154. package/src/prove/smt/solver/flat-literals.ts +51 -0
  155. package/src/prove/smt/solver/goal.ts +138 -0
  156. package/src/prove/smt/solver/hash.ts +173 -0
  157. package/src/prove/smt/solver/hashtable.ts +166 -0
  158. package/src/prove/smt/solver/internalizer.ts +1381 -0
  159. package/src/prove/smt/solver/lbool.ts +5 -0
  160. package/src/prove/smt/solver/literal.ts +24 -0
  161. package/src/prove/smt/solver/lp/bound-propagator.ts +391 -0
  162. package/src/prove/smt/solver/lp/constraints.ts +78 -0
  163. package/src/prove/smt/solver/lp/containers.ts +296 -0
  164. package/src/prove/smt/solver/lp/core-solver.ts +504 -0
  165. package/src/prove/smt/solver/lp/cross-nested.ts +224 -0
  166. package/src/prove/smt/solver/lp/dep-intervals.ts +656 -0
  167. package/src/prove/smt/solver/lp/dependency.ts +51 -0
  168. package/src/prove/smt/solver/lp/dioph-eq.ts +1181 -0
  169. package/src/prove/smt/solver/lp/explanation.ts +46 -0
  170. package/src/prove/smt/solver/lp/gomory.ts +255 -0
  171. package/src/prove/smt/solver/lp/hnf-cutter.ts +125 -0
  172. package/src/prove/smt/solver/lp/hnf.ts +281 -0
  173. package/src/prove/smt/solver/lp/int-cube.ts +295 -0
  174. package/src/prove/smt/solver/lp/int-solver.ts +514 -0
  175. package/src/prove/smt/solver/lp/lar-solver.ts +816 -0
  176. package/src/prove/smt/solver/lp/lar-term.ts +62 -0
  177. package/src/prove/smt/solver/lp/lp-settings.ts +91 -0
  178. package/src/prove/smt/solver/lp/maximize-term.ts +347 -0
  179. package/src/prove/smt/solver/lp/nex-creator.ts +381 -0
  180. package/src/prove/smt/solver/lp/nex.ts +120 -0
  181. package/src/prove/smt/solver/lp/nla-backoff.ts +43 -0
  182. package/src/prove/smt/solver/lp/nla-basics.ts +398 -0
  183. package/src/prove/smt/solver/lp/nla-core.ts +968 -0
  184. package/src/prove/smt/solver/lp/nla-divisions.ts +332 -0
  185. package/src/prove/smt/solver/lp/nla-emonics.ts +373 -0
  186. package/src/prove/smt/solver/lp/nla-factorization.ts +30 -0
  187. package/src/prove/smt/solver/lp/nla-grobner.ts +904 -0
  188. package/src/prove/smt/solver/lp/nla-horner.ts +126 -0
  189. package/src/prove/smt/solver/lp/nla-intervals.ts +265 -0
  190. package/src/prove/smt/solver/lp/nla-monomial-bounds.ts +715 -0
  191. package/src/prove/smt/solver/lp/nla-monotone.ts +59 -0
  192. package/src/prove/smt/solver/lp/nla-order.ts +307 -0
  193. package/src/prove/smt/solver/lp/nla-patcher.ts +112 -0
  194. package/src/prove/smt/solver/lp/nla-tangents.ts +251 -0
  195. package/src/prove/smt/solver/lp/nla-throttle.ts +85 -0
  196. package/src/prove/smt/solver/lp/nla-types.ts +124 -0
  197. package/src/prove/smt/solver/lp/nla-var-eqs.ts +141 -0
  198. package/src/prove/smt/solver/lp/nra-solver.ts +440 -0
  199. package/src/prove/smt/solver/lp/numeric-pair.ts +65 -0
  200. package/src/prove/smt/solver/lp/pdd-interval.ts +31 -0
  201. package/src/prove/smt/solver/lp/pdd-simplifier.ts +184 -0
  202. package/src/prove/smt/solver/lp/pdd-solver.ts +408 -0
  203. package/src/prove/smt/solver/lp/pdd.ts +971 -0
  204. package/src/prove/smt/solver/lp/random-updater.ts +138 -0
  205. package/src/prove/smt/solver/lp/static-matrix.ts +246 -0
  206. package/src/prove/smt/solver/lp/union-find.ts +96 -0
  207. package/src/prove/smt/solver/mam-compiler.ts +847 -0
  208. package/src/prove/smt/solver/mam-interpreter.ts +400 -0
  209. package/src/prove/smt/solver/maximize-ac-sharing.ts +118 -0
  210. package/src/prove/smt/solver/model-checker.ts +347 -0
  211. package/src/prove/smt/solver/model-evaluator.ts +262 -0
  212. package/src/prove/smt/solver/model-finder.ts +155 -0
  213. package/src/prove/smt/solver/model-generator.ts +97 -0
  214. package/src/prove/smt/solver/model-macro-solver.ts +728 -0
  215. package/src/prove/smt/solver/nlsat/algebraic.ts +1161 -0
  216. package/src/prove/smt/solver/nlsat/atoms.ts +238 -0
  217. package/src/prove/smt/solver/nlsat/evaluator.ts +303 -0
  218. package/src/prove/smt/solver/nlsat/explain.ts +607 -0
  219. package/src/prove/smt/solver/nlsat/interval-set.ts +351 -0
  220. package/src/prove/smt/solver/nlsat/levelwise.ts +740 -0
  221. package/src/prove/smt/solver/nlsat/mpbq.ts +161 -0
  222. package/src/prove/smt/solver/nlsat/polynomial.ts +1722 -0
  223. package/src/prove/smt/solver/nlsat/solver.ts +911 -0
  224. package/src/prove/smt/solver/nlsat/types.ts +43 -0
  225. package/src/prove/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
  226. package/src/prove/smt/solver/nlsat/upolynomial.ts +996 -0
  227. package/src/prove/smt/solver/nnf.ts +469 -0
  228. package/src/prove/smt/solver/pattern-inference.ts +351 -0
  229. package/src/prove/smt/solver/poly-rewriter.ts +477 -0
  230. package/src/prove/smt/solver/propagate-values.ts +83 -0
  231. package/src/prove/smt/solver/proto-model.ts +551 -0
  232. package/src/prove/smt/solver/pull-quant.ts +139 -0
  233. package/src/prove/smt/solver/qe-lite-der.ts +526 -0
  234. package/src/prove/smt/solver/qe-lite-fm.ts +576 -0
  235. package/src/prove/smt/solver/qe-lite.ts +381 -0
  236. package/src/prove/smt/solver/qi-queue.ts +362 -0
  237. package/src/prove/smt/solver/quant-tactics.ts +117 -0
  238. package/src/prove/smt/solver/quantifier-analyzer.ts +562 -0
  239. package/src/prove/smt/solver/quantifier-manager.ts +186 -0
  240. package/src/prove/smt/solver/random-gen.ts +10 -0
  241. package/src/prove/smt/solver/rational.ts +165 -0
  242. package/src/prove/smt/solver/ref-vector.ts +62 -0
  243. package/src/prove/smt/solver/relevancy.ts +247 -0
  244. package/src/prove/smt/solver/rewriter-tpl.ts +1159 -0
  245. package/src/prove/smt/solver/rewriter.ts +843 -0
  246. package/src/prove/smt/solver/rlimit.ts +79 -0
  247. package/src/prove/smt/solver/smtlib-parser.ts +526 -0
  248. package/src/prove/smt/solver/solver.ts +71 -0
  249. package/src/prove/smt/solver/sort.ts +35 -0
  250. package/src/prove/smt/solver/sticky-generations.ts +69 -0
  251. package/src/prove/smt/solver/theory-lra-axioms.ts +340 -0
  252. package/src/prove/smt/solver/theory-lra-bounds.ts +226 -0
  253. package/src/prove/smt/solver/theory-lra-final-check.ts +252 -0
  254. package/src/prove/smt/solver/theory-lra-internalize.ts +476 -0
  255. package/src/prove/smt/solver/theory-lra-model.ts +243 -0
  256. package/src/prove/smt/solver/theory-lra-propagate.ts +405 -0
  257. package/src/prove/smt/solver/theory-lra-state.ts +43 -0
  258. package/src/prove/smt/solver/theory-lra.ts +56 -0
  259. package/src/prove/smt/solver/var-subst.ts +258 -0
  260. package/src/prove/smt/solver/z3-license.txt +10 -0
  261. package/src/prove/smt/table.ts +170 -0
  262. package/src/prove/tlapm/tlapm.ts +96 -0
  263. package/src/prove/tlaps-module.ts +510 -0
  264. package/src/prove/verdict.ts +18 -0
  265. package/src/prove/zenon/LICENSE +32 -0
  266. package/src/prove/zenon/check/check.ts +105 -0
  267. package/src/prove/zenon/check/definitions.ts +144 -0
  268. package/src/prove/zenon/check/equality.ts +182 -0
  269. package/src/prove/zenon/check/functions.ts +62 -0
  270. package/src/prove/zenon/check/keys.ts +125 -0
  271. package/src/prove/zenon/check/propositional.ts +104 -0
  272. package/src/prove/zenon/check/records.ts +188 -0
  273. package/src/prove/zenon/check/relations.ts +121 -0
  274. package/src/prove/zenon/check/rewrites.ts +224 -0
  275. package/src/prove/zenon/check/sets.ts +302 -0
  276. package/src/prove/zenon/check/terms.ts +127 -0
  277. package/src/prove/zenon/check/tla.ts +126 -0
  278. package/src/prove/zenon/decide.ts +113 -0
  279. package/src/prove/zenon/encode.ts +437 -0
  280. package/src/prove/zenon/eqrel.ts +300 -0
  281. package/src/prove/zenon/equality-rules.ts +435 -0
  282. package/src/prove/zenon/expr.ts +551 -0
  283. package/src/prove/zenon/index-table.ts +350 -0
  284. package/src/prove/zenon/isar-case.ts +513 -0
  285. package/src/prove/zenon/isar.ts +1249 -0
  286. package/src/prove/zenon/limits.ts +15 -0
  287. package/src/prove/zenon/llproof.ts +173 -0
  288. package/src/prove/zenon/mltoll.ts +1566 -0
  289. package/src/prove/zenon/node.ts +297 -0
  290. package/src/prove/zenon/ocaml.ts +169 -0
  291. package/src/prove/zenon/parse.ts +247 -0
  292. package/src/prove/zenon/phrase.ts +191 -0
  293. package/src/prove/zenon/proof.ts +198 -0
  294. package/src/prove/zenon/propositional-rules.ts +387 -0
  295. package/src/prove/zenon/rules.ts +94 -0
  296. package/src/prove/zenon/search.ts +288 -0
  297. package/src/prove/zenon/tla/functions.ts +151 -0
  298. package/src/prove/zenon/tla/llproof.ts +480 -0
  299. package/src/prove/zenon/tla/records.ts +225 -0
  300. package/src/prove/zenon/tla/rewrites.ts +447 -0
  301. package/src/prove/zenon/tla/sets.ts +304 -0
  302. package/src/prove/zenon/tla/terms.ts +181 -0
  303. package/src/prove/zenon/tla/tla.ts +506 -0
  304. package/src/run-cli.ts +334 -75
  305. package/src/standard-modules.ts +5 -2
  306. package/src/successors.ts +24 -5
  307. package/src/tlapm-cache.ts +236 -0
  308. package/src/tlc-random.ts +55 -32
  309. package/src/tlc-version.ts +8 -7
  310. package/src/values.ts +80 -35
  311. package/src/worker.ts +65 -0
  312. package/dist/parallel.cjs +0 -12
  313. package/dist/parallel.js +0 -12
@@ -0,0 +1,480 @@
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
+
6
+ import { TlaZenonError } from "../../../errors";
7
+ import { difference, union, type Expr, type Expressions } from "../expr";
8
+ import { connect, type Lemma, type LlProof, type LlRule } from "../llproof";
9
+ import type { MlProof, Translated } from "../mltoll";
10
+
11
+ // The lemma's name, the terms it's instantiated with, the conclusions it uses and its branches.
12
+ type LlArgs = [string, Expr[], Expr[], Expr[][]];
13
+
14
+ type Shape = (name: string, args: Expr[]) => LlArgs;
15
+
16
+ const getShapeError = (name: string) =>
17
+ new TlaZenonError(`Zenon: the rule ${name} has too few arguments`);
18
+
19
+ const alpha: Shape = (name, args) => {
20
+ const [conclusion, first, second, ...rest] = args;
21
+ if (second === undefined) throw getShapeError(name);
22
+ return [`zenon_${name}`, rest, [conclusion], [[first, second]]];
23
+ };
24
+
25
+ const beta: Shape = (name, args) => {
26
+ const [conclusion, first, second, ...rest] = args;
27
+ if (second === undefined) throw getShapeError(name);
28
+ return [`zenon_${name}`, rest, [conclusion], [[first], [second]]];
29
+ };
30
+
31
+ const beta2: Shape = (name, args) => {
32
+ const [conclusion, firstA, firstB, secondA, secondB, ...rest] = args;
33
+ if (secondB === undefined) throw getShapeError(name);
34
+ return [
35
+ `zenon_${name}`,
36
+ rest,
37
+ [conclusion],
38
+ [
39
+ [firstA, firstB],
40
+ [secondA, secondB],
41
+ ],
42
+ ];
43
+ };
44
+
45
+ const cut12: Shape = (name, args) => {
46
+ const [first, secondA, secondB, ...rest] = args;
47
+ if (secondB === undefined) throw getShapeError(name);
48
+ return [`zenon_${name}`, rest, [], [[first], [secondA, secondB]]];
49
+ };
50
+
51
+ const single: Shape = (name, args) => {
52
+ const [conclusion, hypothesis, ...rest] = args;
53
+ if (hypothesis === undefined) throw getShapeError(name);
54
+ return [`zenon_${name}`, rest, [conclusion], [[hypothesis]]];
55
+ };
56
+
57
+ const close: Shape = (name, args) => {
58
+ const [conclusion, ...rest] = args;
59
+ if (conclusion === undefined) throw getShapeError(name);
60
+ return [`zenon_${name}`, rest, [conclusion], []];
61
+ };
62
+
63
+ const binsingle: Shape = (name, args) => {
64
+ const [first, second, hypothesis, ...rest] = args;
65
+ if (hypothesis === undefined) throw getShapeError(name);
66
+ return [`zenon_${name}`, rest, [first, second], [[hypothesis]]];
67
+ };
68
+
69
+ const binbeta: Shape = (name, args) => {
70
+ const [first, second, hypothesisA, hypothesisB, ...rest] = args;
71
+ if (hypothesisB === undefined) throw getShapeError(name);
72
+ return [`zenon_${name}`, rest, [first, second], [[hypothesisA], [hypothesisB]]];
73
+ };
74
+
75
+ // A conclusion, two terms and then the hypotheses, in one branch or one branch each.
76
+ const withTerms =
77
+ (isSplit: boolean): Shape =>
78
+ (name, args) => {
79
+ const [conclusion, first, second, ...hypotheses] = args;
80
+ if (second === undefined) throw getShapeError(name);
81
+ return [
82
+ `zenon_${name}`,
83
+ [first, second],
84
+ [conclusion],
85
+ isSplit ? hypotheses.map((hypothesis) => [hypothesis]) : [hypotheses],
86
+ ];
87
+ };
88
+
89
+ // A conclusion and then the hypotheses, in one branch or one branch each.
90
+ const withoutTerms =
91
+ (isSplit: boolean): Shape =>
92
+ (name, args) => {
93
+ const [conclusion, ...hypotheses] = args;
94
+ if (conclusion === undefined) throw getShapeError(name);
95
+ return [
96
+ `zenon_${name}`,
97
+ [],
98
+ [conclusion],
99
+ isSplit ? hypotheses.map((hypothesis) => [hypothesis]) : [hypotheses],
100
+ ];
101
+ };
102
+
103
+ const getCaseBranches = (args: Expr[]): Expr[][] =>
104
+ args.length <= 1
105
+ ? args.length === 0
106
+ ? []
107
+ : [args]
108
+ : [args.slice(0, 2), ...getCaseBranches(args.slice(2))];
109
+
110
+ // Zenon's to_llargs, by rule name. The rules missing here take one hypothesis.
111
+ const SHAPES: Record<string, Shape> = {
112
+ in_emptyset: (name, args) => [`zenon_${name}`, args.slice(1), args.slice(0, 1), []],
113
+ in_nat_0: close,
114
+ in_nat_1: close,
115
+ in_nat_2: close,
116
+ in_upair: beta,
117
+ notin_upair: alpha,
118
+ in_cup: beta,
119
+ notin_cup: alpha,
120
+ in_cap: alpha,
121
+ notin_cap: beta,
122
+ in_setminus: alpha,
123
+ notin_setminus: beta,
124
+ in_subsetof: alpha,
125
+ notin_subsetof: beta,
126
+ in_funcset: (name, args) => {
127
+ const [conclusion, first, second, third, ...rest] = args;
128
+ if (third === undefined) throw getShapeError(name);
129
+ return [`zenon_${name}`, rest, [conclusion], [[first, second, third]]];
130
+ },
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
+ },
136
+ notin_funcset: (name, args) => {
137
+ const [conclusion, first, second, third, ...rest] = args;
138
+ if (third === undefined) throw getShapeError(name);
139
+ return [`zenon_${name}`, rest, [conclusion], [[first], [second], [third]]];
140
+ },
141
+ trueistrue: binsingle,
142
+ fapplyfcn: beta,
143
+ fapplyexcept: (name, args) => {
144
+ const [conclusion, firstA, firstB, firstC, secondA, secondB, secondC, third, ...rest] = args;
145
+ if (third === undefined) throw getShapeError(name);
146
+ return [
147
+ `zenon_${name}`,
148
+ rest,
149
+ [conclusion],
150
+ [[firstA, firstB, firstC], [secondA, secondB, secondC], [third]],
151
+ ];
152
+ },
153
+ boolcase_not: beta2,
154
+ boolcase_and: beta2,
155
+ boolcase_or: beta2,
156
+ boolcase_imply: beta2,
157
+ boolcase_equiv: beta2,
158
+ boolcase_equal: beta2,
159
+ boolcase_all: beta2,
160
+ boolcase_ex: beta2,
161
+ notisafcn_fcn: close,
162
+ notisafcn_except: close,
163
+ notisafcn_onearg: close,
164
+ notisafcn_extend: close,
165
+ ifthenelse: beta2,
166
+ notequalchoose: cut12,
167
+ case: (name, args) => {
168
+ const [conclusion, predicate, ...rest] = args;
169
+ if (predicate === undefined) throw getShapeError(name);
170
+ return [`zenon_${name}`, [predicate], [conclusion], getCaseBranches(rest)];
171
+ },
172
+ p_eq_l: binbeta,
173
+ p_eq_r: binbeta,
174
+ np_eq_l: binbeta,
175
+ np_eq_r: binbeta,
176
+ all_in: binsingle,
177
+ notex_in: binsingle,
178
+ cup_subseteq: alpha,
179
+ not_cup_subseteq: beta,
180
+ subseteq_cap: alpha,
181
+ not_subseteq_cap: beta,
182
+ tuple_eq_match: withoutTerms(false),
183
+ tuple_eq_mismatch: close,
184
+ in_product: withTerms(false),
185
+ notin_product: withTerms(true),
186
+ tuple_notisaseq: close,
187
+ record_eq_match: withoutTerms(false),
188
+ record_neq_match: withoutTerms(true),
189
+ record_eq_mismatch: close,
190
+ neq_record: withTerms(true),
191
+ record_neq: withTerms(true),
192
+ in_recordset: withTerms(false),
193
+ notin_recordset: withTerms(true),
194
+ record_notisafcn: close,
195
+ };
196
+
197
+ // Zenon's Ext_tla.to_llproof, for a rule of the extension and its translated subproofs.
198
+ export const getTlaLlProof = (
199
+ translateExpr: (expression: Expr) => Expr,
200
+ exprs: Expressions,
201
+ proof: MlProof,
202
+ subproofs: Translated[],
203
+ ): Translated => {
204
+ const tr = translateExpr;
205
+ const rule = proof.rule;
206
+ const member = (element: Expr, set: Expr) => exprs.eapp("TLA.in", [element, set]);
207
+ const equal = (left: Expr, right: Expr) => exprs.eapp("=", [left, right]);
208
+ const extension = (
209
+ conclusions: Expr[],
210
+ name: string,
211
+ args: Expr[],
212
+ ruleConclusions: Expr[],
213
+ branches: Expr[][],
214
+ nodeSubproofs: LlProof[],
215
+ ): LlProof => ({
216
+ conclusions: conclusions.map(tr),
217
+ rule: {
218
+ kind: "extension",
219
+ name,
220
+ args: args.map(tr),
221
+ conclusions: ruleConclusions.map(tr),
222
+ branches: branches.map((branch) => branch.map(tr)),
223
+ },
224
+ subproofs: nodeSubproofs,
225
+ });
226
+
227
+ // The membership in an enumerated set, one element at a time.
228
+ const getMembership = (
229
+ element: Expr,
230
+ set: Expr,
231
+ remaining: Translated[],
232
+ conclusions: Expr[],
233
+ isSetOf: boolean,
234
+ ): Translated => {
235
+ const isEmpty = isSetOf
236
+ ? set.kind === "app" && set.symbol === "TLA.set" && set.args.length === 0
237
+ : set.kind === "var" && set.symbol === "TLA.emptyset";
238
+ if (isEmpty)
239
+ return [
240
+ extension(conclusions, "zenon_in_emptyset", [element], [member(element, set)], [], []),
241
+ [],
242
+ ];
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;
249
+ const first = remaining[0];
250
+ if (split === undefined || first === undefined) {
251
+ if (!isSetOf && remaining.length === 1) return remaining[0];
252
+ throw new TlaZenonError("Zenon: a membership proof that doesn't match its set");
253
+ }
254
+ const value = split[0];
255
+ const rest = split[1];
256
+ const conclusion = member(element, set);
257
+ const isValue = equal(element, value);
258
+ const isInRest = member(element, rest);
259
+ const next = getMembership(
260
+ element,
261
+ rest,
262
+ remaining.slice(1),
263
+ [isInRest, ...conclusions],
264
+ isSetOf,
265
+ );
266
+ const extras = difference(union(first[1], next[1]), conclusions);
267
+ return [
268
+ extension(
269
+ [...extras.toReversed(), ...conclusions],
270
+ "zenon_in_addElt",
271
+ [element, value, rest],
272
+ [conclusion],
273
+ [[isValue], [isInRest]],
274
+ [first[0], next[0]],
275
+ ),
276
+ extras,
277
+ ];
278
+ };
279
+
280
+ // The non-membership in an enumerated set, one element at a time.
281
+ const getNonMembership = (
282
+ element: Expr,
283
+ set: Expr,
284
+ sub: Translated,
285
+ conclusions: Expr[],
286
+ isSetOf: boolean,
287
+ ): 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;
294
+ if (split === undefined) return sub;
295
+ const value = split[0];
296
+ const rest = split[1];
297
+ const conclusion = exprs.enot(member(element, set));
298
+ const isNotValue = exprs.enot(equal(element, value));
299
+ const isNotInRest = exprs.enot(member(element, rest));
300
+ const next = getNonMembership(
301
+ element,
302
+ rest,
303
+ sub,
304
+ [isNotValue, isNotInRest, ...conclusions],
305
+ isSetOf,
306
+ );
307
+ const extras = difference(next[1], conclusions);
308
+ return [
309
+ extension(
310
+ [...extras.toReversed(), ...conclusions],
311
+ "zenon_notin_addElt",
312
+ [element, value, rest],
313
+ [conclusion],
314
+ [[isNotValue, isNotInRest]],
315
+ [next[0]],
316
+ ),
317
+ extras,
318
+ ];
319
+ };
320
+
321
+ switch (rule.name) {
322
+ case "in_addElt":
323
+ case "in_set":
324
+ return getMembership(
325
+ rule.args[1],
326
+ rule.args[2],
327
+ subproofs,
328
+ proof.conclusions,
329
+ rule.name === "in_set",
330
+ );
331
+ case "notin_addElt":
332
+ case "notin_set": {
333
+ if (subproofs.length !== 1)
334
+ throw new TlaZenonError(`Zenon: ${rule.name} with ${subproofs.length} subproofs`);
335
+ return getNonMembership(
336
+ rule.args[1],
337
+ rule.args[2],
338
+ subproofs[0],
339
+ proof.conclusions,
340
+ rule.name === "notin_set",
341
+ );
342
+ }
343
+ case "notequivdef": {
344
+ if (subproofs.length !== 1)
345
+ throw new TlaZenonError("Zenon: notequivdef with several subproofs");
346
+ return subproofs[0];
347
+ }
348
+ default: {
349
+ const args: Expr[] = rule.args;
350
+ const llArgs = (SHAPES[rule.name] ?? single)(rule.name, args);
351
+ const extras = difference(
352
+ subproofs.reduce((accumulated: Expr[], entry) => union(accumulated, entry[1]), []),
353
+ proof.conclusions,
354
+ );
355
+ return [
356
+ extension(
357
+ [...extras.toReversed(), ...proof.conclusions],
358
+ llArgs[0],
359
+ llArgs[1],
360
+ llArgs[2],
361
+ llArgs[3],
362
+ subproofs.map((entry) => entry[0]),
363
+ ),
364
+ extras,
365
+ ];
366
+ }
367
+ }
368
+ };
369
+
370
+ // Zenon's Ext_tla.postprocess: the lemmas with each $notequiv written as a negated equivalence.
371
+ export const postprocessTla = (exprs: Expressions, lemmas: Lemma[]): Lemma[] => {
372
+ const cache = new Map<Expr, Expr>();
373
+ const pp = (expression: Expr): Expr => {
374
+ const cached = cache.get(expression);
375
+ if (cached !== undefined) return cached;
376
+ const result = ((): Expr => {
377
+ switch (expression.kind) {
378
+ case "var":
379
+ case "true":
380
+ case "false":
381
+ return expression;
382
+ case "meta":
383
+ throw new TlaZenonError("Zenon: a metavariable in a low-level proof");
384
+ case "app": {
385
+ if (expression.symbol !== "$notequiv")
386
+ return exprs.eapp(expression.symbol, expression.args.map(pp));
387
+ if (expression.args.length !== 2)
388
+ 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));
391
+ }
392
+ case "not":
393
+ return exprs.enot(pp(expression.args[0]));
394
+ case "and":
395
+ case "or":
396
+ case "imply":
397
+ case "equiv": {
398
+ const right = pp(expression.args[1]);
399
+ return connect(exprs, expression.kind, pp(expression.args[0]), right);
400
+ }
401
+ case "all":
402
+ return exprs.eall(expression.args[0], expression.symbol, pp(expression.args[1]));
403
+ case "ex":
404
+ return exprs.eex(expression.args[0], expression.symbol, pp(expression.args[1]));
405
+ case "tau":
406
+ return exprs.etau(expression.args[0], expression.symbol, pp(expression.args[1]));
407
+ case "lam":
408
+ return exprs.elam(expression.args[0], expression.symbol, pp(expression.args[1]));
409
+ }
410
+ })();
411
+ cache.set(expression, result);
412
+ return result;
413
+ };
414
+ const ppRule = (rule: LlRule): LlRule => {
415
+ switch (rule.kind) {
416
+ case "false":
417
+ case "nottrue":
418
+ return rule;
419
+ case "axiom":
420
+ case "cut":
421
+ case "notnot":
422
+ return { kind: rule.kind, formula: pp(rule.formula) };
423
+ case "noteq":
424
+ return { kind: "noteq", term: pp(rule.term) };
425
+ case "eqsym":
426
+ case "notequal":
427
+ return { kind: rule.kind, left: pp(rule.left), right: pp(rule.right) };
428
+ case "connect":
429
+ case "notconnect":
430
+ return {
431
+ kind: rule.kind,
432
+ connective: rule.connective,
433
+ left: pp(rule.left),
434
+ right: pp(rule.right),
435
+ };
436
+ case "ex":
437
+ case "all":
438
+ case "notex":
439
+ case "notall":
440
+ return { kind: rule.kind, quantified: pp(rule.quantified), term: pp(rule.term) };
441
+ case "pnotp":
442
+ return { kind: "pnotp", positive: pp(rule.positive), negative: pp(rule.negative) };
443
+ case "congruencelr":
444
+ case "congruencerl":
445
+ return {
446
+ kind: rule.kind,
447
+ context: pp(rule.context),
448
+ left: pp(rule.left),
449
+ right: pp(rule.right),
450
+ };
451
+ case "definition":
452
+ return {
453
+ kind: "definition",
454
+ name: rule.name,
455
+ folded: pp(rule.folded),
456
+ unfolded: pp(rule.unfolded),
457
+ };
458
+ case "extension":
459
+ return {
460
+ kind: "extension",
461
+ name: rule.name,
462
+ args: rule.args.map(pp),
463
+ conclusions: rule.conclusions.map(pp),
464
+ branches: rule.branches.map((branch) => branch.map(pp)),
465
+ };
466
+ case "lemma":
467
+ return { kind: "lemma", name: rule.name, args: rule.args.map(pp) };
468
+ }
469
+ };
470
+ const ppTree = (tree: LlProof): LlProof => ({
471
+ conclusions: tree.conclusions.map(pp),
472
+ rule: ppRule(tree.rule),
473
+ subproofs: tree.subproofs.map(ppTree),
474
+ });
475
+ return lemmas.map((lemma) => ({
476
+ name: lemma.name,
477
+ params: lemma.params.map((param): [string, Expr] => [param[0], pp(param[1])]),
478
+ proof: ppTree(lemma.proof),
479
+ }));
480
+ };
@@ -0,0 +1,225 @@
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
+
5
+ import { compareExprs, isApp, type Expr } from "../expr";
6
+ import { stableSort } from "../ocaml";
7
+ import type { Priority } from "../node";
8
+ import { makeRule, type Rule } from "../proof";
9
+ import {
10
+ domain,
11
+ equal,
12
+ fapply,
13
+ getBranches,
14
+ getPairs,
15
+ isTriviallyNotIn,
16
+ makeExtensionNode,
17
+ makeNatural,
18
+ member,
19
+ type Item,
20
+ type Literal,
21
+ } from "./terms";
22
+
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
+ const hasDistinctLabels = (pairs: [Expr, Expr][]) => {
30
+ for (let index = 0; index + 1 < pairs.length; index++) {
31
+ const left = pairs[index][0];
32
+ const right = pairs[index + 1][0];
33
+ const leftName = getStringName(left);
34
+ if (leftName !== undefined && leftName === getStringName(right)) return false;
35
+ if (left === right) return false;
36
+ }
37
+ return true;
38
+ };
39
+
40
+ const sortPairs = (pairs: [Expr, Expr][]) =>
41
+ stableSort(pairs, (left, right) => compareExprs(left[0], right[0]));
42
+
43
+ const getSortedLabels = (args: Expr[]) => {
44
+ const sorted = stableSort(
45
+ getPairs(args).map((pair) => pair[0]),
46
+ compareExprs,
47
+ );
48
+ return sorted.filter(
49
+ (label, index) => index === 0 || compareExprs(sorted[index - 1], label) !== 0,
50
+ );
51
+ };
52
+
53
+ export const getTupleNodes = (literal: Literal): Item[] | undefined => {
54
+ const exprs = literal.context.exprs;
55
+ const formula = literal.formula;
56
+ const isNegated = literal.isNegated;
57
+ const atom = literal.atom;
58
+ const relation = literal.relation;
59
+ const node = (priority: Priority, rule: Rule, branches: Expr[][]) =>
60
+ makeExtensionNode(literal, priority, rule, branches);
61
+ if (isNegated && isApp(atom, "TLA.isASeq", 1) && isApp(atom.args[0], "TLA.tuple"))
62
+ return node("prop", makeRule("tuple_notisaseq", [formula]), []);
63
+ if (relation === undefined) return undefined;
64
+ const left = relation.args[0];
65
+ const right = relation.args[1];
66
+ const isEquality = relation.symbol === "=";
67
+ const isMembership = relation.symbol === "TLA.in";
68
+ if (!isNegated && isEquality && isApp(left, "TLA.tuple") && isApp(right, "TLA.tuple")) {
69
+ if (left.args.length !== right.args.length)
70
+ return node("prop", makeRule("tuple_eq_mismatch", [formula, formula]), []);
71
+ const equalities = left.args.map((inner, position) =>
72
+ equal(exprs, inner, right.args[position]),
73
+ );
74
+ return node("prop", makeRule("tuple_eq_match", [formula, ...equalities]), [equalities]);
75
+ }
76
+ if (isMembership && isApp(right, "TLA.Product", 1) && isApp(right.args[0], "TLA.tuple")) {
77
+ const element = left;
78
+ const tuple = right.args[0];
79
+ if (!isNegated) {
80
+ const components = tuple.args.map((inner, position) =>
81
+ member(exprs, fapply(exprs, element, makeNatural(exprs, position + 1)), inner),
82
+ );
83
+ const isSequence = exprs.eapp("TLA.isASeq", [element]);
84
+ const hasLength = equal(
85
+ exprs,
86
+ exprs.eapp("TLA.Len", [element]),
87
+ makeNatural(exprs, tuple.args.length),
88
+ );
89
+ return node(
90
+ "prop",
91
+ makeRule("in_product", [formula, element, tuple, isSequence, hasLength, ...components]),
92
+ [[isSequence, hasLength, ...components]],
93
+ );
94
+ }
95
+ if (
96
+ isApp(element, "TLA.tuple") &&
97
+ (element.args.length !== tuple.args.length ||
98
+ element.args.some((inner, position) => isTriviallyNotIn(inner, tuple.args[position])))
99
+ )
100
+ return [];
101
+ const components = tuple.args.map((inner, position) =>
102
+ exprs.enot(member(exprs, fapply(exprs, element, makeNatural(exprs, position + 1)), inner)),
103
+ );
104
+ const formulas = [
105
+ exprs.enot(exprs.eapp("TLA.isASeq", [element])),
106
+ exprs.enot(
107
+ equal(exprs, exprs.eapp("TLA.Len", [element]), makeNatural(exprs, tuple.args.length)),
108
+ ),
109
+ ...components,
110
+ ];
111
+ return node(
112
+ "prop",
113
+ makeRule("notin_product", [formula, element, tuple, ...formulas]),
114
+ getBranches(formulas),
115
+ );
116
+ }
117
+ return undefined;
118
+ };
119
+
120
+ export const getRecordNodes = (literal: Literal): Item[] | undefined => {
121
+ const exprs = literal.context.exprs;
122
+ const formula = literal.formula;
123
+ const isNegated = literal.isNegated;
124
+ const atom = literal.atom;
125
+ const relation = literal.relation;
126
+ const node = (priority: Priority, rule: Rule, branches: Expr[][]) =>
127
+ makeExtensionNode(literal, priority, rule, branches);
128
+ if (isNegated && isApp(atom, "TLA.isAFcn", 1) && isApp(atom.args[0], "TLA.record"))
129
+ return node("prop", makeRule("record_notisafcn", [formula]), []);
130
+ if (relation === undefined) return undefined;
131
+ const left = relation.args[0];
132
+ const right = relation.args[1];
133
+ const isEquality = relation.symbol === "=";
134
+ const isMembership = relation.symbol === "TLA.in";
135
+ if (isEquality && isApp(left, "TLA.record") && isApp(right, "TLA.record")) {
136
+ const leftFields = sortPairs(getPairs(left.args));
137
+ const rightFields = sortPairs(getPairs(right.args));
138
+ if (!hasDistinctLabels(leftFields) || !hasDistinctLabels(rightFields)) return [];
139
+ const isMatch =
140
+ leftFields.length === rightFields.length &&
141
+ leftFields.every((field, position) => field[0] === rightFields[position][0]);
142
+ if (!isMatch)
143
+ return isNegated ? [] : node("prop", makeRule("record_eq_mismatch", [formula, formula]), []);
144
+ const equalities = leftFields.map((field, position) =>
145
+ equal(exprs, field[1], rightFields[position][1]),
146
+ );
147
+ if (!isNegated)
148
+ return node("prop", makeRule("record_eq_match", [formula, ...equalities]), [equalities]);
149
+ const inequalities = equalities.map((inner) => exprs.enot(inner));
150
+ return node(
151
+ "prop",
152
+ makeRule("record_neq_match", [formula, ...inequalities]),
153
+ getBranches(inequalities),
154
+ );
155
+ }
156
+ if (isNegated && isEquality && (isApp(right, "TLA.record") || isApp(left, "TLA.record"))) {
157
+ const record = isApp(right, "TLA.record") ? right : left;
158
+ const other = isApp(right, "TLA.record") ? left : right;
159
+ const pairs = getPairs(record.args);
160
+ const formulas = [
161
+ exprs.enot(exprs.eapp("TLA.isAFcn", [other])),
162
+ exprs.enot(
163
+ equal(
164
+ exprs,
165
+ domain(exprs, other),
166
+ exprs.eapp(
167
+ "TLA.set",
168
+ pairs.map((pair) => pair[0]),
169
+ ),
170
+ ),
171
+ ),
172
+ ...pairs.map((pair) => exprs.enot(equal(exprs, fapply(exprs, other, pair[0]), pair[1]))),
173
+ ];
174
+ return node(
175
+ "prop",
176
+ makeRule(record === right ? "neq_record" : "record_neq", [
177
+ formula,
178
+ other,
179
+ record,
180
+ ...formulas,
181
+ ]),
182
+ getBranches(formulas),
183
+ );
184
+ }
185
+ if (isMembership && isApp(right, "TLA.recordset")) {
186
+ const pairs = getPairs(right.args);
187
+ const labels = exprs.eapp(
188
+ "TLA.set",
189
+ pairs.map((pair) => pair[0]),
190
+ );
191
+ if (!isNegated) {
192
+ const formulas = [
193
+ exprs.eapp("TLA.isAFcn", [left]),
194
+ equal(exprs, domain(exprs, left), labels),
195
+ ...pairs.map((pair) => member(exprs, fapply(exprs, left, pair[0]), pair[1])),
196
+ ];
197
+ return node("prop", makeRule("in_recordset", [formula, left, right, ...formulas]), [
198
+ formulas,
199
+ ]);
200
+ }
201
+ if (isApp(left, "TLA.record")) {
202
+ const leftLabels = getSortedLabels(left.args);
203
+ const rightLabels = getSortedLabels(right.args);
204
+ const isSameLabels =
205
+ leftLabels.length === rightLabels.length &&
206
+ leftLabels.every((label, position) => label === rightLabels[position]);
207
+ const isFieldNotIn = getPairs(left.args).some((field) => {
208
+ const type = pairs.find((pair) => pair[0] === field[0]);
209
+ return type === undefined || isTriviallyNotIn(field[1], type[1]);
210
+ });
211
+ if (!isSameLabels || isFieldNotIn) return [];
212
+ }
213
+ const formulas = [
214
+ exprs.enot(exprs.eapp("TLA.isAFcn", [left])),
215
+ exprs.enot(equal(exprs, domain(exprs, left), labels)),
216
+ ...pairs.map((pair) => exprs.enot(member(exprs, fapply(exprs, left, pair[0]), pair[1]))),
217
+ ];
218
+ return node(
219
+ "prop",
220
+ makeRule("notin_recordset", [formula, left, right, ...formulas]),
221
+ getBranches(formulas),
222
+ );
223
+ }
224
+ return undefined;
225
+ };