tla-ts 0.0.10-dev.3a85c3a9e → 0.0.10-dev.45c0eaef5

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 (260) hide show
  1. package/dist/compile.cjs +3 -3
  2. package/dist/compile.js +1 -1
  3. package/dist/deciders.cjs +36 -36
  4. package/dist/deciders.js +53 -53
  5. package/dist/index.cjs +1 -1
  6. package/dist/index.d.cts +18 -4
  7. package/dist/index.d.ts +18 -4
  8. package/dist/index.js +1 -1
  9. package/dist/parallel-worker.cjs +1 -1
  10. package/dist/parallel-worker.js +1 -1
  11. package/dist/prove-worker.cjs +1 -1
  12. package/dist/prove-worker.js +1 -1
  13. package/dist/prove.cjs +56 -56
  14. package/dist/prove.js +79 -79
  15. package/dist/run.cjs +40 -44
  16. package/dist/run.js +42 -46
  17. package/dist/tlapm.cjs +1 -1
  18. package/dist/tlapm.js +2 -2
  19. package/dist/transfer.cjs +97 -92
  20. package/dist/transfer.js +97 -92
  21. package/dist/worker.cjs +7 -7
  22. package/dist/worker.js +7 -7
  23. package/package.json +1 -1
  24. package/src/ast.ts +31 -3
  25. package/src/bags.ts +50 -29
  26. package/src/builtins.ts +4 -3
  27. package/src/check-failure.ts +13 -11
  28. package/src/check-trace.ts +146 -107
  29. package/src/check.ts +535 -281
  30. package/src/cli/runtime-invariants.ts +20 -56
  31. package/src/cli/tlc-arguments.ts +2 -2
  32. package/src/cli/tlc-output.ts +21 -7
  33. package/src/cli/tlc.ts +31 -11
  34. package/src/cli/xml-exporter.ts +1 -1
  35. package/src/codegen.ts +23 -10
  36. package/src/coverage.ts +255 -18
  37. package/src/dependencies.ts +68 -15
  38. package/src/dfid.ts +101 -36
  39. package/src/environment.ts +131 -41
  40. package/src/errors.ts +7 -0
  41. package/src/evaluate.ts +424 -135
  42. package/src/exit-codes.ts +28 -13
  43. package/src/instances.ts +135 -11
  44. package/src/java-hash.ts +14 -0
  45. package/src/java-overrides.ts +2 -2
  46. package/src/levels.ts +675 -236
  47. package/src/lexer.ts +12 -2
  48. package/src/liveness-checker.ts +204 -62
  49. package/src/liveness.ts +55 -10
  50. package/src/obligations/index.ts +1 -1
  51. package/src/obligations/normalize.ts +1 -4
  52. package/src/obligations/printer.ts +5 -5
  53. package/src/obligations/source.ts +2 -0
  54. package/src/parallel-worker.ts +8 -2
  55. package/src/parallel.ts +5 -0
  56. package/src/parser.ts +180 -149
  57. package/src/prover/isabelle/isar/attrib.ts +4 -4
  58. package/src/prover/isabelle/isar/rule-cases.ts +8 -6
  59. package/src/prover/isabelle/provers/clasimp.ts +1 -1
  60. package/src/prover/isabelle/provers/hypsubst.ts +2 -2
  61. package/src/prover/isabelle/pure/rewriter.ts +3 -3
  62. package/src/prover/isabelle/pure/term.ts +3 -3
  63. package/src/prover/prep/md5.ts +26 -29
  64. package/src/prover/smt/rewrite.ts +2 -7
  65. package/src/prover/smt/simplify.ts +1 -1
  66. package/src/prover/smt/solver/arith-rewriter.ts +11 -3
  67. package/src/prover/smt/solver/array-rewriter.ts +12 -2
  68. package/src/prover/smt/solver/asserted-formulas.ts +171 -58
  69. package/src/prover/smt/solver/ast-lt.ts +1 -1
  70. package/src/prover/smt/solver/ast.ts +66 -14
  71. package/src/prover/smt/solver/auf-solver.ts +23 -12
  72. package/src/prover/smt/solver/bit-blast-tactic.ts +27 -1
  73. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  74. package/src/prover/smt/solver/bound-simplifier.ts +11 -13
  75. package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
  76. package/src/prover/smt/solver/bv-rewriter.ts +1 -1
  77. package/src/prover/smt/solver/card2bv.ts +35 -18
  78. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
  79. package/src/prover/smt/solver/context.ts +84 -15
  80. package/src/prover/smt/solver/ctx-simplify.ts +1 -2
  81. package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
  82. package/src/prover/smt/solver/dependent-expr-state.ts +28 -16
  83. package/src/prover/smt/solver/diff-neq.ts +1 -2
  84. package/src/prover/smt/solver/dt2bv-tactic.ts +57 -21
  85. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  86. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  87. package/src/prover/smt/solver/elim-uncnstr.ts +5 -8
  88. package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
  89. package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
  90. package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
  91. package/src/prover/smt/solver/euf/egraph.ts +4 -10
  92. package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
  93. package/src/prover/smt/solver/euf/mam.ts +1 -5
  94. package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
  95. package/src/prover/smt/solver/euf/th-solver.ts +0 -7
  96. package/src/prover/smt/solver/expr2polynomial.ts +204 -79
  97. package/src/prover/smt/solver/factor.ts +36 -14
  98. package/src/prover/smt/solver/fd-solver.ts +608 -139
  99. package/src/prover/smt/solver/fix-dl-var.ts +1 -2
  100. package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
  101. package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
  102. package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
  103. package/src/prover/smt/solver/goal.ts +6 -3
  104. package/src/prover/smt/solver/goal2nlsat.ts +57 -30
  105. package/src/prover/smt/solver/hashtable.ts +4 -0
  106. package/src/prover/smt/solver/internalizer.ts +1 -1
  107. package/src/prover/smt/solver/logic-tactics.ts +15 -5
  108. package/src/prover/smt/solver/lp/containers.ts +7 -1
  109. package/src/prover/smt/solver/lp/core-solver.ts +12 -8
  110. package/src/prover/smt/solver/lp/cross-nested.ts +1 -3
  111. package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
  112. package/src/prover/smt/solver/lp/lp-settings.ts +6 -2
  113. package/src/prover/smt/solver/lp/nex-creator.ts +3 -2
  114. package/src/prover/smt/solver/lp/nex.ts +2 -1
  115. package/src/prover/smt/solver/lp/nla-basics.ts +46 -1
  116. package/src/prover/smt/solver/lp/nla-core.ts +26 -6
  117. package/src/prover/smt/solver/lp/nla-grobner.ts +158 -81
  118. package/src/prover/smt/solver/lp/nra-solver.ts +138 -95
  119. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -2
  120. package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -20
  121. package/src/prover/smt/solver/lp/pdd-solver.ts +72 -39
  122. package/src/prover/smt/solver/lp/pdd.ts +725 -290
  123. package/src/prover/smt/solver/lp/union-find.ts +1 -1
  124. package/src/prover/smt/solver/mam-compiler.ts +1 -1
  125. package/src/prover/smt/solver/maxcore.ts +2 -1
  126. package/src/prover/smt/solver/maxsmt-base.ts +1 -0
  127. package/src/prover/smt/solver/model-based-opt.ts +1 -1
  128. package/src/prover/smt/solver/model-checker.ts +1 -1
  129. package/src/prover/smt/solver/model-evaluator.ts +2 -0
  130. package/src/prover/smt/solver/model-generator.ts +85 -43
  131. package/src/prover/smt/solver/mpf.ts +2 -4
  132. package/src/prover/smt/solver/mus.ts +2 -3
  133. package/src/prover/smt/solver/muz/dl-context.ts +22 -44
  134. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
  135. package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
  136. package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
  137. package/src/prover/smt/solver/muz/hnf.ts +2 -2
  138. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
  139. package/src/prover/smt/solver/muz/horn-tactic.ts +15 -2
  140. package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
  141. package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
  142. package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
  143. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
  144. package/src/prover/smt/solver/nlqsat.ts +1 -1
  145. package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
  146. package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
  147. package/src/prover/smt/solver/nlsat/explain.ts +375 -217
  148. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
  149. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
  150. package/src/prover/smt/solver/nlsat/solver.ts +74 -71
  151. package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
  152. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
  153. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
  154. package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
  155. package/src/prover/smt/solver/nnf.ts +6 -2
  156. package/src/prover/smt/solver/opt-context.ts +21 -7
  157. package/src/prover/smt/solver/opt-nlsat.ts +29 -18
  158. package/src/prover/smt/solver/opt-pareto.ts +19 -0
  159. package/src/prover/smt/solver/opt-preprocess.ts +1 -1
  160. package/src/prover/smt/solver/opt-solver.ts +10 -6
  161. package/src/prover/smt/solver/optsmt.ts +1 -1
  162. package/src/prover/smt/solver/parallel-tactic.ts +1 -1
  163. package/src/prover/smt/solver/pb-rewriter.ts +1 -4
  164. package/src/prover/smt/solver/poly-rewriter.ts +75 -18
  165. package/src/prover/smt/solver/probes.ts +88 -23
  166. package/src/prover/smt/solver/proto-model.ts +8 -8
  167. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  168. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
  169. package/src/prover/smt/solver/qe-lite.ts +2 -2
  170. package/src/prover/smt/solver/qe.ts +3 -2
  171. package/src/prover/smt/solver/qsat.ts +23 -8
  172. package/src/prover/smt/solver/quantifier-manager.ts +14 -9
  173. package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
  174. package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
  175. package/src/prover/smt/solver/rewriter.ts +31 -25
  176. package/src/prover/smt/solver/rlimit.ts +20 -3
  177. package/src/prover/smt/solver/sat/config.ts +1 -1
  178. package/src/prover/smt/solver/sat/goal2sat.ts +65 -12
  179. package/src/prover/smt/solver/sat/inc-sat-solver.ts +129 -43
  180. package/src/prover/smt/solver/sat/model-converter.ts +1 -1
  181. package/src/prover/smt/solver/sat/pb-constraint.ts +7 -0
  182. package/src/prover/smt/solver/sat/pb-solver.ts +26 -7
  183. package/src/prover/smt/solver/sat/sat-tactic.ts +17 -7
  184. package/src/prover/smt/solver/sat/sat2goal.ts +72 -48
  185. package/src/prover/smt/solver/sat/simplifier.ts +1 -1
  186. package/src/prover/smt/solver/sat/solver.ts +27 -47
  187. package/src/prover/smt/solver/seq-axioms.ts +20 -35
  188. package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
  189. package/src/prover/smt/solver/seq-derive.ts +4 -7
  190. package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
  191. package/src/prover/smt/solver/seq-monadic.ts +7 -5
  192. package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
  193. package/src/prover/smt/solver/seq-re-util.ts +1 -1
  194. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  195. package/src/prover/smt/solver/seq-regex-live.ts +2 -2
  196. package/src/prover/smt/solver/seq-rewriter.ts +31 -29
  197. package/src/prover/smt/solver/seq-skolem.ts +0 -23
  198. package/src/prover/smt/solver/seq-view-witness.ts +4 -4
  199. package/src/prover/smt/solver/smt-consequences.ts +1 -1
  200. package/src/prover/smt/solver/smt-kernel.ts +48 -7
  201. package/src/prover/smt/solver/smt-setup.ts +106 -13
  202. package/src/prover/smt/solver/smtlib-parser.ts +589 -224
  203. package/src/prover/smt/solver/smtlib-script.ts +713 -210
  204. package/src/prover/smt/solver/solve-eqs.ts +36 -37
  205. package/src/prover/smt/solver/solver.ts +18 -3
  206. package/src/prover/smt/solver/tactic.ts +350 -195
  207. package/src/prover/smt/solver/theory-bv.ts +13 -3
  208. package/src/prover/smt/solver/theory-fpa.ts +1 -1
  209. package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
  210. package/src/prover/smt/solver/theory-lra-internalize.ts +10 -0
  211. package/src/prover/smt/solver/theory-lra-propagate.ts +11 -3
  212. package/src/prover/smt/solver/theory-lra-state.ts +1 -1
  213. package/src/prover/smt/solver/theory-lra.ts +1 -1
  214. package/src/prover/smt/solver/theory-pb.ts +24 -7
  215. package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
  216. package/src/prover/smt/solver/theory-seq-state.ts +2 -21
  217. package/src/prover/smt/solver/theory-without-terms.ts +24 -0
  218. package/src/prover/smt/solver/tseitin-cnf.ts +1 -0
  219. package/src/prover/tlapm/cache.ts +8 -8
  220. package/src/prover/zenon/equality-rules.ts +24 -0
  221. package/src/prover/zenon/expr.ts +21 -0
  222. package/src/prover/zenon/index-table.ts +7 -2
  223. package/src/prover/zenon/isar-case.ts +1 -1
  224. package/src/prover/zenon/isar.ts +2 -2
  225. package/src/prover/zenon/phrase.ts +1 -1
  226. package/src/prover/zenon/rules.ts +2 -1
  227. package/src/resolve.ts +1274 -258
  228. package/src/runtime.ts +25 -2
  229. package/src/sany/builtins.ts +10 -10
  230. package/src/sany/generation.ts +5 -15
  231. package/src/sany/generator-def-entries.ts +123 -36
  232. package/src/sany/generator-definitions.ts +5 -3
  233. package/src/sany/generator-expressions.ts +60 -37
  234. package/src/sany/generator-proofs.ts +18 -12
  235. package/src/sany/generator.ts +12 -6
  236. package/src/sany/lexer.ts +15 -7
  237. package/src/sany/modules.ts +4 -2
  238. package/src/sany/nodes.ts +1 -1
  239. package/src/sany/selectors.ts +11 -6
  240. package/src/sany/xml.ts +2 -3
  241. package/src/search.ts +348 -153
  242. package/src/simulate.ts +250 -185
  243. package/src/spec-description.ts +15 -7
  244. package/src/standard-definitions.ts +5 -0
  245. package/src/standard-modules.ts +56 -22
  246. package/src/subexpressions.ts +564 -138
  247. package/src/successors.ts +50 -20
  248. package/src/symmetry.ts +2 -1
  249. package/src/tlc/jar-data.ts +10 -0
  250. package/src/tlc/messages.ts +3 -3
  251. package/src/tlc/order.ts +14 -3
  252. package/src/tlc/random.ts +2 -1
  253. package/src/tlc/replay.ts +147 -46
  254. package/src/tlc/tlc-operators.ts +10 -8
  255. package/src/tlc/tlcext-operators.ts +87 -26
  256. package/src/tlc/trace-spec.ts +11 -25
  257. package/src/trace-liveness.ts +529 -0
  258. package/src/typed-tier.ts +52 -31
  259. package/src/typescript/types.ts +2 -2
  260. package/src/values.ts +150 -79
package/src/lexer.ts CHANGED
@@ -1,4 +1,5 @@
1
1
  import { TlaSyntaxError } from "./errors";
2
+ import { getEndOfFile } from "./sany/lexer";
2
3
 
3
4
  type TokenKind =
4
5
  | "Identifier"
@@ -479,8 +480,17 @@ export const matchBasedNumber = (source: string, index: number, isTlapm = false)
479
480
 
480
481
  export const tokenize = (source: string, isTlapm = false): Token[] => {
481
482
  const headerMatch = MODULE_HEADER.exec(source);
482
- if (!headerMatch)
483
- throw new TlaSyntaxError("Expected a module header such as ---- MODULE Name ----");
483
+ if (!headerMatch) {
484
+ // SANY skips the text before a module header, so it fails at the end of the file.
485
+ const end = getEndOfFile(source);
486
+ const reason = "Expected a module header such as ---- MODULE Name ----";
487
+ throw new TlaSyntaxError(`${reason} at line ${end.line}, column ${end.column}`, undefined, {
488
+ reason,
489
+ line: end.line,
490
+ column: end.column,
491
+ isEnd: true,
492
+ });
493
+ }
484
494
  const tokens: Token[] = [];
485
495
  // Each name is one string object, so looking a name up in a scope compares pointers.
486
496
  const names = new Map<string, string>();
@@ -22,6 +22,7 @@ import {
22
22
  type Solution,
23
23
  type Tableau,
24
24
  } from "./tableau";
25
+ import { findTraceLasso, type TraceLasso } from "./trace-liveness";
25
26
  import { isSameValue, type Value } from "./values";
26
27
 
27
28
  export interface LiveSuccessor<State = Value[]> {
@@ -45,10 +46,22 @@ export interface LivenessChecker {
45
46
  successors: LiveSuccessor[],
46
47
  tracing?: Environment,
47
48
  ) => number[] | undefined;
49
+ storeState: (pending: number, index: number) => void;
50
+ getStateCounts: () => number[];
48
51
  findViolation: () => Lasso | undefined;
49
52
  getViolatedProperties: (path: Value[][], cycleStart: number) => string[];
50
53
  }
51
54
 
55
+ export interface TraceViolation extends TraceLasso {
56
+ properties: string[];
57
+ failures: TlaEvaluationError[];
58
+ }
59
+
60
+ export interface LivenessChecks {
61
+ solutions: Solution[];
62
+ findTraceViolation: (trace: Value[][], fingerprints: bigint[]) => TraceViolation | undefined;
63
+ }
64
+
52
65
  export interface LiveGraph<State> {
53
66
  branches: number;
54
67
  addInitialState: (index: number, state: State) => void;
@@ -57,13 +70,26 @@ export interface LiveGraph<State> {
57
70
  index: number,
58
71
  state: State,
59
72
  successors: LiveSuccessor<State>[],
73
+ isRerun?: boolean,
60
74
  ) => number[] | undefined;
75
+ storeState: (pending: number, index: number) => void;
76
+ getStateCounts: () => number[];
61
77
  findViolation: () => Lasso | undefined;
62
78
  }
63
79
 
64
80
  export interface SearchGraph<State> {
65
81
  getFingerprint: (successor: LiveSuccessor<State>) => number;
66
- getSuccessors: (index: number, state: State) => LiveSuccessor<State>[];
82
+ forEachActionSuccessors: (
83
+ index: number,
84
+ state: State,
85
+ onSuccessors: (successors: LiveSuccessor<State>[]) => void,
86
+ replay?: Environment,
87
+ ) => void;
88
+ }
89
+
90
+ interface Tracing {
91
+ atoms: LiveAtoms<Value[]>;
92
+ replay: Environment | undefined;
67
93
  }
68
94
 
69
95
  export interface LiveEvaluation<State> {
@@ -114,6 +140,7 @@ interface BehaviorGraph<State> {
114
140
  nextSiblings: number[];
115
141
  nodeIds: NodeTable;
116
142
  isDone: boolean[];
143
+ stateCount: number;
117
144
  errorNode: number | undefined;
118
145
  }
119
146
 
@@ -246,13 +273,14 @@ const getLiveFormula = (
246
273
  const fairness = temporals.map((item) =>
247
274
  toLiveExpression(item.expression, item.scope, environment),
248
275
  );
249
- const negations = properties.map((property) =>
250
- createUnary("Not", toLiveExpression(property.expression, property.scope, environment)),
276
+ const checks = properties.map((property) =>
277
+ toLiveExpression(property.expression, property.scope, environment),
251
278
  );
279
+ const negations = checks.map((check) => createUnary("Not", check));
252
280
  const violation = negations.length === 1 ? negations[0] : createJunction("Or", negations);
253
281
  const formula =
254
282
  fairness.length === 0 ? violation : createJunction("And", [...fairness, violation]);
255
- return { formula, negations };
283
+ return { formula, checks };
256
284
  };
257
285
 
258
286
  export type LiveAtom = LiveState | LiveEnabled | LiveAction;
@@ -307,28 +335,83 @@ export const getLiveExpressions = (solutions: Solution[]) =>
307
335
  getAtomExpressions(atom).map((item) => item.expression),
308
336
  );
309
337
 
310
- export const createLivenessChecker = (
311
- properties: TemporalProperty[],
312
- temporals: ScopedExpression[],
313
- environment: Environment,
314
- search: SearchGraph<Value[]>,
315
- ): LivenessChecker | undefined => {
316
- if (properties.length === 0) return undefined;
317
- const live = getLiveFormula(properties, temporals, environment);
318
- // A check evaluated once for a state shows what TLC shows when no check repeats an effect. A
319
- // definition TLC evaluates as it starts repeats nothing, but a scope can bind any definition.
338
+ const isSharingResults = (formula: LiveExpression, environment: Environment) => {
320
339
  const formulaAtoms = new Set<LiveAtom>();
321
- collectAtoms(live.formula, formulaAtoms);
340
+ collectAtoms(formula, formulaAtoms);
322
341
  const checked = [...formulaAtoms].flatMap(getAtomExpressions);
323
- const isShared = checked.every((item) => item.scope === undefined)
342
+ return checked.every((item) => item.scope === undefined)
324
343
  ? !isExpressionImpure(
325
344
  checked.map((item) => item.expression),
326
345
  environment,
327
346
  "repeated",
328
347
  )
329
348
  : !hasRepeatedEffects(environment);
330
- const tracing = { environment, atoms: getInterpretedAtoms(environment) };
349
+ };
350
+
351
+ const getViolatedProperties = (
352
+ properties: TemporalProperty[],
353
+ checks: LiveExpression[],
354
+ path: Value[][],
355
+ cycleStart: number,
356
+ environment: Environment,
357
+ failures?: TlaEvaluationError[],
358
+ ) => [
359
+ ...new Set(
360
+ properties
361
+ .filter((_property, position) => {
362
+ try {
363
+ return !evaluateOnLasso(checks[position], path, cycleStart, 0, environment);
364
+ } catch (error) {
365
+ if (!failures || !(error instanceof TlaEvaluationError)) throw error;
366
+ failures.push(error);
367
+ return false;
368
+ }
369
+ })
370
+ .map((property) => property.name),
371
+ ),
372
+ ];
373
+
374
+ export const createLivenessChecks = (
375
+ properties: TemporalProperty[],
376
+ temporals: ScopedExpression[],
377
+ environment: Environment,
378
+ ): LivenessChecks | undefined => {
379
+ if (properties.length === 0) return undefined;
380
+ const live = getLiveFormula(properties, temporals, environment);
381
+ const solutions = getSolutions(live.formula);
382
+ const atoms = getInterpretedAtoms(environment);
383
+ const isShared = isSharingResults(live.formula, environment);
384
+ return {
385
+ solutions,
386
+ findTraceViolation: (trace, fingerprints) => {
387
+ const lasso = findTraceLasso(trace, fingerprints, solutions, atoms, isShared);
388
+ if (!lasso) return undefined;
389
+ // Liveness#findViolatedProperties reports a property it fails to evaluate on the lasso and goes on.
390
+ const failures: TlaEvaluationError[] = [];
391
+ const violated = getViolatedProperties(
392
+ properties,
393
+ live.checks,
394
+ lasso.positions.map((position) => trace[position]),
395
+ lasso.cyclePosition - 1,
396
+ environment,
397
+ failures,
398
+ );
399
+ return { ...lasso, properties: violated, failures };
400
+ },
401
+ };
402
+ };
403
+
404
+ export const createLivenessChecker = (
405
+ properties: TemporalProperty[],
406
+ temporals: ScopedExpression[],
407
+ environment: Environment,
408
+ search: SearchGraph<Value[]>,
409
+ ): LivenessChecker | undefined => {
410
+ if (properties.length === 0) return undefined;
411
+ const live = getLiveFormula(properties, temporals, environment);
412
+ const isShared = isSharingResults(live.formula, environment);
331
413
  const solutions = getSolutions(live.formula);
414
+ const tracing: Tracing = { atoms: getInterpretedAtoms(environment), replay: undefined };
332
415
  const graph = createLiveGraph(
333
416
  solutions,
334
417
  {
@@ -347,16 +430,22 @@ export const createLivenessChecker = (
347
430
  }
348
431
  },
349
432
  },
350
- search,
433
+ {
434
+ getFingerprint: search.getFingerprint,
435
+ forEachActionSuccessors: (index, state, onSuccessors) =>
436
+ search.forEachActionSuccessors(index, state, onSuccessors, tracing.replay),
437
+ },
351
438
  environment.runtime.version !== "1.7.4",
352
439
  );
353
440
  const traceWith = <Result>(replay: Environment | undefined, run: () => Result) => {
354
441
  if (replay === undefined) return run();
355
442
  tracing.atoms = getInterpretedAtoms(replay);
443
+ tracing.replay = replay;
356
444
  try {
357
445
  return run();
358
446
  } finally {
359
447
  tracing.atoms = getInterpretedAtoms(environment);
448
+ tracing.replay = undefined;
360
449
  }
361
450
  };
362
451
  return {
@@ -365,18 +454,12 @@ export const createLivenessChecker = (
365
454
  addInitialState: (index, state, replay) =>
366
455
  traceWith(replay, () => graph.addInitialState(index, state)),
367
456
  addState: (index, state, successors, replay) =>
368
- traceWith(replay, () => graph.addState(index, state, successors)),
457
+ traceWith(replay, () => graph.addState(index, state, successors, replay !== undefined)),
458
+ storeState: graph.storeState,
459
+ getStateCounts: graph.getStateCounts,
369
460
  findViolation: graph.findViolation,
370
- getViolatedProperties: (path, cycleStart) => [
371
- ...new Set(
372
- properties
373
- .filter(
374
- (_property, position) =>
375
- !evaluateOnLasso(live.negations[position].body, path, cycleStart, 0, environment),
376
- )
377
- .map((property) => property.name),
378
- ),
379
- ],
461
+ getViolatedProperties: (path, cycleStart) =>
462
+ getViolatedProperties(properties, live.checks, path, cycleStart, environment),
380
463
  };
381
464
  };
382
465
 
@@ -505,6 +588,7 @@ export const createLiveGraph = <State>(
505
588
  nextSiblings: [],
506
589
  nodeIds: { slots: new Int32Array(3 << 10), size: 0, shift: 22 },
507
590
  isDone: [],
591
+ stateCount: 0,
508
592
  errorNode: undefined,
509
593
  }));
510
594
  const checkState = (
@@ -600,8 +684,12 @@ export const createLiveGraph = <State>(
600
684
  const slot = getNodeSlot(behavior.nodeIds, state, tableauNode);
601
685
  return slots[slot] === 0 ? undefined : slots[slot + 2];
602
686
  };
603
- const recordNode = (behavior: BehaviorGraph<State>, state: number, tableauNode: number) => {
604
- const node = pushNode(behavior, state, tableauNode);
687
+ const linkNode = (
688
+ behavior: BehaviorGraph<State>,
689
+ state: number,
690
+ tableauNode: number,
691
+ node: number,
692
+ ) => {
605
693
  const table = behavior.nodeIds;
606
694
  if (++table.size * 2 > table.slots.length / 3) {
607
695
  const old = table.slots;
@@ -617,12 +705,23 @@ export const createLiveGraph = <State>(
617
705
  }
618
706
  }
619
707
  table.slots.set([state + 1, tableauNode, node], getNodeSlot(table, state, tableauNode));
708
+ if (state < 0) return node;
620
709
  const last = behavior.lastNodes.data[state] ?? NO_NODE;
621
710
  if (last === NO_NODE) writeToPool(behavior.firstNodes, state, [node]);
622
711
  else behavior.nextSiblings[last] = node;
623
712
  writeToPool(behavior.lastNodes, state, [node]);
624
713
  return node;
625
714
  };
715
+ const hasState = (behavior: BehaviorGraph<State>, state: number) =>
716
+ state < 0
717
+ ? behavior.checks.nodes.some(
718
+ (_checks, tableauNode) => getNodeId(behavior, state, tableauNode) !== undefined,
719
+ )
720
+ : behavior.isDone[state] === true || (behavior.firstNodes.data[state] ?? NO_NODE) !== NO_NODE;
721
+ const recordNode = (behavior: BehaviorGraph<State>, state: number, tableauNode: number) => {
722
+ if (!hasState(behavior, state)) behavior.stateCount++;
723
+ return linkNode(behavior, state, tableauNode, pushNode(behavior, state, tableauNode));
724
+ };
626
725
  // The action results of the edge to each target are at its position in actions.
627
726
  const writeNode = (
628
727
  behavior: BehaviorGraph<State>,
@@ -731,41 +830,57 @@ export const createLiveGraph = <State>(
731
830
  actions.push(0);
732
831
  if (existing === undefined) expandLate(behavior, tableau, state, index, target, row, offset);
733
832
  }
734
- const nextStates = search.getSuccessors(index, state);
735
833
  // The results of the step to the state itself come first, then those of each successor.
736
- const actionResults = new Uint8Array((nextStates.length + 1) * actionCount);
737
- actionResults.set(selfResults);
738
- const edges = createEdgeRows(nextStates.length);
739
- nextStates.forEach((successor, position) => {
740
- const successorRow = createRows(1);
741
- checkAction(
742
- behavior,
743
- index,
744
- state,
745
- row,
746
- offset,
747
- successor.state,
748
- edges,
749
- position * actionIds.size,
750
- actionResults,
751
- (position + 1) * actionCount,
752
- );
753
- const isDone = behavior.isDone[successor.index] === true;
754
- for (const next of tableauNode.successors) {
755
- if (!isConsistent(behavior, next, index, successor.state, successorRow, 0)) continue;
756
- // Deviation from TLC: TLC records the node of a successor the search never stored, which it never expands.
757
- if (successor.index === -1) continue;
758
- const existing = getNodeId(behavior, successor.index, next);
759
- if (existing !== undefined && successors.includes(existing)) continue;
760
- const target = existing ?? recordNode(behavior, successor.index, next);
761
- successors.push(target);
762
- actions.push(position + 1);
763
- if (existing === undefined && isDone) {
764
- expandLate(behavior, tableau, successor.state, successor.index, target, successorRow, 0);
834
+ const actionBatches = [selfResults];
835
+ let stepCount = 1;
836
+ search.forEachActionSuccessors(index, state, (nextStates) => {
837
+ const edges = createEdgeRows(nextStates.length);
838
+ const results = new Uint8Array(nextStates.length * actionCount);
839
+ actionBatches.push(results);
840
+ for (let position = 0; position < nextStates.length; position++) {
841
+ const successor = nextStates[position];
842
+ const successorRow = createRows(1);
843
+ checkAction(
844
+ behavior,
845
+ index,
846
+ state,
847
+ row,
848
+ offset,
849
+ successor.state,
850
+ edges,
851
+ position * actionIds.size,
852
+ results,
853
+ position * actionCount,
854
+ );
855
+ const isDone = behavior.isDone[successor.index] === true;
856
+ for (const next of tableauNode.successors) {
857
+ if (!isConsistent(behavior, next, index, successor.state, successorRow, 0)) continue;
858
+ const existing = getNodeId(behavior, successor.index, next);
859
+ if (existing !== undefined && successors.includes(existing)) continue;
860
+ const target = existing ?? recordNode(behavior, successor.index, next);
861
+ successors.push(target);
862
+ actions.push(stepCount + position);
863
+ if (existing === undefined && isDone) {
864
+ expandLate(
865
+ behavior,
866
+ tableau,
867
+ successor.state,
868
+ successor.index,
869
+ target,
870
+ successorRow,
871
+ 0,
872
+ );
873
+ }
765
874
  }
766
875
  }
876
+ stepCount += nextStates.length;
767
877
  });
768
878
  if (successors.length > 0) {
879
+ const actionResults = new Uint8Array(stepCount * actionCount);
880
+ for (let batch = 0, resultOffset = 0; batch < actionBatches.length; batch++) {
881
+ actionResults.set(actionBatches[batch], resultOffset);
882
+ resultOffset += actionBatches[batch].length;
883
+ }
769
884
  writeNode(behavior, node, successors, actionResults, actions, stateResults);
770
885
  }
771
886
  };
@@ -791,6 +906,7 @@ export const createLiveGraph = <State>(
791
906
  }
792
907
  }
793
908
  });
909
+ if (!hasState(behavior, index)) behavior.stateCount++;
794
910
  behavior.isDone[index] = true;
795
911
  // TLC expands the nodes recorded before the loop, not the ones the loop records.
796
912
  for (const node of getStateNodes(behavior, index)) {
@@ -840,6 +956,7 @@ export const createLiveGraph = <State>(
840
956
  successors.push(successor.index);
841
957
  actions.push(position);
842
958
  });
959
+ if (!isWritten(behavior, index)) behavior.stateCount++;
843
960
  writeNode(behavior, index, successors, actionResults, actions, stateResults);
844
961
  };
845
962
 
@@ -1118,7 +1235,7 @@ export const createLiveGraph = <State>(
1118
1235
  }
1119
1236
  }
1120
1237
  },
1121
- addState: (index, state, successors) => {
1238
+ addState: (index, state, successors, isRerun) => {
1122
1239
  const set = getSuccessorSet(index, state, successors);
1123
1240
  const rows = createRows(set.length);
1124
1241
  // The set holds the state itself, as a successor of the same index.
@@ -1143,6 +1260,15 @@ export const createLiveGraph = <State>(
1143
1260
  );
1144
1261
  const stateResults = checkState(behavior, index, state, rows, offset);
1145
1262
  const tableau = behavior.solution.tableau;
1263
+ // TLC's rerun for a call stack fails an assertion, without a call stack, on a branch that has every edge of the state.
1264
+ if (
1265
+ isRerun &&
1266
+ (tableau
1267
+ ? getStateNodes(behavior, index).some((node) => behavior.edgeCounts[node] > 0)
1268
+ : set.every((successor) => isWritten(behavior, successor.index)))
1269
+ ) {
1270
+ throw new TlaEvaluationError("The behavior graph holds every edge of the state already.");
1271
+ }
1146
1272
  if (!tableau) {
1147
1273
  addPlainState(behavior, set, actionResults, stateResults, index);
1148
1274
  continue;
@@ -1160,6 +1286,22 @@ export const createLiveGraph = <State>(
1160
1286
  }
1161
1287
  return undefined;
1162
1288
  },
1289
+ storeState: (pending, index) => {
1290
+ for (const behavior of behaviors) {
1291
+ const tableau = behavior.solution.tableau;
1292
+ if (!tableau) continue;
1293
+ const nodes: number[] = [];
1294
+ for (let tableauNode = 0; tableauNode < tableau.nodes.length; tableauNode++) {
1295
+ const node = getNodeId(behavior, pending, tableauNode);
1296
+ if (node !== undefined) nodes.push(node);
1297
+ }
1298
+ for (const node of nodes.sort((left, right) => left - right)) {
1299
+ behavior.nodeStates[node] = index;
1300
+ linkNode(behavior, index, behavior.nodeTableaux[node], node);
1301
+ }
1302
+ }
1303
+ },
1304
+ getStateCounts: () => behaviors.map((behavior) => behavior.stateCount),
1163
1305
  findViolation: () => {
1164
1306
  for (const behavior of behaviors) {
1165
1307
  for (const model of behavior.solution.models) {
package/src/liveness.ts CHANGED
@@ -16,6 +16,7 @@ import {
16
16
  forEachBoundElement,
17
17
  getBoundElements,
18
18
  getDefinition,
19
+ getReevaluatedDefinitions,
19
20
  getStartupValue,
20
21
  lookupScope,
21
22
  resolveApplyOperator,
@@ -26,6 +27,7 @@ import {
26
27
  type Scope,
27
28
  type Thunk,
28
29
  } from "./evaluate";
30
+ import { letDefinitions } from "./coverage";
29
31
  import { mapChildren } from "./instances";
30
32
  import { ACTION_LEVEL, CONSTANT_LEVEL, TEMPORAL_LEVEL, VARIABLE_LEVEL } from "./levels";
31
33
  import { isEnabled } from "./successors";
@@ -243,6 +245,7 @@ export const expandTemporal = (
243
245
  return expression.operands.flatMap((operand) => expand(operand, scope, describeRange(operand)));
244
246
  }
245
247
  if (expression.kind === "Label") return expand(expression.body, scope);
248
+ if (expression.kind === "Selection") return expand(expression.expression, scope);
246
249
  if (expression.kind === "Let") {
247
250
  return expand(expression.body, bindLetDefinitions(expression, scope, environment));
248
251
  }
@@ -323,14 +326,22 @@ export const expandTemporal = (
323
326
  return [{ expression, scope, name: expansion.name, path: expansion.path }];
324
327
  };
325
328
 
326
- const bindLetDefinitions = (
329
+ // TLC takes a formula apart through a LET without binding its definitions, so it evaluates an impure one again at each reference.
330
+ export const bindLetDefinitions = (
327
331
  expression: Expression & { kind: "Let" },
328
332
  scope: Scope | undefined,
329
333
  environment: Environment,
330
334
  ) => {
331
- const bound = bindDefinitions(expression.definitions, getConstantContext(environment, scope));
335
+ const bound = bindDefinitions(
336
+ expression.definitions,
337
+ getConstantContext(environment, scope),
338
+ getReevaluatedDefinitions(expression.definitions, environment),
339
+ );
332
340
  for (let current = bound; current && current !== scope; current = current.parent) {
333
341
  if (current.binding.kind === "Thunk") definitionThunks.add(current.binding);
342
+ const name = current.name;
343
+ const definition = expression.definitions.find((item) => item.name === name);
344
+ if (definition) letDefinitions.set(current, definition);
334
345
  }
335
346
  return bound;
336
347
  };
@@ -488,12 +499,53 @@ export const toLiveExpression = (
488
499
  return level > ACTION_LEVEL ? parts : toAtom(expression, scope, level);
489
500
  };
490
501
 
502
+ // SANY parses `a /\ b /\ c` as `(a /\ b) /\ c`, so TLC takes a prefix below the temporal level as one formula.
503
+ const convertJunction = (
504
+ expression: Expression & { kind: "And" | "Or" },
505
+ scope: Scope | undefined,
506
+ ) => {
507
+ const operands = expression.operands;
508
+ const range = expression.location.range;
509
+ const prefixEnds = expression.prefixEnds;
510
+ if (expression.isBulleted || !range || !prefixEnds) {
511
+ return toWhole(
512
+ expression,
513
+ scope,
514
+ createJunction(
515
+ expression.kind,
516
+ operands.map((operand) => convert(operand, scope)),
517
+ ),
518
+ );
519
+ }
520
+ return operands.slice(1).reduce(
521
+ (prefix, operand, index) => {
522
+ const node =
523
+ index === operands.length - 2
524
+ ? expression
525
+ : {
526
+ ...expression,
527
+ operands: operands.slice(0, index + 2),
528
+ prefixEnds: prefixEnds.slice(0, index + 1),
529
+ location: { ...expression.location, range: { ...range, end: prefixEnds[index] } },
530
+ };
531
+ return toWhole(
532
+ node,
533
+ scope,
534
+ createJunction(expression.kind, [prefix, convert(operand, scope)]),
535
+ );
536
+ },
537
+ convert(operands[0], scope),
538
+ );
539
+ };
540
+
491
541
  // These forms are translated part by part at every level; any other form below the temporal level is an atom.
492
542
  const convert = (expression: Expression, scope: Scope | undefined): LiveExpression => {
493
543
  const level = getLevel(expression, scope, environment);
494
544
  switch (expression.kind) {
495
545
  case "Label":
496
546
  return convert(expression.body, scope);
547
+ case "Selection":
548
+ return convert(expression.expression, scope);
497
549
  case "Let":
498
550
  return convert(expression.body, bindLetDefinitions(expression, scope, environment));
499
551
  case "Apply": {
@@ -512,14 +564,7 @@ export const toLiveExpression = (
512
564
  }
513
565
  case "And":
514
566
  case "Or":
515
- return toWhole(
516
- expression,
517
- scope,
518
- createJunction(
519
- expression.kind,
520
- expression.operands.map((operand) => convert(operand, scope)),
521
- ),
522
- );
567
+ return convertJunction(expression, scope);
523
568
  case "Forall":
524
569
  case "Exists":
525
570
  return convertQuantifier(expression, scope);
@@ -179,7 +179,7 @@ const loadMule = (
179
179
 
180
180
  const schedule = (modules: Map<string, Mule>) => {
181
181
  const dependencies = new Map(
182
- [...modules].map(([name, module]) => [name, getDependencies(module).dependencies]),
182
+ [...modules].map((entry) => [entry[0], getDependencies(entry[1]).dependencies]),
183
183
  );
184
184
  const seen = new Set<string>();
185
185
  const order: Mule[] = [];
@@ -351,10 +351,7 @@ const instantiate = (
351
351
  substitutes.set(name, at({ kind: "Opaque", name }, { location }));
352
352
  }
353
353
  const anonymized = new Map(
354
- [...substitutes].map(([name, expression]) => [
355
- name,
356
- pipeline.anonymizer.expr(instanceScope, expression),
357
- ]),
354
+ [...substitutes].map((entry) => [entry[0], pipeline.anonymizer.expr(instanceScope, entry[1])]),
358
355
  );
359
356
  const body = substituteUnits(
360
357
  shift((instanceScope?.size ?? 0) - (module.depth ?? 0)),
@@ -430,26 +430,26 @@ const createPrinter = (hyps: Hyp[] = [], options: PrinterOptions = {}) => {
430
430
  );
431
431
  case "Choose": {
432
432
  const domainDoc = expression.domain && printExpr(expression.domain);
433
- return withNames(context, [expression.name], ([name]) =>
433
+ return withNames(context, [expression.name], (names) =>
434
434
  createBig(
435
435
  domainDoc
436
436
  ? format(
437
437
  "@[<b2>CHOOSE @[<b2>%s \\in@ %a@] :@ %a@]",
438
- name,
438
+ names[0],
439
439
  domainDoc,
440
440
  printExpr(expression.body),
441
441
  )
442
- : format("@[<b2>CHOOSE %s :@ %a@]", name, printExpr(expression.body)),
442
+ : format("@[<b2>CHOOSE %s :@ %a@]", names[0], printExpr(expression.body)),
443
443
  ),
444
444
  );
445
445
  }
446
446
  case "SetSt": {
447
447
  const domainDoc = printExpr(expression.domain);
448
- return withNames(context, [expression.name], ([name]) =>
448
+ return withNames(context, [expression.name], (names) =>
449
449
  createAtom(
450
450
  format(
451
451
  "@[<b3>{@[<b2>%s \\in@ %a@] :@ %a}@]",
452
- name,
452
+ names[0],
453
453
  domainDoc,
454
454
  printExpr(expression.body),
455
455
  ),
@@ -643,6 +643,8 @@ export const createModuleConverter = (
643
643
  },
644
644
  { location },
645
645
  );
646
+ case "Selection":
647
+ return recurse(expression.expression);
646
648
  case "Subexpression": {
647
649
  const [head, ...selectors] = expression.selectors;
648
650
  if (head.kind !== "Name") throw new TlaProofError("Unexpected subexpression reference");
@@ -41,8 +41,14 @@ const runWorker = (start: StartMessage, parent: Port) => {
41
41
  );
42
42
  const specification = created.specification;
43
43
  const environment = specification.environment;
44
- const search = createSearch(start.config, environment, specification.variableLocations, () =>
45
- created.order.getDeclarationOrder("variable"),
44
+ const search = createSearch(
45
+ start.config,
46
+ environment,
47
+ specification.variableLocations,
48
+ () => created.order.getDeclarationOrder("variable"),
49
+ undefined,
50
+ [],
51
+ specification.runtimeInvariants,
46
52
  );
47
53
  const nextAction = search?.spec.next;
48
54
  if (!search || nextAction === undefined)