tla-ts 0.0.4-dev.2be6058 → 0.0.4-dev.43f28be

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