tla-ts 0.0.10-dev.37a75eb5b → 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 (229) hide show
  1. package/dist/compile.cjs +3 -3
  2. package/dist/compile.js +1 -1
  3. package/dist/deciders.cjs +33 -33
  4. package/dist/deciders.js +53 -53
  5. package/dist/index.cjs +1 -1
  6. package/dist/index.d.cts +17 -3
  7. package/dist/index.d.ts +17 -3
  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 +55 -55
  14. package/dist/prove.js +78 -78
  15. package/dist/run.cjs +40 -42
  16. package/dist/run.js +42 -44
  17. package/dist/tlapm.cjs +1 -1
  18. package/dist/tlapm.js +2 -2
  19. package/dist/transfer.cjs +96 -91
  20. package/dist/transfer.js +95 -90
  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 +12 -10
  26. package/src/builtins.ts +4 -3
  27. package/src/check-failure.ts +13 -11
  28. package/src/check-trace.ts +146 -93
  29. package/src/check.ts +418 -246
  30. package/src/cli/tlc-output.ts +17 -2
  31. package/src/cli/tlc.ts +5 -4
  32. package/src/cli/xml-exporter.ts +1 -1
  33. package/src/codegen.ts +23 -10
  34. package/src/coverage.ts +255 -18
  35. package/src/dependencies.ts +68 -15
  36. package/src/dfid.ts +93 -35
  37. package/src/environment.ts +106 -39
  38. package/src/errors.ts +7 -0
  39. package/src/evaluate.ts +415 -132
  40. package/src/exit-codes.ts +28 -15
  41. package/src/instances.ts +135 -11
  42. package/src/java-hash.ts +14 -0
  43. package/src/java-overrides.ts +2 -2
  44. package/src/levels.ts +674 -236
  45. package/src/lexer.ts +12 -2
  46. package/src/liveness-checker.ts +161 -60
  47. package/src/liveness.ts +55 -10
  48. package/src/obligations/index.ts +1 -1
  49. package/src/obligations/normalize.ts +1 -4
  50. package/src/obligations/printer.ts +5 -5
  51. package/src/obligations/source.ts +2 -0
  52. package/src/parser.ts +110 -111
  53. package/src/prover/isabelle/isar/attrib.ts +4 -4
  54. package/src/prover/isabelle/isar/rule-cases.ts +8 -6
  55. package/src/prover/isabelle/provers/clasimp.ts +1 -1
  56. package/src/prover/isabelle/provers/hypsubst.ts +2 -2
  57. package/src/prover/isabelle/pure/rewriter.ts +3 -3
  58. package/src/prover/isabelle/pure/term.ts +3 -3
  59. package/src/prover/prep/md5.ts +26 -29
  60. package/src/prover/smt/rewrite.ts +2 -7
  61. package/src/prover/smt/simplify.ts +1 -1
  62. package/src/prover/smt/solver/arith-rewriter.ts +11 -3
  63. package/src/prover/smt/solver/array-rewriter.ts +12 -2
  64. package/src/prover/smt/solver/asserted-formulas.ts +164 -58
  65. package/src/prover/smt/solver/ast-lt.ts +1 -1
  66. package/src/prover/smt/solver/ast.ts +65 -13
  67. package/src/prover/smt/solver/auf-solver.ts +23 -12
  68. package/src/prover/smt/solver/bit-blast-tactic.ts +27 -1
  69. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  70. package/src/prover/smt/solver/bound-simplifier.ts +11 -13
  71. package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
  72. package/src/prover/smt/solver/bv-rewriter.ts +1 -1
  73. package/src/prover/smt/solver/card2bv.ts +35 -18
  74. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
  75. package/src/prover/smt/solver/context.ts +65 -14
  76. package/src/prover/smt/solver/ctx-simplify.ts +1 -2
  77. package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
  78. package/src/prover/smt/solver/dependent-expr-state.ts +28 -16
  79. package/src/prover/smt/solver/diff-neq.ts +1 -2
  80. package/src/prover/smt/solver/dt2bv-tactic.ts +57 -21
  81. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  82. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  83. package/src/prover/smt/solver/elim-uncnstr.ts +5 -8
  84. package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
  85. package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
  86. package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
  87. package/src/prover/smt/solver/euf/egraph.ts +3 -9
  88. package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
  89. package/src/prover/smt/solver/euf/mam.ts +1 -5
  90. package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
  91. package/src/prover/smt/solver/euf/th-solver.ts +0 -7
  92. package/src/prover/smt/solver/fd-solver.ts +608 -141
  93. package/src/prover/smt/solver/fix-dl-var.ts +1 -2
  94. package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
  95. package/src/prover/smt/solver/goal.ts +4 -3
  96. package/src/prover/smt/solver/hashtable.ts +4 -0
  97. package/src/prover/smt/solver/internalizer.ts +1 -1
  98. package/src/prover/smt/solver/logic-tactics.ts +15 -5
  99. package/src/prover/smt/solver/lp/core-solver.ts +12 -8
  100. package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
  101. package/src/prover/smt/solver/lp/lp-settings.ts +6 -2
  102. package/src/prover/smt/solver/lp/nla-grobner.ts +2 -2
  103. package/src/prover/smt/solver/lp/pdd.ts +2 -3
  104. package/src/prover/smt/solver/lp/union-find.ts +1 -1
  105. package/src/prover/smt/solver/mam-compiler.ts +1 -1
  106. package/src/prover/smt/solver/maxcore.ts +2 -1
  107. package/src/prover/smt/solver/maxsmt-base.ts +1 -0
  108. package/src/prover/smt/solver/model-based-opt.ts +1 -1
  109. package/src/prover/smt/solver/model-checker.ts +1 -1
  110. package/src/prover/smt/solver/model-evaluator.ts +2 -0
  111. package/src/prover/smt/solver/model-generator.ts +85 -43
  112. package/src/prover/smt/solver/mpf.ts +2 -4
  113. package/src/prover/smt/solver/mus.ts +2 -3
  114. package/src/prover/smt/solver/muz/dl-context.ts +14 -42
  115. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
  116. package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
  117. package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
  118. package/src/prover/smt/solver/muz/hnf.ts +2 -2
  119. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
  120. package/src/prover/smt/solver/muz/horn-tactic.ts +15 -2
  121. package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
  122. package/src/prover/smt/solver/muz/spacer-context.ts +1 -4
  123. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
  124. package/src/prover/smt/solver/nlqsat.ts +1 -1
  125. package/src/prover/smt/solver/nlsat/algebraic.ts +4 -5
  126. package/src/prover/smt/solver/nlsat/levelwise.ts +0 -4
  127. package/src/prover/smt/solver/nlsat/polynomial.ts +1 -36
  128. package/src/prover/smt/solver/nlsat/upolynomial.ts +1 -1
  129. package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
  130. package/src/prover/smt/solver/nnf.ts +6 -2
  131. package/src/prover/smt/solver/opt-context.ts +16 -7
  132. package/src/prover/smt/solver/opt-pareto.ts +19 -0
  133. package/src/prover/smt/solver/opt-preprocess.ts +1 -1
  134. package/src/prover/smt/solver/opt-solver.ts +4 -3
  135. package/src/prover/smt/solver/optsmt.ts +1 -1
  136. package/src/prover/smt/solver/parallel-tactic.ts +1 -1
  137. package/src/prover/smt/solver/pb-rewriter.ts +1 -4
  138. package/src/prover/smt/solver/poly-rewriter.ts +75 -18
  139. package/src/prover/smt/solver/probes.ts +88 -23
  140. package/src/prover/smt/solver/proto-model.ts +8 -8
  141. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  142. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
  143. package/src/prover/smt/solver/qe-lite.ts +2 -2
  144. package/src/prover/smt/solver/qe.ts +3 -2
  145. package/src/prover/smt/solver/qsat.ts +23 -8
  146. package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
  147. package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
  148. package/src/prover/smt/solver/rewriter.ts +31 -25
  149. package/src/prover/smt/solver/rlimit.ts +7 -3
  150. package/src/prover/smt/solver/sat/config.ts +1 -1
  151. package/src/prover/smt/solver/sat/goal2sat.ts +65 -12
  152. package/src/prover/smt/solver/sat/inc-sat-solver.ts +129 -43
  153. package/src/prover/smt/solver/sat/model-converter.ts +1 -1
  154. package/src/prover/smt/solver/sat/pb-constraint.ts +7 -0
  155. package/src/prover/smt/solver/sat/pb-solver.ts +26 -7
  156. package/src/prover/smt/solver/sat/sat-tactic.ts +15 -6
  157. package/src/prover/smt/solver/sat/sat2goal.ts +72 -48
  158. package/src/prover/smt/solver/sat/simplifier.ts +1 -1
  159. package/src/prover/smt/solver/sat/solver.ts +27 -47
  160. package/src/prover/smt/solver/seq-axioms.ts +20 -35
  161. package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
  162. package/src/prover/smt/solver/seq-derive.ts +1 -1
  163. package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
  164. package/src/prover/smt/solver/seq-monadic.ts +7 -5
  165. package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
  166. package/src/prover/smt/solver/seq-re-util.ts +1 -1
  167. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  168. package/src/prover/smt/solver/seq-regex-live.ts +2 -2
  169. package/src/prover/smt/solver/seq-rewriter.ts +31 -29
  170. package/src/prover/smt/solver/seq-skolem.ts +0 -23
  171. package/src/prover/smt/solver/seq-view-witness.ts +4 -4
  172. package/src/prover/smt/solver/smt-consequences.ts +1 -1
  173. package/src/prover/smt/solver/smt-kernel.ts +40 -6
  174. package/src/prover/smt/solver/smt-setup.ts +106 -13
  175. package/src/prover/smt/solver/smtlib-parser.ts +579 -214
  176. package/src/prover/smt/solver/smtlib-script.ts +600 -170
  177. package/src/prover/smt/solver/solve-eqs.ts +36 -37
  178. package/src/prover/smt/solver/solver.ts +18 -3
  179. package/src/prover/smt/solver/tactic.ts +342 -196
  180. package/src/prover/smt/solver/theory-bv.ts +13 -3
  181. package/src/prover/smt/solver/theory-fpa.ts +1 -1
  182. package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
  183. package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
  184. package/src/prover/smt/solver/theory-lra-propagate.ts +11 -3
  185. package/src/prover/smt/solver/theory-lra-state.ts +1 -1
  186. package/src/prover/smt/solver/theory-lra.ts +1 -1
  187. package/src/prover/smt/solver/theory-pb.ts +24 -7
  188. package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
  189. package/src/prover/smt/solver/theory-seq-state.ts +2 -21
  190. package/src/prover/smt/solver/theory-without-terms.ts +24 -0
  191. package/src/prover/smt/solver/tseitin-cnf.ts +1 -0
  192. package/src/prover/tlapm/cache.ts +8 -8
  193. package/src/prover/zenon/index-table.ts +5 -2
  194. package/src/prover/zenon/isar-case.ts +1 -1
  195. package/src/prover/zenon/isar.ts +2 -2
  196. package/src/prover/zenon/phrase.ts +1 -1
  197. package/src/resolve.ts +1226 -246
  198. package/src/runtime.ts +19 -2
  199. package/src/sany/builtins.ts +10 -10
  200. package/src/sany/generation.ts +4 -2
  201. package/src/sany/generator-def-entries.ts +123 -36
  202. package/src/sany/generator-definitions.ts +4 -2
  203. package/src/sany/generator-expressions.ts +51 -20
  204. package/src/sany/generator-proofs.ts +17 -11
  205. package/src/sany/generator.ts +11 -5
  206. package/src/sany/lexer.ts +15 -7
  207. package/src/sany/modules.ts +4 -2
  208. package/src/sany/nodes.ts +1 -1
  209. package/src/sany/selectors.ts +11 -6
  210. package/src/sany/xml.ts +2 -3
  211. package/src/search.ts +283 -126
  212. package/src/simulate.ts +247 -185
  213. package/src/spec-description.ts +15 -7
  214. package/src/standard-definitions.ts +1 -0
  215. package/src/standard-modules.ts +56 -22
  216. package/src/subexpressions.ts +563 -139
  217. package/src/successors.ts +50 -20
  218. package/src/symmetry.ts +2 -1
  219. package/src/tlc/jar-data.ts +1 -3
  220. package/src/tlc/messages.ts +3 -3
  221. package/src/tlc/random.ts +2 -1
  222. package/src/tlc/replay.ts +147 -46
  223. package/src/tlc/tlc-operators.ts +10 -8
  224. package/src/tlc/tlcext-operators.ts +26 -10
  225. package/src/tlc/trace-spec.ts +9 -22
  226. package/src/trace-liveness.ts +529 -0
  227. package/src/typed-tier.ts +52 -31
  228. package/src/typescript/types.ts +2 -2
  229. 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[]> {
@@ -51,6 +52,16 @@ export interface LivenessChecker {
51
52
  getViolatedProperties: (path: Value[][], cycleStart: number) => string[];
52
53
  }
53
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
+
54
65
  export interface LiveGraph<State> {
55
66
  branches: number;
56
67
  addInitialState: (index: number, state: State) => void;
@@ -59,16 +70,26 @@ export interface LiveGraph<State> {
59
70
  index: number,
60
71
  state: State,
61
72
  successors: LiveSuccessor<State>[],
73
+ isRerun?: boolean,
62
74
  ) => number[] | undefined;
63
75
  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
76
  getStateCounts: () => number[];
66
77
  findViolation: () => Lasso | undefined;
67
78
  }
68
79
 
69
80
  export interface SearchGraph<State> {
70
81
  getFingerprint: (successor: LiveSuccessor<State>) => number;
71
- 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;
72
93
  }
73
94
 
74
95
  export interface LiveEvaluation<State> {
@@ -252,13 +273,14 @@ const getLiveFormula = (
252
273
  const fairness = temporals.map((item) =>
253
274
  toLiveExpression(item.expression, item.scope, environment),
254
275
  );
255
- const negations = properties.map((property) =>
256
- createUnary("Not", toLiveExpression(property.expression, property.scope, environment)),
276
+ const checks = properties.map((property) =>
277
+ toLiveExpression(property.expression, property.scope, environment),
257
278
  );
279
+ const negations = checks.map((check) => createUnary("Not", check));
258
280
  const violation = negations.length === 1 ? negations[0] : createJunction("Or", negations);
259
281
  const formula =
260
282
  fairness.length === 0 ? violation : createJunction("And", [...fairness, violation]);
261
- return { formula, negations };
283
+ return { formula, checks };
262
284
  };
263
285
 
264
286
  export type LiveAtom = LiveState | LiveEnabled | LiveAction;
@@ -313,28 +335,83 @@ export const getLiveExpressions = (solutions: Solution[]) =>
313
335
  getAtomExpressions(atom).map((item) => item.expression),
314
336
  );
315
337
 
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.
338
+ const isSharingResults = (formula: LiveExpression, environment: Environment) => {
326
339
  const formulaAtoms = new Set<LiveAtom>();
327
- collectAtoms(live.formula, formulaAtoms);
340
+ collectAtoms(formula, formulaAtoms);
328
341
  const checked = [...formulaAtoms].flatMap(getAtomExpressions);
329
- const isShared = checked.every((item) => item.scope === undefined)
342
+ return checked.every((item) => item.scope === undefined)
330
343
  ? !isExpressionImpure(
331
344
  checked.map((item) => item.expression),
332
345
  environment,
333
346
  "repeated",
334
347
  )
335
348
  : !hasRepeatedEffects(environment);
336
- 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);
337
413
  const solutions = getSolutions(live.formula);
414
+ const tracing: Tracing = { atoms: getInterpretedAtoms(environment), replay: undefined };
338
415
  const graph = createLiveGraph(
339
416
  solutions,
340
417
  {
@@ -353,16 +430,22 @@ export const createLivenessChecker = (
353
430
  }
354
431
  },
355
432
  },
356
- search,
433
+ {
434
+ getFingerprint: search.getFingerprint,
435
+ forEachActionSuccessors: (index, state, onSuccessors) =>
436
+ search.forEachActionSuccessors(index, state, onSuccessors, tracing.replay),
437
+ },
357
438
  environment.runtime.version !== "1.7.4",
358
439
  );
359
440
  const traceWith = <Result>(replay: Environment | undefined, run: () => Result) => {
360
441
  if (replay === undefined) return run();
361
442
  tracing.atoms = getInterpretedAtoms(replay);
443
+ tracing.replay = replay;
362
444
  try {
363
445
  return run();
364
446
  } finally {
365
447
  tracing.atoms = getInterpretedAtoms(environment);
448
+ tracing.replay = undefined;
366
449
  }
367
450
  };
368
451
  return {
@@ -371,20 +454,12 @@ export const createLivenessChecker = (
371
454
  addInitialState: (index, state, replay) =>
372
455
  traceWith(replay, () => graph.addInitialState(index, state)),
373
456
  addState: (index, state, successors, replay) =>
374
- traceWith(replay, () => graph.addState(index, state, successors)),
457
+ traceWith(replay, () => graph.addState(index, state, successors, replay !== undefined)),
375
458
  storeState: graph.storeState,
376
459
  getStateCounts: graph.getStateCounts,
377
460
  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
- ],
461
+ getViolatedProperties: (path, cycleStart) =>
462
+ getViolatedProperties(properties, live.checks, path, cycleStart, environment),
388
463
  };
389
464
  };
390
465
 
@@ -637,7 +712,6 @@ export const createLiveGraph = <State>(
637
712
  writeToPool(behavior.lastNodes, state, [node]);
638
713
  return node;
639
714
  };
640
- // TLC's table of tableau nodes has a state once the search expands it or it has a node.
641
715
  const hasState = (behavior: BehaviorGraph<State>, state: number) =>
642
716
  state < 0
643
717
  ? behavior.checks.nodes.some(
@@ -756,39 +830,57 @@ export const createLiveGraph = <State>(
756
830
  actions.push(0);
757
831
  if (existing === undefined) expandLate(behavior, tableau, state, index, target, row, offset);
758
832
  }
759
- const nextStates = search.getSuccessors(index, state);
760
833
  // 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
- );
778
- const isDone = behavior.isDone[successor.index] === true;
779
- for (const next of tableauNode.successors) {
780
- if (!isConsistent(behavior, next, index, successor.state, successorRow, 0)) continue;
781
- const existing = getNodeId(behavior, successor.index, next);
782
- if (existing !== undefined && successors.includes(existing)) continue;
783
- const target = existing ?? recordNode(behavior, successor.index, next);
784
- successors.push(target);
785
- actions.push(position + 1);
786
- if (existing === undefined && isDone) {
787
- 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
+ }
788
874
  }
789
875
  }
876
+ stepCount += nextStates.length;
790
877
  });
791
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
+ }
792
884
  writeNode(behavior, node, successors, actionResults, actions, stateResults);
793
885
  }
794
886
  };
@@ -1143,7 +1235,7 @@ export const createLiveGraph = <State>(
1143
1235
  }
1144
1236
  }
1145
1237
  },
1146
- addState: (index, state, successors) => {
1238
+ addState: (index, state, successors, isRerun) => {
1147
1239
  const set = getSuccessorSet(index, state, successors);
1148
1240
  const rows = createRows(set.length);
1149
1241
  // The set holds the state itself, as a successor of the same index.
@@ -1168,6 +1260,15 @@ export const createLiveGraph = <State>(
1168
1260
  );
1169
1261
  const stateResults = checkState(behavior, index, state, rows, offset);
1170
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
+ }
1171
1272
  if (!tableau) {
1172
1273
  addPlainState(behavior, set, actionResults, stateResults, index);
1173
1274
  continue;
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");