tla-ts 0.0.4-dev.6dec595 → 0.0.4-dev.7714e32

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 (378) hide show
  1. package/README.md +37 -126
  2. package/dist/cli.cjs +1 -1
  3. package/dist/cli.js +1 -1
  4. package/dist/deciders.cjs +366 -0
  5. package/dist/deciders.js +366 -0
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +44 -12
  8. package/dist/index.d.ts +44 -12
  9. package/dist/index.js +1 -1
  10. package/dist/parallel-worker.cjs +1 -4
  11. package/dist/parallel-worker.js +1 -4
  12. package/dist/prove-worker.cjs +9 -0
  13. package/dist/prove-worker.d.cts +9 -0
  14. package/dist/prove-worker.d.ts +9 -0
  15. package/dist/prove-worker.js +9 -0
  16. package/dist/prove.cjs +1006 -0
  17. package/dist/prove.js +1006 -0
  18. package/dist/run.cjs +45 -0
  19. package/dist/run.js +45 -0
  20. package/dist/tlapm.cjs +10 -0
  21. package/dist/tlapm.js +10 -0
  22. package/dist/transfer.cjs +76 -92
  23. package/dist/transfer.js +76 -92
  24. package/dist/worker.cjs +21 -0
  25. package/dist/worker.js +21 -0
  26. package/package.json +21 -12
  27. package/src/ast.ts +2 -2
  28. package/src/bags.ts +22 -23
  29. package/src/builtins.ts +16 -8
  30. package/src/check.ts +131 -1154
  31. package/src/{cli-options.ts → cli/options.ts} +54 -9
  32. package/src/cli/run.ts +63 -0
  33. package/src/cli/shared.ts +106 -0
  34. package/src/cli/tlapm.ts +374 -0
  35. package/src/{run-cli.ts → cli/tlc.ts} +112 -718
  36. package/src/cli/xml-exporter.ts +221 -0
  37. package/src/cli.ts +1 -1
  38. package/src/codegen.ts +17 -15
  39. package/src/config.ts +5 -5
  40. package/src/dependencies.ts +4 -6
  41. package/src/environment.ts +55 -60
  42. package/src/errors.ts +97 -35
  43. package/src/evaluate.ts +109 -108
  44. package/src/exit-codes.ts +1 -1
  45. package/src/fingerprints.ts +3 -3
  46. package/src/index.ts +10 -0
  47. package/src/instances.ts +56 -46
  48. package/src/java-overrides.ts +79 -41
  49. package/src/json.ts +31 -36
  50. package/src/levels.ts +10 -13
  51. package/src/{live-check.ts → liveness-checker.ts} +169 -142
  52. package/src/liveness.ts +38 -34
  53. package/src/{obligation-action.ts → obligations/action.ts} +248 -74
  54. package/src/{obligation-anon.ts → obligations/anonymize.ts} +55 -57
  55. package/src/obligations/equality.ts +260 -0
  56. package/src/obligations/expression.ts +618 -0
  57. package/src/{obligation-format.ts → obligations/format.ts} +7 -8
  58. package/src/obligations/generate.ts +457 -0
  59. package/src/{obligations.ts → obligations/index.ts} +46 -32
  60. package/src/{obligation-levels.ts → obligations/levels.ts} +44 -40
  61. package/src/obligations/module.ts +445 -0
  62. package/src/obligations/normalize.ts +554 -0
  63. package/src/obligations/operators.ts +176 -0
  64. package/src/obligations/pragma.ts +195 -0
  65. package/src/{obligation-printer.ts → obligations/printer.ts} +65 -230
  66. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
  67. package/src/obligations/regroup.ts +100 -0
  68. package/src/{obligation-generate.ts → obligations/simplify.ts} +130 -536
  69. package/src/{obligation-source.ts → obligations/source.ts} +172 -216
  70. package/src/{obligation-deref.ts → obligations/subexpression.ts} +84 -115
  71. package/src/obligations/substitution.ts +261 -0
  72. package/src/obligations/temporal.ts +321 -0
  73. package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
  74. package/src/parallel-worker.ts +39 -51
  75. package/src/parallel.ts +39 -66
  76. package/src/parser.ts +67 -74
  77. package/src/{pcal-ast.ts → pcal/ast.ts} +2 -17
  78. package/src/{pcal-parse.ts → pcal/parse.ts} +28 -64
  79. package/src/{pcal-tokenize.ts → pcal/tokenize.ts} +10 -39
  80. package/src/{pcal-translate.ts → pcal/translate.ts} +30 -109
  81. package/src/{pcal-validate.ts → pcal/validate.ts} +10 -20
  82. package/src/prover/decide-pool.ts +95 -0
  83. package/src/prover/deciders.ts +33 -0
  84. package/src/prover/first-order.ts +175 -0
  85. package/src/prover/isabelle/LICENSE +36 -0
  86. package/src/prover/isabelle/LICENSE-tlapm +26 -0
  87. package/src/prover/isabelle/decide.ts +44 -0
  88. package/src/prover/isabelle/encode.ts +445 -0
  89. package/src/prover/isabelle/isar/inner-syntax.ts +579 -0
  90. package/src/prover/isabelle/isar/method.ts +367 -0
  91. package/src/prover/isabelle/isar/proof.ts +28 -0
  92. package/src/prover/isabelle/isar/statement.ts +57 -0
  93. package/src/prover/isabelle/isar/theory.ts +192 -0
  94. package/src/prover/isabelle/isar/type-check.ts +278 -0
  95. package/src/prover/isabelle/provers/blast/blast.ts +258 -0
  96. package/src/prover/isabelle/provers/blast/branch.ts +322 -0
  97. package/src/prover/isabelle/provers/blast/prove.ts +347 -0
  98. package/src/prover/isabelle/provers/blast/rules.ts +330 -0
  99. package/src/prover/isabelle/provers/blast/state.ts +180 -0
  100. package/src/prover/isabelle/provers/blast/term.ts +546 -0
  101. package/src/prover/isabelle/provers/clasimp.ts +150 -0
  102. package/src/prover/isabelle/provers/classical.ts +389 -0
  103. package/src/prover/isabelle/provers/hypsubst.ts +433 -0
  104. package/src/prover/isabelle/pure/bicompose.ts +174 -0
  105. package/src/prover/isabelle/pure/consts.ts +32 -0
  106. package/src/prover/isabelle/pure/conv.ts +79 -0
  107. package/src/prover/isabelle/pure/drule.ts +264 -0
  108. package/src/prover/isabelle/pure/envir.ts +331 -0
  109. package/src/prover/isabelle/pure/goal.ts +53 -0
  110. package/src/prover/isabelle/pure/interrupt.ts +16 -0
  111. package/src/prover/isabelle/pure/list.ts +12 -0
  112. package/src/prover/isabelle/pure/logic.ts +330 -0
  113. package/src/prover/isabelle/pure/name.ts +98 -0
  114. package/src/prover/isabelle/pure/net.ts +215 -0
  115. package/src/prover/isabelle/pure/object-logic.ts +41 -0
  116. package/src/prover/isabelle/pure/pattern.ts +631 -0
  117. package/src/prover/isabelle/pure/raw-simplifier.ts +338 -0
  118. package/src/prover/isabelle/pure/rewriter.ts +602 -0
  119. package/src/prover/isabelle/pure/search.ts +68 -0
  120. package/src/prover/isabelle/pure/seq.ts +133 -0
  121. package/src/prover/isabelle/pure/simplifier.ts +106 -0
  122. package/src/prover/isabelle/pure/table.ts +201 -0
  123. package/src/prover/isabelle/pure/tactic.ts +168 -0
  124. package/src/prover/isabelle/pure/tactical.ts +264 -0
  125. package/src/prover/isabelle/pure/term-ord.ts +105 -0
  126. package/src/prover/isabelle/pure/term.ts +688 -0
  127. package/src/prover/isabelle/pure/thm.ts +783 -0
  128. package/src/prover/isabelle/pure/type.ts +121 -0
  129. package/src/prover/isabelle/pure/unify.ts +753 -0
  130. package/src/prover/isabelle/pure/variable.ts +25 -0
  131. package/src/prover/isabelle/tla/classical-setup.ts +101 -0
  132. package/src/prover/isabelle/tla/context.ts +74 -0
  133. package/src/prover/isabelle/tla/logic-data.ts +5 -0
  134. package/src/prover/isabelle/tla/logic.ts +215 -0
  135. package/src/prover/isabelle/tla/simpdata.ts +241 -0
  136. package/src/prover/isabelle/tools/intuitionistic.ts +132 -0
  137. package/src/prover/ocaml.ts +22 -0
  138. package/src/prover/prep/action.ts +508 -0
  139. package/src/prover/prep/enabled-axioms.ts +189 -0
  140. package/src/prover/prep/fingerprint.ts +388 -0
  141. package/src/prover/prep/level-comparison.ts +529 -0
  142. package/src/prover/prep/md5.ts +60 -0
  143. package/src/prover/prep/methods.ts +221 -0
  144. package/src/prover/prep/normalize.ts +309 -0
  145. package/src/prover/prove-worker.ts +22 -0
  146. package/src/prover/prove.ts +492 -0
  147. package/src/prover/ptl/decide.ts +68 -0
  148. package/src/prover/ptl/encode.ts +244 -0
  149. package/src/prover/ptl/sat.ts +151 -0
  150. package/src/prover/ptl/tableau.ts +276 -0
  151. package/src/prover/smt/axioms.ts +209 -0
  152. package/src/prover/smt/context.ts +108 -0
  153. package/src/prover/smt/data.ts +636 -0
  154. package/src/prover/smt/encode.ts +275 -0
  155. package/src/prover/smt/extensionality.ts +65 -0
  156. package/src/prover/smt/flatten.ts +112 -0
  157. package/src/prover/smt/format.ts +154 -0
  158. package/src/prover/smt/instances.ts +181 -0
  159. package/src/prover/smt/rewrite.ts +766 -0
  160. package/src/prover/smt/solver/act-cache.ts +265 -0
  161. package/src/prover/smt/solver/arith-rewriter.ts +962 -0
  162. package/src/prover/smt/solver/array.ts +22 -0
  163. package/src/prover/smt/solver/asserted-formulas.ts +469 -0
  164. package/src/prover/smt/solver/ast-lt.ts +157 -0
  165. package/src/prover/smt/solver/ast-util.ts +91 -0
  166. package/src/prover/smt/solver/ast.ts +1315 -0
  167. package/src/prover/smt/solver/auf-solver.ts +572 -0
  168. package/src/prover/smt/solver/case-split-queue.ts +178 -0
  169. package/src/prover/smt/solver/cg-table.ts +175 -0
  170. package/src/prover/smt/solver/clause.ts +276 -0
  171. package/src/prover/smt/solver/conflict-resolution.ts +343 -0
  172. package/src/prover/smt/solver/context.ts +1292 -0
  173. package/src/prover/smt/solver/ctx-simplify.ts +334 -0
  174. package/src/prover/smt/solver/der.ts +224 -0
  175. package/src/prover/smt/solver/dyn-ack.ts +141 -0
  176. package/src/prover/smt/solver/e-matching.ts +659 -0
  177. package/src/prover/smt/solver/enode.ts +259 -0
  178. package/src/prover/smt/solver/expr-ref.ts +21 -0
  179. package/src/prover/smt/solver/expr-safe-replace.ts +172 -0
  180. package/src/prover/smt/solver/fingerprints.ts +92 -0
  181. package/src/prover/smt/solver/flat-literals.ts +51 -0
  182. package/src/prover/smt/solver/goal.ts +138 -0
  183. package/src/prover/smt/solver/hash.ts +173 -0
  184. package/src/prover/smt/solver/hashtable.ts +166 -0
  185. package/src/prover/smt/solver/internalizer.ts +1381 -0
  186. package/src/prover/smt/solver/lbool.ts +5 -0
  187. package/src/prover/smt/solver/literal.ts +24 -0
  188. package/src/prover/smt/solver/lp/bound-propagator.ts +391 -0
  189. package/src/prover/smt/solver/lp/constraints.ts +78 -0
  190. package/src/prover/smt/solver/lp/containers.ts +296 -0
  191. package/src/prover/smt/solver/lp/core-solver.ts +504 -0
  192. package/src/prover/smt/solver/lp/cross-nested.ts +224 -0
  193. package/src/prover/smt/solver/lp/dep-intervals.ts +642 -0
  194. package/src/prover/smt/solver/lp/dependency.ts +51 -0
  195. package/src/prover/smt/solver/lp/dioph-eq.ts +1181 -0
  196. package/src/prover/smt/solver/lp/explanation.ts +46 -0
  197. package/src/prover/smt/solver/lp/gomory.ts +255 -0
  198. package/src/prover/smt/solver/lp/hnf-cutter.ts +125 -0
  199. package/src/prover/smt/solver/lp/hnf.ts +281 -0
  200. package/src/prover/smt/solver/lp/int-cube.ts +295 -0
  201. package/src/prover/smt/solver/lp/int-solver.ts +514 -0
  202. package/src/prover/smt/solver/lp/lar-solver.ts +816 -0
  203. package/src/prover/smt/solver/lp/lar-term.ts +62 -0
  204. package/src/prover/smt/solver/lp/lp-settings.ts +91 -0
  205. package/src/prover/smt/solver/lp/maximize-term.ts +347 -0
  206. package/src/prover/smt/solver/lp/nex-creator.ts +381 -0
  207. package/src/prover/smt/solver/lp/nex.ts +120 -0
  208. package/src/prover/smt/solver/lp/nla-backoff.ts +43 -0
  209. package/src/prover/smt/solver/lp/nla-basics.ts +398 -0
  210. package/src/prover/smt/solver/lp/nla-core.ts +968 -0
  211. package/src/prover/smt/solver/lp/nla-divisions.ts +332 -0
  212. package/src/prover/smt/solver/lp/nla-emonics.ts +373 -0
  213. package/src/prover/smt/solver/lp/nla-factorization.ts +30 -0
  214. package/src/prover/smt/solver/lp/nla-grobner.ts +904 -0
  215. package/src/prover/smt/solver/lp/nla-horner.ts +126 -0
  216. package/src/prover/smt/solver/lp/nla-intervals.ts +265 -0
  217. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +715 -0
  218. package/src/prover/smt/solver/lp/nla-monotone.ts +59 -0
  219. package/src/prover/smt/solver/lp/nla-order.ts +307 -0
  220. package/src/prover/smt/solver/lp/nla-patcher.ts +112 -0
  221. package/src/prover/smt/solver/lp/nla-tangents.ts +251 -0
  222. package/src/prover/smt/solver/lp/nla-throttle.ts +85 -0
  223. package/src/prover/smt/solver/lp/nla-types.ts +124 -0
  224. package/src/prover/smt/solver/lp/nla-var-eqs.ts +141 -0
  225. package/src/prover/smt/solver/lp/nra-solver.ts +440 -0
  226. package/src/prover/smt/solver/lp/numeric-pair.ts +65 -0
  227. package/src/prover/smt/solver/lp/pdd-interval.ts +31 -0
  228. package/src/prover/smt/solver/lp/pdd-simplifier.ts +184 -0
  229. package/src/prover/smt/solver/lp/pdd-solver.ts +408 -0
  230. package/src/prover/smt/solver/lp/pdd.ts +971 -0
  231. package/src/prover/smt/solver/lp/random-updater.ts +138 -0
  232. package/src/prover/smt/solver/lp/static-matrix.ts +246 -0
  233. package/src/prover/smt/solver/lp/union-find.ts +96 -0
  234. package/src/prover/smt/solver/mam-compiler.ts +847 -0
  235. package/src/prover/smt/solver/mam-interpreter.ts +400 -0
  236. package/src/prover/smt/solver/maximize-ac-sharing.ts +118 -0
  237. package/src/prover/smt/solver/model-checker.ts +347 -0
  238. package/src/prover/smt/solver/model-evaluator.ts +262 -0
  239. package/src/prover/smt/solver/model-finder.ts +155 -0
  240. package/src/prover/smt/solver/model-generator.ts +97 -0
  241. package/src/prover/smt/solver/model-macro-solver.ts +728 -0
  242. package/src/prover/smt/solver/nlsat/algebraic.ts +1161 -0
  243. package/src/prover/smt/solver/nlsat/atoms.ts +238 -0
  244. package/src/prover/smt/solver/nlsat/evaluator.ts +303 -0
  245. package/src/prover/smt/solver/nlsat/explain.ts +607 -0
  246. package/src/prover/smt/solver/nlsat/interval-set.ts +351 -0
  247. package/src/prover/smt/solver/nlsat/levelwise.ts +737 -0
  248. package/src/prover/smt/solver/nlsat/mpbq.ts +161 -0
  249. package/src/prover/smt/solver/nlsat/polynomial.ts +1722 -0
  250. package/src/prover/smt/solver/nlsat/solver.ts +911 -0
  251. package/src/prover/smt/solver/nlsat/types.ts +43 -0
  252. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
  253. package/src/prover/smt/solver/nlsat/upolynomial.ts +996 -0
  254. package/src/prover/smt/solver/nnf.ts +469 -0
  255. package/src/prover/smt/solver/pattern-inference.ts +351 -0
  256. package/src/prover/smt/solver/poly-rewriter.ts +477 -0
  257. package/src/prover/smt/solver/propagate-values.ts +83 -0
  258. package/src/prover/smt/solver/proto-model.ts +551 -0
  259. package/src/prover/smt/solver/pull-quant.ts +139 -0
  260. package/src/prover/smt/solver/qe-lite-der.ts +526 -0
  261. package/src/prover/smt/solver/qe-lite-fm.ts +576 -0
  262. package/src/prover/smt/solver/qe-lite.ts +381 -0
  263. package/src/prover/smt/solver/qi-queue.ts +362 -0
  264. package/src/prover/smt/solver/quant-tactics.ts +117 -0
  265. package/src/prover/smt/solver/quantifier-analyzer.ts +562 -0
  266. package/src/prover/smt/solver/quantifier-manager.ts +186 -0
  267. package/src/prover/smt/solver/random-gen.ts +10 -0
  268. package/src/prover/smt/solver/rational.ts +165 -0
  269. package/src/prover/smt/solver/ref-vector.ts +62 -0
  270. package/src/prover/smt/solver/relevancy.ts +247 -0
  271. package/src/prover/smt/solver/rewriter-tpl.ts +1159 -0
  272. package/src/prover/smt/solver/rewriter.ts +843 -0
  273. package/src/prover/smt/solver/rlimit.ts +79 -0
  274. package/src/prover/smt/solver/smtlib-parser.ts +526 -0
  275. package/src/prover/smt/solver/solver.ts +71 -0
  276. package/src/prover/smt/solver/sort.ts +35 -0
  277. package/src/prover/smt/solver/sticky-generations.ts +69 -0
  278. package/src/prover/smt/solver/theory-lra-axioms.ts +340 -0
  279. package/src/prover/smt/solver/theory-lra-bounds.ts +226 -0
  280. package/src/prover/smt/solver/theory-lra-final-check.ts +252 -0
  281. package/src/prover/smt/solver/theory-lra-internalize.ts +476 -0
  282. package/src/prover/smt/solver/theory-lra-model.ts +243 -0
  283. package/src/prover/smt/solver/theory-lra-propagate.ts +405 -0
  284. package/src/prover/smt/solver/theory-lra-state.ts +43 -0
  285. package/src/prover/smt/solver/theory-lra.ts +56 -0
  286. package/src/prover/smt/solver/var-subst.ts +258 -0
  287. package/src/prover/smt/solver/z3-license.txt +10 -0
  288. package/src/prover/smt/table.ts +170 -0
  289. package/src/prover/tlapm/cache.ts +236 -0
  290. package/src/prover/tlapm/ocaml-marshal.ts +166 -0
  291. package/src/prover/tlapm/tlapm.ts +96 -0
  292. package/src/prover/tlaps-module.ts +510 -0
  293. package/src/prover/verdict.ts +13 -0
  294. package/src/prover/zenon/LICENSE +32 -0
  295. package/src/prover/zenon/check/check.ts +105 -0
  296. package/src/prover/zenon/check/definitions.ts +144 -0
  297. package/src/prover/zenon/check/equality.ts +182 -0
  298. package/src/prover/zenon/check/functions.ts +62 -0
  299. package/src/prover/zenon/check/keys.ts +125 -0
  300. package/src/prover/zenon/check/propositional.ts +104 -0
  301. package/src/prover/zenon/check/records.ts +188 -0
  302. package/src/prover/zenon/check/relations.ts +121 -0
  303. package/src/prover/zenon/check/rewrites.ts +224 -0
  304. package/src/prover/zenon/check/sets.ts +302 -0
  305. package/src/prover/zenon/check/terms.ts +127 -0
  306. package/src/prover/zenon/check/tla.ts +126 -0
  307. package/src/prover/zenon/decide.ts +107 -0
  308. package/src/prover/zenon/encode.ts +378 -0
  309. package/src/prover/zenon/eqrel.ts +300 -0
  310. package/src/prover/zenon/equality-rules.ts +435 -0
  311. package/src/prover/zenon/expr.ts +551 -0
  312. package/src/prover/zenon/index-table.ts +350 -0
  313. package/src/prover/zenon/isar-case.ts +513 -0
  314. package/src/prover/zenon/isar.ts +1249 -0
  315. package/src/prover/zenon/limits.ts +15 -0
  316. package/src/prover/zenon/llproof.ts +173 -0
  317. package/src/prover/zenon/mltoll.ts +1566 -0
  318. package/src/prover/zenon/node.ts +297 -0
  319. package/src/prover/zenon/ocaml.ts +169 -0
  320. package/src/prover/zenon/parse.ts +247 -0
  321. package/src/prover/zenon/phrase.ts +191 -0
  322. package/src/prover/zenon/proof.ts +198 -0
  323. package/src/prover/zenon/propositional-rules.ts +387 -0
  324. package/src/prover/zenon/rules.ts +94 -0
  325. package/src/prover/zenon/search.ts +288 -0
  326. package/src/prover/zenon/tla/functions.ts +151 -0
  327. package/src/prover/zenon/tla/llproof.ts +480 -0
  328. package/src/prover/zenon/tla/records.ts +225 -0
  329. package/src/prover/zenon/tla/rewrites.ts +447 -0
  330. package/src/prover/zenon/tla/sets.ts +304 -0
  331. package/src/prover/zenon/tla/terms.ts +162 -0
  332. package/src/prover/zenon/tla/tla.ts +506 -0
  333. package/src/randomization.ts +19 -24
  334. package/src/resolve.ts +15 -22
  335. package/src/runtime.ts +8 -8
  336. package/src/{sany-builtins.ts → sany/builtins.ts} +1 -1
  337. package/src/{sany-generator.ts → sany/generator.ts} +38 -55
  338. package/src/{sany-levels.ts → sany/levels.ts} +45 -48
  339. package/src/{sany-lexer.ts → sany/lexer.ts} +2 -3
  340. package/src/{sany-linter.ts → sany/linter.ts} +1 -1
  341. package/src/{sany-modules.ts → sany/modules.ts} +2 -2
  342. package/src/{sany-nodes.ts → sany/nodes.ts} +2 -2
  343. package/src/{sany-parse-error.ts → sany/parse-error.ts} +2 -2
  344. package/src/{sany-report.ts → sany/report.ts} +16 -17
  345. package/src/{sany-selectors.ts → sany/selectors.ts} +3 -5
  346. package/src/{sany-source.ts → sany/source.ts} +6 -7
  347. package/src/{sany-xml.ts → sany/xml.ts} +5 -6
  348. package/src/search.ts +969 -0
  349. package/src/spec-description.ts +26 -20
  350. package/src/{standard-levels.ts → standard-definitions.ts} +118 -2
  351. package/src/standard-modules.ts +16 -20
  352. package/src/state-graph.ts +9 -8
  353. package/src/substitution-levels.ts +2 -2
  354. package/src/successors.ts +16 -19
  355. package/src/symmetry.ts +1 -1
  356. package/src/tableau.ts +6 -7
  357. package/src/tlc/fingerprint.ts +214 -0
  358. package/src/{tlc-messages.ts → tlc/messages.ts} +119 -7
  359. package/src/{tlc-order.ts → tlc/order.ts} +7 -7
  360. package/src/{tlc-random.ts → tlc/random.ts} +3 -213
  361. package/src/{tlc-replay.ts → tlc/replay.ts} +40 -36
  362. package/src/{tlc-module.ts → tlc/tlc-operators.ts} +9 -9
  363. package/src/{tlc-ext.ts → tlc/tlcext-operators.ts} +30 -25
  364. package/src/transfer.ts +32 -32
  365. package/src/values.ts +80 -70
  366. package/src/worker.ts +62 -0
  367. package/dist/parallel.cjs +0 -12
  368. package/dist/parallel.js +0 -12
  369. package/dist/run-cli.cjs +0 -55
  370. package/dist/run-cli.js +0 -55
  371. package/src/canonical.ts +0 -40
  372. package/src/obligation-expression.ts +0 -1060
  373. package/src/obligation-module.ts +0 -1042
  374. package/src/standard-ranges.ts +0 -116
  375. package/src/value-sources.ts +0 -29
  376. /package/src/{tlc-modules.ts → tlc/jar-data.ts} +0 -0
  377. /package/src/{tlc-summary.ts → tlc/summary.ts} +0 -0
  378. /package/src/{tlc-version.ts → tlc/version.ts} +0 -0
@@ -0,0 +1,508 @@
1
+ // A port of tlapm's action frontend (Action.process_obligation), which makes an obligation first
2
+ // order for the backends: [A]_v, <<A>>_v and UNCHANGED become primes (Expr.Tla_norm), primes move
3
+ // down to the variables (Symbol_commute), and what remains modal becomes opaque (Coalesce).
4
+
5
+ import { TlapmBugError } from "../../errors";
6
+ import { rewriteUnchanged } from "../../obligations/temporal";
7
+ import {
8
+ adjoin,
9
+ adjoinAll,
10
+ applyBuiltin,
11
+ at,
12
+ createContextMap,
13
+ getBoundedFresh,
14
+ getBoundFresh,
15
+ getFresh,
16
+ getLocalDefn,
17
+ getParamFresh,
18
+ getScopeAt,
19
+ getScopeHyps,
20
+ mapAccumulate,
21
+ mapHyp,
22
+ mapScoped,
23
+ type Builtin,
24
+ type Defn,
25
+ type Expr,
26
+ type Hyp,
27
+ type Level,
28
+ type Scope,
29
+ type Sequent,
30
+ } from "../../obligations/expression";
31
+ import { renderDoc } from "../../obligations/format";
32
+ import { getLevelInfo } from "../../obligations/levels";
33
+ import { printExpression } from "../../obligations/printer";
34
+ import { getMd5 } from "./md5";
35
+
36
+ type Rewrite = (scope: Scope | undefined, expression: Expr) => Expr;
37
+
38
+ const getHyp = (scope: Scope | undefined, index: number) => {
39
+ const hyp = getScopeAt(scope, index - 1)?.hyp;
40
+ if (!hyp) throw new TlapmBugError();
41
+ return hyp;
42
+ };
43
+
44
+ const getLevel = (scope: Scope | undefined, expression: Expr) =>
45
+ getLevelInfo(scope, expression).level;
46
+
47
+ const isBuiltin = (expression: Expr, builtins: Builtin[]) =>
48
+ expression.kind === "Apply" &&
49
+ expression.operator.kind === "Internal" &&
50
+ builtins.includes(expression.operator.builtin);
51
+
52
+ // Visit.map over a sequent: each hypothesis maps in the scope before it, hidden ones too if hyps
53
+ // is "all". The context maps by the obligation's own hypotheses, from which it derives.
54
+ const createSequentMap = (map: Rewrite, hyps: "visible" | "all") => {
55
+ const mapContext = createContextMap<Scope | undefined>(undefined, (scope, hyp) => {
56
+ const mapped = mapHyp(hyp, (inner) => map(scope, inner), hyps);
57
+ return [adjoin(scope, mapped), mapped];
58
+ });
59
+ return (keys: Hyp[], sequent: Sequent): Sequent => {
60
+ const mapped = mapContext(keys, sequent.context);
61
+ return { context: mapped.context, active: map(mapped.state, sequent.active) };
62
+ };
63
+ };
64
+
65
+ // Expr.Tla_norm.expand_action, then expand_unchanged.
66
+ const expandAction: Rewrite = (scope, expression) => {
67
+ if (expression.kind === "Sub" || expression.kind === "Tsub") {
68
+ const action = expandAction(scope, expression.action);
69
+ const subscript = expandAction(scope, expression.subscript);
70
+ const unchanged = applyBuiltin("UNCHANGED", [subscript], expression);
71
+ const step =
72
+ expression.modal === "Box"
73
+ ? applyBuiltin("Disj", [action, unchanged], expression)
74
+ : applyBuiltin("Conj", [action, applyBuiltin("Neg", [unchanged], expression)], expression);
75
+ if (expression.kind === "Sub") return step;
76
+ return applyBuiltin(expression.modal === "Box" ? "BoxTrue" : "Diamond", [step], expression);
77
+ }
78
+ return mapScoped(scope, expression, expandAction, adjoin, "all");
79
+ };
80
+
81
+ const expandUnchanged: Rewrite = (scope, expression) =>
82
+ expression.kind === "Apply" &&
83
+ isBuiltin(expression, ["UNCHANGED"]) &&
84
+ expression.args.length === 1
85
+ ? rewriteUnchanged(expression.args[0])
86
+ : mapScoped(scope, expression, expandUnchanged, adjoin, "all");
87
+
88
+ const applyModal = (builtin: Builtin, expression: Expr) =>
89
+ applyBuiltin(builtin, [expression], expression);
90
+
91
+ // prime_commuter: a prime distributes down to the declarations that are not constant.
92
+ const commutePrime: Rewrite = (scope, expression) => {
93
+ if (expression.kind === "Ix") {
94
+ const hyp = getHyp(scope, expression.index);
95
+ if (hyp.kind === "Fresh" && hyp.level === "Constant") return expression;
96
+ if (
97
+ hyp.kind === "Defn" &&
98
+ hyp.definition.kind === "Operator" &&
99
+ getLevel(getScopeAt(scope, expression.index), hyp.definition.body) === 0
100
+ )
101
+ return expression;
102
+ return applyModal("Prime", expression);
103
+ }
104
+ if (
105
+ isBuiltin(expression, ["ENABLED"]) ||
106
+ expression.kind === "Opaque" ||
107
+ expression.kind === "Sequent" ||
108
+ expression.kind === "Let"
109
+ )
110
+ return applyModal("Prime", expression);
111
+ if (
112
+ isBuiltin(expression, [
113
+ "UNCHANGED",
114
+ "Cdot",
115
+ "Leadsto",
116
+ "Actplus",
117
+ "BoxTrue",
118
+ "BoxFalse",
119
+ "Diamond",
120
+ ]) ||
121
+ expression.kind === "Tquant" ||
122
+ expression.kind === "Sub" ||
123
+ expression.kind === "Tsub" ||
124
+ expression.kind === "Fair"
125
+ )
126
+ throw new TlapmBugError();
127
+ return mapScoped(scope, expression, commutePrime, adjoin);
128
+ };
129
+
130
+ // box_commuter and dia_commuter: [] distributes over /\ and \A, and <> over \/ and \E, and both
131
+ // vanish on a constant.
132
+ const getModalCommuter = (builtin: "BoxTrue" | "Diamond"): Rewrite => {
133
+ const connective: Builtin = builtin === "BoxTrue" ? "Conj" : "Disj";
134
+ const quantifier = builtin === "BoxTrue" ? "Forall" : "Exists";
135
+ const commute: Rewrite = (scope, expression) => {
136
+ if (getLevel(scope, expression) === 0) return expression;
137
+ const isDistributed =
138
+ isBuiltin(expression, [connective]) ||
139
+ ((expression.kind === "Quant" || expression.kind === "Tquant") &&
140
+ expression.quantifier === quantifier);
141
+ return isDistributed
142
+ ? mapScoped(scope, expression, commute, adjoin)
143
+ : applyModal(builtin, expression);
144
+ };
145
+ return commute;
146
+ };
147
+
148
+ const COMMUTERS: Partial<Record<Builtin, Rewrite>> = {
149
+ Prime: commutePrime,
150
+ BoxTrue: getModalCommuter("BoxTrue"),
151
+ Diamond: getModalCommuter("Diamond"),
152
+ };
153
+
154
+ // symbol_commute: each prime, [] and <> commutes down its operand.
155
+ const commuteSymbols: Rewrite = (scope, expression) => {
156
+ if (expression.kind === "Apply" && expression.operator.kind === "Internal") {
157
+ const commuter = COMMUTERS[expression.operator.builtin];
158
+ if (commuter) {
159
+ if (expression.args.length !== 1) throw new TlapmBugError();
160
+ return commuter(scope, expression.args[0]);
161
+ }
162
+ }
163
+ return mapScoped(scope, expression, commuteSymbols, adjoin, "all");
164
+ };
165
+
166
+ // The prefix rename_with_loc gives a declaration of each level, and a definition by the number of
167
+ // its body's level.
168
+ export const LEVEL_PREFIXES: Record<Level, string> = {
169
+ Constant: "CONSTANT",
170
+ State: "STATE",
171
+ Action: "ACTION",
172
+ Temporal: "TEMPORAL",
173
+ Unknown: "Unknown",
174
+ };
175
+
176
+ export const LEVEL_NUMBER_PREFIXES = ["CONSTANT", "STATE", "ACTION", "TEMPORAL"];
177
+
178
+ const getRenamed = (kind: string, name: string) => `${kind}_${name}_`;
179
+
180
+ interface RenameState {
181
+ scope: Scope | undefined;
182
+ original: Scope | undefined;
183
+ }
184
+
185
+ // rename_with_loc: each declaration's name tells its level, as in CONSTANT_x_ or VARIABLE_x_. A
186
+ // definition's level is the one its body had before the commuters ran, unless given.
187
+ const renameDefn = (scope: Scope | undefined, definition: Defn, level?: number): Defn => {
188
+ if (definition.kind !== "Operator") {
189
+ return definition.kind === "Bpragma"
190
+ ? { ...definition, body: rename(scope, definition.body) }
191
+ : definition;
192
+ }
193
+ const body = rename(scope, definition.body);
194
+ const kind = LEVEL_NUMBER_PREFIXES[level ?? getLevel(scope, body)];
195
+ if (kind === undefined) throw new TlapmBugError();
196
+ return { ...definition, name: getRenamed(kind, definition.name), body };
197
+ };
198
+
199
+ const renameHyp = (scope: Scope | undefined, hyp: Hyp, level?: number): Hyp => {
200
+ switch (hyp.kind) {
201
+ case "Fresh":
202
+ return {
203
+ ...hyp,
204
+ name: getRenamed(LEVEL_PREFIXES[hyp.level], hyp.name),
205
+ domain: hyp.domain && rename(scope, hyp.domain),
206
+ };
207
+ case "Flex":
208
+ return { ...hyp, name: getRenamed("VARIABLE", hyp.name) };
209
+ case "Defn":
210
+ return { ...hyp, definition: renameDefn(scope, hyp.definition, level) };
211
+ case "Fact":
212
+ return { ...hyp, expression: rename(scope, hyp.expression) };
213
+ }
214
+ };
215
+
216
+ // tlapm reads levels from properties that Expr.Levels computes before the frontend rewrites
217
+ // anything, and each node it builds takes the properties of a node it replaces: UNCHANGED's
218
+ // equalities those of the tuple or its only element, and a commuted prime, [] or <> those of its
219
+ // operand. A definition's name tells the level its body's top node ends up with.
220
+ const getOriginalLevel = (scope: Scope | undefined, hyp: Hyp) => {
221
+ if (hyp.kind !== "Defn" || hyp.definition.kind !== "Operator") return undefined;
222
+ const getNodeLevel = (expression: Expr) => {
223
+ if (!isBuiltin(expression, ["UNCHANGED"]) || expression.kind !== "Apply") {
224
+ return getLevel(scope, expression);
225
+ }
226
+ const flatten = (inner: Expr): Expr[] =>
227
+ inner.kind === "Tuple" ? inner.elements.flatMap(flatten) : [inner];
228
+ const items = flatten(expression.args[0]);
229
+ return getLevel(scope, items.length === 1 ? items[0] : expression.args[0]);
230
+ };
231
+ const body = hyp.definition.body;
232
+ const isCommuted =
233
+ isBuiltin(body, ["Prime", "BoxTrue", "Diamond"]) &&
234
+ body.kind === "Apply" &&
235
+ body.args.length === 1;
236
+ return getNodeLevel(isCommuted && body.kind === "Apply" ? body.args[0] : body);
237
+ };
238
+
239
+ // renameSequent on the obligation, with the levels of its definitions from before commuting.
240
+ const renameContext = createContextMap<RenameState>(
241
+ { scope: undefined, original: undefined },
242
+ (current, hyp, original) => {
243
+ const renamed = renameHyp(current.scope, hyp, getOriginalLevel(current.original, original));
244
+ const next = {
245
+ scope: adjoin(current.scope, renamed),
246
+ original: adjoin(current.original, original),
247
+ };
248
+ return [next, renamed];
249
+ },
250
+ );
251
+
252
+ const renameObligation = (commuted: Sequent, original: Sequent): Sequent => {
253
+ const renamed = renameContext(original.context, commuted.context);
254
+ return { context: renamed.context, active: rename(renamed.state.scope, commuted.active) };
255
+ };
256
+
257
+ const renameSequent = (scope: Scope | undefined, sequent: Sequent): Sequent => {
258
+ const [inner, context] = mapAccumulate(scope, sequent.context, (current, hyp) => {
259
+ const renamed = renameHyp(current, hyp);
260
+ return [adjoin(current, renamed), renamed];
261
+ });
262
+ return { context, active: rename(inner, sequent.active) };
263
+ };
264
+
265
+ const rename: Rewrite = (scope, expression) => {
266
+ switch (expression.kind) {
267
+ case "Lambda": {
268
+ const params = expression.params.map((param) => ({
269
+ ...param,
270
+ name: getRenamed("Unknown", param.name),
271
+ }));
272
+ const inner = adjoinAll(scope, params.map(getParamFresh));
273
+ return { ...expression, params, body: rename(inner, expression.body) };
274
+ }
275
+ case "Tquant": {
276
+ const inner = adjoinAll(
277
+ scope,
278
+ expression.names.map((name) => ({ kind: "Flex", name: getRenamed("VARIABLE", name) })),
279
+ );
280
+ return { ...expression, body: rename(inner, expression.body) };
281
+ }
282
+ case "Choose": {
283
+ const domain = expression.domain && rename(scope, expression.domain);
284
+ const name = getRenamed("CONSTANT", expression.name);
285
+ const hyp = domain ? getBoundedFresh(name, domain) : getFresh(name, "Constant");
286
+ return { ...expression, name, domain, body: rename(adjoin(scope, hyp), expression.body) };
287
+ }
288
+ case "SetSt": {
289
+ const domain = rename(scope, expression.domain);
290
+ const name = getRenamed("CONSTANT", expression.name);
291
+ const body = rename(adjoin(scope, getBoundedFresh(name, domain)), expression.body);
292
+ return { ...expression, name, domain, body };
293
+ }
294
+ case "Quant":
295
+ case "Fcn":
296
+ case "SetOf": {
297
+ const bounds = expression.bounds.map((bound) => ({
298
+ ...bound,
299
+ name: getRenamed(LEVEL_PREFIXES[bound.level], bound.name),
300
+ domain:
301
+ bound.domain.kind === "Domain"
302
+ ? { kind: "Domain" as const, expression: rename(scope, bound.domain.expression) }
303
+ : bound.domain,
304
+ }));
305
+ const inner = adjoinAll(scope, bounds.map(getBoundFresh));
306
+ return expression.kind === "SetOf"
307
+ ? { ...expression, bounds, element: rename(inner, expression.element) }
308
+ : { ...expression, bounds, body: rename(inner, expression.body) };
309
+ }
310
+ case "Let": {
311
+ const [inner, definitions] = mapAccumulate(
312
+ scope,
313
+ expression.definitions,
314
+ (current, definition) => {
315
+ const renamed = renameDefn(current, definition);
316
+ return [adjoin(current, getLocalDefn(renamed)), renamed];
317
+ },
318
+ );
319
+ return { ...expression, definitions, body: rename(inner, expression.body) };
320
+ }
321
+ case "Sequent":
322
+ return { ...expression, sequent: renameSequent(scope, expression.sequent) };
323
+ default:
324
+ return mapScoped(scope, expression, rename, adjoin, "all");
325
+ }
326
+ };
327
+
328
+ // E_substitutive.make_array: for each parameter of an operator, counting from the last, whether
329
+ // the body uses it only outside primes and the other modal operators.
330
+ const substitutiveArgs = new WeakMap<Defn, boolean[]>();
331
+
332
+ const getSubstitutiveArgs = (scope: Scope | undefined, definition: Defn): boolean[] => {
333
+ const cached = substitutiveArgs.get(definition);
334
+ if (cached) return cached;
335
+ const body = definition.kind === "Operator" ? definition.body : undefined;
336
+ if (body?.kind !== "Lambda") return [];
337
+ const inner = adjoinAll(scope, body.params.map(getParamFresh));
338
+ const result = body.params.map((_param, index) =>
339
+ isSubstitutive(inner, body.body, index + 1, true),
340
+ );
341
+ substitutiveArgs.set(definition, result);
342
+ return result;
343
+ };
344
+
345
+ const UNARY_MODALS: Builtin[] = [
346
+ "Prime",
347
+ "StrongPrime",
348
+ "BoxTrue",
349
+ "BoxFalse",
350
+ "Diamond",
351
+ "ENABLED",
352
+ "UNCHANGED",
353
+ ];
354
+
355
+ const BINARY_MODALS: Builtin[] = ["Leadsto", "Actplus", "Cdot"];
356
+
357
+ // compute_substitutivity_array: whether the parameter at index occurs only where scope holds.
358
+ const isSubstitutive = (
359
+ scope: Scope | undefined,
360
+ expression: Expr,
361
+ index: number,
362
+ isInScope: boolean,
363
+ ): boolean => {
364
+ if (expression.kind === "Ix") return isInScope || expression.index !== index;
365
+ if (expression.kind === "Apply" && expression.operator.kind === "Internal") {
366
+ const builtin = expression.operator.builtin;
367
+ if (
368
+ (UNARY_MODALS.includes(builtin) && expression.args.length === 1) ||
369
+ (BINARY_MODALS.includes(builtin) && expression.args.length === 2)
370
+ ) {
371
+ return expression.args.every((arg) => isSubstitutive(scope, arg, index, false));
372
+ }
373
+ }
374
+ if (expression.kind === "Sub") {
375
+ return [expression.action, expression.subscript].every((inner) =>
376
+ isSubstitutive(scope, inner, index, false),
377
+ );
378
+ }
379
+ if (expression.kind === "Apply" && expression.operator.kind === "Ix") {
380
+ const hypScope = getScopeAt(scope, expression.operator.index - 1);
381
+ const hyp = hypScope?.hyp;
382
+ if (hypScope && hyp?.kind === "Defn" && hyp.definition.kind === "Operator") {
383
+ const args = getSubstitutiveArgs(hypScope.rest, hyp.definition);
384
+ return expression.args.every((arg, position) => {
385
+ const isArgInScope = args[position];
386
+ if (isArgInScope === undefined) throw new TlapmBugError();
387
+ return isSubstitutive(scope, arg, index, isArgInScope);
388
+ });
389
+ }
390
+ }
391
+ const found = { isSubstitutive: true };
392
+ mapScoped(
393
+ { scope, index },
394
+ expression,
395
+ (state, inner) => {
396
+ found.isSubstitutive &&= isSubstitutive(state.scope, inner, state.index, isInScope);
397
+ return inner;
398
+ },
399
+ (state, hyp) => ({ scope: adjoin(state.scope, hyp), index: state.index + 1 }),
400
+ "all",
401
+ );
402
+ return found.isSubstitutive;
403
+ };
404
+
405
+ // Coalesce.crypthash: h and the first five hexadecimal digits of the MD5 of the expression as
406
+ // tlapm prints it.
407
+ export const getHashName = (hyps: Hyp[], expression: Expr) =>
408
+ `h${getMd5(renderDoc(printExpression(hyps, expression))).slice(0, 5)}`;
409
+
410
+ const coalesce = (scope: Scope | undefined, expression: Expr): Expr =>
411
+ at({ kind: "Opaque", name: getHashName(getScopeHyps(scope), expression) }, expression);
412
+
413
+ // coalesce_operator: an operator applied to arguments that are not all substitutive is opaque,
414
+ // hiding the arguments that are constant or substitutive.
415
+ const coalesceOperator = (
416
+ scope: Scope | undefined,
417
+ name: string,
418
+ substitutive: boolean[],
419
+ from: Expr,
420
+ args: Expr[],
421
+ ) => {
422
+ const starred = args.map((arg, position) => {
423
+ const isHidden = getLevel(scope, arg) === 0 || substitutive[args.length - position - 1];
424
+ return isHidden ? at({ kind: "Opaque", name: "*" }, arg) : arg;
425
+ });
426
+ return coalesce(
427
+ scope,
428
+ at({ kind: "Apply", operator: { kind: "Opaque", name }, args: starred }, from),
429
+ );
430
+ };
431
+
432
+ const MODAL_BUILTINS: Builtin[] = [
433
+ "Prime",
434
+ "StrongPrime",
435
+ "BoxTrue",
436
+ "BoxFalse",
437
+ "Diamond",
438
+ "Leadsto",
439
+ "ENABLED",
440
+ "Cdot",
441
+ "UNCHANGED",
442
+ ];
443
+
444
+ // coalesce_modal_visitor: a primed declaration becomes the opaque name#prime, and every other
445
+ // modal expression an opaque name. tlapm means to apply that name to the expression's free
446
+ // variables, but compute_vars collects them into an instance variable and returns its own empty
447
+ // set, so the name always stands alone.
448
+ const coalesceModal: Rewrite = (scope, expression) => {
449
+ if (expression.kind !== "Apply") return mapScoped(scope, expression, coalesceModal, adjoin);
450
+ const operator = expression.operator;
451
+ const [arg] = expression.args;
452
+ if (
453
+ isBuiltin(expression, ["Prime", "StrongPrime"]) &&
454
+ expression.args.length === 1 &&
455
+ arg.kind === "Ix"
456
+ ) {
457
+ const hyp = getHyp(scope, arg.index);
458
+ if (hyp.kind === "Fresh" || hyp.kind === "Flex") {
459
+ return at({ kind: "Opaque", name: `${hyp.name}#prime` }, expression);
460
+ }
461
+ }
462
+ if (isBuiltin(expression, MODAL_BUILTINS)) return coalesce(scope, expression);
463
+ if (operator.kind !== "Ix") return mapScoped(scope, expression, coalesceModal, adjoin);
464
+ const hypScope = getScopeAt(scope, operator.index - 1);
465
+ const hyp = hypScope?.hyp;
466
+ if (!hyp) throw new TlapmBugError();
467
+ const args = expression.args;
468
+ if (hyp.kind === "Defn" && hyp.definition.kind === "Operator") {
469
+ const substitutive = getSubstitutiveArgs(hypScope.rest, hyp.definition);
470
+ const isKept = args.every(
471
+ (inner, position) => getLevel(scope, inner) === 0 || substitutive[args.length - position - 1],
472
+ );
473
+ if (isKept) return mapScoped(scope, expression, coalesceModal, adjoin);
474
+ const opaque = coalesceOperator(scope, hyp.definition.name, substitutive, operator, args);
475
+ return at(
476
+ { kind: "Apply", operator: opaque, args: args.map((inner) => coalesceModal(scope, inner)) },
477
+ expression,
478
+ );
479
+ }
480
+ if (hyp.kind === "Flex") return mapScoped(scope, expression, coalesceModal, adjoin);
481
+ if (hyp.kind === "Fresh") {
482
+ if (hyp.level === "Constant") {
483
+ return at(
484
+ { kind: "Apply", operator, args: args.map((inner) => coalesceModal(scope, inner)) },
485
+ expression,
486
+ );
487
+ }
488
+ const notSubstitutive = args.map(() => false);
489
+ return coalesceOperator(scope, hyp.name, notSubstitutive, operator, args);
490
+ }
491
+ throw new TlapmBugError();
492
+ };
493
+
494
+ // process_eob, on an obligation's sequent.
495
+ const expandActionSequent = createSequentMap(expandAction, "all");
496
+
497
+ const expandUnchangedSequent = createSequentMap(expandUnchanged, "all");
498
+
499
+ const commuteSequent = createSequentMap(commuteSymbols, "all");
500
+
501
+ const coalesceSequent = createSequentMap(coalesceModal, "visible");
502
+
503
+ export const processObligation = (sequent: Sequent): Sequent => {
504
+ const keys = sequent.context;
505
+ const expanded = expandUnchangedSequent(keys, expandActionSequent(keys, sequent));
506
+ const commuted = commuteSequent(keys, expanded);
507
+ return coalesceSequent(keys, renameObligation(commuted, sequent));
508
+ };
@@ -0,0 +1,189 @@
1
+ // Expr.Action.implication_to_enabled, the ENABLEDaxioms frontend: it proves a rule about ENABLED
2
+ // from facts of the form the rule needs.
3
+
4
+ import { TlapmBugError, TlaProverError } from "../../errors";
5
+ import { shiftExpr } from "../../obligations/substitution";
6
+ import { isEqualExpr } from "../../obligations/equality";
7
+ import {
8
+ adjoin,
9
+ adjoinAll,
10
+ getScopeAt,
11
+ mapScoped,
12
+ type Builtin,
13
+ type Expr,
14
+ type Scope,
15
+ type Sequent,
16
+ } from "../../obligations/expression";
17
+ import { getLevelInfo } from "../../obligations/levels";
18
+
19
+ interface Rule {
20
+ name: string;
21
+ left: Expr;
22
+ right: Expr;
23
+ }
24
+
25
+ const TRUE: Expr = { kind: "Internal", builtin: "TRUE" };
26
+
27
+ const getOperands = (expression: Expr, builtin: Builtin) =>
28
+ expression.kind === "Apply" &&
29
+ expression.operator.kind === "Internal" &&
30
+ expression.operator.builtin === builtin &&
31
+ expression.args.length === 2
32
+ ? expression.args
33
+ : undefined;
34
+
35
+ const getEnabled = (expression: Expr) =>
36
+ expression.kind === "Apply" &&
37
+ expression.operator.kind === "Internal" &&
38
+ expression.operator.builtin === "ENABLED" &&
39
+ expression.args.length === 1
40
+ ? expression.args[0]
41
+ : undefined;
42
+
43
+ // Both operands of the connective, when each is an ENABLED.
44
+ const getEnabledOperands = (expression: Expr, builtin: Builtin) => {
45
+ const operands = getOperands(expression, builtin);
46
+ const left = operands && getEnabled(operands[0]);
47
+ const right = operands && getEnabled(operands[1]);
48
+ return left && right ? [left, right] : undefined;
49
+ };
50
+
51
+ // E_visit.collect_primed_vars: the variables under a prime, an UNCHANGED, or a subscript.
52
+ const getPrimedVariables = (scope: Scope | undefined, expression: Expr) => {
53
+ const names = new Set<string>();
54
+ const visit = (state: { scope: Scope | undefined; isPrimed: boolean }, inner: Expr): Expr => {
55
+ const primed = { ...state, isPrimed: true };
56
+ const operator = inner.kind === "Apply" && inner.operator.kind === "Internal" && inner.operator;
57
+ const builtin = operator && operator.builtin;
58
+ const args = inner.kind === "Apply" ? inner.args : [];
59
+ const isScoped =
60
+ (builtin === "Prime" && args.length === 1) ||
61
+ builtin === "ENABLED" ||
62
+ (builtin === "Cdot" && args.length === 2) ||
63
+ (builtin === "UNCHANGED" && args.length === 1) ||
64
+ inner.kind === "Sub";
65
+ if (isScoped && state.isPrimed) throw new TlapmBugError();
66
+ if (builtin === "Prime" && args.length === 1) visit(primed, args[0]);
67
+ else if (builtin === "Cdot" && args.length === 2) visit(state, args[1]);
68
+ else if (builtin === "UNCHANGED" && args.length === 1) visit(primed, args[0]);
69
+ else if (inner.kind === "Sub") {
70
+ visit(state, inner.action);
71
+ visit(primed, inner.subscript);
72
+ } else if (inner.kind === "Ix") {
73
+ const hyp = getScopeAt(state.scope, inner.index - 1)?.hyp;
74
+ if (!hyp) throw new TlapmBugError();
75
+ if (hyp.kind === "Flex" && state.isPrimed) names.add(hyp.name);
76
+ } else if (builtin !== "ENABLED") {
77
+ mapScoped(state, inner, visit, (current, hyp) => ({
78
+ ...current,
79
+ scope: adjoin(current.scope, hyp),
80
+ }));
81
+ }
82
+ return inner;
83
+ };
84
+ visit({ scope, isPrimed: false }, expression);
85
+ return names;
86
+ };
87
+
88
+ const isDisjoint = (scope: Scope | undefined, left: Expr, right: Expr) => {
89
+ const leftNames = getPrimedVariables(scope, left);
90
+ return [...getPrimedVariables(scope, right)].every((name) => !leftNames.has(name));
91
+ };
92
+
93
+ // check_active: the rule the goal's form calls for, with the operands the facts must mention.
94
+ const getRule = (scope: Scope | undefined, goal: Expr): Rule | undefined => {
95
+ const getLevelOf = (expression: Expr) => getLevelInfo(scope, expression).level;
96
+ const assertActions = (left: Expr, right: Expr) => {
97
+ if (getLevelOf(left) > 2 || getLevelOf(right) > 2) throw new TlapmBugError();
98
+ };
99
+ const enabled = getEnabled(goal);
100
+ const enabledDisjunction = enabled && getOperands(enabled, "Disj");
101
+ if (enabledDisjunction) {
102
+ assertActions(enabledDisjunction[0], enabledDisjunction[1]);
103
+ return { name: "abdisj_inverse", left: enabledDisjunction[0], right: enabledDisjunction[1] };
104
+ }
105
+ const disjunction = getEnabledOperands(goal, "Disj");
106
+ if (disjunction) {
107
+ assertActions(disjunction[0], disjunction[1]);
108
+ return { name: "abdisj", left: disjunction[0], right: disjunction[1] };
109
+ }
110
+ const enabledConjunction = enabled && getOperands(enabled, "Conj");
111
+ if (enabledConjunction) {
112
+ const left = enabledConjunction[0];
113
+ const right = enabledConjunction[1];
114
+ const isApart = isDisjoint(scope, left, right);
115
+ assertActions(left, right);
116
+ if (!isApart) return undefined;
117
+ return { name: getLevelOf(left) === 2 ? "abconj_inverse" : "pconj_inverse", left, right };
118
+ }
119
+ const conjunction = getEnabledOperands(goal, "Conj");
120
+ if (conjunction) {
121
+ return isDisjoint(scope, conjunction[0], conjunction[1])
122
+ ? { name: "abconj", left: conjunction[0], right: conjunction[1] }
123
+ : undefined;
124
+ }
125
+ const operands = getOperands(goal, "Conj");
126
+ const action = operands && getEnabled(operands[1]);
127
+ if (operands && action) {
128
+ return getLevelOf(operands[0]) <= 1 && getLevelOf(action) <= 2
129
+ ? { name: "pconj", left: operands[0], right: action }
130
+ : undefined;
131
+ }
132
+ const equivalence = getEnabledOperands(goal, "Equiv") ?? getEnabledOperands(goal, "Eq");
133
+ if (equivalence) return { name: "equiv", left: equivalence[0], right: equivalence[1] };
134
+ const implication = getEnabledOperands(goal, "Implies");
135
+ return implication && { name: "implies", left: implication[0], right: implication[1] };
136
+ };
137
+
138
+ // implication_to_enabled: the goal follows by the rule its form calls for when a visible fact is
139
+ // the rule's premise and others say that both operands are in BOOLEAN, or the premise is an
140
+ // equivalence. The goal then becomes TRUE; otherwise tlapm records the obligation as not tried.
141
+ export const implicationToEnabled = (sequent: Sequent): Sequent => {
142
+ const goalScope = adjoinAll(undefined, sequent.context);
143
+ const rule = getRule(goalScope, sequent.active);
144
+ const found = { isPremise: false, isLeftBoolean: false, isRightBoolean: false };
145
+ sequent.context.forEach((hyp, index) => {
146
+ if (!rule || hyp.kind !== "Fact" || hyp.visibility !== "Visible") return;
147
+ const amount = sequent.context.length - index;
148
+ const fact = hyp.expression;
149
+ const isLeft = (expression: Expr) => isEqualExpr(shiftExpr(amount, expression), rule.left);
150
+ const isRight = (expression: Expr) => isEqualExpr(shiftExpr(amount, expression), rule.right);
151
+ const isPair = (operands: Expr[] | undefined, names: string[]) =>
152
+ operands !== undefined &&
153
+ isLeft(operands[0]) &&
154
+ isRight(operands[1]) &&
155
+ names.includes(rule.name);
156
+ const enabled = getEnabled(fact);
157
+ const enabledConjunction = enabled && getOperands(enabled, "Conj");
158
+ const conjunction = getOperands(fact, "Conj");
159
+ const action = conjunction && getEnabled(conjunction[1]);
160
+ const membership = getOperands(fact, "Mem");
161
+ const isBoolean = membership?.[1].kind === "Internal" && membership[1].builtin === "BOOLEAN";
162
+ if (
163
+ isPair(enabledConjunction, ["pconj"]) ||
164
+ isPair(enabled && getOperands(enabled, "Disj"), ["abdisj"]) ||
165
+ isPair(getEnabledOperands(fact, "Disj"), ["abdisj_inverse"]) ||
166
+ isPair(enabledConjunction, ["abconj"]) ||
167
+ isPair(getEnabledOperands(fact, "Conj"), ["abconj_inverse", "pconj_inverse"]) ||
168
+ isPair(conjunction && action && [conjunction[0], action], ["pconj_inverse"])
169
+ ) {
170
+ found.isPremise = true;
171
+ } else if (isPair(getOperands(fact, "Equiv"), ["equiv"])) {
172
+ found.isPremise = true;
173
+ found.isLeftBoolean = true;
174
+ found.isRightBoolean = true;
175
+ } else if (isPair(getOperands(fact, "Eq"), ["equiv"])) {
176
+ found.isPremise = true;
177
+ } else if (membership && isBoolean && isLeft(membership[0])) {
178
+ found.isLeftBoolean = true;
179
+ } else if (membership && isBoolean && isRight(membership[0])) {
180
+ found.isRightBoolean = true;
181
+ } else if (isPair(getOperands(fact, "Implies"), ["implies"])) {
182
+ found.isPremise = true;
183
+ }
184
+ });
185
+ if (!found.isPremise || !found.isLeftBoolean || !found.isRightBoolean) {
186
+ throw new TlaProverError("ENABLEDaxioms proof directive did not succeed.\n");
187
+ }
188
+ return { ...sequent, active: TRUE };
189
+ };