tla-ts 0.0.3 → 0.0.4-dev.2a873ee

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 (370) hide show
  1. package/README.md +46 -115
  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 +194 -8
  8. package/dist/index.d.ts +194 -8
  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 +996 -0
  17. package/dist/prove.js +996 -0
  18. package/dist/run-cli.cjs +37 -20
  19. package/dist/run-cli.js +37 -20
  20. package/dist/tlapm.cjs +10 -0
  21. package/dist/tlapm.js +10 -0
  22. package/dist/transfer.cjs +1387 -18
  23. package/dist/transfer.js +1387 -18
  24. package/dist/worker.cjs +21 -0
  25. package/dist/worker.js +21 -0
  26. package/package.json +24 -11
  27. package/src/ast.ts +149 -8
  28. package/src/bags.ts +4 -7
  29. package/src/builtins.ts +29 -11
  30. package/src/bundled-modules.ts +3 -3
  31. package/src/canonical.ts +4 -3
  32. package/src/check.ts +1540 -235
  33. package/src/cli-options.ts +12 -6
  34. package/src/cli.ts +8 -1
  35. package/src/codegen.ts +98 -39
  36. package/src/config.ts +254 -181
  37. package/src/dependencies.ts +2 -2
  38. package/src/environment.ts +540 -140
  39. package/src/errors.ts +284 -4
  40. package/src/evaluate.ts +1043 -293
  41. package/src/exit-codes.ts +22 -43
  42. package/src/fingerprints.ts +46 -11
  43. package/src/index.ts +11 -0
  44. package/src/instances.ts +19 -16
  45. package/src/java-overrides.ts +104 -25
  46. package/src/levels.ts +191 -45
  47. package/src/lexer.ts +127 -30
  48. package/src/live-check.ts +867 -0
  49. package/src/liveness.ts +218 -572
  50. package/src/{obligation-action.ts → obligations/action.ts} +247 -69
  51. package/src/{obligation-anon.ts → obligations/anon.ts} +49 -47
  52. package/src/obligations/ctx.ts +64 -0
  53. package/src/{obligation-deref.ts → obligations/deref.ts} +51 -92
  54. package/src/{obligation-expression.ts → obligations/expression.ts} +117 -57
  55. package/src/{obligation-format.ts → obligations/format.ts} +7 -8
  56. package/src/{obligation-generate.ts → obligations/generate.ts} +170 -192
  57. package/src/{obligations.ts → obligations/index.ts} +32 -16
  58. package/src/{obligation-levels.ts → obligations/levels.ts} +26 -28
  59. package/src/{obligation-module.ts → obligations/module.ts} +113 -121
  60. package/src/obligations/pickle.ts +98 -0
  61. package/src/obligations/pragma.ts +189 -0
  62. package/src/{obligation-printer.ts → obligations/printer.ts} +22 -80
  63. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
  64. package/src/{obligation-source.ts → obligations/source.ts} +156 -99
  65. package/src/obligations/temporal.ts +321 -0
  66. package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
  67. package/src/ocaml-marshal.ts +166 -0
  68. package/src/parallel-worker.ts +169 -224
  69. package/src/parallel.ts +140 -81
  70. package/src/parser.ts +456 -147
  71. package/src/pcal-ast.ts +770 -0
  72. package/src/pcal-parse.ts +1523 -0
  73. package/src/pcal-tokenize.ts +516 -0
  74. package/src/pcal-translate.ts +1230 -0
  75. package/src/pcal-validate.ts +454 -0
  76. package/src/prove/decide-pool.ts +95 -0
  77. package/src/prove/deciders.ts +33 -0
  78. package/src/prove/first-order.ts +78 -0
  79. package/src/prove/isabelle/LICENSE +36 -0
  80. package/src/prove/isabelle/LICENSE-tlapm +26 -0
  81. package/src/prove/isabelle/decide.ts +47 -0
  82. package/src/prove/isabelle/encode.ts +446 -0
  83. package/src/prove/isabelle/isar/inner-syntax.ts +579 -0
  84. package/src/prove/isabelle/isar/method.ts +367 -0
  85. package/src/prove/isabelle/isar/proof.ts +28 -0
  86. package/src/prove/isabelle/isar/statement.ts +57 -0
  87. package/src/prove/isabelle/isar/theory.ts +192 -0
  88. package/src/prove/isabelle/isar/type-check.ts +278 -0
  89. package/src/prove/isabelle/provers/blast/blast.ts +258 -0
  90. package/src/prove/isabelle/provers/blast/branch.ts +322 -0
  91. package/src/prove/isabelle/provers/blast/prove.ts +347 -0
  92. package/src/prove/isabelle/provers/blast/rules.ts +330 -0
  93. package/src/prove/isabelle/provers/blast/state.ts +180 -0
  94. package/src/prove/isabelle/provers/blast/term.ts +546 -0
  95. package/src/prove/isabelle/provers/clasimp.ts +150 -0
  96. package/src/prove/isabelle/provers/classical.ts +389 -0
  97. package/src/prove/isabelle/provers/hypsubst.ts +433 -0
  98. package/src/prove/isabelle/pure/bicompose.ts +174 -0
  99. package/src/prove/isabelle/pure/consts.ts +32 -0
  100. package/src/prove/isabelle/pure/conv.ts +79 -0
  101. package/src/prove/isabelle/pure/drule.ts +264 -0
  102. package/src/prove/isabelle/pure/envir.ts +331 -0
  103. package/src/prove/isabelle/pure/goal.ts +53 -0
  104. package/src/prove/isabelle/pure/interrupt.ts +16 -0
  105. package/src/prove/isabelle/pure/list.ts +12 -0
  106. package/src/prove/isabelle/pure/logic.ts +330 -0
  107. package/src/prove/isabelle/pure/name.ts +98 -0
  108. package/src/prove/isabelle/pure/net.ts +215 -0
  109. package/src/prove/isabelle/pure/object-logic.ts +41 -0
  110. package/src/prove/isabelle/pure/pattern.ts +631 -0
  111. package/src/prove/isabelle/pure/raw-simplifier.ts +338 -0
  112. package/src/prove/isabelle/pure/rewriter.ts +602 -0
  113. package/src/prove/isabelle/pure/search.ts +68 -0
  114. package/src/prove/isabelle/pure/seq.ts +133 -0
  115. package/src/prove/isabelle/pure/simplifier.ts +106 -0
  116. package/src/prove/isabelle/pure/table.ts +201 -0
  117. package/src/prove/isabelle/pure/tactic.ts +168 -0
  118. package/src/prove/isabelle/pure/tactical.ts +264 -0
  119. package/src/prove/isabelle/pure/term-ord.ts +105 -0
  120. package/src/prove/isabelle/pure/term.ts +688 -0
  121. package/src/prove/isabelle/pure/thm.ts +783 -0
  122. package/src/prove/isabelle/pure/type.ts +121 -0
  123. package/src/prove/isabelle/pure/unify.ts +753 -0
  124. package/src/prove/isabelle/pure/variable.ts +25 -0
  125. package/src/prove/isabelle/tla/classical-setup.ts +101 -0
  126. package/src/prove/isabelle/tla/context.ts +74 -0
  127. package/src/prove/isabelle/tla/logic-data.ts +5 -0
  128. package/src/prove/isabelle/tla/logic.ts +215 -0
  129. package/src/prove/isabelle/tla/simpdata.ts +241 -0
  130. package/src/prove/isabelle/tools/intuitionistic.ts +132 -0
  131. package/src/prove/ocaml.ts +22 -0
  132. package/src/prove/prep/action.ts +508 -0
  133. package/src/prove/prep/defs.ts +33 -0
  134. package/src/prove/prep/elab.ts +156 -0
  135. package/src/prove/prep/enabled-axioms.ts +189 -0
  136. package/src/prove/prep/enabled.ts +43 -0
  137. package/src/prove/prep/fingerprint.ts +388 -0
  138. package/src/prove/prep/flatten.ts +70 -0
  139. package/src/prove/prep/level-comparison.ts +529 -0
  140. package/src/prove/prep/md5.ts +67 -0
  141. package/src/prove/prep/pragma.ts +221 -0
  142. package/src/prove/prep/trivial.ts +22 -0
  143. package/src/prove/prove-worker.ts +22 -0
  144. package/src/prove/prove.ts +498 -0
  145. package/src/prove/ptl/decide.ts +68 -0
  146. package/src/prove/ptl/encode.ts +255 -0
  147. package/src/prove/ptl/sat.ts +151 -0
  148. package/src/prove/ptl/tableau.ts +276 -0
  149. package/src/prove/smt/axiomatize.ts +69 -0
  150. package/src/prove/smt/axioms.ts +209 -0
  151. package/src/prove/smt/context.ts +108 -0
  152. package/src/prove/smt/data.ts +636 -0
  153. package/src/prove/smt/encode.ts +164 -0
  154. package/src/prove/smt/extensionality.ts +65 -0
  155. package/src/prove/smt/flatten.ts +112 -0
  156. package/src/prove/smt/format.ts +154 -0
  157. package/src/prove/smt/instances.ts +181 -0
  158. package/src/prove/smt/rewrite.ts +772 -0
  159. package/src/prove/smt/simplify.ts +57 -0
  160. package/src/prove/smt/solver/act-cache.ts +265 -0
  161. package/src/prove/smt/solver/arith-rewriter.ts +962 -0
  162. package/src/prove/smt/solver/array.ts +22 -0
  163. package/src/prove/smt/solver/asserted-formulas.ts +469 -0
  164. package/src/prove/smt/solver/ast-lt.ts +157 -0
  165. package/src/prove/smt/solver/ast-util.ts +91 -0
  166. package/src/prove/smt/solver/ast.ts +1315 -0
  167. package/src/prove/smt/solver/auf-solver.ts +572 -0
  168. package/src/prove/smt/solver/case-split-queue.ts +178 -0
  169. package/src/prove/smt/solver/cg-table.ts +175 -0
  170. package/src/prove/smt/solver/clause.ts +276 -0
  171. package/src/prove/smt/solver/conflict-resolution.ts +343 -0
  172. package/src/prove/smt/solver/context.ts +1292 -0
  173. package/src/prove/smt/solver/ctx-simplify.ts +334 -0
  174. package/src/prove/smt/solver/der.ts +224 -0
  175. package/src/prove/smt/solver/dyn-ack.ts +141 -0
  176. package/src/prove/smt/solver/e-matching.ts +659 -0
  177. package/src/prove/smt/solver/enode.ts +259 -0
  178. package/src/prove/smt/solver/expr-ref.ts +21 -0
  179. package/src/prove/smt/solver/expr-safe-replace.ts +172 -0
  180. package/src/prove/smt/solver/fingerprints.ts +92 -0
  181. package/src/prove/smt/solver/flat-literals.ts +51 -0
  182. package/src/prove/smt/solver/goal.ts +138 -0
  183. package/src/prove/smt/solver/hash.ts +173 -0
  184. package/src/prove/smt/solver/hashtable.ts +166 -0
  185. package/src/prove/smt/solver/internalizer.ts +1381 -0
  186. package/src/prove/smt/solver/lbool.ts +5 -0
  187. package/src/prove/smt/solver/literal.ts +24 -0
  188. package/src/prove/smt/solver/lp/bound-propagator.ts +391 -0
  189. package/src/prove/smt/solver/lp/constraints.ts +78 -0
  190. package/src/prove/smt/solver/lp/containers.ts +296 -0
  191. package/src/prove/smt/solver/lp/core-solver.ts +504 -0
  192. package/src/prove/smt/solver/lp/cross-nested.ts +224 -0
  193. package/src/prove/smt/solver/lp/dep-intervals.ts +642 -0
  194. package/src/prove/smt/solver/lp/dependency.ts +51 -0
  195. package/src/prove/smt/solver/lp/dioph-eq.ts +1181 -0
  196. package/src/prove/smt/solver/lp/explanation.ts +46 -0
  197. package/src/prove/smt/solver/lp/gomory.ts +255 -0
  198. package/src/prove/smt/solver/lp/hnf-cutter.ts +125 -0
  199. package/src/prove/smt/solver/lp/hnf.ts +281 -0
  200. package/src/prove/smt/solver/lp/int-cube.ts +295 -0
  201. package/src/prove/smt/solver/lp/int-solver.ts +514 -0
  202. package/src/prove/smt/solver/lp/lar-solver.ts +816 -0
  203. package/src/prove/smt/solver/lp/lar-term.ts +62 -0
  204. package/src/prove/smt/solver/lp/lp-settings.ts +91 -0
  205. package/src/prove/smt/solver/lp/maximize-term.ts +347 -0
  206. package/src/prove/smt/solver/lp/nex-creator.ts +381 -0
  207. package/src/prove/smt/solver/lp/nex.ts +120 -0
  208. package/src/prove/smt/solver/lp/nla-backoff.ts +43 -0
  209. package/src/prove/smt/solver/lp/nla-basics.ts +398 -0
  210. package/src/prove/smt/solver/lp/nla-core.ts +968 -0
  211. package/src/prove/smt/solver/lp/nla-divisions.ts +332 -0
  212. package/src/prove/smt/solver/lp/nla-emonics.ts +373 -0
  213. package/src/prove/smt/solver/lp/nla-factorization.ts +30 -0
  214. package/src/prove/smt/solver/lp/nla-grobner.ts +904 -0
  215. package/src/prove/smt/solver/lp/nla-horner.ts +126 -0
  216. package/src/prove/smt/solver/lp/nla-intervals.ts +265 -0
  217. package/src/prove/smt/solver/lp/nla-monomial-bounds.ts +715 -0
  218. package/src/prove/smt/solver/lp/nla-monotone.ts +59 -0
  219. package/src/prove/smt/solver/lp/nla-order.ts +307 -0
  220. package/src/prove/smt/solver/lp/nla-patcher.ts +112 -0
  221. package/src/prove/smt/solver/lp/nla-tangents.ts +251 -0
  222. package/src/prove/smt/solver/lp/nla-throttle.ts +85 -0
  223. package/src/prove/smt/solver/lp/nla-types.ts +124 -0
  224. package/src/prove/smt/solver/lp/nla-var-eqs.ts +141 -0
  225. package/src/prove/smt/solver/lp/nra-solver.ts +440 -0
  226. package/src/prove/smt/solver/lp/numeric-pair.ts +65 -0
  227. package/src/prove/smt/solver/lp/pdd-interval.ts +31 -0
  228. package/src/prove/smt/solver/lp/pdd-simplifier.ts +184 -0
  229. package/src/prove/smt/solver/lp/pdd-solver.ts +408 -0
  230. package/src/prove/smt/solver/lp/pdd.ts +971 -0
  231. package/src/prove/smt/solver/lp/random-updater.ts +138 -0
  232. package/src/prove/smt/solver/lp/static-matrix.ts +246 -0
  233. package/src/prove/smt/solver/lp/union-find.ts +96 -0
  234. package/src/prove/smt/solver/mam-compiler.ts +847 -0
  235. package/src/prove/smt/solver/mam-interpreter.ts +400 -0
  236. package/src/prove/smt/solver/maximize-ac-sharing.ts +118 -0
  237. package/src/prove/smt/solver/model-checker.ts +347 -0
  238. package/src/prove/smt/solver/model-evaluator.ts +262 -0
  239. package/src/prove/smt/solver/model-finder.ts +155 -0
  240. package/src/prove/smt/solver/model-generator.ts +97 -0
  241. package/src/prove/smt/solver/model-macro-solver.ts +728 -0
  242. package/src/prove/smt/solver/nlsat/algebraic.ts +1161 -0
  243. package/src/prove/smt/solver/nlsat/atoms.ts +238 -0
  244. package/src/prove/smt/solver/nlsat/evaluator.ts +303 -0
  245. package/src/prove/smt/solver/nlsat/explain.ts +607 -0
  246. package/src/prove/smt/solver/nlsat/interval-set.ts +351 -0
  247. package/src/prove/smt/solver/nlsat/levelwise.ts +737 -0
  248. package/src/prove/smt/solver/nlsat/mpbq.ts +161 -0
  249. package/src/prove/smt/solver/nlsat/polynomial.ts +1722 -0
  250. package/src/prove/smt/solver/nlsat/solver.ts +911 -0
  251. package/src/prove/smt/solver/nlsat/types.ts +43 -0
  252. package/src/prove/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
  253. package/src/prove/smt/solver/nlsat/upolynomial.ts +996 -0
  254. package/src/prove/smt/solver/nnf.ts +469 -0
  255. package/src/prove/smt/solver/pattern-inference.ts +351 -0
  256. package/src/prove/smt/solver/poly-rewriter.ts +477 -0
  257. package/src/prove/smt/solver/propagate-values.ts +83 -0
  258. package/src/prove/smt/solver/proto-model.ts +551 -0
  259. package/src/prove/smt/solver/pull-quant.ts +139 -0
  260. package/src/prove/smt/solver/qe-lite-der.ts +526 -0
  261. package/src/prove/smt/solver/qe-lite-fm.ts +576 -0
  262. package/src/prove/smt/solver/qe-lite.ts +381 -0
  263. package/src/prove/smt/solver/qi-queue.ts +362 -0
  264. package/src/prove/smt/solver/quant-tactics.ts +117 -0
  265. package/src/prove/smt/solver/quantifier-analyzer.ts +562 -0
  266. package/src/prove/smt/solver/quantifier-manager.ts +186 -0
  267. package/src/prove/smt/solver/random-gen.ts +10 -0
  268. package/src/prove/smt/solver/rational.ts +165 -0
  269. package/src/prove/smt/solver/ref-vector.ts +62 -0
  270. package/src/prove/smt/solver/relevancy.ts +247 -0
  271. package/src/prove/smt/solver/rewriter-tpl.ts +1159 -0
  272. package/src/prove/smt/solver/rewriter.ts +843 -0
  273. package/src/prove/smt/solver/rlimit.ts +79 -0
  274. package/src/prove/smt/solver/smtlib-parser.ts +526 -0
  275. package/src/prove/smt/solver/solver.ts +71 -0
  276. package/src/prove/smt/solver/sort.ts +35 -0
  277. package/src/prove/smt/solver/sticky-generations.ts +69 -0
  278. package/src/prove/smt/solver/theory-lra-axioms.ts +340 -0
  279. package/src/prove/smt/solver/theory-lra-bounds.ts +226 -0
  280. package/src/prove/smt/solver/theory-lra-final-check.ts +252 -0
  281. package/src/prove/smt/solver/theory-lra-internalize.ts +476 -0
  282. package/src/prove/smt/solver/theory-lra-model.ts +243 -0
  283. package/src/prove/smt/solver/theory-lra-propagate.ts +405 -0
  284. package/src/prove/smt/solver/theory-lra-state.ts +43 -0
  285. package/src/prove/smt/solver/theory-lra.ts +56 -0
  286. package/src/prove/smt/solver/var-subst.ts +258 -0
  287. package/src/prove/smt/solver/z3-license.txt +10 -0
  288. package/src/prove/smt/table.ts +170 -0
  289. package/src/prove/tlapm/tlapm.ts +96 -0
  290. package/src/prove/tlaps-module.ts +510 -0
  291. package/src/prove/verdict.ts +18 -0
  292. package/src/prove/zenon/LICENSE +32 -0
  293. package/src/prove/zenon/check/check.ts +105 -0
  294. package/src/prove/zenon/check/definitions.ts +144 -0
  295. package/src/prove/zenon/check/equality.ts +182 -0
  296. package/src/prove/zenon/check/functions.ts +62 -0
  297. package/src/prove/zenon/check/keys.ts +125 -0
  298. package/src/prove/zenon/check/propositional.ts +104 -0
  299. package/src/prove/zenon/check/records.ts +188 -0
  300. package/src/prove/zenon/check/relations.ts +121 -0
  301. package/src/prove/zenon/check/rewrites.ts +224 -0
  302. package/src/prove/zenon/check/sets.ts +302 -0
  303. package/src/prove/zenon/check/terms.ts +127 -0
  304. package/src/prove/zenon/check/tla.ts +126 -0
  305. package/src/prove/zenon/decide.ts +113 -0
  306. package/src/prove/zenon/encode.ts +379 -0
  307. package/src/prove/zenon/eqrel.ts +300 -0
  308. package/src/prove/zenon/equality-rules.ts +435 -0
  309. package/src/prove/zenon/expr.ts +551 -0
  310. package/src/prove/zenon/index-table.ts +350 -0
  311. package/src/prove/zenon/isar-case.ts +513 -0
  312. package/src/prove/zenon/isar.ts +1249 -0
  313. package/src/prove/zenon/limits.ts +15 -0
  314. package/src/prove/zenon/llproof.ts +173 -0
  315. package/src/prove/zenon/mltoll.ts +1566 -0
  316. package/src/prove/zenon/node.ts +297 -0
  317. package/src/prove/zenon/ocaml.ts +169 -0
  318. package/src/prove/zenon/parse.ts +247 -0
  319. package/src/prove/zenon/phrase.ts +191 -0
  320. package/src/prove/zenon/proof.ts +198 -0
  321. package/src/prove/zenon/propositional-rules.ts +387 -0
  322. package/src/prove/zenon/rules.ts +94 -0
  323. package/src/prove/zenon/search.ts +288 -0
  324. package/src/prove/zenon/tla/functions.ts +151 -0
  325. package/src/prove/zenon/tla/llproof.ts +480 -0
  326. package/src/prove/zenon/tla/records.ts +225 -0
  327. package/src/prove/zenon/tla/rewrites.ts +447 -0
  328. package/src/prove/zenon/tla/sets.ts +304 -0
  329. package/src/prove/zenon/tla/terms.ts +162 -0
  330. package/src/prove/zenon/tla/tla.ts +506 -0
  331. package/src/randomization.ts +24 -7
  332. package/src/resolve.ts +1481 -426
  333. package/src/run-cli.ts +1483 -212
  334. package/src/runtime.ts +19 -1
  335. package/src/sany-builtins.ts +147 -0
  336. package/src/sany-generator.ts +3128 -0
  337. package/src/sany-levels.ts +1208 -0
  338. package/src/sany-lexer.ts +545 -0
  339. package/src/sany-linter.ts +122 -0
  340. package/src/sany-modules.ts +1398 -0
  341. package/src/sany-nodes.ts +463 -0
  342. package/src/sany-parse-error.ts +2161 -0
  343. package/src/sany-report.ts +356 -0
  344. package/src/sany-selectors.ts +738 -0
  345. package/src/sany-source.ts +248 -0
  346. package/src/sany-xml.ts +1017 -0
  347. package/src/spec-description.ts +42 -11
  348. package/src/standard-modules.ts +203 -148
  349. package/src/standard-ranges.ts +116 -0
  350. package/src/state-graph.ts +180 -0
  351. package/src/subexpressions.ts +231 -171
  352. package/src/substitution-levels.ts +38 -17
  353. package/src/successors.ts +241 -110
  354. package/src/symmetry.ts +194 -54
  355. package/src/tableau.ts +54 -25
  356. package/src/tlapm-cache.ts +236 -0
  357. package/src/tlc-ext.ts +42 -29
  358. package/src/tlc-messages.ts +329 -0
  359. package/src/tlc-module.ts +52 -43
  360. package/src/tlc-modules.ts +4 -0
  361. package/src/tlc-order.ts +78 -10
  362. package/src/tlc-random.ts +84 -33
  363. package/src/tlc-replay.ts +655 -0
  364. package/src/tlc-summary.ts +20 -5
  365. package/src/tlc-version.ts +19 -0
  366. package/src/transfer.ts +15 -3
  367. package/src/values.ts +787 -190
  368. package/src/worker.ts +65 -0
  369. package/dist/parallel.cjs +0 -12
  370. package/dist/parallel.js +0 -12
@@ -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 {
6
+ adjoin,
7
+ adjoinAll,
8
+ getScopeAt,
9
+ isEqualExpr,
10
+ mapScoped,
11
+ shiftExpr,
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
+ };
@@ -0,0 +1,43 @@
1
+ import { TlapmBugError } from "../../errors";
2
+ import { expandActionOperators, lambdify } from "../../obligations/action";
3
+ import { createAnonymizer } from "../../obligations/anon";
4
+ import type { Expr, Sequent } from "../../obligations/expression";
5
+ import { implicationToEnabled } from "./enabled-axioms";
6
+ import { checkLevelChange } from "./level-comparison";
7
+
8
+ // expand_enabled_cdot: the first frontend the methods cite, in tlapm's order, transforms the
9
+ // obligation. Its soundness checks throw a TlaProverError, as tlapm then runs no backend.
10
+ export const expandEnabledCdot = (sequent: Sequent, frontends: Set<string>): Sequent => {
11
+ const isEnabled = frontends.has("expandenabled");
12
+ const isCdot = frontends.has("expandcdot");
13
+ const isAutoUse = frontends.has("autouse");
14
+ const isLambdify = frontends.has("lambdify");
15
+ if (!isEnabled && !isCdot && !isLambdify) {
16
+ if (frontends.has("levelcomparison")) return checkLevelChange(sequent);
17
+ if (frontends.has("enabledaxioms")) return implicationToEnabled(sequent);
18
+ return sequent;
19
+ }
20
+ // Expr.Anon's anon, which only meets the names that lambdification binds.
21
+ const anonymizer = createAnonymizer(
22
+ { value: 0 },
23
+ () => {
24
+ throw new TlapmBugError();
25
+ },
26
+ () => {},
27
+ );
28
+ const expression: Expr = { kind: "Sequent", sequent };
29
+ const result =
30
+ isEnabled || isCdot
31
+ ? expandActionOperators(anonymizer, () => {}, undefined, expression, {
32
+ isEnabled,
33
+ isCdot,
34
+ isAutoUse,
35
+ })
36
+ : lambdify(anonymizer, () => {}, undefined, expression, {
37
+ isEnabled: true,
38
+ isCdot: true,
39
+ isAutoUse,
40
+ });
41
+ if (result.kind !== "Sequent") throw new TlapmBugError();
42
+ return result.sequent;
43
+ };
@@ -0,0 +1,388 @@
1
+ // A port of tlapm's Backend.Fingerprints.fp_sequent: the digest of an obligation that names its
2
+ // hypotheses and bound variables by the order of their first use, so two obligations that differ
3
+ // only in names share it.
4
+
5
+ import { TlapmBugError } from "../../errors";
6
+ import {
7
+ adjoin,
8
+ type Bound,
9
+ type Builtin,
10
+ type Expr,
11
+ type Hyp,
12
+ type Scope,
13
+ type Sequent,
14
+ } from "../../obligations/expression";
15
+ import { isConstant } from "../../obligations/temporal";
16
+ import { getMd5 } from "./md5";
17
+
18
+ // builtin_to_int, whose numbers skip [], which fp_bin prints by name.
19
+ const BUILTIN_NUMBERS: Builtin[] = [
20
+ "TRUE",
21
+ "FALSE",
22
+ "Implies",
23
+ "Equiv",
24
+ "Conj",
25
+ "Disj",
26
+ "Neg",
27
+ "Eq",
28
+ "Neq",
29
+ "STRING",
30
+ "BOOLEAN",
31
+ "SUBSET",
32
+ "UNION",
33
+ "DOMAIN",
34
+ "Subseteq",
35
+ "Mem",
36
+ "Notmem",
37
+ "Setminus",
38
+ "Cap",
39
+ "Cup",
40
+ "Prime",
41
+ "StrongPrime",
42
+ "Leadsto",
43
+ "ENABLED",
44
+ "UNCHANGED",
45
+ "Cdot",
46
+ "Actplus",
47
+ "Diamond",
48
+ "Nat",
49
+ "Int",
50
+ "Real",
51
+ "Plus",
52
+ "Minus",
53
+ "Uminus",
54
+ "Times",
55
+ "Ratio",
56
+ "Quotient",
57
+ "Remainder",
58
+ "Exp",
59
+ "Infinity",
60
+ "Lteq",
61
+ "Lt",
62
+ "Gteq",
63
+ "Gt",
64
+ "Divides",
65
+ "Range",
66
+ "Seq",
67
+ "Len",
68
+ "BSeq",
69
+ "Cat",
70
+ "Append",
71
+ "Head",
72
+ "Tail",
73
+ "SubSeq",
74
+ "SelectSeq",
75
+ "OneArg",
76
+ "Extend",
77
+ "Print",
78
+ "PrintT",
79
+ "Assert",
80
+ "JavaTime",
81
+ "TLCGet",
82
+ "TLCSet",
83
+ "Permutations",
84
+ "SortSeq",
85
+ "RandomElement",
86
+ "Any",
87
+ "ToString",
88
+ "Unprimable",
89
+ "Irregular",
90
+ ];
91
+
92
+ const BULLETS = { And: 0, Or: 1, Refs: 2 };
93
+
94
+ const QUANTIFIERS = { Forall: 0, Exists: 1 };
95
+
96
+ const MODALS = { Box: 0, Dia: 1 };
97
+
98
+ const FAIRNESS = { Weak: 0, Strong: 1 };
99
+
100
+ // What a stack entry stands for: a hypothesis not yet used, under the label its first use prints,
101
+ // one used, numbered, a bound variable not yet used, one used, a pragma, or a hidden fact.
102
+ type Ident =
103
+ | { kind: "Hyp"; label: string }
104
+ | { kind: "HypIndex"; index: number }
105
+ | { kind: "Var" }
106
+ | { kind: "VarIndex"; index: number }
107
+ | { kind: "Pragma" }
108
+ | { kind: "None" };
109
+
110
+ interface Entry {
111
+ ident: Ident;
112
+ isUsed: boolean;
113
+ }
114
+
115
+ interface Counters {
116
+ hyp: number;
117
+ variable: number;
118
+ }
119
+
120
+ const OCAML_ESCAPES: Record<number, string> = {
121
+ 0x22: '\\"',
122
+ 0x5c: "\\\\",
123
+ 0x0a: "\\n",
124
+ 0x09: "\\t",
125
+ 0x0d: "\\r",
126
+ 0x08: "\\b",
127
+ };
128
+
129
+ // OCaml's %S: a string literal, with each byte outside printable ASCII as a decimal escape.
130
+ const quoteString = (value: string) =>
131
+ `"${[...new TextEncoder().encode(value)]
132
+ .map(
133
+ (byte) =>
134
+ OCAML_ESCAPES[byte] ??
135
+ (byte < 0x20 || byte > 0x7e
136
+ ? `\\${String(byte).padStart(3, "0")}`
137
+ : String.fromCharCode(byte)),
138
+ )
139
+ .join("")}"`;
140
+
141
+ const getBuiltin = (builtin: Builtin) => {
142
+ if (builtin === "BoxTrue") return "$Box";
143
+ if (builtin === "BoxFalse") return "$FakeBox";
144
+ return `$${BUILTIN_NUMBERS.indexOf(builtin)}`;
145
+ };
146
+
147
+ const getFreshLabel = (hyp: Extract<Hyp, { kind: "Fresh" }>) =>
148
+ hyp.level === "Unknown" ? "Unknown" : hyp.level.toUpperCase();
149
+
150
+ // fp_sequent's text for an obligation, before its digest.
151
+ const getFingerprintText = (sequent: Sequent) => {
152
+ const stack: Entry[] = [];
153
+ const get = (index: number) => {
154
+ const entry = stack[stack.length - index];
155
+ if (!entry) throw new TlapmBugError();
156
+ return entry;
157
+ };
158
+ const push = (ident: Ident) => stack.push({ ident, isUsed: false });
159
+ const pop = () => {
160
+ const entry = stack.pop();
161
+ if (!entry) throw new TlapmBugError();
162
+ return entry;
163
+ };
164
+ const pushVariables = (count: number) =>
165
+ Array.from({ length: count }).forEach(() => push({ kind: "Var" }));
166
+ // Stack.popn: the entries from the top down.
167
+ const popVariables = (count: number) => Array.from({ length: count }, pop);
168
+ const getVariableNumber = (entry: Entry) => {
169
+ if (entry.ident.kind === "VarIndex") return entry.ident.index;
170
+ if (entry.ident.kind === "Var") return 0;
171
+ throw new TlapmBugError();
172
+ };
173
+ const getHypNumber = (entry: Entry) => {
174
+ if (entry.ident.kind !== "HypIndex") throw new TlapmBugError();
175
+ return entry.ident.index;
176
+ };
177
+
178
+ const printExpr = (counters: Counters, expression: Expr): string => {
179
+ const print = (inner: Expr) => printExpr(counters, inner);
180
+ const printList = (items: Expr[]) => items.map(print).join(",");
181
+ // fp_bounds pairs each bound with an entry, and prints those with a domain.
182
+ const printBounds = (entries: Entry[], bounds: Bound[]) =>
183
+ bounds
184
+ .map((bound, index) =>
185
+ bound.domain.kind === "Domain"
186
+ ? `${getVariableNumber(entries[index])}:${print(bound.domain.expression)},`
187
+ : "",
188
+ )
189
+ .join("");
190
+ // A binder's body comes first, then what pops off the stack after it.
191
+ const printBound = (count: number, body: Expr) => {
192
+ pushVariables(count);
193
+ const text = print(body);
194
+ return { text, entries: popVariables(count) };
195
+ };
196
+ const printNumbers = (entries: Entry[]) =>
197
+ entries.map((entry) => `${getVariableNumber(entry)}.`).join("");
198
+ switch (expression.kind) {
199
+ case "Ix": {
200
+ const entry = get(expression.index);
201
+ entry.isUsed = true;
202
+ const ident = entry.ident;
203
+ switch (ident.kind) {
204
+ case "None":
205
+ return `$V(${expression.index}SHOULD_NOT_APPEAR)`;
206
+ case "Hyp": {
207
+ const index = counters.hyp++;
208
+ entry.ident = { kind: "HypIndex", index };
209
+ return `$${ident.label}(${index})`;
210
+ }
211
+ case "Var": {
212
+ const index = counters.variable++;
213
+ entry.ident = { kind: "VarIndex", index };
214
+ return `$PRM(${index})`;
215
+ }
216
+ case "HypIndex":
217
+ return `$HYP(${ident.index})`;
218
+ case "VarIndex":
219
+ return `$PRM(${ident.index})`;
220
+ case "Pragma":
221
+ return "";
222
+ }
223
+ throw new TlapmBugError();
224
+ }
225
+ case "Opaque":
226
+ return expression.name;
227
+ case "Internal":
228
+ return getBuiltin(expression.builtin);
229
+ case "Lambda": {
230
+ const bound = printBound(expression.params.length, expression.body);
231
+ return `$Lam(${printNumbers(bound.entries.toReversed())}${bound.text})`;
232
+ }
233
+ case "Sequent":
234
+ return printSequent(expression.sequent);
235
+ case "Apply": {
236
+ const operator = expression.operator;
237
+ if (operator.kind === "Ix" && get(operator.index).ident.kind === "Pragma") return "";
238
+ return `$OpApp(${print(operator)};${printList(expression.args)})`;
239
+ }
240
+ case "With":
241
+ case "Parens":
242
+ return print(expression.expression);
243
+ case "If":
244
+ return `$If(${print(expression.condition)},${print(expression.consequent)},${print(expression.alternative)})`;
245
+ case "List":
246
+ return `$List(${BULLETS[expression.bullet]};${printList(expression.items)})`;
247
+ case "Let": {
248
+ const definitions = expression.definitions.map((definition) => {
249
+ if (definition.kind !== "Operator" && definition.kind !== "Bpragma")
250
+ throw new TlapmBugError();
251
+ const text = `${print(definition.body)}.`;
252
+ push({ kind: "Var" });
253
+ return text;
254
+ });
255
+ const body = print(expression.body);
256
+ popVariables(definitions.length);
257
+ return `${definitions.join("")}${body}`;
258
+ }
259
+ // fp_expr pairs a quantifier's bounds with its variables from the last one down.
260
+ case "Quant": {
261
+ const bound = printBound(expression.bounds.length, expression.body);
262
+ return `$Quant(${QUANTIFIERS[expression.quantifier]};${printBounds(bound.entries, expression.bounds)}.${bound.text})`;
263
+ }
264
+ case "Tquant": {
265
+ const bound = printBound(expression.names.length, expression.body);
266
+ return `$Tquant(${QUANTIFIERS[expression.quantifier]}${printNumbers(bound.entries.toReversed())}${bound.text})`;
267
+ }
268
+ case "Choose": {
269
+ const bound = printBound(1, expression.body);
270
+ const number = getVariableNumber(bound.entries[0]);
271
+ return expression.domain
272
+ ? `$Bch(${number}:${print(expression.domain)};${bound.text})`
273
+ : `$Ch(${number}:${bound.text})`;
274
+ }
275
+ case "SetSt": {
276
+ const bound = printBound(1, expression.body);
277
+ return `$SSt(${getVariableNumber(bound.entries[0])}:${print(expression.domain)};${bound.text})`;
278
+ }
279
+ case "SetOf": {
280
+ const bound = printBound(expression.bounds.length, expression.element);
281
+ return `$Sof(${printBounds(bound.entries.toReversed(), expression.bounds)}.${bound.text})`;
282
+ }
283
+ case "Fcn": {
284
+ const bound = printBound(expression.bounds.length, expression.body);
285
+ return `$Fcn(${printBounds(bound.entries.toReversed(), expression.bounds)}.${bound.text})`;
286
+ }
287
+ case "SetEnum":
288
+ return `$Set(${printList(expression.elements)})`;
289
+ case "Tuple":
290
+ return `$Tup(${printList(expression.elements)})`;
291
+ case "Product":
292
+ return `$Prod(${printList(expression.factors)})`;
293
+ case "FcnApp":
294
+ return `$FcnApp(${print(expression.function)};${printList(expression.args)})`;
295
+ case "Arrow":
296
+ return `$Arrow(${print(expression.domain)},${print(expression.range)})`;
297
+ case "Rect":
298
+ case "Record":
299
+ return `$${expression.kind}(${expression.fields.map((field) => `(${field.name},${print(field.value)})`).join(",")})`;
300
+ case "Except": {
301
+ const base = print(expression.function);
302
+ const specs = expression.specs.map((spec) => {
303
+ const trail = spec.trail
304
+ .map((point) =>
305
+ point.kind === "Dot" ? `.${point.field}` : `.${print(point.expression)}`,
306
+ )
307
+ .join("");
308
+ return `(${trail}=${print(spec.value)})`;
309
+ });
310
+ return `$Except(${base},${specs.join(",")})`;
311
+ }
312
+ case "Dot":
313
+ return `$Dot(${print(expression.expression)},${expression.field})`;
314
+ case "Sub":
315
+ case "Tsub":
316
+ return `$${expression.kind}(${MODALS[expression.modal]},${print(expression.action)},${print(expression.subscript)})`;
317
+ case "Fair":
318
+ return `$Fair(${FAIRNESS[expression.fairness]},${print(expression.subscript)},${print(expression.action)})`;
319
+ case "Case": {
320
+ const arms = expression.arms
321
+ .map((arm) => `(${print(arm.condition)},${print(arm.body)})`)
322
+ .join(",");
323
+ return `$Case(${arms},${expression.other ? print(expression.other) : ""})`;
324
+ }
325
+ case "String":
326
+ return quoteString(expression.value);
327
+ case "Num":
328
+ return `$Num(${expression.integer},${expression.fraction})`;
329
+ case "At":
330
+ return "$At";
331
+ case "Bang":
332
+ throw new TlapmBugError();
333
+ }
334
+ };
335
+
336
+ // Each hypothesis prints after the goal and the hypotheses after it, once their uses have
337
+ // numbered it.
338
+ const printSequent = (inner: Sequent): string => {
339
+ const counters = { hyp: 1, variable: 1 };
340
+ const spin = (index: number, scope: Scope | undefined): string => {
341
+ const hyp = inner.context[index];
342
+ if (!hyp) return `$Goal(${printExpr(counters, inner.active)})`;
343
+ const getRest = (ident: Ident) => {
344
+ push(ident);
345
+ const rest = spin(index + 1, adjoin(scope, hyp));
346
+ return { rest, entry: pop() };
347
+ };
348
+ switch (hyp.kind) {
349
+ case "Fresh": {
350
+ if (!hyp.domain) {
351
+ const label = getFreshLabel(hyp);
352
+ const after = getRest({ kind: "Hyp", label });
353
+ return after.entry.isUsed ? `${after.rest}${label}${hyp.name}` : after.rest;
354
+ }
355
+ const after = getRest({ kind: "Hyp", label: "CON" });
356
+ if (hyp.domainVisibility === "Hidden") return after.rest;
357
+ const number = after.entry.isUsed ? String(getHypNumber(after.entry)) : "_";
358
+ return `${after.rest}$Dom(${number};${printExpr(counters, hyp.domain)})`;
359
+ }
360
+ case "Flex":
361
+ return getRest({ kind: "Hyp", label: "VAR" }).rest;
362
+ case "Defn": {
363
+ const definition = hyp.definition;
364
+ if (definition.kind === "Recursive") return getRest({ kind: "Hyp", label: "CON" }).rest;
365
+ if (definition.kind === "Bpragma") return getRest({ kind: "Pragma" }).rest;
366
+ if (definition.kind === "Instance") throw new TlapmBugError();
367
+ const after = getRest({ kind: "Hyp", label: "HYP" });
368
+ if (!after.entry.isUsed) return after.rest;
369
+ const number = getHypNumber(after.entry);
370
+ return hyp.visibility === "Hidden"
371
+ ? `${after.rest}$Def(${number},${isConstant(scope, definition.body) ? 0 : 3})`
372
+ : `${after.rest}$Def(${number};${printExpr(counters, definition.body)})`;
373
+ }
374
+ case "Fact": {
375
+ if (hyp.visibility === "Hidden") return getRest({ kind: "None" }).rest;
376
+ const after = getRest({ kind: "Hyp", label: "HYP" });
377
+ return `${after.rest}$Fact(${printExpr(counters, hyp.expression)},${hyp.time.toLowerCase()})`;
378
+ }
379
+ }
380
+ };
381
+ return spin(0, undefined);
382
+ };
383
+
384
+ return printSequent(sequent);
385
+ };
386
+
387
+ // fingerprint: the hex digest of an obligation's fp_sequent text.
388
+ export const getFingerprint = (sequent: Sequent) => getMd5(getFingerprintText(sequent));
@@ -0,0 +1,70 @@
1
+ import {
2
+ at,
3
+ bumpBy,
4
+ shift,
5
+ shiftExpr,
6
+ substituteExpr,
7
+ substituteHyp,
8
+ type Bound,
9
+ type Expr,
10
+ type Hyp,
11
+ type Sequent,
12
+ type Substitution,
13
+ } from "../../obligations/expression";
14
+
15
+ const isUnbounded = (bound: Bound) => bound.domain.kind === "NoDomain";
16
+
17
+ // extract_equalities: the equalities in a conjunction, apart from the rest of it.
18
+ const extractEqualities = (expression: Expr): [Expr[], Expr | undefined] => {
19
+ if (expression.kind === "List" && (expression.bullet === "And" || expression.bullet === "Refs")) {
20
+ const parts = expression.items.map(extractEqualities);
21
+ const equalities = parts.flatMap((part) => part[0]);
22
+ const rest = parts.flatMap((part) => (part[1] ? [part[1]] : []));
23
+ if (rest.length <= 1) return [equalities, rest[0]];
24
+ return [equalities, { ...expression, bullet: "And", items: rest }];
25
+ }
26
+ if (expression.kind === "Apply" && expression.operator.kind === "Internal") {
27
+ const builtin = expression.operator.builtin;
28
+ if (builtin === "Conj" && expression.args.length === 2) {
29
+ const left = extractEqualities(expression.args[0]);
30
+ const right = extractEqualities(expression.args[1]);
31
+ const equalities = [...left[0], ...right[0]];
32
+ if (left[1] && right[1]) return [equalities, { ...expression, args: [left[1], right[1]] }];
33
+ return [equalities, left[1] ?? right[1]];
34
+ }
35
+ if (builtin === "Eq") return [[expression], undefined];
36
+ }
37
+ if (expression.kind === "Internal" && expression.builtin === "TRUE") return [[], undefined];
38
+ if (
39
+ expression.kind === "Quant" &&
40
+ expression.quantifier === "Forall" &&
41
+ expression.bounds.every(isUnbounded)
42
+ ) {
43
+ const extracted = extractEqualities(expression.body);
44
+ const quantify = (inner: Expr, from: Expr) =>
45
+ at({ kind: "Quant", quantifier: "Forall", bounds: expression.bounds, body: inner }, from);
46
+ return [
47
+ extracted[0].map((equality) => quantify(equality, equality)),
48
+ extracted[1] && quantify(extracted[1], expression),
49
+ ];
50
+ }
51
+ return [[], expression];
52
+ };
53
+
54
+ // flatten: each visible fact becomes the rest of it, then its equalities.
55
+ export const flatten = (sequent: Sequent): Sequent => {
56
+ const context: Hyp[] = [];
57
+ const substitution = sequent.context.reduce<Substitution>((current, hyp) => {
58
+ if (hyp.kind !== "Fact" || hyp.visibility !== "Visible") {
59
+ context.push(substituteHyp(current, hyp));
60
+ return bumpBy(1, current);
61
+ }
62
+ const extracted = extractEqualities(hyp.expression);
63
+ const facts = [...(extracted[1] ? [extracted[1]] : []), ...extracted[0]];
64
+ facts.forEach((fact, index) =>
65
+ context.push({ ...hyp, expression: shiftExpr(index, substituteExpr(current, fact)) }),
66
+ );
67
+ return { kind: "Compose", outer: shift(facts.length - 1), inner: bumpBy(1, current) };
68
+ }, shift(0));
69
+ return { context, active: substituteExpr(substitution, sequent.active) };
70
+ };