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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (313) hide show
  1. package/README.md +27 -141
  2. package/dist/deciders.cjs +366 -0
  3. package/dist/deciders.js +366 -0
  4. package/dist/index.cjs +1 -1
  5. package/dist/index.d.cts +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 +37 -47
  17. package/dist/run-cli.js +37 -47
  18. package/dist/tlapm.cjs +10 -0
  19. package/dist/tlapm.js +10 -0
  20. package/dist/transfer.cjs +38 -44
  21. package/dist/transfer.js +38 -44
  22. package/dist/worker.cjs +21 -0
  23. package/dist/worker.js +21 -0
  24. package/package.json +21 -12
  25. package/src/check.ts +1 -0
  26. package/src/codegen.ts +26 -7
  27. package/src/errors.ts +86 -0
  28. package/src/evaluate.ts +63 -20
  29. package/src/index.ts +10 -0
  30. package/src/{obligation-action.ts → obligations/action.ts} +265 -55
  31. package/src/{obligation-anon.ts → obligations/anon.ts} +47 -37
  32. package/src/obligations/ctx.ts +64 -0
  33. package/src/{obligation-deref.ts → obligations/deref.ts} +38 -61
  34. package/src/{obligation-expression.ts → obligations/expression.ts} +78 -45
  35. package/src/{obligation-format.ts → obligations/format.ts} +7 -8
  36. package/src/{obligation-generate.ts → obligations/generate.ts} +147 -74
  37. package/src/{obligations.ts → obligations/index.ts} +29 -13
  38. package/src/{obligation-levels.ts → obligations/levels.ts} +14 -5
  39. package/src/{obligation-module.ts → obligations/module.ts} +56 -33
  40. package/src/obligations/pickle.ts +98 -0
  41. package/src/obligations/pragma.ts +189 -0
  42. package/src/{obligation-printer.ts → obligations/printer.ts} +22 -80
  43. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -1
  44. package/src/{obligation-source.ts → obligations/source.ts} +159 -97
  45. package/src/obligations/temporal.ts +319 -0
  46. package/src/{obligation-tuples.ts → obligations/tuples.ts} +1 -1
  47. package/src/ocaml-marshal.ts +166 -0
  48. package/src/parallel-worker.ts +2 -18
  49. package/src/parallel.ts +10 -43
  50. package/src/prove/decide-pool.ts +100 -0
  51. package/src/prove/deciders.ts +33 -0
  52. package/src/prove/isabelle/LICENSE +36 -0
  53. package/src/prove/isabelle/LICENSE-tlapm +26 -0
  54. package/src/prove/isabelle/decide.ts +47 -0
  55. package/src/prove/isabelle/encode.ts +503 -0
  56. package/src/prove/isabelle/isar/inner-syntax.ts +579 -0
  57. package/src/prove/isabelle/isar/method.ts +367 -0
  58. package/src/prove/isabelle/isar/proof.ts +28 -0
  59. package/src/prove/isabelle/isar/statement.ts +57 -0
  60. package/src/prove/isabelle/isar/theory.ts +192 -0
  61. package/src/prove/isabelle/isar/type-check.ts +278 -0
  62. package/src/prove/isabelle/provers/blast/blast.ts +258 -0
  63. package/src/prove/isabelle/provers/blast/branch.ts +322 -0
  64. package/src/prove/isabelle/provers/blast/prove.ts +347 -0
  65. package/src/prove/isabelle/provers/blast/rules.ts +330 -0
  66. package/src/prove/isabelle/provers/blast/state.ts +180 -0
  67. package/src/prove/isabelle/provers/blast/term.ts +547 -0
  68. package/src/prove/isabelle/provers/clasimp.ts +150 -0
  69. package/src/prove/isabelle/provers/classical.ts +389 -0
  70. package/src/prove/isabelle/provers/hypsubst.ts +441 -0
  71. package/src/prove/isabelle/pure/bicompose.ts +174 -0
  72. package/src/prove/isabelle/pure/consts.ts +32 -0
  73. package/src/prove/isabelle/pure/conv.ts +79 -0
  74. package/src/prove/isabelle/pure/drule.ts +264 -0
  75. package/src/prove/isabelle/pure/envir.ts +363 -0
  76. package/src/prove/isabelle/pure/goal.ts +53 -0
  77. package/src/prove/isabelle/pure/interrupt.ts +16 -0
  78. package/src/prove/isabelle/pure/list.ts +12 -0
  79. package/src/prove/isabelle/pure/logic.ts +402 -0
  80. package/src/prove/isabelle/pure/name.ts +110 -0
  81. package/src/prove/isabelle/pure/net.ts +262 -0
  82. package/src/prove/isabelle/pure/object-logic.ts +41 -0
  83. package/src/prove/isabelle/pure/pattern.ts +650 -0
  84. package/src/prove/isabelle/pure/raw-simplifier.ts +353 -0
  85. package/src/prove/isabelle/pure/rewriter.ts +602 -0
  86. package/src/prove/isabelle/pure/search.ts +68 -0
  87. package/src/prove/isabelle/pure/seq.ts +156 -0
  88. package/src/prove/isabelle/pure/simplifier.ts +112 -0
  89. package/src/prove/isabelle/pure/table.ts +208 -0
  90. package/src/prove/isabelle/pure/tactic.ts +276 -0
  91. package/src/prove/isabelle/pure/tactical.ts +347 -0
  92. package/src/prove/isabelle/pure/term-ord.ts +159 -0
  93. package/src/prove/isabelle/pure/term.ts +808 -0
  94. package/src/prove/isabelle/pure/thm.ts +806 -0
  95. package/src/prove/isabelle/pure/type.ts +133 -0
  96. package/src/prove/isabelle/pure/unify.ts +753 -0
  97. package/src/prove/isabelle/pure/variable.ts +25 -0
  98. package/src/prove/isabelle/tla/classical-setup.ts +101 -0
  99. package/src/prove/isabelle/tla/context.ts +74 -0
  100. package/src/prove/isabelle/tla/logic-data.ts +5 -0
  101. package/src/prove/isabelle/tla/logic.ts +215 -0
  102. package/src/prove/isabelle/tla/simpdata.ts +241 -0
  103. package/src/prove/isabelle/tools/intuitionistic.ts +132 -0
  104. package/src/prove/ocaml.ts +22 -0
  105. package/src/prove/prep/action.ts +521 -0
  106. package/src/prove/prep/defs.ts +33 -0
  107. package/src/prove/prep/elab.ts +156 -0
  108. package/src/prove/prep/enabled-axioms.ts +189 -0
  109. package/src/prove/prep/enabled.ts +43 -0
  110. package/src/prove/prep/fingerprint.ts +388 -0
  111. package/src/prove/prep/flatten.ts +70 -0
  112. package/src/prove/prep/level-comparison.ts +557 -0
  113. package/src/prove/prep/md5.ts +67 -0
  114. package/src/prove/prep/pragma.ts +221 -0
  115. package/src/prove/prep/trivial.ts +22 -0
  116. package/src/prove/prove-worker.ts +25 -0
  117. package/src/prove/prove.ts +505 -0
  118. package/src/prove/ptl/decide.ts +68 -0
  119. package/src/prove/ptl/encode.ts +256 -0
  120. package/src/prove/ptl/sat.ts +151 -0
  121. package/src/prove/ptl/tableau.ts +276 -0
  122. package/src/prove/smt/axiomatize.ts +69 -0
  123. package/src/prove/smt/axioms.ts +222 -0
  124. package/src/prove/smt/context.ts +108 -0
  125. package/src/prove/smt/data.ts +636 -0
  126. package/src/prove/smt/encode.ts +166 -0
  127. package/src/prove/smt/extensionality.ts +65 -0
  128. package/src/prove/smt/flatten.ts +112 -0
  129. package/src/prove/smt/format.ts +154 -0
  130. package/src/prove/smt/instances.ts +182 -0
  131. package/src/prove/smt/rewrite.ts +773 -0
  132. package/src/prove/smt/simplify.ts +57 -0
  133. package/src/prove/smt/solver/act-cache.ts +265 -0
  134. package/src/prove/smt/solver/arith-rewriter.ts +962 -0
  135. package/src/prove/smt/solver/array.ts +22 -0
  136. package/src/prove/smt/solver/asserted-formulas.ts +469 -0
  137. package/src/prove/smt/solver/ast-lt.ts +157 -0
  138. package/src/prove/smt/solver/ast-util.ts +147 -0
  139. package/src/prove/smt/solver/ast.ts +1315 -0
  140. package/src/prove/smt/solver/auf-solver.ts +572 -0
  141. package/src/prove/smt/solver/case-split-queue.ts +178 -0
  142. package/src/prove/smt/solver/cg-table.ts +175 -0
  143. package/src/prove/smt/solver/clause.ts +276 -0
  144. package/src/prove/smt/solver/conflict-resolution.ts +343 -0
  145. package/src/prove/smt/solver/context.ts +1292 -0
  146. package/src/prove/smt/solver/ctx-simplify.ts +334 -0
  147. package/src/prove/smt/solver/der.ts +224 -0
  148. package/src/prove/smt/solver/dyn-ack.ts +141 -0
  149. package/src/prove/smt/solver/e-matching.ts +659 -0
  150. package/src/prove/smt/solver/enode.ts +259 -0
  151. package/src/prove/smt/solver/expr-ref.ts +21 -0
  152. package/src/prove/smt/solver/expr-safe-replace.ts +172 -0
  153. package/src/prove/smt/solver/fingerprints.ts +92 -0
  154. package/src/prove/smt/solver/flat-literals.ts +51 -0
  155. package/src/prove/smt/solver/goal.ts +138 -0
  156. package/src/prove/smt/solver/hash.ts +173 -0
  157. package/src/prove/smt/solver/hashtable.ts +166 -0
  158. package/src/prove/smt/solver/internalizer.ts +1381 -0
  159. package/src/prove/smt/solver/lbool.ts +5 -0
  160. package/src/prove/smt/solver/literal.ts +24 -0
  161. package/src/prove/smt/solver/lp/bound-propagator.ts +391 -0
  162. package/src/prove/smt/solver/lp/constraints.ts +78 -0
  163. package/src/prove/smt/solver/lp/containers.ts +296 -0
  164. package/src/prove/smt/solver/lp/core-solver.ts +504 -0
  165. package/src/prove/smt/solver/lp/cross-nested.ts +224 -0
  166. package/src/prove/smt/solver/lp/dep-intervals.ts +656 -0
  167. package/src/prove/smt/solver/lp/dependency.ts +51 -0
  168. package/src/prove/smt/solver/lp/dioph-eq.ts +1181 -0
  169. package/src/prove/smt/solver/lp/explanation.ts +46 -0
  170. package/src/prove/smt/solver/lp/gomory.ts +255 -0
  171. package/src/prove/smt/solver/lp/hnf-cutter.ts +125 -0
  172. package/src/prove/smt/solver/lp/hnf.ts +281 -0
  173. package/src/prove/smt/solver/lp/int-cube.ts +295 -0
  174. package/src/prove/smt/solver/lp/int-solver.ts +514 -0
  175. package/src/prove/smt/solver/lp/lar-solver.ts +816 -0
  176. package/src/prove/smt/solver/lp/lar-term.ts +62 -0
  177. package/src/prove/smt/solver/lp/lp-settings.ts +91 -0
  178. package/src/prove/smt/solver/lp/maximize-term.ts +347 -0
  179. package/src/prove/smt/solver/lp/nex-creator.ts +381 -0
  180. package/src/prove/smt/solver/lp/nex.ts +120 -0
  181. package/src/prove/smt/solver/lp/nla-backoff.ts +43 -0
  182. package/src/prove/smt/solver/lp/nla-basics.ts +398 -0
  183. package/src/prove/smt/solver/lp/nla-core.ts +968 -0
  184. package/src/prove/smt/solver/lp/nla-divisions.ts +332 -0
  185. package/src/prove/smt/solver/lp/nla-emonics.ts +373 -0
  186. package/src/prove/smt/solver/lp/nla-factorization.ts +30 -0
  187. package/src/prove/smt/solver/lp/nla-grobner.ts +904 -0
  188. package/src/prove/smt/solver/lp/nla-horner.ts +126 -0
  189. package/src/prove/smt/solver/lp/nla-intervals.ts +265 -0
  190. package/src/prove/smt/solver/lp/nla-monomial-bounds.ts +715 -0
  191. package/src/prove/smt/solver/lp/nla-monotone.ts +59 -0
  192. package/src/prove/smt/solver/lp/nla-order.ts +307 -0
  193. package/src/prove/smt/solver/lp/nla-patcher.ts +112 -0
  194. package/src/prove/smt/solver/lp/nla-tangents.ts +251 -0
  195. package/src/prove/smt/solver/lp/nla-throttle.ts +85 -0
  196. package/src/prove/smt/solver/lp/nla-types.ts +124 -0
  197. package/src/prove/smt/solver/lp/nla-var-eqs.ts +141 -0
  198. package/src/prove/smt/solver/lp/nra-solver.ts +440 -0
  199. package/src/prove/smt/solver/lp/numeric-pair.ts +65 -0
  200. package/src/prove/smt/solver/lp/pdd-interval.ts +31 -0
  201. package/src/prove/smt/solver/lp/pdd-simplifier.ts +184 -0
  202. package/src/prove/smt/solver/lp/pdd-solver.ts +408 -0
  203. package/src/prove/smt/solver/lp/pdd.ts +971 -0
  204. package/src/prove/smt/solver/lp/random-updater.ts +138 -0
  205. package/src/prove/smt/solver/lp/static-matrix.ts +246 -0
  206. package/src/prove/smt/solver/lp/union-find.ts +96 -0
  207. package/src/prove/smt/solver/mam-compiler.ts +847 -0
  208. package/src/prove/smt/solver/mam-interpreter.ts +400 -0
  209. package/src/prove/smt/solver/maximize-ac-sharing.ts +118 -0
  210. package/src/prove/smt/solver/model-checker.ts +347 -0
  211. package/src/prove/smt/solver/model-evaluator.ts +262 -0
  212. package/src/prove/smt/solver/model-finder.ts +155 -0
  213. package/src/prove/smt/solver/model-generator.ts +97 -0
  214. package/src/prove/smt/solver/model-macro-solver.ts +728 -0
  215. package/src/prove/smt/solver/nlsat/algebraic.ts +1161 -0
  216. package/src/prove/smt/solver/nlsat/atoms.ts +238 -0
  217. package/src/prove/smt/solver/nlsat/evaluator.ts +303 -0
  218. package/src/prove/smt/solver/nlsat/explain.ts +607 -0
  219. package/src/prove/smt/solver/nlsat/interval-set.ts +351 -0
  220. package/src/prove/smt/solver/nlsat/levelwise.ts +740 -0
  221. package/src/prove/smt/solver/nlsat/mpbq.ts +161 -0
  222. package/src/prove/smt/solver/nlsat/polynomial.ts +1722 -0
  223. package/src/prove/smt/solver/nlsat/solver.ts +911 -0
  224. package/src/prove/smt/solver/nlsat/types.ts +43 -0
  225. package/src/prove/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
  226. package/src/prove/smt/solver/nlsat/upolynomial.ts +996 -0
  227. package/src/prove/smt/solver/nnf.ts +469 -0
  228. package/src/prove/smt/solver/pattern-inference.ts +351 -0
  229. package/src/prove/smt/solver/poly-rewriter.ts +477 -0
  230. package/src/prove/smt/solver/propagate-values.ts +83 -0
  231. package/src/prove/smt/solver/proto-model.ts +551 -0
  232. package/src/prove/smt/solver/pull-quant.ts +139 -0
  233. package/src/prove/smt/solver/qe-lite-der.ts +526 -0
  234. package/src/prove/smt/solver/qe-lite-fm.ts +576 -0
  235. package/src/prove/smt/solver/qe-lite.ts +381 -0
  236. package/src/prove/smt/solver/qi-queue.ts +362 -0
  237. package/src/prove/smt/solver/quant-tactics.ts +117 -0
  238. package/src/prove/smt/solver/quantifier-analyzer.ts +562 -0
  239. package/src/prove/smt/solver/quantifier-manager.ts +186 -0
  240. package/src/prove/smt/solver/random-gen.ts +10 -0
  241. package/src/prove/smt/solver/rational.ts +165 -0
  242. package/src/prove/smt/solver/ref-vector.ts +62 -0
  243. package/src/prove/smt/solver/relevancy.ts +247 -0
  244. package/src/prove/smt/solver/rewriter-tpl.ts +1159 -0
  245. package/src/prove/smt/solver/rewriter.ts +843 -0
  246. package/src/prove/smt/solver/rlimit.ts +79 -0
  247. package/src/prove/smt/solver/smtlib-parser.ts +526 -0
  248. package/src/prove/smt/solver/solver.ts +71 -0
  249. package/src/prove/smt/solver/sort.ts +35 -0
  250. package/src/prove/smt/solver/sticky-generations.ts +69 -0
  251. package/src/prove/smt/solver/theory-lra-axioms.ts +340 -0
  252. package/src/prove/smt/solver/theory-lra-bounds.ts +226 -0
  253. package/src/prove/smt/solver/theory-lra-final-check.ts +252 -0
  254. package/src/prove/smt/solver/theory-lra-internalize.ts +476 -0
  255. package/src/prove/smt/solver/theory-lra-model.ts +243 -0
  256. package/src/prove/smt/solver/theory-lra-propagate.ts +405 -0
  257. package/src/prove/smt/solver/theory-lra-state.ts +43 -0
  258. package/src/prove/smt/solver/theory-lra.ts +56 -0
  259. package/src/prove/smt/solver/var-subst.ts +258 -0
  260. package/src/prove/smt/solver/z3-license.txt +10 -0
  261. package/src/prove/smt/table.ts +170 -0
  262. package/src/prove/tlapm/tlapm.ts +96 -0
  263. package/src/prove/tlaps-module.ts +510 -0
  264. package/src/prove/verdict.ts +18 -0
  265. package/src/prove/zenon/LICENSE +32 -0
  266. package/src/prove/zenon/check/check.ts +105 -0
  267. package/src/prove/zenon/check/definitions.ts +144 -0
  268. package/src/prove/zenon/check/equality.ts +182 -0
  269. package/src/prove/zenon/check/functions.ts +62 -0
  270. package/src/prove/zenon/check/keys.ts +125 -0
  271. package/src/prove/zenon/check/propositional.ts +104 -0
  272. package/src/prove/zenon/check/records.ts +188 -0
  273. package/src/prove/zenon/check/relations.ts +121 -0
  274. package/src/prove/zenon/check/rewrites.ts +224 -0
  275. package/src/prove/zenon/check/sets.ts +302 -0
  276. package/src/prove/zenon/check/terms.ts +127 -0
  277. package/src/prove/zenon/check/tla.ts +126 -0
  278. package/src/prove/zenon/decide.ts +113 -0
  279. package/src/prove/zenon/encode.ts +437 -0
  280. package/src/prove/zenon/eqrel.ts +300 -0
  281. package/src/prove/zenon/equality-rules.ts +435 -0
  282. package/src/prove/zenon/expr.ts +551 -0
  283. package/src/prove/zenon/index-table.ts +350 -0
  284. package/src/prove/zenon/isar-case.ts +513 -0
  285. package/src/prove/zenon/isar.ts +1249 -0
  286. package/src/prove/zenon/limits.ts +15 -0
  287. package/src/prove/zenon/llproof.ts +173 -0
  288. package/src/prove/zenon/mltoll.ts +1566 -0
  289. package/src/prove/zenon/node.ts +297 -0
  290. package/src/prove/zenon/ocaml.ts +169 -0
  291. package/src/prove/zenon/parse.ts +247 -0
  292. package/src/prove/zenon/phrase.ts +191 -0
  293. package/src/prove/zenon/proof.ts +198 -0
  294. package/src/prove/zenon/propositional-rules.ts +387 -0
  295. package/src/prove/zenon/rules.ts +94 -0
  296. package/src/prove/zenon/search.ts +288 -0
  297. package/src/prove/zenon/tla/functions.ts +151 -0
  298. package/src/prove/zenon/tla/llproof.ts +480 -0
  299. package/src/prove/zenon/tla/records.ts +225 -0
  300. package/src/prove/zenon/tla/rewrites.ts +447 -0
  301. package/src/prove/zenon/tla/sets.ts +304 -0
  302. package/src/prove/zenon/tla/terms.ts +181 -0
  303. package/src/prove/zenon/tla/tla.ts +506 -0
  304. package/src/run-cli.ts +334 -75
  305. package/src/standard-modules.ts +5 -2
  306. package/src/successors.ts +24 -5
  307. package/src/tlapm-cache.ts +236 -0
  308. package/src/tlc-random.ts +55 -32
  309. package/src/tlc-version.ts +8 -7
  310. package/src/values.ts +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,256 @@
1
+ // tlapm's PTL backend up to the text it sends LS4 (Pltl.process_obligation, Prep.flatten, and
2
+ // Ls4's printer): temporal operators reduce to [], <> and prime, assumptions that hold
3
+ // always get a [], and every other subformula becomes an atom named by a hash of its printed form.
4
+ // The text is the negated obligation.
5
+
6
+ import {
7
+ adjoin,
8
+ applyBuiltin,
9
+ at,
10
+ bumpBy,
11
+ mapAccumulate,
12
+ mapScoped,
13
+ shift,
14
+ shiftExpr,
15
+ substituteExpr,
16
+ substituteHyp,
17
+ type Builtin,
18
+ type Expr,
19
+ type Hyp,
20
+ type Level,
21
+ type Scope,
22
+ type Sequent,
23
+ type Substitution,
24
+ } from "../../obligations/expression";
25
+ import { renderDoc } from "../../obligations/format";
26
+ import { getLevelInfo } from "../../obligations/levels";
27
+ import { printExpression } from "../../obligations/printer";
28
+ import { expandAction, expandFairness, expandLeadsto, getTime } from "../../obligations/temporal";
29
+ import { getMd5 } from "../prep/md5";
30
+
31
+ const KIND_NAMES: Record<Level, string> = {
32
+ Constant: "CONSTANT",
33
+ State: "STATE",
34
+ Action: "ACTION",
35
+ Temporal: "TEMPORAL",
36
+ Unknown: "Unknown",
37
+ };
38
+
39
+ const LEVEL_NAMES = ["CONSTANT", "STATE", "ACTION", "TEMPORAL"];
40
+
41
+ // Coalesce.rename_with_loc: each declared name gets its kind in front, or its level for a definition,
42
+ // as in VARIABLE_x_ and CONSTANT_i_, so atoms print with the names tlapm hashes. A variable a
43
+ // temporal quantifier binds keeps its name.
44
+ const renameSequent = (scope: Scope | undefined, sequent: Sequent): Sequent => {
45
+ const [inner, context] = mapAccumulate(
46
+ scope,
47
+ sequent.context,
48
+ (current, hyp): [Scope | undefined, Hyp] => {
49
+ const renamed = ((): Hyp => {
50
+ switch (hyp.kind) {
51
+ case "Fresh":
52
+ return {
53
+ ...hyp,
54
+ name: `${KIND_NAMES[hyp.level]}_${hyp.name}_`,
55
+ domain: hyp.domain && renameDeclarations(current, hyp.domain),
56
+ };
57
+ case "Flex":
58
+ return { ...hyp, name: `VARIABLE_${hyp.name}_` };
59
+ case "Defn": {
60
+ const definition = hyp.definition;
61
+ if (definition.kind !== "Operator") return hyp;
62
+ const body = renameDeclarations(current, definition.body);
63
+ const level = LEVEL_NAMES[getLevelInfo(current, body).level];
64
+ return {
65
+ ...hyp,
66
+ definition: { ...definition, name: `${level}_${definition.name}_`, body },
67
+ };
68
+ }
69
+ case "Fact":
70
+ return { ...hyp, expression: renameDeclarations(current, hyp.expression) };
71
+ }
72
+ })();
73
+ return [adjoin(current, renamed), renamed];
74
+ },
75
+ );
76
+ return { context, active: renameDeclarations(inner, sequent.active) };
77
+ };
78
+
79
+ const renameDeclarations = (scope: Scope | undefined, expression: Expr): Expr => {
80
+ if (expression.kind === "Sequent")
81
+ return { ...expression, sequent: renameSequent(scope, expression.sequent) };
82
+ const mapped = mapScoped(scope, expression, renameDeclarations, adjoin, "all");
83
+ switch (mapped.kind) {
84
+ case "Lambda":
85
+ return {
86
+ ...mapped,
87
+ params: mapped.params.map((param) => ({ ...param, name: `Unknown_${param.name}_` })),
88
+ };
89
+ case "Quant":
90
+ case "Fcn":
91
+ case "SetOf":
92
+ return {
93
+ ...mapped,
94
+ bounds: mapped.bounds.map((bound) => ({
95
+ ...bound,
96
+ name: `${KIND_NAMES[bound.level]}_${bound.name}_`,
97
+ })),
98
+ };
99
+ case "Choose":
100
+ case "SetSt":
101
+ return { ...mapped, name: `CONSTANT_${mapped.name}_` };
102
+ default:
103
+ return mapped;
104
+ }
105
+ };
106
+
107
+ interface PreparedHyps {
108
+ scope: Scope | undefined;
109
+ substitution: Substitution;
110
+ context: Hyp[];
111
+ }
112
+
113
+ // Pltl.expand_domains and Pltl.box_assumptions: NEW x \in S becomes NEW x and the fact x \in S, and
114
+ // each visible fact that holds always gets a [].
115
+ const prepareHyps = (scope: Scope | undefined, expression: Expr): Expr => {
116
+ if (expression.kind !== "Sequent")
117
+ return mapScoped(scope, expression, prepareHyps, adjoin, "all");
118
+ const state: PreparedHyps = { scope, substitution: shift(0), context: [] };
119
+ const push = (hyp: Hyp) => {
120
+ const prepared =
121
+ hyp.kind === "Fact" && hyp.visibility === "Visible" && hyp.time === "Always"
122
+ ? { ...hyp, expression: applyBuiltin("BoxTrue", [hyp.expression], hyp.expression) }
123
+ : hyp;
124
+ state.context.push(prepared);
125
+ state.scope = adjoin(state.scope, prepared);
126
+ };
127
+ for (const original of expression.sequent.context) {
128
+ const hyp = substituteHyp(state.substitution, original);
129
+ if (hyp.kind === "Fact") {
130
+ push({ ...hyp, expression: prepareHyps(state.scope, hyp.expression) });
131
+ state.substitution = bumpBy(1, state.substitution);
132
+ continue;
133
+ }
134
+ if (hyp.kind !== "Fresh" || !hyp.domain || original.kind !== "Fresh" || !original.domain) {
135
+ push(hyp);
136
+ state.substitution = bumpBy(1, state.substitution);
137
+ continue;
138
+ }
139
+ const domain = prepareHyps(state.scope, hyp.domain);
140
+ push({ ...hyp, domain: undefined });
141
+ // tlapm judges the time of the domain as written, one hypothesis too deep.
142
+ push({
143
+ kind: "Fact",
144
+ expression: applyBuiltin(
145
+ "Mem",
146
+ [at({ kind: "Ix", index: 1 }, domain), shiftExpr(1, domain)],
147
+ domain,
148
+ ),
149
+ visibility: hyp.domainVisibility,
150
+ time: hyp.level === "Constant" ? getTime(state.scope, original.domain) : "Now",
151
+ location: hyp.location,
152
+ });
153
+ state.substitution = {
154
+ kind: "Compose",
155
+ outer: shift(1),
156
+ inner: bumpBy(1, state.substitution),
157
+ };
158
+ }
159
+ const active = substituteExpr(state.substitution, expression.sequent.active);
160
+ return {
161
+ ...expression,
162
+ sequent: { context: state.context, active: prepareHyps(state.scope, active) },
163
+ };
164
+ };
165
+
166
+ const BINARY: Partial<Record<Builtin, string>> = {
167
+ Conj: "&",
168
+ Disj: "|",
169
+ Implies: "->",
170
+ Equiv: "<->",
171
+ };
172
+
173
+ const UNARY: Partial<Record<Builtin, string>> = {
174
+ Neg: "~",
175
+ BoxTrue: "always",
176
+ BoxFalse: "always",
177
+ Diamond: "sometime",
178
+ Prime: "next",
179
+ };
180
+
181
+ // Prep.flatten, which tlapm applies after Pltl.process_obligation has made every equality an atom:
182
+ // TRUE drops out of the conjunctions of each visible fact, and a fact left with nothing disappears.
183
+ const removeTrue = (expression: Expr): Expr | undefined => {
184
+ if (expression.kind === "Internal" && expression.builtin === "TRUE") return undefined;
185
+ if (expression.kind === "List" && expression.bullet !== "Or") {
186
+ const items = expression.items.flatMap((item) => removeTrue(item) ?? []);
187
+ if (items.length <= 1) return items[0];
188
+ return { ...expression, bullet: "And", items };
189
+ }
190
+ if (
191
+ expression.kind !== "Apply" ||
192
+ expression.operator.kind !== "Internal" ||
193
+ expression.operator.builtin !== "Conj" ||
194
+ expression.args.length !== 2
195
+ )
196
+ return expression;
197
+ const left = removeTrue(expression.args[0]);
198
+ const right = removeTrue(expression.args[1]);
199
+ return left && right ? { ...expression, args: [left, right] } : (left ?? right);
200
+ };
201
+
202
+ const TRUE_TEXT = "(cc | ~ cc)";
203
+
204
+ // The text tlapm sends LS4 for an obligation after Prep.normalize_expand.
205
+ export const encodePtl = (sequent: Sequent): string => {
206
+ // Ls4's printer. A sequent becomes an implication from its visible facts, joined by &, and
207
+ // Prep.flatten applies to the facts of the outermost one.
208
+ const print = (hyps: Hyp[], expression: Expr, isOutermost = false): string => {
209
+ const recurse = (inner: Expr) => print(hyps, inner);
210
+ switch (expression.kind) {
211
+ case "Internal":
212
+ if (expression.builtin === "TRUE") return TRUE_TEXT;
213
+ if (expression.builtin === "FALSE") return "(cc & ~ cc)";
214
+ break;
215
+ case "Apply": {
216
+ const operator = expression.operator;
217
+ const args = expression.args;
218
+ if (operator.kind !== "Internal") break;
219
+ const binary = BINARY[operator.builtin];
220
+ if (binary && args.length === 2)
221
+ return `(${recurse(args[0])} ${binary} ${recurse(args[1])})`;
222
+ const unary = UNARY[operator.builtin];
223
+ if (unary && args.length === 1) return `(${unary} ${recurse(args[0])})`;
224
+ break;
225
+ }
226
+ case "List": {
227
+ if (expression.items.length === 0) return TRUE_TEXT;
228
+ const junction = expression.bullet === "Or" ? "|" : "&";
229
+ return expression.items
230
+ .map(recurse)
231
+ .reduceRight((right, left) => `(${left} ${junction} ${right})`);
232
+ }
233
+ case "Sequent": {
234
+ const inner = [...hyps];
235
+ const facts: string[] = [];
236
+ for (const hyp of expression.sequent.context) {
237
+ const fact =
238
+ hyp.kind !== "Fact" || hyp.visibility !== "Visible"
239
+ ? undefined
240
+ : isOutermost
241
+ ? removeTrue(hyp.expression)
242
+ : hyp.expression;
243
+ if (fact) facts.push(print(inner, fact));
244
+ inner.push(hyp);
245
+ }
246
+ const goal = print(inner, expression.sequent.active);
247
+ return facts.length === 0 ? goal : `(${facts.join(" & ")} -> ${goal})`;
248
+ }
249
+ }
250
+ // Pltl.coalesce_fol: an atom is named by the first five hex digits of the MD5 of its print.
251
+ return `h${getMd5(renderDoc(printExpression(hyps, expression))).slice(0, 5)}`;
252
+ };
253
+ const renamed = renameDeclarations(undefined, { kind: "Sequent", sequent });
254
+ const prepared = prepareHyps(undefined, expandAction(expandLeadsto(expandFairness(renamed))));
255
+ return `not (${print([], prepared, true)})`;
256
+ };
@@ -0,0 +1,151 @@
1
+ // A conflict-driven clause learning SAT solver for the clauses of one tableau node. A literal is a
2
+ // variable number, negated when below zero. The solver keeps what it learns across calls, which add
3
+ // clauses or assume literals. It decides each open variable false first, so a model sets few
4
+ // variables, and a model holds 1 for each true variable and -1 for each false one. It gives up at
5
+ // the first conflict after isExpired turns true.
6
+
7
+ const getIndex = (literal: number) => (literal > 0 ? 2 * literal : -2 * literal + 1);
8
+
9
+ export const createSolver = (variableCount: number, isExpired: () => boolean) => {
10
+ const values = new Int8Array(variableCount + 1);
11
+ const levels = new Int32Array(variableCount + 1);
12
+ const reasons = Array.from<number[] | undefined>({ length: variableCount + 1 });
13
+ const activities = new Float64Array(variableCount + 1);
14
+ const seen = new Uint8Array(variableCount + 1);
15
+ const watches: number[][][] = Array.from({ length: 2 * variableCount + 2 }, () => []);
16
+ const trail: number[] = [];
17
+ const levelStarts: number[] = [];
18
+ const state = { head: 0, bump: 1, isUnsatisfiable: false };
19
+ const getValue = (literal: number) => (literal > 0 ? values[literal] : -values[-literal]);
20
+ const assign = (literal: number, reason: number[] | undefined) => {
21
+ const variable = Math.abs(literal);
22
+ values[variable] = literal > 0 ? 1 : -1;
23
+ levels[variable] = levelStarts.length;
24
+ reasons[variable] = reason;
25
+ trail.push(literal);
26
+ };
27
+ const watch = (clause: number[]) => {
28
+ watches[getIndex(clause[0])].push(clause);
29
+ watches[getIndex(clause[1])].push(clause);
30
+ };
31
+ // Moves each watch off a literal that turned false, and returns the clause of a conflict. The
32
+ // literal a clause implies sits first in it.
33
+ const propagate = () => {
34
+ for (; state.head < trail.length; state.head++) {
35
+ const falsified = -trail[state.head];
36
+ const watching = watches[getIndex(falsified)];
37
+ for (let position = 0; position < watching.length; position++) {
38
+ const clause = watching[position];
39
+ if (clause[0] === falsified) [clause[0], clause[1]] = [clause[1], clause[0]];
40
+ if (getValue(clause[0]) > 0) continue;
41
+ const replacement = clause.findIndex(
42
+ (literal, index) => index > 1 && getValue(literal) >= 0,
43
+ );
44
+ if (replacement !== -1) {
45
+ [clause[1], clause[replacement]] = [clause[replacement], clause[1]];
46
+ watches[getIndex(clause[1])].push(clause);
47
+ watching[position--] = watching[watching.length - 1];
48
+ watching.pop();
49
+ continue;
50
+ }
51
+ if (getValue(clause[0]) < 0) return clause;
52
+ assign(clause[0], clause);
53
+ }
54
+ }
55
+ return undefined;
56
+ };
57
+ const backtrack = (level: number) => {
58
+ if (level >= levelStarts.length) return;
59
+ const size = levelStarts[level];
60
+ while (trail.length > size) values[Math.abs(trail.pop() ?? 0)] = 0;
61
+ levelStarts.length = level;
62
+ state.head = trail.length;
63
+ };
64
+ // Resolves the conflict back to the first literal of the current level that all its paths pass
65
+ // through, and returns the learned clause with that literal first.
66
+ const analyze = (conflict: number[]) => {
67
+ const learned = [0];
68
+ const current = levelStarts.length;
69
+ const walk = { pending: 0, literal: 0, index: trail.length - 1 };
70
+ for (let clause: number[] | undefined = conflict; ;) {
71
+ for (const literal of clause?.slice(walk.literal === 0 ? 0 : 1) ?? []) {
72
+ const variable = Math.abs(literal);
73
+ if (seen[variable] || levels[variable] === 0) continue;
74
+ seen[variable] = 1;
75
+ activities[variable] += state.bump;
76
+ if (levels[variable] === current) walk.pending++;
77
+ else learned.push(literal);
78
+ }
79
+ while (!seen[Math.abs(trail[walk.index])]) walk.index--;
80
+ walk.literal = trail[walk.index--];
81
+ seen[Math.abs(walk.literal)] = 0;
82
+ clause = reasons[Math.abs(walk.literal)];
83
+ if (--walk.pending === 0) break;
84
+ }
85
+ learned[0] = -walk.literal;
86
+ learned.forEach((literal) => (seen[Math.abs(literal)] = 0));
87
+ state.bump *= 1.05;
88
+ return learned;
89
+ };
90
+ // Literals false for good are dropped, since the solver adds clauses only at level 0.
91
+ const addClause = (clause: number[]) => {
92
+ backtrack(0);
93
+ const literals = [...new Set(clause)];
94
+ if (state.isUnsatisfiable || literals.some((literal) => getValue(literal) > 0)) return;
95
+ if (literals.some((literal) => literals.includes(-literal))) return;
96
+ const open = literals.filter((literal) => getValue(literal) === 0);
97
+ if (open.length > 1) {
98
+ watch(open);
99
+ return;
100
+ }
101
+ if (open.length === 0) {
102
+ state.isUnsatisfiable = true;
103
+ return;
104
+ }
105
+ assign(open[0], undefined);
106
+ if (propagate()) state.isUnsatisfiable = true;
107
+ };
108
+ // A model of the clauses in which every assumed literal holds, or unsat when there is none.
109
+ const solve = (assumptions: number[]): Int8Array | "unsat" | "unknown" => {
110
+ backtrack(0);
111
+ if (state.isUnsatisfiable) return "unsat";
112
+ for (;;) {
113
+ const conflict = propagate();
114
+ if (conflict) {
115
+ if (levelStarts.length === 0) {
116
+ state.isUnsatisfiable = true;
117
+ return "unsat";
118
+ }
119
+ if (isExpired()) return "unknown";
120
+ const learned = analyze(conflict);
121
+ const deepest = learned
122
+ .slice(1)
123
+ .reduce(
124
+ (best, literal, index) =>
125
+ levels[Math.abs(literal)] > levels[Math.abs(learned[best])] ? index + 1 : best,
126
+ 1,
127
+ );
128
+ if (learned.length > 1) [learned[1], learned[deepest]] = [learned[deepest], learned[1]];
129
+ backtrack(learned.length === 1 ? 0 : levels[Math.abs(learned[1])]);
130
+ if (learned.length > 1) watch(learned);
131
+ assign(learned[0], learned.length > 1 ? learned : undefined);
132
+ continue;
133
+ }
134
+ const assumption = assumptions.find((literal) => getValue(literal) <= 0);
135
+ if (assumption !== undefined && getValue(assumption) < 0) return "unsat";
136
+ const decision =
137
+ assumption ??
138
+ -values.reduce(
139
+ (best, value, variable) =>
140
+ variable > 0 && value === 0 && (best === 0 || activities[variable] > activities[best])
141
+ ? variable
142
+ : best,
143
+ 0,
144
+ );
145
+ if (decision === 0) return Int8Array.from(values);
146
+ levelStarts.push(trail.length);
147
+ assign(decision, undefined);
148
+ }
149
+ };
150
+ return { addClause, solve };
151
+ };
@@ -0,0 +1,276 @@
1
+ // Decides satisfiability of propositional linear temporal logic over infinite traces, the logic LS4
2
+ // decides. A tableau node is the set of formulas that must hold now. A SAT call per step picks the
3
+ // atoms and the formulas the next node must hold, and the formula is satisfiable when a reachable
4
+ // strongly connected component can fulfill every eventuality it postpones.
5
+
6
+ import type { Verdict } from "../verdict";
7
+ import { createSolver } from "./sat";
8
+
9
+ export type PtlFormula =
10
+ | { kind: "Atom"; name: string }
11
+ | { kind: "Not" | "Next" | "Always" | "Eventually"; body: PtlFormula }
12
+ | { kind: "And" | "Or" | "Implies" | "Equiv"; left: PtlFormula; right: PtlFormula };
13
+
14
+ // Formulas in negation normal form, numbered so that equal formulas share a number.
15
+ type Normal =
16
+ | { kind: "Constant"; value: boolean }
17
+ | { kind: "Literal"; atom: string; isPositive: boolean }
18
+ | { kind: "And" | "Or"; children: number[] }
19
+ | { kind: "Next" | "Always" | "Eventually"; body: number };
20
+
21
+ interface Step {
22
+ next: number[];
23
+ pending: number[];
24
+ }
25
+
26
+ interface Edge {
27
+ target: number;
28
+ pending: number[];
29
+ }
30
+
31
+ const createTable = () => {
32
+ const normals: Normal[] = [];
33
+ const numbers = new Map<string, number>();
34
+ const intern = (key: string, normal: Normal) => {
35
+ const existing = numbers.get(key);
36
+ if (existing !== undefined) return existing;
37
+ numbers.set(key, normals.length);
38
+ normals.push(normal);
39
+ return normals.length - 1;
40
+ };
41
+ const getConstant = (value: boolean) => intern(String(value), { kind: "Constant", value });
42
+ const getJunction = (kind: "And" | "Or", operands: number[]): number => {
43
+ const absorbing = kind === "Or";
44
+ const children = new Set<number>();
45
+ for (const operand of operands) {
46
+ const normal = normals[operand];
47
+ if (normal.kind === "Constant") {
48
+ if (normal.value === absorbing) return operand;
49
+ continue;
50
+ }
51
+ if (normal.kind === kind) normal.children.forEach((child) => children.add(child));
52
+ else children.add(operand);
53
+ }
54
+ const sorted = [...children].sort((left, right) => left - right);
55
+ if (sorted.length === 0) return getConstant(!absorbing);
56
+ if (sorted.length === 1) return sorted[0];
57
+ return intern(`${kind}(${sorted.join(",")})`, { kind, children: sorted });
58
+ };
59
+ const getModal = (kind: "Next" | "Always" | "Eventually", body: number) => {
60
+ const normal = normals[body];
61
+ if (normal.kind === "Constant" || (kind !== "Next" && normal.kind === kind)) return body;
62
+ return intern(`${kind}(${body})`, { kind, body });
63
+ };
64
+ const memo = [new WeakMap<PtlFormula, number>(), new WeakMap<PtlFormula, number>()];
65
+ const normalize = (formula: PtlFormula, isNegated: boolean): number => {
66
+ const cache = memo[isNegated ? 1 : 0];
67
+ const cached = cache.get(formula);
68
+ if (cached !== undefined) return cached;
69
+ const result = ((): number => {
70
+ switch (formula.kind) {
71
+ case "Atom":
72
+ return intern(`${isNegated ? "-" : "+"}${formula.name}`, {
73
+ kind: "Literal",
74
+ atom: formula.name,
75
+ isPositive: !isNegated,
76
+ });
77
+ case "Not":
78
+ return normalize(formula.body, !isNegated);
79
+ case "Next":
80
+ return getModal("Next", normalize(formula.body, isNegated));
81
+ case "Always":
82
+ case "Eventually":
83
+ return getModal(
84
+ (formula.kind === "Always") === isNegated ? "Eventually" : "Always",
85
+ normalize(formula.body, isNegated),
86
+ );
87
+ case "And":
88
+ case "Or":
89
+ return getJunction((formula.kind === "And") === isNegated ? "Or" : "And", [
90
+ normalize(formula.left, isNegated),
91
+ normalize(formula.right, isNegated),
92
+ ]);
93
+ case "Implies":
94
+ return getJunction(isNegated ? "And" : "Or", [
95
+ normalize(formula.left, !isNegated),
96
+ normalize(formula.right, isNegated),
97
+ ]);
98
+ case "Equiv":
99
+ return getJunction(isNegated ? "Or" : "And", [
100
+ getJunction(isNegated ? "And" : "Or", [
101
+ normalize(formula.left, !isNegated),
102
+ normalize(formula.right, isNegated),
103
+ ]),
104
+ getJunction(isNegated ? "And" : "Or", [
105
+ normalize(formula.left, isNegated),
106
+ normalize(formula.right, !isNegated),
107
+ ]),
108
+ ]);
109
+ }
110
+ })();
111
+ cache.set(formula, result);
112
+ return result;
113
+ };
114
+ return { normals, normalize };
115
+ };
116
+
117
+ // Every way to satisfy the formulas now, keeping only the steps that require the fewest next
118
+ // formulas and leave the fewest eventualities pending. A step that requires more of both can only
119
+ // do what a smaller one can, so dropping it keeps the decision complete. Undefined once isExpired
120
+ // turns true.
121
+ const getSteps = (
122
+ normals: Normal[],
123
+ formulas: number[],
124
+ isExpired: () => boolean,
125
+ ): Step[] | undefined => {
126
+ const clauses: number[][] = [];
127
+ const atoms = new Map<string, number>();
128
+ const nexts = new Map<number, number>();
129
+ const pendings = new Map<number, number>();
130
+ const literals = new Map<number, number>();
131
+ const counter = { value: 0 };
132
+ const createVariable = () => ++counter.value;
133
+ const getVariable = <Key>(variables: Map<Key, number>, key: Key) => {
134
+ const existing = variables.get(key);
135
+ if (existing !== undefined) return existing;
136
+ const variable = createVariable();
137
+ variables.set(key, variable);
138
+ return variable;
139
+ };
140
+ // Plaisted-Greenbaum: a formula's literal implies the formula, which suffices in normal form.
141
+ const encode = (formula: number): number => {
142
+ const cached = literals.get(formula);
143
+ if (cached !== undefined) return cached;
144
+ const normal = normals[formula];
145
+ const literal = ((): number => {
146
+ switch (normal.kind) {
147
+ case "Constant": {
148
+ const variable = createVariable();
149
+ clauses.push([normal.value ? variable : -variable]);
150
+ return variable;
151
+ }
152
+ case "Literal": {
153
+ const variable = getVariable(atoms, normal.atom);
154
+ return normal.isPositive ? variable : -variable;
155
+ }
156
+ case "Next":
157
+ return getVariable(nexts, normal.body);
158
+ case "And": {
159
+ const variable = createVariable();
160
+ normal.children.forEach((child) => clauses.push([-variable, encode(child)]));
161
+ return variable;
162
+ }
163
+ case "Or": {
164
+ const variable = createVariable();
165
+ clauses.push([-variable, ...normal.children.map(encode)]);
166
+ return variable;
167
+ }
168
+ case "Always": {
169
+ const variable = createVariable();
170
+ clauses.push([-variable, encode(normal.body)], [-variable, getVariable(nexts, formula)]);
171
+ return variable;
172
+ }
173
+ case "Eventually": {
174
+ const variable = createVariable();
175
+ const body = encode(normal.body);
176
+ const next = getVariable(nexts, formula);
177
+ clauses.push([-variable, body, next], [-next, body, getVariable(pendings, formula)]);
178
+ return variable;
179
+ }
180
+ }
181
+ })();
182
+ literals.set(formula, literal);
183
+ return literal;
184
+ };
185
+ formulas.forEach((formula) => clauses.push([encode(formula)]));
186
+ const choices = [...nexts.values(), ...pendings.values()];
187
+ const solver = createSolver(counter.value, isExpired);
188
+ clauses.forEach(solver.addClause);
189
+ const steps: Step[] = [];
190
+ for (;;) {
191
+ const model = solver.solve([]);
192
+ if (typeof model === "string") return model === "unsat" ? steps : undefined;
193
+ // Drops each chosen variable that a model with no other choice can do without. A variable one
194
+ // pass keeps stays needed as the set shrinks, so the set that remains is minimal.
195
+ const minimal = choices.reduce<Int8Array | undefined>((current, choice) => {
196
+ if (current?.[choice] !== 1) return current;
197
+ const unchosen = choices.filter((other) => current[other] !== 1);
198
+ const smaller = solver.solve([-choice, ...unchosen.map((other) => -other)]);
199
+ if (smaller === "unknown") return undefined;
200
+ return smaller === "unsat" ? current : smaller;
201
+ }, model);
202
+ if (!minimal) return undefined;
203
+ const isChosen = (variable: number) => minimal[variable] === 1;
204
+ steps.push({
205
+ next: [...nexts].flatMap((entry) => (isChosen(entry[1]) ? [entry[0]] : [])),
206
+ pending: [...pendings].flatMap((entry) => (isChosen(entry[1]) ? [entry[0]] : [])),
207
+ });
208
+ solver.addClause(choices.filter(isChosen).map((choice) => -choice));
209
+ }
210
+ };
211
+
212
+ // Whether the formula is satisfiable, or unknown once isExpired turns true.
213
+ export const getSatisfiability = (formula: PtlFormula, isExpired: () => boolean): Verdict => {
214
+ const table = createTable();
215
+ const nodes: number[][] = [];
216
+ const numbers = new Map<string, number>();
217
+ const getNode = (formulas: number[]) => {
218
+ const sorted = [...new Set(formulas)].sort((left, right) => left - right);
219
+ const key = sorted.join(",");
220
+ const existing = numbers.get(key);
221
+ if (existing !== undefined) return existing;
222
+ numbers.set(key, nodes.length);
223
+ nodes.push(sorted);
224
+ return nodes.length - 1;
225
+ };
226
+ getNode([table.normalize(formula, false)]);
227
+ const edges: Edge[][] = [];
228
+ for (let node = 0; node < nodes.length; node++) {
229
+ const steps = isExpired() ? undefined : getSteps(table.normals, nodes[node], isExpired);
230
+ if (!steps) return "unknown";
231
+ edges.push(steps.map((step) => ({ target: getNode(step.next), pending: step.pending })));
232
+ }
233
+ // Tarjan's algorithm, checking each component as it closes.
234
+ const indices = new Int32Array(nodes.length).fill(-1);
235
+ const lowlinks = new Int32Array(nodes.length);
236
+ const components = new Int32Array(nodes.length).fill(-1);
237
+ const stack: number[] = [];
238
+ const counter = { index: 0, component: 0 };
239
+ const isFair = (component: number) => {
240
+ const inner = edges.flatMap((outgoing, source) =>
241
+ components[source] === component
242
+ ? outgoing.filter((edge) => components[edge.target] === component)
243
+ : [],
244
+ );
245
+ if (inner.length === 0) return false;
246
+ const unfulfilled = inner
247
+ .slice(1)
248
+ .reduce(
249
+ (always, edge) => always.filter((eventuality) => edge.pending.includes(eventuality)),
250
+ inner[0].pending,
251
+ );
252
+ return unfulfilled.length === 0;
253
+ };
254
+ const visit = (node: number): boolean => {
255
+ indices[node] = counter.index;
256
+ lowlinks[node] = counter.index;
257
+ counter.index++;
258
+ stack.push(node);
259
+ for (const edge of edges[node]) {
260
+ if (indices[edge.target] === -1) {
261
+ if (visit(edge.target)) return true;
262
+ lowlinks[node] = Math.min(lowlinks[node], lowlinks[edge.target]);
263
+ } else if (components[edge.target] === -1) {
264
+ lowlinks[node] = Math.min(lowlinks[node], indices[edge.target]);
265
+ }
266
+ }
267
+ if (lowlinks[node] !== indices[node]) return false;
268
+ const component = counter.component++;
269
+ for (let member = stack.pop(); member !== undefined; member = stack.pop()) {
270
+ components[member] = component;
271
+ if (member === node) break;
272
+ }
273
+ return isFair(component);
274
+ };
275
+ return visit(0) ? "sat" : "unsat";
276
+ };