tla-ts 0.0.10-dev.d618a2d79 → 0.0.10-dev.e3e5dd576

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 (252) 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 +78 -78
  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 +49 -44
  20. package/dist/transfer.js +48 -43
  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 +14 -2
  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 +116 -64
  29. package/src/check.ts +516 -280
  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 +18 -4
  33. package/src/cli/tlc.ts +18 -12
  34. package/src/cli/xml-exporter.ts +1 -1
  35. package/src/codegen.ts +23 -10
  36. package/src/coverage.ts +190 -1
  37. package/src/dependencies.ts +68 -15
  38. package/src/dfid.ts +101 -36
  39. package/src/environment.ts +123 -38
  40. package/src/errors.ts +7 -0
  41. package/src/evaluate.ts +370 -99
  42. package/src/exit-codes.ts +28 -14
  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 +179 -60
  49. package/src/liveness.ts +51 -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 -11
  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/core-solver.ts +12 -8
  109. package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
  110. package/src/prover/smt/solver/lp/lp-settings.ts +6 -2
  111. package/src/prover/smt/solver/lp/nla-core.ts +1 -1
  112. package/src/prover/smt/solver/lp/nla-grobner.ts +158 -80
  113. package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
  114. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -2
  115. package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -20
  116. package/src/prover/smt/solver/lp/pdd-solver.ts +72 -39
  117. package/src/prover/smt/solver/lp/pdd.ts +725 -290
  118. package/src/prover/smt/solver/lp/union-find.ts +1 -1
  119. package/src/prover/smt/solver/mam-compiler.ts +1 -1
  120. package/src/prover/smt/solver/maxcore.ts +2 -1
  121. package/src/prover/smt/solver/maxsmt-base.ts +1 -0
  122. package/src/prover/smt/solver/model-based-opt.ts +1 -1
  123. package/src/prover/smt/solver/model-checker.ts +1 -1
  124. package/src/prover/smt/solver/model-evaluator.ts +2 -0
  125. package/src/prover/smt/solver/model-generator.ts +85 -43
  126. package/src/prover/smt/solver/mpf.ts +2 -4
  127. package/src/prover/smt/solver/mus.ts +2 -3
  128. package/src/prover/smt/solver/muz/dl-context.ts +22 -44
  129. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
  130. package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
  131. package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
  132. package/src/prover/smt/solver/muz/hnf.ts +2 -2
  133. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
  134. package/src/prover/smt/solver/muz/horn-tactic.ts +15 -2
  135. package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
  136. package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
  137. package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
  138. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
  139. package/src/prover/smt/solver/nlqsat.ts +1 -1
  140. package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
  141. package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
  142. package/src/prover/smt/solver/nlsat/explain.ts +375 -217
  143. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
  144. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
  145. package/src/prover/smt/solver/nlsat/solver.ts +74 -64
  146. package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
  147. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
  148. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
  149. package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
  150. package/src/prover/smt/solver/nnf.ts +6 -2
  151. package/src/prover/smt/solver/opt-context.ts +21 -7
  152. package/src/prover/smt/solver/opt-nlsat.ts +29 -18
  153. package/src/prover/smt/solver/opt-pareto.ts +19 -0
  154. package/src/prover/smt/solver/opt-preprocess.ts +1 -1
  155. package/src/prover/smt/solver/opt-solver.ts +10 -6
  156. package/src/prover/smt/solver/optsmt.ts +1 -1
  157. package/src/prover/smt/solver/parallel-tactic.ts +1 -1
  158. package/src/prover/smt/solver/pb-rewriter.ts +1 -4
  159. package/src/prover/smt/solver/poly-rewriter.ts +75 -18
  160. package/src/prover/smt/solver/probes.ts +88 -23
  161. package/src/prover/smt/solver/proto-model.ts +8 -8
  162. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  163. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
  164. package/src/prover/smt/solver/qe-lite.ts +2 -2
  165. package/src/prover/smt/solver/qe.ts +3 -2
  166. package/src/prover/smt/solver/qsat.ts +23 -8
  167. package/src/prover/smt/solver/quantifier-manager.ts +14 -9
  168. package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
  169. package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
  170. package/src/prover/smt/solver/rewriter.ts +31 -25
  171. package/src/prover/smt/solver/rlimit.ts +7 -3
  172. package/src/prover/smt/solver/sat/config.ts +1 -1
  173. package/src/prover/smt/solver/sat/goal2sat.ts +65 -12
  174. package/src/prover/smt/solver/sat/inc-sat-solver.ts +129 -43
  175. package/src/prover/smt/solver/sat/model-converter.ts +1 -1
  176. package/src/prover/smt/solver/sat/pb-constraint.ts +7 -0
  177. package/src/prover/smt/solver/sat/pb-solver.ts +26 -7
  178. package/src/prover/smt/solver/sat/sat-tactic.ts +17 -7
  179. package/src/prover/smt/solver/sat/sat2goal.ts +72 -48
  180. package/src/prover/smt/solver/sat/simplifier.ts +1 -1
  181. package/src/prover/smt/solver/sat/solver.ts +27 -47
  182. package/src/prover/smt/solver/seq-axioms.ts +20 -35
  183. package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
  184. package/src/prover/smt/solver/seq-derive.ts +2 -2
  185. package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
  186. package/src/prover/smt/solver/seq-monadic.ts +7 -5
  187. package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
  188. package/src/prover/smt/solver/seq-re-util.ts +1 -1
  189. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  190. package/src/prover/smt/solver/seq-regex-live.ts +2 -2
  191. package/src/prover/smt/solver/seq-rewriter.ts +31 -29
  192. package/src/prover/smt/solver/seq-skolem.ts +0 -23
  193. package/src/prover/smt/solver/seq-view-witness.ts +4 -4
  194. package/src/prover/smt/solver/smt-consequences.ts +1 -1
  195. package/src/prover/smt/solver/smt-kernel.ts +48 -7
  196. package/src/prover/smt/solver/smt-setup.ts +106 -13
  197. package/src/prover/smt/solver/smtlib-parser.ts +589 -224
  198. package/src/prover/smt/solver/smtlib-script.ts +713 -210
  199. package/src/prover/smt/solver/solve-eqs.ts +36 -37
  200. package/src/prover/smt/solver/solver.ts +18 -3
  201. package/src/prover/smt/solver/tactic.ts +350 -195
  202. package/src/prover/smt/solver/theory-bv.ts +13 -3
  203. package/src/prover/smt/solver/theory-fpa.ts +1 -1
  204. package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
  205. package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
  206. package/src/prover/smt/solver/theory-lra-propagate.ts +11 -3
  207. package/src/prover/smt/solver/theory-lra-state.ts +1 -1
  208. package/src/prover/smt/solver/theory-lra.ts +1 -1
  209. package/src/prover/smt/solver/theory-pb.ts +24 -7
  210. package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
  211. package/src/prover/smt/solver/theory-seq-state.ts +2 -21
  212. package/src/prover/smt/solver/theory-without-terms.ts +24 -0
  213. package/src/prover/smt/solver/tseitin-cnf.ts +1 -0
  214. package/src/prover/tlapm/cache.ts +8 -8
  215. package/src/prover/zenon/index-table.ts +5 -2
  216. package/src/prover/zenon/isar-case.ts +1 -1
  217. package/src/prover/zenon/isar.ts +2 -2
  218. package/src/prover/zenon/phrase.ts +1 -1
  219. package/src/resolve.ts +1274 -257
  220. package/src/runtime.ts +7 -1
  221. package/src/sany/builtins.ts +10 -10
  222. package/src/sany/generation.ts +5 -15
  223. package/src/sany/generator-def-entries.ts +123 -36
  224. package/src/sany/generator-definitions.ts +5 -3
  225. package/src/sany/generator-expressions.ts +60 -37
  226. package/src/sany/generator-proofs.ts +18 -12
  227. package/src/sany/generator.ts +12 -6
  228. package/src/sany/lexer.ts +15 -7
  229. package/src/sany/modules.ts +4 -2
  230. package/src/sany/nodes.ts +1 -1
  231. package/src/sany/selectors.ts +11 -6
  232. package/src/sany/xml.ts +2 -3
  233. package/src/search.ts +319 -135
  234. package/src/simulate.ts +235 -182
  235. package/src/spec-description.ts +8 -6
  236. package/src/standard-definitions.ts +1 -0
  237. package/src/standard-modules.ts +56 -22
  238. package/src/subexpressions.ts +564 -138
  239. package/src/successors.ts +37 -13
  240. package/src/symmetry.ts +2 -1
  241. package/src/tlc/jar-data.ts +10 -0
  242. package/src/tlc/messages.ts +3 -3
  243. package/src/tlc/order.ts +14 -3
  244. package/src/tlc/random.ts +2 -1
  245. package/src/tlc/replay.ts +67 -43
  246. package/src/tlc/tlc-operators.ts +10 -8
  247. package/src/tlc/tlcext-operators.ts +44 -15
  248. package/src/tlc/trace-spec.ts +9 -22
  249. package/src/trace-liveness.ts +529 -0
  250. package/src/typed-tier.ts +52 -31
  251. package/src/typescript/types.ts +2 -2
  252. 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[]> {
@@ -46,10 +47,21 @@ export interface LivenessChecker {
46
47
  tracing?: Environment,
47
48
  ) => number[] | undefined;
48
49
  storeState: (pending: number, index: number) => void;
50
+ getStateCounts: () => number[];
49
51
  findViolation: () => Lasso | undefined;
50
52
  getViolatedProperties: (path: Value[][], cycleStart: number) => string[];
51
53
  }
52
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
+
53
65
  export interface LiveGraph<State> {
54
66
  branches: number;
55
67
  addInitialState: (index: number, state: State) => void;
@@ -58,14 +70,26 @@ export interface LiveGraph<State> {
58
70
  index: number,
59
71
  state: State,
60
72
  successors: LiveSuccessor<State>[],
73
+ isRerun?: boolean,
61
74
  ) => number[] | undefined;
62
75
  storeState: (pending: number, index: number) => void;
76
+ getStateCounts: () => number[];
63
77
  findViolation: () => Lasso | undefined;
64
78
  }
65
79
 
66
80
  export interface SearchGraph<State> {
67
81
  getFingerprint: (successor: LiveSuccessor<State>) => number;
68
- 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;
69
93
  }
70
94
 
71
95
  export interface LiveEvaluation<State> {
@@ -116,6 +140,7 @@ interface BehaviorGraph<State> {
116
140
  nextSiblings: number[];
117
141
  nodeIds: NodeTable;
118
142
  isDone: boolean[];
143
+ stateCount: number;
119
144
  errorNode: number | undefined;
120
145
  }
121
146
 
@@ -248,13 +273,14 @@ const getLiveFormula = (
248
273
  const fairness = temporals.map((item) =>
249
274
  toLiveExpression(item.expression, item.scope, environment),
250
275
  );
251
- const negations = properties.map((property) =>
252
- createUnary("Not", toLiveExpression(property.expression, property.scope, environment)),
276
+ const checks = properties.map((property) =>
277
+ toLiveExpression(property.expression, property.scope, environment),
253
278
  );
279
+ const negations = checks.map((check) => createUnary("Not", check));
254
280
  const violation = negations.length === 1 ? negations[0] : createJunction("Or", negations);
255
281
  const formula =
256
282
  fairness.length === 0 ? violation : createJunction("And", [...fairness, violation]);
257
- return { formula, negations };
283
+ return { formula, checks };
258
284
  };
259
285
 
260
286
  export type LiveAtom = LiveState | LiveEnabled | LiveAction;
@@ -309,28 +335,83 @@ export const getLiveExpressions = (solutions: Solution[]) =>
309
335
  getAtomExpressions(atom).map((item) => item.expression),
310
336
  );
311
337
 
312
- export const createLivenessChecker = (
313
- properties: TemporalProperty[],
314
- temporals: ScopedExpression[],
315
- environment: Environment,
316
- search: SearchGraph<Value[]>,
317
- ): LivenessChecker | undefined => {
318
- if (properties.length === 0) return undefined;
319
- const live = getLiveFormula(properties, temporals, environment);
320
- // A check evaluated once for a state shows what TLC shows when no check repeats an effect. A
321
- // definition TLC evaluates as it starts repeats nothing, but a scope can bind any definition.
338
+ const isSharingResults = (formula: LiveExpression, environment: Environment) => {
322
339
  const formulaAtoms = new Set<LiveAtom>();
323
- collectAtoms(live.formula, formulaAtoms);
340
+ collectAtoms(formula, formulaAtoms);
324
341
  const checked = [...formulaAtoms].flatMap(getAtomExpressions);
325
- const isShared = checked.every((item) => item.scope === undefined)
342
+ return checked.every((item) => item.scope === undefined)
326
343
  ? !isExpressionImpure(
327
344
  checked.map((item) => item.expression),
328
345
  environment,
329
346
  "repeated",
330
347
  )
331
348
  : !hasRepeatedEffects(environment);
332
- 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);
333
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);
413
+ const solutions = getSolutions(live.formula);
414
+ const tracing: Tracing = { atoms: getInterpretedAtoms(environment), replay: undefined };
334
415
  const graph = createLiveGraph(
335
416
  solutions,
336
417
  {
@@ -349,16 +430,22 @@ export const createLivenessChecker = (
349
430
  }
350
431
  },
351
432
  },
352
- search,
433
+ {
434
+ getFingerprint: search.getFingerprint,
435
+ forEachActionSuccessors: (index, state, onSuccessors) =>
436
+ search.forEachActionSuccessors(index, state, onSuccessors, tracing.replay),
437
+ },
353
438
  environment.runtime.version !== "1.7.4",
354
439
  );
355
440
  const traceWith = <Result>(replay: Environment | undefined, run: () => Result) => {
356
441
  if (replay === undefined) return run();
357
442
  tracing.atoms = getInterpretedAtoms(replay);
443
+ tracing.replay = replay;
358
444
  try {
359
445
  return run();
360
446
  } finally {
361
447
  tracing.atoms = getInterpretedAtoms(environment);
448
+ tracing.replay = undefined;
362
449
  }
363
450
  };
364
451
  return {
@@ -367,19 +454,12 @@ export const createLivenessChecker = (
367
454
  addInitialState: (index, state, replay) =>
368
455
  traceWith(replay, () => graph.addInitialState(index, state)),
369
456
  addState: (index, state, successors, replay) =>
370
- traceWith(replay, () => graph.addState(index, state, successors)),
457
+ traceWith(replay, () => graph.addState(index, state, successors, replay !== undefined)),
371
458
  storeState: graph.storeState,
459
+ getStateCounts: graph.getStateCounts,
372
460
  findViolation: graph.findViolation,
373
- getViolatedProperties: (path, cycleStart) => [
374
- ...new Set(
375
- properties
376
- .filter(
377
- (_property, position) =>
378
- !evaluateOnLasso(live.negations[position].body, path, cycleStart, 0, environment),
379
- )
380
- .map((property) => property.name),
381
- ),
382
- ],
461
+ getViolatedProperties: (path, cycleStart) =>
462
+ getViolatedProperties(properties, live.checks, path, cycleStart, environment),
383
463
  };
384
464
  };
385
465
 
@@ -508,6 +588,7 @@ export const createLiveGraph = <State>(
508
588
  nextSiblings: [],
509
589
  nodeIds: { slots: new Int32Array(3 << 10), size: 0, shift: 22 },
510
590
  isDone: [],
591
+ stateCount: 0,
511
592
  errorNode: undefined,
512
593
  }));
513
594
  const checkState = (
@@ -631,8 +712,16 @@ export const createLiveGraph = <State>(
631
712
  writeToPool(behavior.lastNodes, state, [node]);
632
713
  return node;
633
714
  };
634
- const recordNode = (behavior: BehaviorGraph<State>, state: number, tableauNode: number) =>
635
- linkNode(behavior, state, tableauNode, pushNode(behavior, state, tableauNode));
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
+ };
636
725
  // The action results of the edge to each target are at its position in actions.
637
726
  const writeNode = (
638
727
  behavior: BehaviorGraph<State>,
@@ -741,39 +830,57 @@ export const createLiveGraph = <State>(
741
830
  actions.push(0);
742
831
  if (existing === undefined) expandLate(behavior, tableau, state, index, target, row, offset);
743
832
  }
744
- const nextStates = search.getSuccessors(index, state);
745
833
  // The results of the step to the state itself come first, then those of each successor.
746
- const actionResults = new Uint8Array((nextStates.length + 1) * actionCount);
747
- actionResults.set(selfResults);
748
- const edges = createEdgeRows(nextStates.length);
749
- nextStates.forEach((successor, position) => {
750
- const successorRow = createRows(1);
751
- checkAction(
752
- behavior,
753
- index,
754
- state,
755
- row,
756
- offset,
757
- successor.state,
758
- edges,
759
- position * actionIds.size,
760
- actionResults,
761
- (position + 1) * actionCount,
762
- );
763
- const isDone = behavior.isDone[successor.index] === true;
764
- for (const next of tableauNode.successors) {
765
- if (!isConsistent(behavior, next, index, successor.state, successorRow, 0)) continue;
766
- const existing = getNodeId(behavior, successor.index, next);
767
- if (existing !== undefined && successors.includes(existing)) continue;
768
- const target = existing ?? recordNode(behavior, successor.index, next);
769
- successors.push(target);
770
- actions.push(position + 1);
771
- if (existing === undefined && isDone) {
772
- 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
+ }
773
874
  }
774
875
  }
876
+ stepCount += nextStates.length;
775
877
  });
776
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
+ }
777
884
  writeNode(behavior, node, successors, actionResults, actions, stateResults);
778
885
  }
779
886
  };
@@ -799,6 +906,7 @@ export const createLiveGraph = <State>(
799
906
  }
800
907
  }
801
908
  });
909
+ if (!hasState(behavior, index)) behavior.stateCount++;
802
910
  behavior.isDone[index] = true;
803
911
  // TLC expands the nodes recorded before the loop, not the ones the loop records.
804
912
  for (const node of getStateNodes(behavior, index)) {
@@ -848,6 +956,7 @@ export const createLiveGraph = <State>(
848
956
  successors.push(successor.index);
849
957
  actions.push(position);
850
958
  });
959
+ if (!isWritten(behavior, index)) behavior.stateCount++;
851
960
  writeNode(behavior, index, successors, actionResults, actions, stateResults);
852
961
  };
853
962
 
@@ -1126,7 +1235,7 @@ export const createLiveGraph = <State>(
1126
1235
  }
1127
1236
  }
1128
1237
  },
1129
- addState: (index, state, successors) => {
1238
+ addState: (index, state, successors, isRerun) => {
1130
1239
  const set = getSuccessorSet(index, state, successors);
1131
1240
  const rows = createRows(set.length);
1132
1241
  // The set holds the state itself, as a successor of the same index.
@@ -1151,6 +1260,15 @@ export const createLiveGraph = <State>(
1151
1260
  );
1152
1261
  const stateResults = checkState(behavior, index, state, rows, offset);
1153
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
+ }
1154
1272
  if (!tableau) {
1155
1273
  addPlainState(behavior, set, actionResults, stateResults, index);
1156
1274
  continue;
@@ -1183,6 +1301,7 @@ export const createLiveGraph = <State>(
1183
1301
  }
1184
1302
  }
1185
1303
  },
1304
+ getStateCounts: () => behaviors.map((behavior) => behavior.stateCount),
1186
1305
  findViolation: () => {
1187
1306
  for (const behavior of behaviors) {
1188
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,
@@ -243,6 +244,7 @@ export const expandTemporal = (
243
244
  return expression.operands.flatMap((operand) => expand(operand, scope, describeRange(operand)));
244
245
  }
245
246
  if (expression.kind === "Label") return expand(expression.body, scope);
247
+ if (expression.kind === "Selection") return expand(expression.expression, scope);
246
248
  if (expression.kind === "Let") {
247
249
  return expand(expression.body, bindLetDefinitions(expression, scope, environment));
248
250
  }
@@ -323,12 +325,17 @@ export const expandTemporal = (
323
325
  return [{ expression, scope, name: expansion.name, path: expansion.path }];
324
326
  };
325
327
 
326
- const bindLetDefinitions = (
328
+ // TLC takes a formula apart through a LET without binding its definitions, so it evaluates an impure one again at each reference.
329
+ export const bindLetDefinitions = (
327
330
  expression: Expression & { kind: "Let" },
328
331
  scope: Scope | undefined,
329
332
  environment: Environment,
330
333
  ) => {
331
- const bound = bindDefinitions(expression.definitions, getConstantContext(environment, scope));
334
+ const bound = bindDefinitions(
335
+ expression.definitions,
336
+ getConstantContext(environment, scope),
337
+ getReevaluatedDefinitions(expression.definitions, environment),
338
+ );
332
339
  for (let current = bound; current && current !== scope; current = current.parent) {
333
340
  if (current.binding.kind === "Thunk") definitionThunks.add(current.binding);
334
341
  }
@@ -488,12 +495,53 @@ export const toLiveExpression = (
488
495
  return level > ACTION_LEVEL ? parts : toAtom(expression, scope, level);
489
496
  };
490
497
 
498
+ // SANY parses `a /\ b /\ c` as `(a /\ b) /\ c`, so TLC takes a prefix below the temporal level as one formula.
499
+ const convertJunction = (
500
+ expression: Expression & { kind: "And" | "Or" },
501
+ scope: Scope | undefined,
502
+ ) => {
503
+ const operands = expression.operands;
504
+ const range = expression.location.range;
505
+ const prefixEnds = expression.prefixEnds;
506
+ if (expression.isBulleted || !range || !prefixEnds) {
507
+ return toWhole(
508
+ expression,
509
+ scope,
510
+ createJunction(
511
+ expression.kind,
512
+ operands.map((operand) => convert(operand, scope)),
513
+ ),
514
+ );
515
+ }
516
+ return operands.slice(1).reduce(
517
+ (prefix, operand, index) => {
518
+ const node =
519
+ index === operands.length - 2
520
+ ? expression
521
+ : {
522
+ ...expression,
523
+ operands: operands.slice(0, index + 2),
524
+ prefixEnds: prefixEnds.slice(0, index + 1),
525
+ location: { ...expression.location, range: { ...range, end: prefixEnds[index] } },
526
+ };
527
+ return toWhole(
528
+ node,
529
+ scope,
530
+ createJunction(expression.kind, [prefix, convert(operand, scope)]),
531
+ );
532
+ },
533
+ convert(operands[0], scope),
534
+ );
535
+ };
536
+
491
537
  // These forms are translated part by part at every level; any other form below the temporal level is an atom.
492
538
  const convert = (expression: Expression, scope: Scope | undefined): LiveExpression => {
493
539
  const level = getLevel(expression, scope, environment);
494
540
  switch (expression.kind) {
495
541
  case "Label":
496
542
  return convert(expression.body, scope);
543
+ case "Selection":
544
+ return convert(expression.expression, scope);
497
545
  case "Let":
498
546
  return convert(expression.body, bindLetDefinitions(expression, scope, environment));
499
547
  case "Apply": {
@@ -512,14 +560,7 @@ export const toLiveExpression = (
512
560
  }
513
561
  case "And":
514
562
  case "Or":
515
- return toWhole(
516
- expression,
517
- scope,
518
- createJunction(
519
- expression.kind,
520
- expression.operands.map((operand) => convert(operand, scope)),
521
- ),
522
- );
563
+ return convertJunction(expression, scope);
523
564
  case "Forall":
524
565
  case "Exists":
525
566
  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)
package/src/parallel.ts CHANGED
@@ -8,6 +8,7 @@ import {
8
8
  } from "./check";
9
9
  import { parseConfig, type ModelConfig } from "./config";
10
10
  import { TlaEvaluationError } from "./errors";
11
+ import type { RuntimeInvariant } from "./environment";
11
12
  import { isImpure } from "./evaluate";
12
13
  import {
13
14
  createSharedFingerprints,
@@ -43,6 +44,7 @@ export interface StartMessage extends Pick<
43
44
  > {
44
45
  type: "start";
45
46
  config: ModelConfig;
47
+ runtimeInvariants: RuntimeInvariant[];
46
48
  modules: [string, string | undefined][];
47
49
  classes: [string, Uint8Array | undefined][];
48
50
  index: number;
@@ -146,6 +148,8 @@ export const check = async (options: CheckOptions): Promise<CheckResult> => {
146
148
  specification.variableLocations,
147
149
  () => created.order.getDeclarationOrder("variable"),
148
150
  report,
151
+ [],
152
+ specification.runtimeInvariants,
149
153
  );
150
154
  if (findAssumptionViolation(specification.assumptions, environment)) return fallBack();
151
155
  if (
@@ -273,6 +277,7 @@ export const check = async (options: CheckOptions): Promise<CheckResult> => {
273
277
  type: "start",
274
278
  source: options.source,
275
279
  config,
280
+ runtimeInvariants: specification.runtimeInvariants,
276
281
  modules: [...modules],
277
282
  classes: [...classes],
278
283
  index,