tla-ts 0.0.10-dev.b4a856304 → 0.0.10-dev.c92e6a4ea

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 (586) hide show
  1. package/README.md +2 -1
  2. package/dist/compile.cjs +6 -6
  3. package/dist/compile.js +10 -10
  4. package/dist/deciders.cjs +41 -37
  5. package/dist/deciders.js +57 -53
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +37 -0
  8. package/dist/index.d.ts +37 -0
  9. package/dist/index.js +1 -1
  10. package/dist/parallel-worker.cjs +1 -1
  11. package/dist/parallel-worker.js +1 -1
  12. package/dist/prove.cjs +2683 -427
  13. package/dist/prove.js +2681 -425
  14. package/dist/run.cjs +45 -44
  15. package/dist/run.js +45 -44
  16. package/dist/tlapm.cjs +2 -2
  17. package/dist/tlapm.js +2 -2
  18. package/dist/transfer.cjs +44 -41
  19. package/dist/transfer.js +45 -42
  20. package/dist/worker.cjs +7 -7
  21. package/dist/worker.js +7 -7
  22. package/package.json +1 -1
  23. package/src/ast.ts +41 -41
  24. package/src/bags.ts +2 -5
  25. package/src/builtins.ts +5 -21
  26. package/src/check-failure.ts +116 -0
  27. package/src/check-trace.ts +268 -0
  28. package/src/check.ts +578 -757
  29. package/src/cli/options.ts +6 -31
  30. package/src/cli/run.ts +0 -2
  31. package/src/cli/runtime-invariants.ts +27 -62
  32. package/src/cli/shared.ts +1 -5
  33. package/src/cli/tlapm.ts +433 -70
  34. package/src/cli/tlc-arguments.ts +246 -240
  35. package/src/cli/tlc-output.ts +686 -0
  36. package/src/cli/tlc-usage.ts +3 -5
  37. package/src/cli/tlc.ts +59 -707
  38. package/src/cli/xml-exporter.ts +23 -33
  39. package/src/codegen.ts +5 -10
  40. package/src/coverage.ts +3 -10
  41. package/src/dependencies.ts +30 -14
  42. package/src/dfid.ts +16 -16
  43. package/src/environment-config.ts +315 -0
  44. package/src/environment.ts +73 -338
  45. package/src/errors.ts +33 -5
  46. package/src/evaluate.ts +34 -107
  47. package/src/exit-codes.ts +3 -0
  48. package/src/fingerprints.ts +65 -1
  49. package/src/instances.ts +47 -10
  50. package/src/java-hash.ts +7 -0
  51. package/src/java-overrides.ts +4 -9
  52. package/src/json-reader.ts +1 -2
  53. package/src/json.ts +8 -18
  54. package/src/levels.ts +46 -57
  55. package/src/lexer.ts +76 -85
  56. package/src/liveness-checker.ts +634 -306
  57. package/src/liveness.ts +104 -120
  58. package/src/obligations/action.ts +14 -17
  59. package/src/obligations/anonymize.ts +37 -16
  60. package/src/obligations/enabled-axioms.ts +218 -0
  61. package/src/obligations/equality.ts +1 -3
  62. package/src/obligations/expression.ts +36 -8
  63. package/src/obligations/format.ts +0 -2
  64. package/src/obligations/generate.ts +66 -54
  65. package/src/obligations/index.ts +38 -8
  66. package/src/obligations/levels.ts +24 -11
  67. package/src/obligations/module.ts +28 -41
  68. package/src/obligations/normalize.ts +26 -14
  69. package/src/obligations/operators.ts +0 -2
  70. package/src/obligations/pragma.ts +53 -16
  71. package/src/obligations/printer.ts +43 -13
  72. package/src/obligations/proof.ts +3 -2
  73. package/src/obligations/regroup.ts +0 -2
  74. package/src/obligations/simplify.ts +55 -50
  75. package/src/obligations/source.ts +118 -74
  76. package/src/obligations/subexpression.ts +45 -18
  77. package/src/obligations/substitution.ts +1 -3
  78. package/src/obligations/temporal.ts +5 -7
  79. package/src/obligations/tuples.ts +0 -2
  80. package/src/parallel-worker.ts +17 -31
  81. package/src/parallel.ts +55 -80
  82. package/src/parser.ts +722 -385
  83. package/src/pcal/ast.ts +53 -65
  84. package/src/pcal/parse.ts +144 -191
  85. package/src/pcal/tokenize.ts +91 -115
  86. package/src/pcal/translate.ts +83 -98
  87. package/src/pcal/validate.ts +48 -50
  88. package/src/pretty-print.ts +7 -7
  89. package/src/prover/decide-pool.ts +3 -3
  90. package/src/prover/deciders.ts +12 -9
  91. package/src/prover/isabelle/decide.ts +3 -25
  92. package/src/prover/isabelle/encode.ts +72 -42
  93. package/src/prover/isabelle/isar/attrib.ts +250 -0
  94. package/src/prover/isabelle/isar/context.ts +335 -0
  95. package/src/prover/isabelle/isar/induct.ts +382 -0
  96. package/src/prover/isabelle/isar/inner-syntax.ts +158 -7
  97. package/src/prover/isabelle/isar/method.ts +509 -212
  98. package/src/prover/isabelle/isar/proof.ts +570 -14
  99. package/src/prover/isabelle/isar/rule-cases.ts +224 -0
  100. package/src/prover/isabelle/isar/theory.ts +487 -76
  101. package/src/prover/isabelle/isar/toplevel.ts +331 -0
  102. package/src/prover/isabelle/isar/type-check.ts +89 -14
  103. package/src/prover/isabelle/provers/blast/blast.ts +7 -65
  104. package/src/prover/isabelle/provers/blast/branch.ts +0 -2
  105. package/src/prover/isabelle/provers/blast/prove.ts +0 -2
  106. package/src/prover/isabelle/provers/blast/rules.ts +0 -2
  107. package/src/prover/isabelle/provers/blast/state.ts +0 -2
  108. package/src/prover/isabelle/provers/blast/term.ts +0 -2
  109. package/src/prover/isabelle/provers/clasimp.ts +0 -2
  110. package/src/prover/isabelle/provers/classical.ts +45 -20
  111. package/src/prover/isabelle/provers/hypsubst.ts +17 -28
  112. package/src/prover/isabelle/pure/bicompose.ts +9 -27
  113. package/src/prover/isabelle/pure/consts.ts +0 -2
  114. package/src/prover/isabelle/pure/conv.ts +2 -10
  115. package/src/prover/isabelle/pure/drule.ts +72 -6
  116. package/src/prover/isabelle/pure/envir.ts +0 -2
  117. package/src/prover/isabelle/pure/goal.ts +1 -3
  118. package/src/prover/isabelle/pure/logic.ts +1 -3
  119. package/src/prover/isabelle/pure/name.ts +0 -2
  120. package/src/prover/isabelle/pure/net.ts +0 -2
  121. package/src/prover/isabelle/pure/object-logic.ts +13 -7
  122. package/src/prover/isabelle/pure/pattern.ts +0 -2
  123. package/src/prover/isabelle/pure/raw-simplifier.ts +4 -15
  124. package/src/prover/isabelle/pure/rewriter.ts +6 -17
  125. package/src/prover/isabelle/pure/search.ts +0 -2
  126. package/src/prover/isabelle/pure/seq.ts +0 -2
  127. package/src/prover/isabelle/pure/simplifier.ts +26 -7
  128. package/src/prover/isabelle/pure/table.ts +2 -3
  129. package/src/prover/isabelle/pure/tactic.ts +0 -2
  130. package/src/prover/isabelle/pure/tactical.ts +42 -37
  131. package/src/prover/isabelle/pure/term-ord.ts +0 -2
  132. package/src/prover/isabelle/pure/term.ts +0 -2
  133. package/src/prover/isabelle/pure/thm.ts +14 -13
  134. package/src/prover/isabelle/pure/type.ts +0 -2
  135. package/src/prover/isabelle/pure/unify.ts +0 -2
  136. package/src/prover/isabelle/pure/variable.ts +0 -2
  137. package/src/prover/isabelle/tla/classical-setup.ts +18 -16
  138. package/src/prover/isabelle/tla/context.ts +58 -11
  139. package/src/prover/isabelle/tla/logic-data.ts +1 -1
  140. package/src/prover/isabelle/tla/logic.ts +49 -21
  141. package/src/prover/isabelle/tla/simpdata.ts +1 -12
  142. package/src/prover/isabelle/tools/intuitionistic.ts +28 -12
  143. package/src/prover/ocaml.ts +4 -1
  144. package/src/prover/prep/action.ts +30 -31
  145. package/src/prover/prep/enabled-axioms.ts +11 -2
  146. package/src/prover/prep/fingerprint.ts +2 -5
  147. package/src/prover/prep/methods.ts +181 -51
  148. package/src/prover/prep/normalize.ts +38 -9
  149. package/src/prover/prove.ts +395 -94
  150. package/src/prover/ptl/decide.ts +95 -50
  151. package/src/prover/ptl/encode.ts +2 -3
  152. package/src/prover/ptl/tableau.ts +28 -2
  153. package/src/prover/smt/arithmetic.ts +310 -0
  154. package/src/prover/smt/axioms.ts +12 -8
  155. package/src/prover/smt/context.ts +43 -8
  156. package/src/prover/smt/data.ts +498 -379
  157. package/src/prover/smt/encode.ts +148 -57
  158. package/src/prover/smt/extensionality.ts +5 -3
  159. package/src/prover/smt/flatten.ts +4 -6
  160. package/src/prover/smt/format.ts +28 -4
  161. package/src/prover/smt/instances.ts +7 -1
  162. package/src/prover/smt/layout.ts +91 -0
  163. package/src/prover/smt/rewrite.ts +1021 -618
  164. package/src/prover/smt/simplify.ts +441 -0
  165. package/src/prover/smt/solver/ackermannize-bv-tactic.ts +61 -0
  166. package/src/prover/smt/solver/ackr-helper.ts +179 -0
  167. package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
  168. package/src/prover/smt/solver/act-cache.ts +0 -1
  169. package/src/prover/smt/solver/add-bounds-tactic.ts +59 -0
  170. package/src/prover/smt/solver/aig-tactic.ts +52 -0
  171. package/src/prover/smt/solver/aig.ts +889 -0
  172. package/src/prover/smt/solver/arith-rewriter.ts +613 -6
  173. package/src/prover/smt/solver/arith-terms.ts +121 -0
  174. package/src/prover/smt/solver/array-decl-plugin.ts +175 -0
  175. package/src/prover/smt/solver/array-rewriter.ts +309 -0
  176. package/src/prover/smt/solver/asserted-formulas.ts +87 -16
  177. package/src/prover/smt/solver/ast-lt.ts +166 -12
  178. package/src/prover/smt/solver/ast-util.ts +160 -2
  179. package/src/prover/smt/solver/ast.ts +1427 -41
  180. package/src/prover/smt/solver/auf-solver.ts +2 -6
  181. package/src/prover/smt/solver/bit-blast-tactic.ts +582 -0
  182. package/src/prover/smt/solver/bit-blaster.ts +871 -0
  183. package/src/prover/smt/solver/bound-manager.ts +196 -0
  184. package/src/prover/smt/solver/bound-simplifier.ts +600 -0
  185. package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
  186. package/src/prover/smt/solver/bv-decl-plugin.ts +338 -0
  187. package/src/prover/smt/solver/bv-divrem-bounds.ts +95 -0
  188. package/src/prover/smt/solver/bv-rewriter.ts +1901 -0
  189. package/src/prover/smt/solver/bv1-blast.ts +214 -0
  190. package/src/prover/smt/solver/bv2fpa-converter.ts +174 -0
  191. package/src/prover/smt/solver/bv2int-rewriter.ts +544 -0
  192. package/src/prover/smt/solver/bv2real-rewriter.ts +533 -0
  193. package/src/prover/smt/solver/card2bv.ts +110 -0
  194. package/src/prover/smt/solver/case-split-queue.ts +0 -2
  195. package/src/prover/smt/solver/cg-table.ts +39 -25
  196. package/src/prover/smt/solver/check-logic.ts +330 -0
  197. package/src/prover/smt/solver/clause.ts +0 -1
  198. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +278 -0
  199. package/src/prover/smt/solver/conflict-resolution.ts +78 -2
  200. package/src/prover/smt/solver/context.ts +516 -115
  201. package/src/prover/smt/solver/ctx-simplify.ts +20 -10
  202. package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
  203. package/src/prover/smt/solver/datatype-decl-plugin.ts +572 -0
  204. package/src/prover/smt/solver/datatype-rewriter.ts +82 -0
  205. package/src/prover/smt/solver/demodulator.ts +786 -0
  206. package/src/prover/smt/solver/dependent-expr-state.ts +81 -0
  207. package/src/prover/smt/solver/der.ts +38 -10
  208. package/src/prover/smt/solver/diff-neq.ts +206 -0
  209. package/src/prover/smt/solver/distribute-forall.ts +57 -0
  210. package/src/prover/smt/solver/dom-simplify.ts +511 -0
  211. package/src/prover/smt/solver/dt2bv-tactic.ts +260 -0
  212. package/src/prover/smt/solver/dyn-ack.ts +0 -1
  213. package/src/prover/smt/solver/e-matching.ts +7 -8
  214. package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
  215. package/src/prover/smt/solver/elim-uncnstr.ts +545 -0
  216. package/src/prover/smt/solver/enode.ts +100 -3
  217. package/src/prover/smt/solver/eq2bv-tactic.ts +218 -0
  218. package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
  219. package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
  220. package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
  221. package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
  222. package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
  223. package/src/prover/smt/solver/euf/array-solver.ts +306 -0
  224. package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
  225. package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
  226. package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
  227. package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
  228. package/src/prover/smt/solver/euf/egraph.ts +908 -0
  229. package/src/prover/smt/solver/euf/euf-solver.ts +1205 -0
  230. package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
  231. package/src/prover/smt/solver/euf/mam.ts +1050 -0
  232. package/src/prover/smt/solver/euf/q-ematch.ts +830 -0
  233. package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
  234. package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
  235. package/src/prover/smt/solver/euf/q-solver.ts +361 -0
  236. package/src/prover/smt/solver/euf/th-solver.ts +335 -0
  237. package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
  238. package/src/prover/smt/solver/expr-ref.ts +0 -1
  239. package/src/prover/smt/solver/expr-safe-replace.ts +26 -2
  240. package/src/prover/smt/solver/expr2polynomial.ts +146 -0
  241. package/src/prover/smt/solver/factor.ts +141 -0
  242. package/src/prover/smt/solver/fd-solver.ts +265 -0
  243. package/src/prover/smt/solver/fingerprints.ts +15 -15
  244. package/src/prover/smt/solver/fix-dl-var.ts +148 -0
  245. package/src/prover/smt/solver/flat-literals.ts +0 -1
  246. package/src/prover/smt/solver/fm-tactic.ts +884 -0
  247. package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
  248. package/src/prover/smt/solver/fpa-rewriter.ts +640 -0
  249. package/src/prover/smt/solver/fpa2bv-converter.ts +2249 -0
  250. package/src/prover/smt/solver/fpa2bv-rewriter.ts +348 -0
  251. package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
  252. package/src/prover/smt/solver/goal.ts +175 -15
  253. package/src/prover/smt/solver/goal2nlsat.ts +189 -0
  254. package/src/prover/smt/solver/guard-set.ts +219 -0
  255. package/src/prover/smt/solver/hash.ts +0 -1
  256. package/src/prover/smt/solver/hashtable.ts +30 -16
  257. package/src/prover/smt/solver/inf-eps.ts +63 -0
  258. package/src/prover/smt/solver/inj-axiom.ts +101 -0
  259. package/src/prover/smt/solver/internalizer.ts +110 -38
  260. package/src/prover/smt/solver/lackr.ts +381 -0
  261. package/src/prover/smt/solver/lbool.ts +0 -1
  262. package/src/prover/smt/solver/lia2card.ts +268 -0
  263. package/src/prover/smt/solver/lia2pb.ts +154 -0
  264. package/src/prover/smt/solver/literal.ts +0 -1
  265. package/src/prover/smt/solver/logic-tactics.ts +345 -0
  266. package/src/prover/smt/solver/lp/bound-propagator.ts +0 -1
  267. package/src/prover/smt/solver/lp/constraints.ts +0 -1
  268. package/src/prover/smt/solver/lp/containers.ts +7 -2
  269. package/src/prover/smt/solver/lp/core-solver.ts +18 -3
  270. package/src/prover/smt/solver/lp/cross-nested.ts +1 -4
  271. package/src/prover/smt/solver/lp/dep-intervals.ts +0 -3
  272. package/src/prover/smt/solver/lp/dependency.ts +0 -2
  273. package/src/prover/smt/solver/lp/dioph-eq.ts +1 -10
  274. package/src/prover/smt/solver/lp/explanation.ts +0 -1
  275. package/src/prover/smt/solver/lp/gomory.ts +0 -1
  276. package/src/prover/smt/solver/lp/hnf-cutter.ts +1 -2
  277. package/src/prover/smt/solver/lp/hnf.ts +0 -3
  278. package/src/prover/smt/solver/lp/int-cube.ts +3 -4
  279. package/src/prover/smt/solver/lp/int-solver.ts +0 -2
  280. package/src/prover/smt/solver/lp/lar-solver.ts +40 -4
  281. package/src/prover/smt/solver/lp/lar-term.ts +0 -1
  282. package/src/prover/smt/solver/lp/lp-settings.ts +0 -1
  283. package/src/prover/smt/solver/lp/maximize-term.ts +59 -10
  284. package/src/prover/smt/solver/lp/nex-creator.ts +3 -3
  285. package/src/prover/smt/solver/lp/nex.ts +2 -2
  286. package/src/prover/smt/solver/lp/nla-backoff.ts +0 -2
  287. package/src/prover/smt/solver/lp/nla-basics.ts +46 -3
  288. package/src/prover/smt/solver/lp/nla-core.ts +67 -16
  289. package/src/prover/smt/solver/lp/nla-divisions.ts +0 -2
  290. package/src/prover/smt/solver/lp/nla-emonics.ts +0 -1
  291. package/src/prover/smt/solver/lp/nla-factorization.ts +0 -1
  292. package/src/prover/smt/solver/lp/nla-grobner.ts +165 -83
  293. package/src/prover/smt/solver/lp/nla-horner.ts +0 -2
  294. package/src/prover/smt/solver/lp/nla-intervals.ts +0 -1
  295. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +0 -2
  296. package/src/prover/smt/solver/lp/nla-monotone.ts +0 -1
  297. package/src/prover/smt/solver/lp/nla-order.ts +0 -2
  298. package/src/prover/smt/solver/lp/nla-patcher.ts +0 -1
  299. package/src/prover/smt/solver/lp/nla-powers.ts +220 -0
  300. package/src/prover/smt/solver/lp/nla-tangents.ts +0 -2
  301. package/src/prover/smt/solver/lp/nla-throttle.ts +0 -1
  302. package/src/prover/smt/solver/lp/nla-transcendentals.ts +324 -0
  303. package/src/prover/smt/solver/lp/nla-types.ts +0 -2
  304. package/src/prover/smt/solver/lp/nla-var-eqs.ts +0 -1
  305. package/src/prover/smt/solver/lp/nra-solver.ts +122 -64
  306. package/src/prover/smt/solver/lp/numeric-pair.ts +0 -1
  307. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -3
  308. package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -21
  309. package/src/prover/smt/solver/lp/pdd-solver.ts +72 -41
  310. package/src/prover/smt/solver/lp/pdd.ts +725 -289
  311. package/src/prover/smt/solver/lp/random-updater.ts +0 -2
  312. package/src/prover/smt/solver/lp/static-matrix.ts +0 -1
  313. package/src/prover/smt/solver/lp/union-find.ts +7 -2
  314. package/src/prover/smt/solver/macro-finder.ts +530 -0
  315. package/src/prover/smt/solver/mam-compiler.ts +122 -90
  316. package/src/prover/smt/solver/mam-interpreter.ts +0 -1
  317. package/src/prover/smt/solver/max-bv-sharing-tactic.ts +17 -0
  318. package/src/prover/smt/solver/max-cliques.ts +105 -0
  319. package/src/prover/smt/solver/maxcore.ts +309 -0
  320. package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -6
  321. package/src/prover/smt/solver/maxlex.ts +115 -0
  322. package/src/prover/smt/solver/maxsmt-base.ts +105 -0
  323. package/src/prover/smt/solver/maxsmt.ts +92 -0
  324. package/src/prover/smt/solver/mbp/mbp-arith.ts +467 -0
  325. package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +101 -0
  326. package/src/prover/smt/solver/mbp/mbp-plugin.ts +287 -0
  327. package/src/prover/smt/solver/mbp/mbp-qel.ts +48 -0
  328. package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +271 -0
  329. package/src/prover/smt/solver/mbp/mbp-term-graph.ts +606 -0
  330. package/src/prover/smt/solver/model-based-opt.ts +844 -0
  331. package/src/prover/smt/solver/model-checker.ts +18 -27
  332. package/src/prover/smt/solver/model-evaluator.ts +188 -12
  333. package/src/prover/smt/solver/model-finder.ts +12 -18
  334. package/src/prover/smt/solver/model-generator.ts +56 -29
  335. package/src/prover/smt/solver/model-macro-solver.ts +49 -46
  336. package/src/prover/smt/solver/model-printer.ts +214 -0
  337. package/src/prover/smt/solver/mpf.ts +711 -0
  338. package/src/prover/smt/solver/mus.ts +51 -0
  339. package/src/prover/smt/solver/muz/dl-context.ts +404 -0
  340. package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +97 -0
  341. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +167 -0
  342. package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +125 -0
  343. package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +299 -0
  344. package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +455 -0
  345. package/src/prover/smt/solver/muz/dl-mk-slice.ts +340 -0
  346. package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +163 -0
  347. package/src/prover/smt/solver/muz/dl-rule-set.ts +273 -0
  348. package/src/prover/smt/solver/muz/dl-rule-transformer.ts +123 -0
  349. package/src/prover/smt/solver/muz/dl-rule.ts +496 -0
  350. package/src/prover/smt/solver/muz/hnf.ts +201 -0
  351. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
  352. package/src/prover/smt/solver/muz/horn-tactic.ts +201 -0
  353. package/src/prover/smt/solver/muz/rule-properties.ts +337 -0
  354. package/src/prover/smt/solver/muz/spacer-context.ts +1406 -0
  355. package/src/prover/smt/solver/muz/spacer-dl-interface.ts +52 -0
  356. package/src/prover/smt/solver/muz/spacer-generalizers.ts +241 -0
  357. package/src/prover/smt/solver/muz/spacer-manager.ts +127 -0
  358. package/src/prover/smt/solver/muz/spacer-pdr.ts +218 -0
  359. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +333 -0
  360. package/src/prover/smt/solver/muz/spacer-util.ts +282 -0
  361. package/src/prover/smt/solver/muz/substitution.ts +203 -0
  362. package/src/prover/smt/solver/nla2bv-tactic.ts +285 -0
  363. package/src/prover/smt/solver/nlqsat.ts +484 -0
  364. package/src/prover/smt/solver/nlsat/algebraic.ts +125 -12
  365. package/src/prover/smt/solver/nlsat/atoms.ts +20 -6
  366. package/src/prover/smt/solver/nlsat/evaluator.ts +0 -1
  367. package/src/prover/smt/solver/nlsat/explain.ts +63 -23
  368. package/src/prover/smt/solver/nlsat/interval-set.ts +1 -2
  369. package/src/prover/smt/solver/nlsat/levelwise.ts +3 -9
  370. package/src/prover/smt/solver/nlsat/mpbq.ts +45 -1
  371. package/src/prover/smt/solver/nlsat/polynomial.ts +13 -6
  372. package/src/prover/smt/solver/nlsat/solver.ts +236 -45
  373. package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
  374. package/src/prover/smt/solver/nlsat/transcendentals.ts +367 -0
  375. package/src/prover/smt/solver/nlsat/types.ts +0 -2
  376. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +1 -4
  377. package/src/prover/smt/solver/nlsat/upolynomial.ts +0 -2
  378. package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
  379. package/src/prover/smt/solver/nnf.ts +105 -23
  380. package/src/prover/smt/solver/normalize-bounds.ts +53 -0
  381. package/src/prover/smt/solver/occf.ts +97 -0
  382. package/src/prover/smt/solver/opt-context.ts +787 -0
  383. package/src/prover/smt/solver/opt-nlsat.ts +375 -0
  384. package/src/prover/smt/solver/opt-pareto.ts +282 -0
  385. package/src/prover/smt/solver/opt-preprocess.ts +101 -0
  386. package/src/prover/smt/solver/opt-solver.ts +308 -0
  387. package/src/prover/smt/solver/opt-value.ts +55 -0
  388. package/src/prover/smt/solver/optsmt.ts +692 -0
  389. package/src/prover/smt/solver/parallel-tactic.ts +299 -0
  390. package/src/prover/smt/solver/pattern-inference.ts +19 -11
  391. package/src/prover/smt/solver/pb-rewriter.ts +284 -0
  392. package/src/prover/smt/solver/pb2bv-tactic.ts +540 -0
  393. package/src/prover/smt/solver/poly-rewriter.ts +202 -57
  394. package/src/prover/smt/solver/probes.ts +512 -0
  395. package/src/prover/smt/solver/propagate-values.ts +37 -21
  396. package/src/prover/smt/solver/proto-model.ts +648 -19
  397. package/src/prover/smt/solver/pull-quant.ts +28 -12
  398. package/src/prover/smt/solver/purify-arith.ts +632 -0
  399. package/src/prover/smt/solver/qe-arith-plugin.ts +1098 -0
  400. package/src/prover/smt/solver/qe-lite-der.ts +2 -3
  401. package/src/prover/smt/solver/qe-lite-fm.ts +3 -4
  402. package/src/prover/smt/solver/qe-lite.ts +37 -17
  403. package/src/prover/smt/solver/qe-mbp.ts +270 -0
  404. package/src/prover/smt/solver/qe.ts +1498 -0
  405. package/src/prover/smt/solver/qel.ts +25 -0
  406. package/src/prover/smt/solver/qi-queue.ts +0 -1
  407. package/src/prover/smt/solver/qsat.ts +814 -0
  408. package/src/prover/smt/solver/quant-hoist.ts +196 -0
  409. package/src/prover/smt/solver/quant-tactics.ts +16 -56
  410. package/src/prover/smt/solver/quantifier-analyzer.ts +19 -20
  411. package/src/prover/smt/solver/quantifier-manager.ts +8 -16
  412. package/src/prover/smt/solver/quasi-macros.ts +243 -0
  413. package/src/prover/smt/solver/random-gen.ts +0 -1
  414. package/src/prover/smt/solver/rational.ts +45 -1
  415. package/src/prover/smt/solver/recfun-decl-plugin.ts +261 -0
  416. package/src/prover/smt/solver/recfun-rewriter.ts +107 -0
  417. package/src/prover/smt/solver/reduce-args.ts +225 -0
  418. package/src/prover/smt/solver/reduce-bv-size.ts +119 -0
  419. package/src/prover/smt/solver/ref-vector.ts +0 -1
  420. package/src/prover/smt/solver/relevancy.ts +1 -2
  421. package/src/prover/smt/solver/rewriter-tpl.ts +77 -10
  422. package/src/prover/smt/solver/rewriter.ts +475 -36
  423. package/src/prover/smt/solver/rlimit.ts +38 -2
  424. package/src/prover/smt/solver/sat/asymm-branch.ts +325 -0
  425. package/src/prover/smt/solver/sat/big.ts +177 -0
  426. package/src/prover/smt/solver/sat/clause-use-list.ts +71 -0
  427. package/src/prover/smt/solver/sat/clause.ts +203 -0
  428. package/src/prover/smt/solver/sat/cleaner.ts +94 -0
  429. package/src/prover/smt/solver/sat/config.ts +122 -0
  430. package/src/prover/smt/solver/sat/consequences.ts +203 -0
  431. package/src/prover/smt/solver/sat/elim-eqs.ts +142 -0
  432. package/src/prover/smt/solver/sat/goal2sat.ts +526 -0
  433. package/src/prover/smt/solver/sat/inc-sat-solver.ts +378 -0
  434. package/src/prover/smt/solver/sat/model-converter.ts +136 -0
  435. package/src/prover/smt/solver/sat/pb-constraint.ts +261 -0
  436. package/src/prover/smt/solver/sat/pb-solver.ts +1577 -0
  437. package/src/prover/smt/solver/sat/probing.ts +170 -0
  438. package/src/prover/smt/solver/sat/sat-tactic.ts +43 -0
  439. package/src/prover/smt/solver/sat/sat2goal.ts +165 -0
  440. package/src/prover/smt/solver/sat/scc.ts +142 -0
  441. package/src/prover/smt/solver/sat/simplifier.ts +1618 -0
  442. package/src/prover/smt/solver/sat/solver.ts +2127 -0
  443. package/src/prover/smt/solver/sat/var-queue.ts +117 -0
  444. package/src/prover/smt/solver/sat/watch-list.ts +140 -0
  445. package/src/prover/smt/solver/search-tree.ts +284 -0
  446. package/src/prover/smt/solver/seq-axioms.ts +1010 -0
  447. package/src/prover/smt/solver/seq-decl-plugin.ts +819 -0
  448. package/src/prover/smt/solver/seq-derive.ts +1298 -0
  449. package/src/prover/smt/solver/seq-eq-approx.ts +236 -0
  450. package/src/prover/smt/solver/seq-eq-solver.ts +439 -0
  451. package/src/prover/smt/solver/seq-factory.ts +89 -0
  452. package/src/prover/smt/solver/seq-monadic.ts +728 -0
  453. package/src/prover/smt/solver/seq-range-predicate.ts +235 -0
  454. package/src/prover/smt/solver/seq-re-rewriter.ts +1170 -0
  455. package/src/prover/smt/solver/seq-re-util.ts +758 -0
  456. package/src/prover/smt/solver/seq-regex-bisim.ts +144 -0
  457. package/src/prover/smt/solver/seq-regex-live.ts +200 -0
  458. package/src/prover/smt/solver/seq-rewriter.ts +2402 -0
  459. package/src/prover/smt/solver/seq-skolem.ts +317 -0
  460. package/src/prover/smt/solver/seq-subset.ts +165 -0
  461. package/src/prover/smt/solver/seq-view-witness.ts +353 -0
  462. package/src/prover/smt/solver/smt-consequences.ts +297 -0
  463. package/src/prover/smt/solver/smt-kernel.ts +83 -0
  464. package/src/prover/smt/solver/smt-logics.ts +66 -0
  465. package/src/prover/smt/solver/smt-setup.ts +496 -0
  466. package/src/prover/smt/solver/smt2-printer.ts +765 -0
  467. package/src/prover/smt/solver/smtlib-parser.ts +3126 -316
  468. package/src/prover/smt/solver/smtlib-script.ts +1631 -0
  469. package/src/prover/smt/solver/solve-eqs.ts +929 -0
  470. package/src/prover/smt/solver/solver.ts +113 -22
  471. package/src/prover/smt/solver/static-features.ts +314 -0
  472. package/src/prover/smt/solver/sticky-generations.ts +0 -1
  473. package/src/prover/smt/solver/tactic.ts +1986 -0
  474. package/src/prover/smt/solver/term-enumeration.ts +205 -0
  475. package/src/prover/smt/solver/theory-array.ts +1240 -0
  476. package/src/prover/smt/solver/theory-bv.ts +1200 -0
  477. package/src/prover/smt/solver/theory-char.ts +355 -0
  478. package/src/prover/smt/solver/theory-datatype.ts +598 -0
  479. package/src/prover/smt/solver/theory-finite-set.ts +30 -0
  480. package/src/prover/smt/solver/theory-fpa.ts +389 -0
  481. package/src/prover/smt/solver/theory-lra-axioms.ts +53 -2
  482. package/src/prover/smt/solver/theory-lra-bounds.ts +31 -6
  483. package/src/prover/smt/solver/theory-lra-final-check.ts +56 -70
  484. package/src/prover/smt/solver/theory-lra-internalize.ts +94 -27
  485. package/src/prover/smt/solver/theory-lra-model.ts +20 -35
  486. package/src/prover/smt/solver/theory-lra-propagate.ts +24 -26
  487. package/src/prover/smt/solver/theory-lra-state.ts +6 -22
  488. package/src/prover/smt/solver/theory-lra.ts +188 -1
  489. package/src/prover/smt/solver/theory-pb.ts +934 -0
  490. package/src/prover/smt/solver/theory-polymorphism.ts +58 -0
  491. package/src/prover/smt/solver/theory-recfun.ts +307 -0
  492. package/src/prover/smt/solver/theory-seq-regex.ts +867 -0
  493. package/src/prover/smt/solver/theory-seq-solve.ts +1373 -0
  494. package/src/prover/smt/solver/theory-seq-state.ts +871 -0
  495. package/src/prover/smt/solver/theory-seq.ts +961 -0
  496. package/src/prover/smt/solver/theory.ts +189 -0
  497. package/src/prover/smt/solver/tseitin-cnf.ts +485 -0
  498. package/src/prover/smt/solver/var-subst.ts +36 -14
  499. package/src/prover/smt/table.ts +3 -2
  500. package/src/prover/smt/types.ts +146 -0
  501. package/src/prover/tlapm/cache.ts +50 -19
  502. package/src/prover/tlapm/tlapm.ts +15 -9
  503. package/src/prover/tlapm-library.ts +3208 -0
  504. package/src/prover/verdict.ts +9 -0
  505. package/src/prover/zenon/check/check.ts +1 -2
  506. package/src/prover/zenon/check/records.ts +1 -1
  507. package/src/prover/zenon/check/relations.ts +2 -1
  508. package/src/prover/zenon/check/rewrites.ts +2 -15
  509. package/src/prover/zenon/check/sets.ts +40 -58
  510. package/src/prover/zenon/check/terms.ts +1 -2
  511. package/src/prover/zenon/decide.ts +10 -7
  512. package/src/prover/zenon/encode.ts +0 -2
  513. package/src/prover/zenon/eqrel.ts +2 -2
  514. package/src/prover/zenon/equality-rules.ts +24 -2
  515. package/src/prover/zenon/expr.ts +28 -2
  516. package/src/prover/zenon/index-table.ts +11 -21
  517. package/src/prover/zenon/isar-case.ts +0 -2
  518. package/src/prover/zenon/isar.ts +35 -37
  519. package/src/prover/zenon/llproof.ts +2 -13
  520. package/src/prover/zenon/mltoll.ts +12 -30
  521. package/src/prover/zenon/node.ts +20 -5
  522. package/src/prover/zenon/parse.ts +9 -8
  523. package/src/prover/zenon/phrase.ts +0 -2
  524. package/src/prover/zenon/proof.ts +0 -2
  525. package/src/prover/zenon/propositional-rules.ts +0 -2
  526. package/src/prover/zenon/rules.ts +2 -3
  527. package/src/prover/zenon/search.ts +11 -19
  528. package/src/prover/zenon/tla/functions.ts +2 -4
  529. package/src/prover/zenon/tla/llproof.ts +9 -13
  530. package/src/prover/zenon/tla/records.ts +1 -8
  531. package/src/prover/zenon/tla/rewrites.ts +0 -2
  532. package/src/prover/zenon/tla/sets.ts +22 -22
  533. package/src/prover/zenon/tla/terms.ts +0 -2
  534. package/src/prover/zenon/tla/tla.ts +7 -8
  535. package/src/randomization.ts +1 -4
  536. package/src/resolve.ts +67 -143
  537. package/src/runtime.ts +17 -18
  538. package/src/sany/builtins.ts +1 -3
  539. package/src/sany/generation.ts +394 -0
  540. package/src/sany/generator-def-entries.ts +210 -0
  541. package/src/sany/generator-definitions.ts +686 -0
  542. package/src/sany/generator-expressions.ts +1100 -0
  543. package/src/sany/generator-proofs.ts +662 -0
  544. package/src/sany/generator.ts +160 -2683
  545. package/src/sany/levels.ts +5 -11
  546. package/src/sany/lexer.ts +57 -60
  547. package/src/sany/linter.ts +0 -3
  548. package/src/sany/nodes.ts +6 -13
  549. package/src/sany/report.ts +3 -6
  550. package/src/sany/selectors.ts +35 -38
  551. package/src/sany/xml.ts +23 -55
  552. package/src/search.ts +244 -53
  553. package/src/simulate.ts +202 -184
  554. package/src/spec-description.ts +56 -82
  555. package/src/standard-definitions.ts +4 -3
  556. package/src/standard-modules.ts +17 -44
  557. package/src/state-graph.ts +3 -17
  558. package/src/subexpressions.ts +38 -47
  559. package/src/substitution-levels.ts +5 -4
  560. package/src/successors.ts +20 -43
  561. package/src/symmetry.ts +6 -21
  562. package/src/tableau.ts +2 -2
  563. package/src/tlc/fingerprint.ts +96 -30
  564. package/src/tlc/jar-data.ts +0 -1
  565. package/src/tlc/messages.ts +22 -36
  566. package/src/tlc/order.ts +36 -50
  567. package/src/tlc/random.ts +22 -34
  568. package/src/tlc/replay.ts +21 -48
  569. package/src/tlc/summary.ts +64 -58
  570. package/src/tlc/tlc-operators.ts +6 -17
  571. package/src/tlc/tlcext-operators.ts +70 -29
  572. package/src/tlc/trace-spec.ts +26 -51
  573. package/src/tlc/value-stream.ts +9 -13
  574. package/src/tlc/version.ts +0 -1
  575. package/src/typed-tier.ts +6535 -0
  576. package/src/typescript/actions.ts +2 -4
  577. package/src/typescript/collections.ts +34 -20
  578. package/src/typescript/compile.ts +1 -3
  579. package/src/typescript/formula.ts +5 -3
  580. package/src/typescript/model.ts +4 -5
  581. package/src/typescript/steps.ts +20 -18
  582. package/src/values.ts +136 -338
  583. package/src/prover/isabelle/isar/statement.ts +0 -52
  584. package/src/prover/smt/solver/z3-license.txt +0 -10
  585. package/src/prover/tlaps-module.ts +0 -510
  586. package/src/prover/zenon/LICENSE +0 -32
@@ -1,9 +1,11 @@
1
1
  import { TlaEvaluationError } from "./errors";
2
+ import { isExpressionImpure } from "./dependencies";
2
3
  import { hasRepeatedEffects, type Environment } from "./evaluate";
3
4
  import {
4
- evaluateLive,
5
5
  evaluateOnLasso,
6
+ getInterpretedAtoms,
6
7
  toLiveExpression,
8
+ type LiveAtoms,
7
9
  type ScopedExpression,
8
10
  type TemporalProperty,
9
11
  } from "./liveness";
@@ -13,30 +15,29 @@ import {
13
15
  getSolutions,
14
16
  getTermKey,
15
17
  isFulfilling,
18
+ type LiveAction,
19
+ type LiveEnabled,
16
20
  type LiveExpression,
21
+ type LiveState,
17
22
  type Solution,
18
23
  type Tableau,
19
24
  } from "./tableau";
20
25
  import { isSameValue, type Value } from "./values";
21
26
 
22
- export interface LiveSuccessor {
27
+ export interface LiveSuccessor<State = Value[]> {
23
28
  index: number;
24
- state: Value[];
29
+ state: State;
25
30
  }
26
31
 
27
32
  export interface Lasso {
28
33
  prefix: number[];
29
34
  cycle: number[];
30
- // TLC warns that a stuttering counterexample to a liveness property may come from a missing
31
- // fairness constraint.
32
35
  isCycleConstrained: boolean;
33
36
  }
34
37
 
35
38
  export interface LivenessChecker {
36
- // How many solutions of the negated properties TLC checks, which it calls branches.
37
39
  branches: number;
38
- // With a tracing environment, the checks record their call stack as TLC's replay of a failed
39
- // check does.
40
+ solutions: Solution[];
40
41
  addInitialState: (index: number, state: Value[], tracing?: Environment) => void;
41
42
  addState: (
42
43
  index: number,
@@ -44,44 +45,81 @@ export interface LivenessChecker {
44
45
  successors: LiveSuccessor[],
45
46
  tracing?: Environment,
46
47
  ) => number[] | undefined;
48
+ storeState: (pending: number, index: number) => void;
49
+ getStateCounts: () => number[];
47
50
  findViolation: () => Lasso | undefined;
48
51
  getViolatedProperties: (path: Value[][], cycleStart: number) => string[];
49
52
  }
50
53
 
51
- interface SearchGraph {
52
- getFingerprint: (successor: LiveSuccessor) => number;
53
- getSuccessors: (index: number, state: Value[]) => LiveSuccessor[];
54
+ export interface LiveGraph<State> {
55
+ branches: number;
56
+ addInitialState: (index: number, state: State) => void;
57
+ // The path to an accepting node the state reaches, if any.
58
+ addState: (
59
+ index: number,
60
+ state: State,
61
+ successors: LiveSuccessor<State>[],
62
+ ) => number[] | undefined;
63
+ storeState: (pending: number, index: number) => void;
64
+ // How many states the graph of each branch has, which TLC counts as the fingerprints of its nodes.
65
+ getStateCounts: () => number[];
66
+ findViolation: () => Lasso | undefined;
67
+ }
68
+
69
+ export interface SearchGraph<State> {
70
+ getFingerprint: (successor: LiveSuccessor<State>) => number;
71
+ getSuccessors: (index: number, state: State) => LiveSuccessor<State>[];
72
+ }
73
+
74
+ export interface LiveEvaluation<State> {
75
+ atoms: LiveAtoms<State>;
76
+ // Whether a check's result for a state holds for every step from it.
77
+ isShared: boolean;
78
+ isSame: (left: State, right: State) => boolean;
79
+ // Evaluates the checks of a state the search found from the state at source.
80
+ evaluateFrom: <Result>(source: number | undefined, evaluate: () => Result) => Result;
54
81
  }
55
82
 
56
- // Numbers in a typed array that doubles as it fills, so a graph of millions of nodes takes a few
57
- // bytes for each.
58
83
  interface Pool<Data extends Int32Array | Uint8Array> {
59
84
  data: Data;
60
85
  length: number;
61
86
  create: (length: number) => Data;
62
87
  }
63
88
 
64
- interface BehaviorGraph {
89
+ // A check reads and fills the state atoms of a state in its row, which starts at offset.
90
+ type Check<State> = (
91
+ state: State,
92
+ row: Int8Array,
93
+ offset: number,
94
+ next: State | undefined,
95
+ ) => boolean;
96
+
97
+ interface BehaviorChecks<State> {
98
+ states: Check<State>[];
99
+ actions: Check<State>[];
100
+ // The state predicates of each tableau node, or, where its checks share results and it has only
101
+ // state atoms and their negations, each atom's id * 2 plus 1 if it must hold.
102
+ nodes: (Check<State>[] | Int32Array)[];
103
+ }
104
+
105
+ interface BehaviorGraph<State> {
65
106
  solution: Solution;
107
+ checks: BehaviorChecks<State>;
66
108
  actionIds: Int32Array;
67
109
  nodeStates: number[];
68
110
  nodeTableaux: number[];
69
- // Where a node's edges start in edgeTargets, or UNWRITTEN until TLC writes the node with its
70
- // successors, and how many it has.
71
111
  edgeStarts: number[];
72
112
  edgeCounts: number[];
73
113
  edgeTargets: Pool<Int32Array>;
74
- // The results of the action checks on each edge, and of the state checks on each state, which
75
- // are the same for every node of the state.
76
114
  edgeActions: Pool<Uint8Array>;
77
115
  stateResults: Pool<Uint8Array>;
78
116
  initial: number[];
79
- // The nodes of each state in the order they are recorded, a list through nextSiblings.
80
117
  firstNodes: Pool<Int32Array>;
81
118
  lastNodes: Pool<Int32Array>;
82
119
  nextSiblings: number[];
83
120
  nodeIds: NodeTable;
84
121
  isDone: boolean[];
122
+ stateCount: number;
85
123
  errorNode: number | undefined;
86
124
  }
87
125
 
@@ -101,14 +139,14 @@ const containsAlways = (expression: LiveExpression): boolean => {
101
139
  }
102
140
  };
103
141
 
142
+ const isEmptyModel = (model: Solution["models"][number]) =>
143
+ model.eventuallyAlways.length === 0 &&
144
+ model.infinitelyOftenStates.length === 0 &&
145
+ model.infinitelyOftenActions.length === 0;
146
+
104
147
  const isCycleConstrained = (solution: Solution) =>
105
148
  solution.promises.some((promise) => containsAlways(promise.body)) ||
106
- solution.models.some(
107
- (model) =>
108
- model.eventuallyAlways.length > 0 ||
109
- model.infinitelyOftenStates.length > 0 ||
110
- model.infinitelyOftenActions.length > 0,
111
- );
149
+ solution.models.some((model) => !isEmptyModel(model));
112
150
 
113
151
  const isSameState = (left: Value[], right: Value[]) =>
114
152
  left.every((value, position) => isSameValue(value, right[position]));
@@ -124,21 +162,24 @@ const writeToPool = <Data extends Int32Array | Uint8Array>(
124
162
  pool: Pool<Data>,
125
163
  offset: number,
126
164
  values: ArrayLike<number>,
165
+ start = 0,
166
+ length = values.length - start,
127
167
  ) => {
128
- const end = offset + values.length;
168
+ const end = offset + length;
129
169
  if (end > pool.data.length) {
130
170
  const data = pool.create(Math.max(2 * pool.data.length, end));
131
171
  data.set(pool.data);
132
172
  pool.data = data;
133
173
  }
134
- pool.data.set(values, offset);
174
+ for (let position = 0; position < length; position++) {
175
+ pool.data[offset + position] = values[start + position];
176
+ }
135
177
  pool.length = Math.max(pool.length, end);
136
178
  };
137
179
 
138
180
  const NO_NODE = -1;
139
181
 
140
- // A Map holds at most 2^24 entries, so each tableau node of a state finds its node in an
141
- // open-addressing table of (state plus one, tableau node, node) triples.
182
+ // A Map holds at most 2^24 entries, so an open-addressing table of (state plus one, tableau node, node) triples finds each node.
142
183
  interface NodeTable {
143
184
  slots: Int32Array;
144
185
  size: number;
@@ -161,20 +202,20 @@ const createNodes = (length: number) => new Int32Array(length).fill(NO_NODE);
161
202
 
162
203
  const UNWRITTEN = -1;
163
204
 
164
- const isWritten = (behavior: BehaviorGraph, node: number) =>
205
+ const isWritten = <State>(behavior: BehaviorGraph<State>, node: number) =>
165
206
  (behavior.edgeStarts[node] ?? UNWRITTEN) !== UNWRITTEN;
166
207
 
167
- const getNodeSuccessors = (behavior: BehaviorGraph, node: number) => {
208
+ const getNodeSuccessors = <State>(behavior: BehaviorGraph<State>, node: number) => {
168
209
  const start = behavior.edgeStarts[node];
169
210
  return behavior.edgeTargets.data.subarray(start, start + behavior.edgeCounts[node]);
170
211
  };
171
212
 
172
- const getStateResult = (behavior: BehaviorGraph, node: number, position: number) =>
213
+ const getStateResult = <State>(behavior: BehaviorGraph<State>, node: number, position: number) =>
173
214
  behavior.stateResults.data[
174
215
  behavior.nodeStates[node] * behavior.solution.stateChecks.length + position
175
216
  ] === 1;
176
217
 
177
- const pushNode = (behavior: BehaviorGraph, state: number, tableauNode: number) => {
218
+ const pushNode = <State>(behavior: BehaviorGraph<State>, state: number, tableauNode: number) => {
178
219
  behavior.nodeStates.push(state);
179
220
  behavior.nodeTableaux.push(tableauNode);
180
221
  behavior.edgeStarts.push(UNWRITTEN);
@@ -183,7 +224,7 @@ const pushNode = (behavior: BehaviorGraph, state: number, tableauNode: number) =
183
224
  return behavior.nodeStates.length - 1;
184
225
  };
185
226
 
186
- const getStateNodes = (behavior: BehaviorGraph, state: number) => {
227
+ const getStateNodes = <State>(behavior: BehaviorGraph<State>, state: number) => {
187
228
  const nodes: number[] = [];
188
229
  for (
189
230
  let node = behavior.firstNodes.data[state] ?? NO_NODE;
@@ -203,13 +244,11 @@ const UNVISITED = -1;
203
244
 
204
245
  const MAXIMUM_LINK = Number.MAX_SAFE_INTEGER;
205
246
 
206
- export const createLivenessChecker = (
247
+ const getLiveFormula = (
207
248
  properties: TemporalProperty[],
208
249
  temporals: ScopedExpression[],
209
250
  environment: Environment,
210
- search: SearchGraph,
211
- ): LivenessChecker | undefined => {
212
- if (properties.length === 0) return undefined;
251
+ ) => {
213
252
  const fairness = temporals.map((item) =>
214
253
  toLiveExpression(item.expression, item.scope, environment),
215
254
  );
@@ -219,15 +258,247 @@ export const createLivenessChecker = (
219
258
  const violation = negations.length === 1 ? negations[0] : createJunction("Or", negations);
220
259
  const formula =
221
260
  fairness.length === 0 ? violation : createJunction("And", [...fairness, violation]);
222
- const solutions = getSolutions(formula);
261
+ return { formula, negations };
262
+ };
263
+
264
+ export type LiveAtom = LiveState | LiveEnabled | LiveAction;
265
+
266
+ const getAtomExpressions = (atom: LiveAtom): ScopedExpression[] => {
267
+ switch (atom.kind) {
268
+ case "State":
269
+ return [atom];
270
+ case "Enabled":
271
+ return [{ expression: atom.step, scope: atom.scope }];
272
+ case "Action":
273
+ return [atom.expression, atom.subscript].flatMap((inner) =>
274
+ inner ? [{ expression: inner, scope: atom.scope }] : [],
275
+ );
276
+ }
277
+ };
278
+
279
+ const collectAtoms = (expression: LiveExpression, atoms: Set<LiveAtom>) => {
280
+ switch (expression.kind) {
281
+ case "Boolean":
282
+ return;
283
+ case "State":
284
+ case "Enabled":
285
+ case "Action":
286
+ atoms.add(expression);
287
+ return;
288
+ case "And":
289
+ case "Or":
290
+ expression.operands.forEach((operand) => collectAtoms(operand, atoms));
291
+ return;
292
+ default:
293
+ collectAtoms(expression.body, atoms);
294
+ }
295
+ };
296
+
297
+ // The atoms the checks of the solutions evaluate.
298
+ export const getLiveAtoms = (solutions: Solution[]) => {
299
+ const atoms = new Set<LiveAtom>();
300
+ for (const solution of solutions) {
301
+ [
302
+ ...solution.stateChecks,
303
+ ...solution.actionChecks,
304
+ ...(solution.tableau?.nodes.flatMap((node) => node.statePredicates) ?? []),
305
+ ].forEach((check) => collectAtoms(check, atoms));
306
+ }
307
+ return [...atoms];
308
+ };
309
+
310
+ // The expressions the checks of the solutions evaluate.
311
+ export const getLiveExpressions = (solutions: Solution[]) =>
312
+ getLiveAtoms(solutions).flatMap((atom) =>
313
+ getAtomExpressions(atom).map((item) => item.expression),
314
+ );
315
+
316
+ export const createLivenessChecker = (
317
+ properties: TemporalProperty[],
318
+ temporals: ScopedExpression[],
319
+ environment: Environment,
320
+ search: SearchGraph<Value[]>,
321
+ ): LivenessChecker | undefined => {
322
+ if (properties.length === 0) return undefined;
323
+ const live = getLiveFormula(properties, temporals, environment);
324
+ // A check evaluated once for a state shows what TLC shows when no check repeats an effect. A
325
+ // definition TLC evaluates as it starts repeats nothing, but a scope can bind any definition.
326
+ const formulaAtoms = new Set<LiveAtom>();
327
+ collectAtoms(live.formula, formulaAtoms);
328
+ const checked = [...formulaAtoms].flatMap(getAtomExpressions);
329
+ const isShared = checked.every((item) => item.scope === undefined)
330
+ ? !isExpressionImpure(
331
+ checked.map((item) => item.expression),
332
+ environment,
333
+ "repeated",
334
+ )
335
+ : !hasRepeatedEffects(environment);
336
+ const tracing = { environment, atoms: getInterpretedAtoms(environment) };
337
+ const solutions = getSolutions(live.formula);
338
+ const graph = createLiveGraph(
339
+ solutions,
340
+ {
341
+ atoms: {
342
+ holdsState: (atom, state) => tracing.atoms.holdsState(atom, state),
343
+ holdsAction: (atom, state, next) => tracing.atoms.holdsAction(atom, state, next),
344
+ },
345
+ isShared,
346
+ isSame: isSameState,
347
+ evaluateFrom: (source, evaluate) => {
348
+ environment.runtime.setLivenessSource(source);
349
+ try {
350
+ return evaluate();
351
+ } finally {
352
+ environment.runtime.setLivenessSource(undefined);
353
+ }
354
+ },
355
+ },
356
+ search,
357
+ environment.runtime.version !== "1.7.4",
358
+ );
359
+ const traceWith = <Result>(replay: Environment | undefined, run: () => Result) => {
360
+ if (replay === undefined) return run();
361
+ tracing.atoms = getInterpretedAtoms(replay);
362
+ try {
363
+ return run();
364
+ } finally {
365
+ tracing.atoms = getInterpretedAtoms(environment);
366
+ }
367
+ };
368
+ return {
369
+ branches: graph.branches,
370
+ solutions,
371
+ addInitialState: (index, state, replay) =>
372
+ traceWith(replay, () => graph.addInitialState(index, state)),
373
+ addState: (index, state, successors, replay) =>
374
+ traceWith(replay, () => graph.addState(index, state, successors)),
375
+ storeState: graph.storeState,
376
+ getStateCounts: graph.getStateCounts,
377
+ findViolation: graph.findViolation,
378
+ getViolatedProperties: (path, cycleStart) => [
379
+ ...new Set(
380
+ properties
381
+ .filter(
382
+ (_property, position) =>
383
+ !evaluateOnLasso(live.negations[position].body, path, cycleStart, 0, environment),
384
+ )
385
+ .map((property) => property.name),
386
+ ),
387
+ ],
388
+ };
389
+ };
390
+
391
+ export const createLiveGraph = <State>(
392
+ solutions: Solution[],
393
+ evaluation: LiveEvaluation<State>,
394
+ search: SearchGraph<State>,
395
+ isAcceptingFound: boolean,
396
+ ): LiveGraph<State> => {
223
397
  const actionIds = new Map<string, number>();
224
- const behaviors = solutions.map((solution): BehaviorGraph => ({
398
+ let capacityMultiplier = 1;
399
+ const isShared = evaluation.isShared;
400
+ const atoms = evaluation.atoms;
401
+ const evaluateFrom = evaluation.evaluateFrom;
402
+ const stateAtoms = new Map<LiveState | LiveEnabled, number>();
403
+ const atomsById: (LiveState | LiveEnabled)[] = [];
404
+ const getAtomId = (atom: LiveState | LiveEnabled) => {
405
+ const id = stateAtoms.get(atom) ?? stateAtoms.size;
406
+ stateAtoms.set(atom, id);
407
+ atomsById[id] = atom;
408
+ return id;
409
+ };
410
+ const getLiterals = (expression: LiveExpression): number[] | undefined => {
411
+ if (expression.kind === "State" || expression.kind === "Enabled") {
412
+ return [getAtomId(expression) * 2 + 1];
413
+ }
414
+ if (expression.kind === "Not") {
415
+ const body = expression.body;
416
+ return body.kind === "State" || body.kind === "Enabled" ? [getAtomId(body) * 2] : undefined;
417
+ }
418
+ if (expression.kind !== "And") return undefined;
419
+ const operands = expression.operands.map(getLiterals);
420
+ return operands.every((operand) => operand !== undefined) ? operands.flat() : undefined;
421
+ };
422
+ // The rows of states, one after another, hold whether each state atom holds of a state: 1 or 0,
423
+ // or -1 before it is evaluated.
424
+ const createRows = (count: number) => new Int8Array(count * stateAtoms.size).fill(-1);
425
+ // The edge rows of steps hold the result of each action check, shared by the behaviors that
426
+ // check it.
427
+ const createEdgeRows = (count: number) => new Int8Array(count * actionIds.size).fill(-1);
428
+ // Unless the checks share results, each check evaluates its atoms afresh.
429
+ const runCheck = (
430
+ check: Check<State>,
431
+ state: State,
432
+ row: Int8Array,
433
+ offset: number,
434
+ next?: State,
435
+ ) => (isShared ? check(state, row, offset, next) : check(state, createRows(1), 0, next));
436
+ const compileCheck = (expression: LiveExpression): Check<State> => {
437
+ switch (expression.kind) {
438
+ case "Boolean": {
439
+ const value = expression.value;
440
+ return () => value;
441
+ }
442
+ case "State":
443
+ case "Enabled": {
444
+ const id = getAtomId(expression);
445
+ return (state, row, offset) => {
446
+ if (row[offset + id] === -1) {
447
+ row[offset + id] = atoms.holdsState(expression, state) ? 1 : 0;
448
+ }
449
+ return row[offset + id] === 1;
450
+ };
451
+ }
452
+ case "Action": {
453
+ const enabled = expression.enabled && getAtomId(expression.enabled);
454
+ return (state, row, offset, next) =>
455
+ !(enabled !== undefined && row[offset + enabled] === 0) &&
456
+ next !== undefined &&
457
+ atoms.holdsAction(expression, state, next);
458
+ }
459
+ case "Not": {
460
+ const body = compileCheck(expression.body);
461
+ return (state, row, offset, next) => !body(state, row, offset, next);
462
+ }
463
+ case "And": {
464
+ const operands = expression.operands.map(compileCheck);
465
+ return (state, row, offset, next) =>
466
+ operands.every((operand) => operand(state, row, offset, next));
467
+ }
468
+ case "Or": {
469
+ const operands = expression.operands.map(compileCheck);
470
+ return (state, row, offset, next) =>
471
+ operands.some((operand) => operand(state, row, offset, next));
472
+ }
473
+ case "Next": {
474
+ const body = compileCheck(expression.body);
475
+ return (state, _row, _offset, next) => body(next ?? state, createRows(1), 0, undefined);
476
+ }
477
+ case "Always":
478
+ case "Eventually":
479
+ return () => {
480
+ throw new TlaEvaluationError("TLC cannot evaluate a temporal formula in a single step");
481
+ };
482
+ }
483
+ };
484
+ const behaviors = solutions.map((solution): BehaviorGraph<State> => ({
225
485
  solution,
486
+ checks: {
487
+ states: solution.stateChecks.map(compileCheck),
488
+ actions: solution.actionChecks.map(compileCheck),
489
+ nodes:
490
+ solution.tableau?.nodes.map((node) => {
491
+ const literals = isShared
492
+ ? getLiterals({ kind: "And", operands: node.statePredicates })
493
+ : undefined;
494
+ return literals ? Int32Array.from(literals) : node.statePredicates.map(compileCheck);
495
+ }) ?? [],
496
+ },
226
497
  actionIds: Int32Array.from(solution.actionChecks, (predicate) => {
227
498
  const key = getTermKey(predicate);
228
- const id = actionIds.get(key) ?? actionIds.size;
229
- actionIds.set(key, id);
230
- return id;
499
+ const actionId = actionIds.get(key) ?? actionIds.size;
500
+ actionIds.set(key, actionId);
501
+ return actionId;
231
502
  }),
232
503
  nodeStates: [],
233
504
  nodeTableaux: [],
@@ -242,93 +513,88 @@ export const createLivenessChecker = (
242
513
  nextSiblings: [],
243
514
  nodeIds: { slots: new Int32Array(3 << 10), size: 0, shift: 22 },
244
515
  isDone: [],
516
+ stateCount: 0,
245
517
  errorNode: undefined,
246
518
  }));
247
- const capacity = { multiplier: 1 };
248
-
249
- // TLC evaluates every check on its own. Without side effects the order can't show, so the
250
- // checks of one state share their results.
251
- const isShared = !hasRepeatedEffects(environment);
252
- const evaluation = { environment };
253
- const shared = {
254
- states: new Map<Value[], Map<LiveExpression, boolean>>(),
255
- actions: new Map<Value[], Map<Value[], Int8Array>>(),
256
- };
257
- const getStateCache = (state: Value[]) => {
258
- const cache = shared.states.get(state) ?? new Map<LiveExpression, boolean>();
259
- shared.states.set(state, cache);
260
- return cache;
261
- };
262
- // TLCGet("level") reads the level of the state whose successors the checks run on.
263
- // A check that fails leaves no source, so the failure's trace reads the levels of the search.
264
- const evaluateFrom = <Result>(source: number | undefined, evaluate: () => Result) => {
265
- environment.runtime.setLivenessSource(source);
266
- try {
267
- return evaluate();
268
- } finally {
269
- environment.runtime.setLivenessSource(undefined);
270
- }
271
- };
272
- const evaluateState = (predicate: LiveExpression, state: Value[]) =>
273
- evaluateLive(
274
- predicate,
275
- state,
276
- undefined,
277
- evaluation.environment,
278
- isShared ? getStateCache(state) : new Map(),
279
- );
280
- const checkState = (behavior: BehaviorGraph, source: number, state: Value[]) =>
281
- evaluateFrom(source, () =>
282
- Uint8Array.from(behavior.solution.stateChecks, (predicate) =>
283
- evaluateState(predicate, state) ? 1 : 0,
284
- ),
285
- );
519
+ const checkState = (
520
+ behavior: BehaviorGraph<State>,
521
+ source: number,
522
+ state: State,
523
+ row: Int8Array,
524
+ offset: number,
525
+ ) =>
526
+ evaluateFrom(source, () => {
527
+ const checks = behavior.checks.states;
528
+ const results = new Uint8Array(checks.length);
529
+ checks.forEach((check, position) => {
530
+ results[position] = runCheck(check, state, row, offset) ? 1 : 0;
531
+ });
532
+ return results;
533
+ });
534
+ // Writes the result of each action check of the step to successor at resultOffset in results.
286
535
  const checkAction = (
287
- behavior: BehaviorGraph,
536
+ behavior: BehaviorGraph<State>,
288
537
  source: number,
289
- state: Value[],
290
- successor: Value[],
538
+ state: State,
539
+ row: Int8Array,
540
+ offset: number,
541
+ successor: State,
542
+ edges: Int8Array,
543
+ edgeOffset: number,
544
+ results: Uint8Array,
545
+ resultOffset: number,
291
546
  ) =>
292
547
  evaluateFrom(source, () => {
293
- const predicates = behavior.solution.actionChecks;
294
- if (!isShared) {
295
- return Uint8Array.from(predicates, (predicate) =>
296
- evaluateLive(predicate, state, successor, evaluation.environment, new Map()) ? 1 : 0,
297
- );
298
- }
299
- const stateCache = getStateCache(state);
300
- const results = shared.actions.get(state) ?? new Map<Value[], Int8Array>();
301
- shared.actions.set(state, results);
302
- const known = results.get(successor) ?? new Int8Array(actionIds.size).fill(-1);
303
- results.set(successor, known);
304
- return Uint8Array.from(behavior.actionIds, (id, position) => {
305
- if (known[id] === -1) {
306
- known[id] = evaluateLive(
307
- predicates[position],
548
+ const actions = behavior.checks.actions;
549
+ for (let position = 0; position < actions.length; position++) {
550
+ if (!isShared) {
551
+ results[resultOffset + position] = runCheck(
552
+ actions[position],
308
553
  state,
554
+ row,
555
+ offset,
309
556
  successor,
310
- evaluation.environment,
311
- stateCache,
312
557
  )
313
558
  ? 1
314
559
  : 0;
560
+ continue;
315
561
  }
316
- return known[id];
317
- });
562
+ const edge = edgeOffset + behavior.actionIds[position];
563
+ if (edges[edge] === -1)
564
+ edges[edge] = actions[position](state, row, offset, successor) ? 1 : 0;
565
+ results[resultOffset + position] = edges[edge];
566
+ }
318
567
  });
568
+ const holdsNode = (
569
+ behavior: BehaviorGraph<State>,
570
+ node: number,
571
+ state: State,
572
+ row: Int8Array,
573
+ offset: number,
574
+ ) => {
575
+ const checks = behavior.checks.nodes[node];
576
+ if (!(checks instanceof Int32Array)) {
577
+ return checks.every((check) => runCheck(check, state, row, offset));
578
+ }
579
+ for (let position = 0; position < checks.length; position++) {
580
+ const literal: number = checks[position];
581
+ const cell = offset + (literal >> 1);
582
+ if (row[cell] === -1) row[cell] = atoms.holdsState(atomsById[literal >> 1], state) ? 1 : 0;
583
+ if (row[cell] !== (literal & 1)) return false;
584
+ }
585
+ return true;
586
+ };
319
587
  const isConsistent = (
320
- tableau: Tableau,
588
+ behavior: BehaviorGraph<State>,
321
589
  node: number,
322
590
  source: number | undefined,
323
- state: Value[],
324
- ) =>
325
- evaluateFrom(source, () =>
326
- tableau.nodes[node].statePredicates.every((predicate) => evaluateState(predicate, state)),
327
- );
328
- // TLC 1.7.4 doesn't stop at a tableau node that accepts every behavior, so it finds a violation
329
- // of a property like a safety property only in its liveness checks.
591
+ state: State,
592
+ row: Int8Array,
593
+ offset: number,
594
+ ) => evaluateFrom(source, () => holdsNode(behavior, node, state, row, offset));
595
+
330
596
  const isAccepting = (tableau: Tableau, node: number) => {
331
- if (environment.runtime.version === "1.7.4") return false;
597
+ if (!isAcceptingFound) return false;
332
598
  const tableauNode = tableau.nodes[node];
333
599
  return (
334
600
  tableauNode.particle.length === 0 &&
@@ -336,22 +602,19 @@ export const createLivenessChecker = (
336
602
  tableauNode.successors[0] === node
337
603
  );
338
604
  };
339
- const hasEmptyModel = (behavior: BehaviorGraph) =>
340
- behavior.solution.models.some(
341
- (model) =>
342
- model.eventuallyAlways.length === 0 &&
343
- model.infinitelyOftenStates.length === 0 &&
344
- model.infinitelyOftenActions.length === 0,
345
- );
346
605
 
347
- const getNodeId = (behavior: BehaviorGraph, state: number, tableauNode: number) => {
606
+ const getNodeId = (behavior: BehaviorGraph<State>, state: number, tableauNode: number) => {
348
607
  if (!behavior.solution.tableau) return state;
349
608
  const slots = behavior.nodeIds.slots;
350
609
  const slot = getNodeSlot(behavior.nodeIds, state, tableauNode);
351
610
  return slots[slot] === 0 ? undefined : slots[slot + 2];
352
611
  };
353
- const recordNode = (behavior: BehaviorGraph, state: number, tableauNode: number) => {
354
- const node = pushNode(behavior, state, tableauNode);
612
+ const linkNode = (
613
+ behavior: BehaviorGraph<State>,
614
+ state: number,
615
+ tableauNode: number,
616
+ node: number,
617
+ ) => {
355
618
  const table = behavior.nodeIds;
356
619
  if (++table.size * 2 > table.slots.length / 3) {
357
620
  const old = table.slots;
@@ -367,24 +630,44 @@ export const createLivenessChecker = (
367
630
  }
368
631
  }
369
632
  table.slots.set([state + 1, tableauNode, node], getNodeSlot(table, state, tableauNode));
633
+ if (state < 0) return node;
370
634
  const last = behavior.lastNodes.data[state] ?? NO_NODE;
371
635
  if (last === NO_NODE) writeToPool(behavior.firstNodes, state, [node]);
372
636
  else behavior.nextSiblings[last] = node;
373
637
  writeToPool(behavior.lastNodes, state, [node]);
374
638
  return node;
375
639
  };
640
+ // TLC's table of tableau nodes has a state once the search expands it or it has a node.
641
+ const hasState = (behavior: BehaviorGraph<State>, state: number) =>
642
+ state < 0
643
+ ? behavior.checks.nodes.some(
644
+ (_checks, tableauNode) => getNodeId(behavior, state, tableauNode) !== undefined,
645
+ )
646
+ : behavior.isDone[state] === true || (behavior.firstNodes.data[state] ?? NO_NODE) !== NO_NODE;
647
+ const recordNode = (behavior: BehaviorGraph<State>, state: number, tableauNode: number) => {
648
+ if (!hasState(behavior, state)) behavior.stateCount++;
649
+ return linkNode(behavior, state, tableauNode, pushNode(behavior, state, tableauNode));
650
+ };
651
+ // The action results of the edge to each target are at its position in actions.
376
652
  const writeNode = (
377
- behavior: BehaviorGraph,
653
+ behavior: BehaviorGraph<State>,
378
654
  node: number,
379
655
  targets: number[],
380
- actions: Uint8Array[],
656
+ actionResults: Uint8Array,
657
+ actions: number[],
381
658
  stateResults: Uint8Array,
382
659
  ) => {
383
660
  const start = behavior.edgeTargets.length;
384
661
  const actionCount = behavior.solution.actionChecks.length;
385
662
  writeToPool(behavior.edgeTargets, start, targets);
386
- actions.forEach((results, position) =>
387
- writeToPool(behavior.edgeActions, (start + position) * actionCount, results),
663
+ actions.forEach((position, edge) =>
664
+ writeToPool(
665
+ behavior.edgeActions,
666
+ (start + edge) * actionCount,
667
+ actionResults,
668
+ position * actionCount,
669
+ actionCount,
670
+ ),
388
671
  );
389
672
  writeToPool(
390
673
  behavior.stateResults,
@@ -395,66 +678,73 @@ export const createLivenessChecker = (
395
678
  behavior.edgeCounts[node] = targets.length;
396
679
  };
397
680
 
398
- // TLC collects a state's successors and the state itself in a SetOfStates, a hash set it
399
- // iterates in slot order. Its capacity starts at 16 times a factor that grows with every set
400
- // that outgrows it.
401
- const getSuccessorSet = (index: number, state: Value[], successors: LiveSuccessor[]) => {
402
- const table = {
403
- slots: Array.from<LiveSuccessor | undefined>({
404
- length: SUCCESSOR_CAPACITY * capacity.multiplier,
405
- }),
406
- count: 0,
407
- };
408
- const insertSuccessor = (slots: (LiveSuccessor | undefined)[], successor: LiveSuccessor) => {
681
+ // TLC iterates a state's successors and the state itself in the slot order of a SetOfStates, a hash set whose capacity grows with every set that outgrows it.
682
+ // Each slot holds a candidate's position plus one, or 0 when it is empty.
683
+ const successorSet = { slots: new Int32Array(0) };
684
+ const getSuccessorSet = (index: number, state: State, successors: LiveSuccessor<State>[]) => {
685
+ const candidates = [...successors, { index, state }];
686
+ const capacity = SUCCESSOR_CAPACITY * capacityMultiplier;
687
+ successorSet.slots =
688
+ successorSet.slots.length === capacity
689
+ ? successorSet.slots.fill(0)
690
+ : new Int32Array(capacity);
691
+ const insert = (position: number) => {
692
+ const slots = successorSet.slots;
693
+ const candidate = candidates[position];
409
694
  for (
410
- let slot = (search.getFingerprint(successor) & 0x7fffffff) % slots.length;
695
+ let slot = (search.getFingerprint(candidate) & 0x7fffffff) % slots.length;
411
696
  ;
412
697
  slot = (slot + 1) % slots.length
413
698
  ) {
414
699
  const entry = slots[slot];
415
- if (entry === undefined) {
416
- slots[slot] = successor;
700
+ if (entry === 0) {
701
+ slots[slot] = position + 1;
417
702
  return true;
418
703
  }
419
- if (entry.index === successor.index && isSameState(entry.state, successor.state))
704
+ const stored = candidates[entry - 1];
705
+ if (stored.index === candidate.index && evaluation.isSame(stored.state, candidate.state))
420
706
  return false;
421
707
  }
422
708
  };
423
- const addSuccessor = (successor: LiveSuccessor) => {
424
- if (table.count >= table.slots.length >> 1) {
425
- const old = table.slots;
426
- table.slots = Array.from<LiveSuccessor | undefined>({ length: 2 * old.length + 1 });
427
- for (const entry of old) if (entry) insertSuccessor(table.slots, entry);
709
+ let count = 0;
710
+ for (let position = 0; position < candidates.length; position++) {
711
+ if (count >= successorSet.slots.length >> 1) {
712
+ const old = successorSet.slots;
713
+ successorSet.slots = new Int32Array(2 * old.length + 1);
714
+ for (const entry of old) if (entry !== 0) insert(entry - 1);
428
715
  }
429
- if (insertSuccessor(table.slots, successor)) table.count++;
430
- };
431
- successors.forEach(addSuccessor);
432
- addSuccessor({ index, state });
433
- if (table.slots.length > SUCCESSOR_CAPACITY * capacity.multiplier) capacity.multiplier++;
434
- return table.slots.filter((entry): entry is LiveSuccessor => entry !== undefined);
716
+ if (insert(position)) count++;
717
+ }
718
+ if (successorSet.slots.length > capacity) capacityMultiplier++;
719
+ const set: LiveSuccessor<State>[] = [];
720
+ for (const entry of successorSet.slots) if (entry !== 0) set.push(candidates[entry - 1]);
721
+ return set;
435
722
  };
436
723
 
437
724
  const expandLate = (
438
- behavior: BehaviorGraph,
725
+ behavior: BehaviorGraph<State>,
439
726
  tableau: Tableau,
440
- state: Value[],
727
+ state: State,
441
728
  index: number,
442
729
  node: number,
730
+ row: Int8Array,
731
+ offset: number,
443
732
  ) => {
444
- const stateResults = checkState(behavior, index, state);
733
+ const stateResults = checkState(behavior, index, state, row, offset);
445
734
  const tableauNode = tableau.nodes[behavior.nodeTableaux[node]];
446
- const actions: Uint8Array[] = [];
735
+ const actionCount = behavior.checks.actions.length;
736
+ const actions: number[] = [];
447
737
  const successors: number[] = [];
448
- const selfActions =
449
- tableauNode.successors.length > 0
450
- ? checkAction(behavior, index, state, state)
451
- : new Uint8Array(0);
738
+ const selfResults = new Uint8Array(actionCount);
739
+ if (tableauNode.successors.length > 0) {
740
+ checkAction(behavior, index, state, row, offset, state, createEdgeRows(1), 0, selfResults, 0);
741
+ }
452
742
  for (const next of tableauNode.successors) {
453
- if (!isConsistent(tableau, next, index, state)) continue;
743
+ if (!isConsistent(behavior, next, index, state, row, offset)) continue;
454
744
  if (
455
745
  isAccepting(tableau, next) &&
456
746
  behavior.errorNode === undefined &&
457
- hasEmptyModel(behavior)
747
+ behavior.solution.models.some(isEmptyModel)
458
748
  ) {
459
749
  behavior.errorNode = node;
460
750
  return;
@@ -463,89 +753,122 @@ export const createLivenessChecker = (
463
753
  if (existing !== undefined && successors.includes(existing)) continue;
464
754
  const target = existing ?? recordNode(behavior, index, next);
465
755
  successors.push(target);
466
- actions.push(selfActions);
467
- if (existing === undefined) expandLate(behavior, tableau, state, index, target);
756
+ actions.push(0);
757
+ if (existing === undefined) expandLate(behavior, tableau, state, index, target, row, offset);
468
758
  }
469
- for (const successor of search.getSuccessors(index, state)) {
470
- const successorActions = checkAction(behavior, index, state, successor.state);
759
+ const nextStates = search.getSuccessors(index, state);
760
+ // The results of the step to the state itself come first, then those of each successor.
761
+ const actionResults = new Uint8Array((nextStates.length + 1) * actionCount);
762
+ actionResults.set(selfResults);
763
+ const edges = createEdgeRows(nextStates.length);
764
+ nextStates.forEach((successor, position) => {
765
+ const successorRow = createRows(1);
766
+ checkAction(
767
+ behavior,
768
+ index,
769
+ state,
770
+ row,
771
+ offset,
772
+ successor.state,
773
+ edges,
774
+ position * actionIds.size,
775
+ actionResults,
776
+ (position + 1) * actionCount,
777
+ );
471
778
  const isDone = behavior.isDone[successor.index] === true;
472
779
  for (const next of tableauNode.successors) {
473
- if (!isConsistent(tableau, next, index, successor.state)) continue;
474
- // A successor the search never stored follows a violation or an error, after which nothing
475
- // checks the graph. TLC records its node, which it never expands.
476
- if (successor.index === -1) continue;
780
+ if (!isConsistent(behavior, next, index, successor.state, successorRow, 0)) continue;
477
781
  const existing = getNodeId(behavior, successor.index, next);
478
782
  if (existing !== undefined && successors.includes(existing)) continue;
479
783
  const target = existing ?? recordNode(behavior, successor.index, next);
480
784
  successors.push(target);
481
- actions.push(successorActions);
785
+ actions.push(position + 1);
482
786
  if (existing === undefined && isDone) {
483
- expandLate(behavior, tableau, successor.state, successor.index, target);
787
+ expandLate(behavior, tableau, successor.state, successor.index, target, successorRow, 0);
484
788
  }
485
789
  }
790
+ });
791
+ if (successors.length > 0) {
792
+ writeNode(behavior, node, successors, actionResults, actions, stateResults);
486
793
  }
487
- if (successors.length > 0) writeNode(behavior, node, successors, actions, stateResults);
488
794
  };
489
795
 
490
796
  const addTableauState = (
491
- behavior: BehaviorGraph,
797
+ behavior: BehaviorGraph<State>,
492
798
  tableau: Tableau,
493
- set: LiveSuccessor[],
494
- actionResults: Uint8Array[],
799
+ set: LiveSuccessor<State>[],
800
+ rows: Int8Array,
801
+ actionResults: Uint8Array,
495
802
  stateResults: Uint8Array,
496
803
  index: number,
497
804
  ) => {
498
- const consistency = tableau.nodes.map((_, node) =>
499
- set.map((successor) => isConsistent(tableau, node, index, successor.state)),
500
- );
805
+ const atomCount = stateAtoms.size;
806
+ // Whether each successor is consistent with each tableau node, node by node.
807
+ const consistency = new Uint8Array(tableau.nodes.length * set.length);
808
+ evaluateFrom(index, () => {
809
+ for (let node = 0; node < tableau.nodes.length; node++) {
810
+ for (let position = 0; position < set.length; position++) {
811
+ if (holdsNode(behavior, node, set[position].state, rows, position * atomCount)) {
812
+ consistency[node * set.length + position] = 1;
813
+ }
814
+ }
815
+ }
816
+ });
817
+ if (!hasState(behavior, index)) behavior.stateCount++;
501
818
  behavior.isDone[index] = true;
502
819
  // TLC expands the nodes recorded before the loop, not the ones the loop records.
503
820
  for (const node of getStateNodes(behavior, index)) {
504
821
  const successors: number[] = [];
505
- const actions: Uint8Array[] = [];
822
+ const actions: number[] = [];
506
823
  set.forEach((successor, position) => {
507
824
  const isDone = behavior.isDone[successor.index] === true;
508
825
  for (const next of tableau.nodes[behavior.nodeTableaux[node]].successors) {
509
- if (!consistency[next][position]) continue;
826
+ if (consistency[next * set.length + position] === 0) continue;
510
827
  const existing = getNodeId(behavior, successor.index, next);
511
828
  if (existing !== undefined && successors.includes(existing)) continue;
512
829
  const target = existing ?? recordNode(behavior, successor.index, next);
513
830
  successors.push(target);
514
- actions.push(actionResults[position]);
831
+ actions.push(position);
515
832
  if (existing === undefined && isDone) {
516
- expandLate(behavior, tableau, successor.state, successor.index, target);
833
+ expandLate(
834
+ behavior,
835
+ tableau,
836
+ successor.state,
837
+ successor.index,
838
+ target,
839
+ rows,
840
+ position * atomCount,
841
+ );
517
842
  }
518
843
  }
519
844
  });
520
- writeNode(behavior, node, successors, actions, stateResults);
845
+ writeNode(behavior, node, successors, actionResults, actions, stateResults);
521
846
  }
522
- if (behavior.errorNode === undefined) return undefined;
523
- return removeRepeats(
524
- getPath(behavior, behavior.errorNode)
525
- .reverse()
526
- .map((node) => behavior.nodeStates[node]),
527
- );
847
+ return behavior.errorNode === undefined
848
+ ? undefined
849
+ : getStatePath(behavior, behavior.errorNode);
528
850
  };
529
851
 
530
852
  const addPlainState = (
531
- behavior: BehaviorGraph,
532
- set: LiveSuccessor[],
533
- actionResults: Uint8Array[],
853
+ behavior: BehaviorGraph<State>,
854
+ set: LiveSuccessor<State>[],
855
+ actionResults: Uint8Array,
534
856
  stateResults: Uint8Array,
535
857
  index: number,
536
858
  ) => {
537
859
  while (behavior.nodeStates.length <= index) pushNode(behavior, behavior.nodeStates.length, -1);
538
860
  const successors: number[] = [];
539
- const actions: Uint8Array[] = [];
861
+ const actions: number[] = [];
540
862
  set.forEach((successor, position) => {
541
863
  if (isWritten(behavior, successor.index) && successors.includes(successor.index)) return;
542
864
  successors.push(successor.index);
543
- actions.push(actionResults[position]);
865
+ actions.push(position);
544
866
  });
545
- writeNode(behavior, index, successors, actions, stateResults);
867
+ if (!isWritten(behavior, index)) behavior.stateCount++;
868
+ writeNode(behavior, index, successors, actionResults, actions, stateResults);
546
869
  };
547
870
 
548
- const getPath = (behavior: BehaviorGraph, target: number) => {
871
+ const getPath = (behavior: BehaviorGraph<State>, target: number) => {
549
872
  if (behavior.initial.includes(target)) return [target];
550
873
  const parents = new Map<number, number>();
551
874
  const queue: number[] = [];
@@ -571,9 +894,15 @@ export const createLivenessChecker = (
571
894
  throw new TlaEvaluationError(`Couldn't re-create liveness trace (path) starting at: ${target}`);
572
895
  };
573
896
 
574
- // TLC's LiveWorker#checkSccs, a Tarjan search that pushes every successor of a node at once.
897
+ const getStatePath = (behavior: BehaviorGraph<State>, target: number) =>
898
+ removeRepeats(
899
+ getPath(behavior, target)
900
+ .reverse()
901
+ .map((node) => behavior.nodeStates[node]),
902
+ );
903
+
575
904
  const findLassoInModel = (
576
- behavior: BehaviorGraph,
905
+ behavior: BehaviorGraph<State>,
577
906
  model: Solution["models"][number],
578
907
  ): Lasso | undefined => {
579
908
  const solution = behavior.solution;
@@ -628,91 +957,85 @@ export const createLivenessChecker = (
628
957
  return getLasso(root, members, membersByState);
629
958
  };
630
959
 
631
- // TLC's LiveWorker#printTrace: a prefix to the root, a greedy walk through the component until it
632
- // satisfies every check, and a breadth-first path back to the root.
633
960
  const getLasso = (
634
961
  root: number,
635
962
  members: Set<number>,
636
963
  membersByState: Map<number, number[]>,
637
964
  ) => {
638
- const prefix = removeRepeats(
639
- getPath(behavior, root)
640
- .reverse()
641
- .map((node) => behavior.nodeStates[node]),
642
- );
965
+ const prefix = getStatePath(behavior, root);
643
966
  const cycleStack: number[] = [];
644
967
  const seen = new Set<number>([root]);
645
968
  const stateDone = model.infinitelyOftenStates.map(() => false);
646
969
  const actionDone = model.infinitelyOftenActions.map(() => false);
647
970
  const promiseDone = solution.promises.map(() => false);
648
- const remaining = { count: stateDone.length + actionDone.length + promiseDone.length };
649
- const current = { node: root };
650
- const isMember = (node: number) => members.has(node);
971
+ let remainingCount = stateDone.length + actionDone.length + promiseDone.length;
972
+ let currentNode = root;
651
973
  const moveTo = (next: number) => {
652
- cycleStack.push(current.node);
653
- current.node = next;
974
+ cycleStack.push(currentNode);
975
+ currentNode = next;
654
976
  };
655
- while (remaining.count > 0) {
656
- const countAtStart = remaining.count;
977
+ while (remainingCount > 0) {
978
+ const countAtStart = remainingCount;
657
979
  while (true) {
658
980
  model.infinitelyOftenStates.forEach((position, slot) => {
659
- if (!stateDone[slot] && getStateResult(behavior, current.node, position)) {
981
+ if (!stateDone[slot] && getStateResult(behavior, currentNode, position)) {
660
982
  stateDone[slot] = true;
661
- remaining.count--;
983
+ remainingCount--;
662
984
  }
663
985
  });
664
986
  solution.promises.forEach((promise, position) => {
665
- if (!promiseDone[position] && isFulfilled(current.node, promise)) {
987
+ if (!promiseDone[position] && isFulfilled(currentNode, promise)) {
666
988
  promiseDone[position] = true;
667
- remaining.count--;
989
+ remainingCount--;
668
990
  }
669
991
  });
670
- if (remaining.count <= 0) break;
671
- const step = { last: -1, unvisited: -1 };
672
- const countBeforeActions = remaining.count;
673
- const taken = getNodeSuccessors(behavior, current.node).some((next, edge) => {
992
+ if (remainingCount <= 0) break;
993
+ let lastNext = -1;
994
+ let unvisitedNext = -1;
995
+ const countBeforeActions = remainingCount;
996
+ const isTaken = getNodeSuccessors(behavior, currentNode).some((next, edge) => {
674
997
  if (membersByState.has(behavior.nodeStates[next])) {
675
- if (!isMember(next) || !isAllowed(current.node, edge)) return false;
676
- step.last = next;
998
+ if (!members.has(next) || !isAllowed(currentNode, edge)) return false;
999
+ lastNext = next;
677
1000
  model.infinitelyOftenActions.forEach((position, slot) => {
678
- if (!actionDone[slot] && getAction(current.node, edge, position)) {
1001
+ if (!actionDone[slot] && getAction(currentNode, edge, position)) {
679
1002
  actionDone[slot] = true;
680
- remaining.count--;
1003
+ remainingCount--;
681
1004
  }
682
1005
  });
683
1006
  }
684
- if (remaining.count < countBeforeActions) {
1007
+ if (remainingCount < countBeforeActions) {
685
1008
  moveTo(next);
686
1009
  seen.clear();
687
1010
  return true;
688
1011
  }
689
- if (isMember(next) && !seen.has(next)) step.unvisited = next;
1012
+ if (members.has(next) && !seen.has(next)) unvisitedNext = next;
690
1013
  return false;
691
1014
  });
692
- if (taken) break;
693
- if (remaining.count < countAtStart) {
694
- moveTo(step.last);
1015
+ if (isTaken) break;
1016
+ if (remainingCount < countAtStart) {
1017
+ moveTo(lastNext);
695
1018
  seen.clear();
696
1019
  break;
697
1020
  }
698
- while (step.unvisited === -1) {
1021
+ while (unvisitedNext === -1) {
699
1022
  const previous = cycleStack.pop();
700
1023
  if (previous === undefined) {
701
1024
  throw new TlaEvaluationError(
702
1025
  "TLC failed to build the counterexample of a liveness property",
703
1026
  );
704
1027
  }
705
- current.node = previous;
706
- step.unvisited =
1028
+ currentNode = previous;
1029
+ unvisitedNext =
707
1030
  getNodeSuccessors(behavior, previous).find(
708
- (next) => isMember(next) && !seen.has(next),
1031
+ (next) => members.has(next) && !seen.has(next),
709
1032
  ) ?? -1;
710
1033
  }
711
- moveTo(step.unvisited);
712
- seen.add(step.unvisited);
1034
+ moveTo(unvisitedNext);
1035
+ seen.add(unvisitedNext);
713
1036
  }
714
1037
  }
715
- const postfix = getClosingPath(root, current.node, membersByState, isAllowed);
1038
+ const postfix = getClosingPath(root, currentNode, membersByState);
716
1039
  for (let position = cycleStack.length - 1; position >= 0; position--) {
717
1040
  const state = behavior.nodeStates[cycleStack[position]];
718
1041
  if (postfix[postfix.length - 1] !== state) postfix.push(state);
@@ -726,12 +1049,7 @@ export const createLivenessChecker = (
726
1049
  };
727
1050
  };
728
1051
 
729
- const getClosingPath = (
730
- root: number,
731
- end: number,
732
- membersByState: Map<number, number[]>,
733
- isAllowedEdge: (node: number, edge: number) => boolean,
734
- ) => {
1052
+ const getClosingPath = (root: number, end: number, membersByState: Map<number, number[]>) => {
735
1053
  if (end === root) return [];
736
1054
  const start = behavior.nodeStates[end];
737
1055
  const parents = new Map<number, number>();
@@ -740,7 +1058,7 @@ export const createLivenessChecker = (
740
1058
  for (let state = start, parent = -1, position = 0; ; position++) {
741
1059
  for (const node of membersByState.get(state) ?? []) {
742
1060
  for (const [edge, next] of getNodeSuccessors(behavior, node).entries()) {
743
- if (next === node || !isAllowedEdge(node, edge)) continue;
1061
+ if (next === node || !isAllowed(node, edge)) continue;
744
1062
  if (next === root) {
745
1063
  const path: number[] = [];
746
1064
  for (let item = state, itemParent = parent; item !== start;) {
@@ -771,7 +1089,7 @@ export const createLivenessChecker = (
771
1089
 
772
1090
  for (let position = 0; position < queue.length; position++) {
773
1091
  const stack = [queue[position], UNVISITED, 0];
774
- const counter = { link: 0 };
1092
+ let nextLink = 0;
775
1093
  while (stack.length >= 3) {
776
1094
  const lowLink = stack.pop() ?? 0;
777
1095
  const location = stack.pop();
@@ -788,10 +1106,10 @@ export const createLivenessChecker = (
788
1106
  stack.push(Math.min(lowLink, links[node]));
789
1107
  continue;
790
1108
  }
791
- links[node] = counter.link;
1109
+ links[node] = nextLink;
792
1110
  stack.push(lowLink, node, SCC_MARKER);
793
1111
  components.push(node);
794
- const nextLowLink = { value: counter.link++ };
1112
+ let nextLowLink = nextLink++;
795
1113
  getNodeSuccessors(behavior, node).forEach((next, edge) => {
796
1114
  if (!isWritten(behavior, next)) return;
797
1115
  if (!isAllowed(node, edge)) {
@@ -799,9 +1117,9 @@ export const createLivenessChecker = (
799
1117
  return;
800
1118
  }
801
1119
  if (links[next] === UNVISITED) stack.push(next, UNVISITED);
802
- else nextLowLink.value = Math.min(nextLowLink.value, links[next]);
1120
+ else nextLowLink = Math.min(nextLowLink, links[next]);
803
1121
  });
804
- stack.push(nextLowLink.value);
1122
+ stack.push(nextLowLink);
805
1123
  }
806
1124
  }
807
1125
  return undefined;
@@ -809,59 +1127,80 @@ export const createLivenessChecker = (
809
1127
 
810
1128
  return {
811
1129
  branches: behaviors.length,
812
- addInitialState: (index, state, tracing) => {
813
- evaluation.environment = tracing ?? environment;
814
- shared.states.clear();
815
- shared.actions.clear();
816
- try {
817
- for (const behavior of behaviors) {
818
- const tableau = behavior.solution.tableau;
819
- if (!tableau) {
820
- behavior.initial.push(index);
821
- continue;
822
- }
823
- for (let node = 0; node < tableau.initialCount; node++) {
824
- if (!isConsistent(tableau, node, undefined, state)) continue;
825
- behavior.initial.push(
826
- getNodeId(behavior, index, node) ?? recordNode(behavior, index, node),
827
- );
828
- }
1130
+ addInitialState: (index, state) => {
1131
+ const row = createRows(1);
1132
+ for (const behavior of behaviors) {
1133
+ const tableau = behavior.solution.tableau;
1134
+ if (!tableau) {
1135
+ behavior.initial.push(index);
1136
+ continue;
1137
+ }
1138
+ for (let node = 0; node < tableau.initialCount; node++) {
1139
+ if (!isConsistent(behavior, node, undefined, state, row, 0)) continue;
1140
+ behavior.initial.push(
1141
+ getNodeId(behavior, index, node) ?? recordNode(behavior, index, node),
1142
+ );
829
1143
  }
830
- } finally {
831
- evaluation.environment = environment;
832
1144
  }
833
1145
  },
834
- addState: (index, state, successors, tracing) => {
835
- evaluation.environment = tracing ?? environment;
836
- shared.states.clear();
837
- shared.actions.clear();
838
- try {
839
- const set = getSuccessorSet(index, state, successors);
840
- for (const behavior of behaviors) {
841
- const actionResults = set.map((successor) =>
842
- checkAction(behavior, index, state, successor.state),
843
- );
844
- const stateResults = checkState(behavior, index, state);
845
- const tableau = behavior.solution.tableau;
846
- if (!tableau) {
847
- addPlainState(behavior, set, actionResults, stateResults, index);
848
- continue;
849
- }
850
- const accepted = addTableauState(
1146
+ addState: (index, state, successors) => {
1147
+ const set = getSuccessorSet(index, state, successors);
1148
+ const rows = createRows(set.length);
1149
+ // The set holds the state itself, as a successor of the same index.
1150
+ const offset = set.findIndex((successor) => successor.index === index) * stateAtoms.size;
1151
+ const edges = createEdgeRows(set.length);
1152
+ for (const behavior of behaviors) {
1153
+ const actionCount = behavior.checks.actions.length;
1154
+ const actionResults = new Uint8Array(set.length * actionCount);
1155
+ set.forEach((successor, position) =>
1156
+ checkAction(
851
1157
  behavior,
852
- tableau,
853
- set,
854
- actionResults,
855
- stateResults,
856
1158
  index,
857
- );
858
- if (accepted) return accepted;
1159
+ state,
1160
+ rows,
1161
+ offset,
1162
+ successor.state,
1163
+ edges,
1164
+ position * actionIds.size,
1165
+ actionResults,
1166
+ position * actionCount,
1167
+ ),
1168
+ );
1169
+ const stateResults = checkState(behavior, index, state, rows, offset);
1170
+ const tableau = behavior.solution.tableau;
1171
+ if (!tableau) {
1172
+ addPlainState(behavior, set, actionResults, stateResults, index);
1173
+ continue;
859
1174
  }
860
- return undefined;
861
- } finally {
862
- evaluation.environment = environment;
1175
+ const accepted = addTableauState(
1176
+ behavior,
1177
+ tableau,
1178
+ set,
1179
+ rows,
1180
+ actionResults,
1181
+ stateResults,
1182
+ index,
1183
+ );
1184
+ if (accepted) return accepted;
863
1185
  }
1186
+ return undefined;
864
1187
  },
1188
+ storeState: (pending, index) => {
1189
+ for (const behavior of behaviors) {
1190
+ const tableau = behavior.solution.tableau;
1191
+ if (!tableau) continue;
1192
+ const nodes: number[] = [];
1193
+ for (let tableauNode = 0; tableauNode < tableau.nodes.length; tableauNode++) {
1194
+ const node = getNodeId(behavior, pending, tableauNode);
1195
+ if (node !== undefined) nodes.push(node);
1196
+ }
1197
+ for (const node of nodes.sort((left, right) => left - right)) {
1198
+ behavior.nodeStates[node] = index;
1199
+ linkNode(behavior, index, behavior.nodeTableaux[node], node);
1200
+ }
1201
+ }
1202
+ },
1203
+ getStateCounts: () => behaviors.map((behavior) => behavior.stateCount),
865
1204
  findViolation: () => {
866
1205
  for (const behavior of behaviors) {
867
1206
  for (const model of behavior.solution.models) {
@@ -871,16 +1210,5 @@ export const createLivenessChecker = (
871
1210
  }
872
1211
  return undefined;
873
1212
  },
874
- // TLC names every property that the counterexample violates, once each.
875
- getViolatedProperties: (path, cycleStart) => [
876
- ...new Set(
877
- properties
878
- .filter(
879
- (_, position) =>
880
- !evaluateOnLasso(negations[position].body, path, cycleStart, 0, environment),
881
- )
882
- .map((property) => property.name),
883
- ),
884
- ],
885
1213
  };
886
1214
  };