tla-ts 0.0.3-dev.949cce6 → 0.0.3-dev.9b15ea6

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 (80) hide show
  1. package/dist/cli.cjs +1 -1
  2. package/dist/cli.js +1 -1
  3. package/dist/index.cjs +1 -1
  4. package/dist/index.d.cts +146 -8
  5. package/dist/index.d.ts +146 -8
  6. package/dist/index.js +1 -1
  7. package/dist/parallel-worker.cjs +1 -1
  8. package/dist/parallel-worker.js +2 -2
  9. package/dist/parallel.cjs +1 -1
  10. package/dist/parallel.js +2 -2
  11. package/dist/run-cli.cjs +1351 -20
  12. package/dist/run-cli.js +1351 -20
  13. package/dist/transfer.cjs +86 -28
  14. package/dist/transfer.js +86 -28
  15. package/package.json +5 -1
  16. package/src/ast.ts +48 -6
  17. package/src/bags.ts +4 -7
  18. package/src/builtins.ts +29 -11
  19. package/src/bundled-modules.ts +3 -3
  20. package/src/canonical.ts +4 -3
  21. package/src/check.ts +1352 -215
  22. package/src/cli.ts +8 -1
  23. package/src/codegen.ts +68 -18
  24. package/src/config.ts +252 -179
  25. package/src/environment.ts +451 -129
  26. package/src/errors.ts +217 -3
  27. package/src/evaluate.ts +724 -117
  28. package/src/exit-codes.ts +5 -4
  29. package/src/index.ts +1 -0
  30. package/src/instances.ts +4 -2
  31. package/src/java-overrides.ts +104 -25
  32. package/src/levels.ts +183 -37
  33. package/src/lexer.ts +14 -1
  34. package/src/live-check.ts +211 -89
  35. package/src/liveness.ts +192 -65
  36. package/src/obligation-expression.ts +2 -2
  37. package/src/obligation-source.ts +2 -0
  38. package/src/parallel-worker.ts +8 -3
  39. package/src/parallel.ts +56 -5
  40. package/src/parser.ts +423 -126
  41. package/src/pcal-ast.ts +770 -0
  42. package/src/pcal-parse.ts +1523 -0
  43. package/src/pcal-tokenize.ts +516 -0
  44. package/src/pcal-translate.ts +1230 -0
  45. package/src/pcal-validate.ts +454 -0
  46. package/src/randomization.ts +24 -7
  47. package/src/resolve.ts +1363 -405
  48. package/src/run-cli.ts +1167 -155
  49. package/src/runtime.ts +16 -0
  50. package/src/sany-builtins.ts +147 -0
  51. package/src/sany-generator.ts +3112 -0
  52. package/src/sany-levels.ts +1208 -0
  53. package/src/sany-lexer.ts +545 -0
  54. package/src/sany-linter.ts +122 -0
  55. package/src/sany-modules.ts +1398 -0
  56. package/src/sany-nodes.ts +463 -0
  57. package/src/sany-parse-error.ts +2161 -0
  58. package/src/sany-report.ts +354 -0
  59. package/src/sany-selectors.ts +738 -0
  60. package/src/sany-source.ts +248 -0
  61. package/src/sany-xml.ts +1017 -0
  62. package/src/spec-description.ts +26 -7
  63. package/src/standard-modules.ts +203 -146
  64. package/src/standard-ranges.ts +116 -0
  65. package/src/state-graph.ts +29 -6
  66. package/src/subexpressions.ts +221 -161
  67. package/src/substitution-levels.ts +38 -17
  68. package/src/successors.ts +162 -114
  69. package/src/symmetry.ts +180 -52
  70. package/src/tableau.ts +4 -2
  71. package/src/tlc-ext.ts +13 -17
  72. package/src/tlc-messages.ts +329 -0
  73. package/src/tlc-module.ts +46 -18
  74. package/src/tlc-order.ts +56 -6
  75. package/src/tlc-random.ts +28 -3
  76. package/src/tlc-replay.ts +655 -0
  77. package/src/tlc-version.ts +18 -0
  78. package/src/transfer.ts +15 -3
  79. package/src/value-sources.ts +29 -0
  80. package/src/values.ts +684 -204
package/src/live-check.ts CHANGED
@@ -1,8 +1,8 @@
1
1
  import { TlaEvaluationError } from "./errors";
2
2
  import { hasRepeatedEffects, type Environment } from "./evaluate";
3
3
  import {
4
+ createTautologyError,
4
5
  evaluateLive,
5
- TAUTOLOGY_MESSAGE,
6
6
  evaluateOnLasso,
7
7
  toLiveExpression,
8
8
  type ScopedExpression,
@@ -28,18 +28,38 @@ export interface LiveSuccessor {
28
28
  export interface Lasso {
29
29
  prefix: number[];
30
30
  cycle: number[];
31
+ // Whether the solution that the lasso violates constrains the cycle, as a liveness property does.
32
+ // TLC warns that a stuttering counterexample to one may come from a missing fairness constraint.
33
+ isCycleConstrained: boolean;
31
34
  }
32
35
 
33
36
  export interface LivenessChecker {
34
- addInitialState: (index: number, state: Value[]) => void;
35
- addState: (index: number, state: Value[], successors: LiveSuccessor[]) => number[] | undefined;
37
+ // How many solutions of the negated properties TLC checks, which it calls branches.
38
+ branches: number;
39
+ // With a tracing environment, the checks record their call stack as TLC's replay of a failed
40
+ // check does.
41
+ addInitialState: (index: number, state: Value[], tracing?: Environment) => void;
42
+ addState: (
43
+ index: number,
44
+ state: Value[],
45
+ successors: LiveSuccessor[],
46
+ tracing?: Environment,
47
+ ) => number[] | undefined;
36
48
  findViolation: () => Lasso | undefined;
37
49
  getViolatedProperties: (path: Value[][], cycleStart: number) => string[];
38
50
  }
39
51
 
40
52
  export interface LiveGraph {
41
- getFingerprint: (index: number) => number;
42
- getSuccessors: (state: Value[]) => LiveSuccessor[];
53
+ getFingerprint: (successor: LiveSuccessor) => number;
54
+ getSuccessors: (index: number, state: Value[]) => LiveSuccessor[];
55
+ }
56
+
57
+ // Numbers in a typed array that doubles as it fills, so a graph of millions of nodes takes a few
58
+ // bytes for each.
59
+ interface Pool<Data extends Int32Array | Uint8Array> {
60
+ data: Data;
61
+ length: number;
62
+ create: (length: number) => Data;
43
63
  }
44
64
 
45
65
  // TLC's behavior graph for one solution: a node per state, or per state and tableau node.
@@ -49,37 +69,115 @@ interface Check {
49
69
  actionIds: Int32Array;
50
70
  nodeStates: number[];
51
71
  nodeTableaux: number[];
52
- successors: number[][];
53
- // Each written node's state results, then its action results edge by edge, from the node's
54
- // offset in one buffer, so a node costs no objects of its own. An unwritten node has offset -1.
55
- offsets: number[];
56
- results: { bytes: Uint8Array; length: number };
72
+ // Where a node's edges start in edgeTargets, or UNWRITTEN until TLC writes the node with its
73
+ // successors, and how many it has.
74
+ edgeStarts: number[];
75
+ edgeCounts: number[];
76
+ edgeTargets: Pool<Int32Array>;
77
+ // The results of the action checks on each edge, and of the state checks on each state, which
78
+ // are the same for every node of the state.
79
+ edgeActions: Pool<Uint8Array>;
80
+ stateResults: Pool<Uint8Array>;
57
81
  initial: number[];
58
- nodeIds: Map<number, number>;
59
- nodesByState: Map<number, number[]>;
82
+ // The nodes of each state in the order the check records them, a list through nextSiblings.
83
+ firstNodes: Pool<Int32Array>;
84
+ lastNodes: Pool<Int32Array>;
85
+ nextSiblings: number[];
60
86
  isDone: boolean[];
61
87
  errorNode: number | undefined;
62
88
  }
63
89
 
90
+ const containsAlways = (expression: LiveExpression): boolean => {
91
+ switch (expression.kind) {
92
+ case "Always":
93
+ return true;
94
+ case "Eventually":
95
+ case "Not":
96
+ case "Next":
97
+ return containsAlways(expression.body);
98
+ case "And":
99
+ case "Or":
100
+ return expression.operands.some(containsAlways);
101
+ default:
102
+ return false;
103
+ }
104
+ };
105
+
106
+ // TLC's OrderOfSolution#hasEmptyPEMAndBoxFreePromises, negated.
107
+ const isCycleConstrained = (solution: Solution) =>
108
+ solution.promises.some((promise) => containsAlways(promise.body)) ||
109
+ solution.models.some(
110
+ (model) =>
111
+ model.eventuallyAlways.length > 0 ||
112
+ model.infinitelyOftenStates.length > 0 ||
113
+ model.infinitelyOftenActions.length > 0,
114
+ );
115
+
64
116
  const isSameState = (left: Value[], right: Value[]) =>
65
117
  left.every((value, position) => isSameValue(value, right[position]));
66
118
 
67
119
  const removeRepeats = (path: number[]) =>
68
120
  path.filter((node, position) => position === 0 || path[position - 1] !== node);
69
121
 
122
+ const createPool = <Data extends Int32Array | Uint8Array>(
123
+ create: (length: number) => Data,
124
+ ): Pool<Data> => ({ data: create(1024), length: 0, create });
125
+
126
+ const writeToPool = <Data extends Int32Array | Uint8Array>(
127
+ pool: Pool<Data>,
128
+ offset: number,
129
+ values: ArrayLike<number>,
130
+ ) => {
131
+ const end = offset + values.length;
132
+ if (end > pool.data.length) {
133
+ const data = pool.create(Math.max(2 * pool.data.length, end));
134
+ data.set(pool.data);
135
+ pool.data = data;
136
+ }
137
+ pool.data.set(values, offset);
138
+ pool.length = Math.max(pool.length, end);
139
+ };
140
+
141
+ const NO_NODE = -1;
142
+
143
+ const createNodes = (length: number) => new Int32Array(length).fill(NO_NODE);
144
+
145
+ const UNWRITTEN = -1;
146
+
147
+ const isWritten = (check: Check, node: number) =>
148
+ (check.edgeStarts[node] ?? UNWRITTEN) !== UNWRITTEN;
149
+
150
+ const getSuccessors = (check: Check, node: number) => {
151
+ const start = check.edgeStarts[node];
152
+ return check.edgeTargets.data.subarray(start, start + check.edgeCounts[node]);
153
+ };
154
+
155
+ const getStateResult = (check: Check, node: number, position: number) =>
156
+ check.stateResults.data[check.nodeStates[node] * check.solution.stateChecks.length + position] ===
157
+ 1;
158
+
70
159
  // A node owns one entry in each of its check's per-node arrays.
71
160
  const pushNode = (check: Check, state: number, tableauNode: number) => {
72
161
  check.nodeStates.push(state);
73
162
  check.nodeTableaux.push(tableauNode);
74
- check.successors.push([]);
75
- check.offsets.push(-1);
163
+ check.edgeStarts.push(UNWRITTEN);
164
+ check.edgeCounts.push(0);
165
+ check.nextSiblings.push(NO_NODE);
76
166
  return check.nodeStates.length - 1;
77
167
  };
78
168
 
79
- const isWritten = (check: Check, node: number) => check.offsets[node] !== -1;
80
-
81
- const getStateResult = (check: Check, node: number, position: number) =>
82
- check.results.bytes[check.offsets[node] + position] === 1;
169
+ // The nodes of the state, in the order the check recorded them.
170
+ const getStateNodes = (check: Check, state: number) => {
171
+ const nodes: number[] = [];
172
+ for (
173
+ let node = check.firstNodes.data[state] ?? NO_NODE;
174
+ node !== NO_NODE;
175
+ node = check.nextSiblings[node]
176
+ ) {
177
+ nodes.push(node);
178
+ }
179
+ return nodes;
180
+ };
83
181
 
84
182
  const SUCCESSOR_CAPACITY = 16;
85
183
 
@@ -107,7 +205,7 @@ export const createLivenessChecker = (
107
205
  fairness.length === 0 ? violation : createJunction("And", [...fairness, violation]);
108
206
  const solutions = getSolutions(formula);
109
207
  if (solutions.length === 0) {
110
- throw new TlaEvaluationError(TAUTOLOGY_MESSAGE);
208
+ throw createTautologyError();
111
209
  }
112
210
  const actionIds = new Map<string, number>();
113
211
  const checks = solutions.map((solution): Check => ({
@@ -120,12 +218,15 @@ export const createLivenessChecker = (
120
218
  }),
121
219
  nodeStates: [],
122
220
  nodeTableaux: [],
123
- successors: [],
124
- offsets: [],
125
- results: { bytes: new Uint8Array(1024), length: 0 },
221
+ edgeStarts: [],
222
+ edgeCounts: [],
223
+ edgeTargets: createPool((length) => new Int32Array(length)),
224
+ edgeActions: createPool((length) => new Uint8Array(length)),
225
+ stateResults: createPool((length) => new Uint8Array(length)),
126
226
  initial: [],
127
- nodeIds: new Map(),
128
- nodesByState: new Map(),
227
+ firstNodes: createPool(createNodes),
228
+ lastNodes: createPool(createNodes),
229
+ nextSiblings: [],
129
230
  isDone: [],
130
231
  errorNode: undefined,
131
232
  }));
@@ -134,6 +235,7 @@ export const createLivenessChecker = (
134
235
  // TLC evaluates every check on its own. Without side effects the order can't show, so the
135
236
  // checks of one state share their results.
136
237
  const isShared = !hasRepeatedEffects(environment);
238
+ const evaluation = { environment };
137
239
  const shared = {
138
240
  states: new Map<Value[], Map<LiveExpression, boolean>>(),
139
241
  actions: new Map<Value[], Map<Value[], Int8Array>>(),
@@ -155,7 +257,7 @@ export const createLivenessChecker = (
155
257
  predicate,
156
258
  state,
157
259
  undefined,
158
- environment,
260
+ evaluation.environment,
159
261
  isShared ? getStateCache(state) : new Map(),
160
262
  );
161
263
  const checkState = (check: Check, source: number, state: Value[]) =>
@@ -169,7 +271,7 @@ export const createLivenessChecker = (
169
271
  const predicates = check.solution.actionChecks;
170
272
  if (!isShared) {
171
273
  return Uint8Array.from(predicates, (predicate) =>
172
- evaluateLive(predicate, state, successor, environment, new Map()) ? 1 : 0,
274
+ evaluateLive(predicate, state, successor, evaluation.environment, new Map()) ? 1 : 0,
173
275
  );
174
276
  }
175
277
  const stateCache = getStateCache(state);
@@ -179,7 +281,13 @@ export const createLivenessChecker = (
179
281
  results.set(successor, known);
180
282
  return Uint8Array.from(check.actionIds, (id, position) => {
181
283
  if (known[id] === -1) {
182
- known[id] = evaluateLive(predicates[position], state, successor, environment, stateCache)
284
+ known[id] = evaluateLive(
285
+ predicates[position],
286
+ state,
287
+ successor,
288
+ evaluation.environment,
289
+ stateCache,
290
+ )
183
291
  ? 1
184
292
  : 0;
185
293
  }
@@ -195,7 +303,10 @@ export const createLivenessChecker = (
195
303
  evaluateFrom(source, () =>
196
304
  tableau.nodes[node].statePredicates.every((predicate) => evaluateState(predicate, state)),
197
305
  );
306
+ // TLC 1.7.4 doesn't stop at a tableau node that accepts every behavior, so it finds a violation
307
+ // of a property like a safety property only in its liveness checks.
198
308
  const isAccepting = (tableau: Tableau, node: number) => {
309
+ if (environment.runtime.version === "1.7.4") return false;
199
310
  const tableauNode = tableau.nodes[node];
200
311
  return (
201
312
  tableauNode.particle.length === 0 &&
@@ -213,38 +324,32 @@ export const createLivenessChecker = (
213
324
 
214
325
  const getNodeId = (check: Check, state: number, tableauNode: number) =>
215
326
  check.solution.tableau
216
- ? check.nodeIds.get(state * check.solution.tableau.nodes.length + tableauNode)
327
+ ? getStateNodes(check, state).find((node) => check.nodeTableaux[node] === tableauNode)
217
328
  : state;
218
329
  const recordNode = (check: Check, state: number, tableauNode: number) => {
219
330
  const node = pushNode(check, state, tableauNode);
220
- check.nodeIds.set(state * (check.solution.tableau?.nodes.length ?? 1) + tableauNode, node);
221
- const siblings = check.nodesByState.get(state);
222
- if (siblings) siblings.push(node);
223
- else check.nodesByState.set(state, [node]);
331
+ const last = check.lastNodes.data[state] ?? NO_NODE;
332
+ if (last === NO_NODE) writeToPool(check.firstNodes, state, [node]);
333
+ else check.nextSiblings[last] = node;
334
+ writeToPool(check.lastNodes, state, [node]);
224
335
  return node;
225
336
  };
226
337
  const writeNode = (
227
338
  check: Check,
228
339
  node: number,
340
+ targets: number[],
229
341
  actions: Uint8Array[],
230
342
  stateResults: Uint8Array,
231
343
  ) => {
344
+ const start = check.edgeTargets.length;
232
345
  const actionCount = check.solution.actionChecks.length;
233
- const results = check.results;
234
- const offset = results.length;
235
- results.length += stateResults.length + actions.length * actionCount;
236
- if (results.length > results.bytes.length) {
237
- const grown = new Uint8Array(Math.max(2 * results.bytes.length, results.length));
238
- grown.set(results.bytes);
239
- results.bytes = grown;
240
- }
241
- results.bytes.set(stateResults, offset);
242
- actions.forEach((edge, position) =>
243
- results.bytes.set(edge, offset + stateResults.length + position * actionCount),
346
+ writeToPool(check.edgeTargets, start, targets);
347
+ actions.forEach((results, position) =>
348
+ writeToPool(check.edgeActions, (start + position) * actionCount, results),
244
349
  );
245
- check.offsets[node] = offset;
246
- // A node gets no successors once written, so it keeps them without spare capacity.
247
- check.successors[node] = check.successors[node].slice();
350
+ writeToPool(check.stateResults, check.nodeStates[node] * stateResults.length, stateResults);
351
+ check.edgeStarts[node] = start;
352
+ check.edgeCounts[node] = targets.length;
248
353
  };
249
354
 
250
355
  // TLC collects a state's successors and the state itself in a SetOfStates, a hash set it
@@ -259,7 +364,7 @@ export const createLivenessChecker = (
259
364
  };
260
365
  const insert = (slots: (LiveSuccessor | undefined)[], successor: LiveSuccessor) => {
261
366
  for (
262
- let slot = (graph.getFingerprint(successor.index) & 0x7fffffff) % slots.length;
367
+ let slot = (graph.getFingerprint(successor) & 0x7fffffff) % slots.length;
263
368
  ;
264
369
  slot = (slot + 1) % slots.length
265
370
  ) {
@@ -297,7 +402,7 @@ export const createLivenessChecker = (
297
402
  const stateResults = checkState(check, index, state);
298
403
  const tableauNode = tableau.nodes[check.nodeTableaux[node]];
299
404
  const actions: Uint8Array[] = [];
300
- const successors = check.successors[node];
405
+ const successors: number[] = [];
301
406
  const selfActions =
302
407
  tableauNode.successors.length > 0
303
408
  ? checkAction(check, index, state, state)
@@ -315,11 +420,14 @@ export const createLivenessChecker = (
315
420
  actions.push(selfActions);
316
421
  if (existing === undefined) expandLate(check, tableau, state, index, target);
317
422
  }
318
- for (const successor of graph.getSuccessors(state)) {
423
+ for (const successor of graph.getSuccessors(index, state)) {
319
424
  const successorActions = checkAction(check, index, state, successor.state);
320
425
  const isDone = check.isDone[successor.index] === true;
321
426
  for (const next of tableauNode.successors) {
322
427
  if (!isConsistent(tableau, next, index, successor.state)) continue;
428
+ // A successor the search never stored follows a violation or an error, after which nothing
429
+ // checks the graph. TLC records its node, which it never expands.
430
+ if (successor.index === -1) continue;
323
431
  const existing = getNodeId(check, successor.index, next);
324
432
  if (existing !== undefined && successors.includes(existing)) continue;
325
433
  const target = existing ?? recordNode(check, successor.index, next);
@@ -330,7 +438,7 @@ export const createLivenessChecker = (
330
438
  }
331
439
  }
332
440
  }
333
- if (successors.length > 0) writeNode(check, node, actions, stateResults);
441
+ if (successors.length > 0) writeNode(check, node, successors, actions, stateResults);
334
442
  };
335
443
 
336
444
  const addTableauState = (
@@ -346,8 +454,8 @@ export const createLivenessChecker = (
346
454
  );
347
455
  check.isDone[index] = true;
348
456
  // TLC expands the nodes recorded before the loop, not the ones the loop records.
349
- for (const node of (check.nodesByState.get(index) ?? []).slice()) {
350
- const successors = check.successors[node];
457
+ for (const node of getStateNodes(check, index)) {
458
+ const successors: number[] = [];
351
459
  const actions: Uint8Array[] = [];
352
460
  set.forEach((successor, position) => {
353
461
  const isDone = check.isDone[successor.index] === true;
@@ -363,7 +471,7 @@ export const createLivenessChecker = (
363
471
  }
364
472
  }
365
473
  });
366
- writeNode(check, node, actions, stateResults);
474
+ writeNode(check, node, successors, actions, stateResults);
367
475
  }
368
476
  if (check.errorNode === undefined) return undefined;
369
477
  return removeRepeats(
@@ -381,14 +489,14 @@ export const createLivenessChecker = (
381
489
  index: number,
382
490
  ) => {
383
491
  while (check.nodeStates.length <= index) pushNode(check, check.nodeStates.length, -1);
384
- const successors = check.successors[index];
492
+ const successors: number[] = [];
385
493
  const actions: Uint8Array[] = [];
386
494
  set.forEach((successor, position) => {
387
495
  if (isWritten(check, successor.index) && successors.includes(successor.index)) return;
388
496
  successors.push(successor.index);
389
497
  actions.push(actionResults[position]);
390
498
  });
391
- writeNode(check, index, actions, stateResults);
499
+ writeNode(check, index, successors, actions, stateResults);
392
500
  return undefined;
393
501
  };
394
502
 
@@ -404,7 +512,7 @@ export const createLivenessChecker = (
404
512
  }
405
513
  for (let position = 0; position < queue.length; position++) {
406
514
  const current = queue[position];
407
- for (const next of check.successors[current]) {
515
+ for (const next of getSuccessors(check, current)) {
408
516
  if (next === current && check.solution.tableau) continue;
409
517
  if (next === target) {
410
518
  const path = [target];
@@ -423,9 +531,8 @@ export const createLivenessChecker = (
423
531
  const findInModel = (check: Check, model: Solution["models"][number]): Lasso | undefined => {
424
532
  const solution = check.solution;
425
533
  const actionCount = solution.actionChecks.length;
426
- const stateCount = solution.stateChecks.length;
427
534
  const getAction = (node: number, edge: number, position: number) =>
428
- check.results.bytes[check.offsets[node] + stateCount + edge * actionCount + position] === 1;
535
+ check.edgeActions.data[(check.edgeStarts[node] + edge) * actionCount + position] === 1;
429
536
  const isAllowed = (node: number, edge: number) =>
430
537
  model.eventuallyAlways.every((position) => getAction(node, edge, position));
431
538
  const links = new Float64Array(check.nodeStates.length).fill(UNVISITED);
@@ -433,7 +540,7 @@ export const createLivenessChecker = (
433
540
  const components: number[] = [];
434
541
 
435
542
  const isStuttering = (node: number) => {
436
- const edge = check.successors[node].indexOf(node);
543
+ const edge = getSuccessors(check, node).indexOf(node);
437
544
  return edge !== -1 && isAllowed(node, edge);
438
545
  };
439
546
  const isFulfilled = (node: number, promise: Solution["promises"][number]) =>
@@ -461,7 +568,7 @@ export const createLivenessChecker = (
461
568
  );
462
569
  const isActionSatisfied = model.infinitelyOftenActions.every((position) =>
463
570
  [...members].some((node) =>
464
- check.successors[node].some(
571
+ getSuccessors(check, node).some(
465
572
  (next, edge) =>
466
573
  members.has(next) && isAllowed(node, edge) && getAction(node, edge, position),
467
574
  ),
@@ -516,8 +623,7 @@ export const createLivenessChecker = (
516
623
  if (remaining.count <= 0) break;
517
624
  const step = { last: -1, unvisited: -1 };
518
625
  const countBeforeActions = remaining.count;
519
- const successors = check.successors[current.node];
520
- const taken = successors.some((next, edge) => {
626
+ const taken = getSuccessors(check, current.node).some((next, edge) => {
521
627
  if (membersByState.has(check.nodeStates[next])) {
522
628
  if (!isMember(next) || !isAllowed(current.node, edge)) return false;
523
629
  step.last = next;
@@ -551,7 +657,8 @@ export const createLivenessChecker = (
551
657
  }
552
658
  current.node = previous;
553
659
  step.unvisited =
554
- check.successors[previous].find((next) => isMember(next) && !seen.has(next)) ?? -1;
660
+ getSuccessors(check, previous).find((next) => isMember(next) && !seen.has(next)) ??
661
+ -1;
555
662
  }
556
663
  take(step.unvisited);
557
664
  seen.add(step.unvisited);
@@ -564,7 +671,11 @@ export const createLivenessChecker = (
564
671
  }
565
672
  const cycleState = prefix[prefix.length - 1];
566
673
  if (postfix[postfix.length - 1] === cycleState) postfix.pop();
567
- return { prefix: prefix.slice(0, -1), cycle: [cycleState, ...postfix.reverse()] };
674
+ return {
675
+ prefix: prefix.slice(0, -1),
676
+ cycle: [cycleState, ...postfix.reverse()],
677
+ isCycleConstrained: isCycleConstrained(solution),
678
+ };
568
679
  };
569
680
 
570
681
  // TLC's LiveWorker#bfsPostFix, the states from the walk's end back to the root, last first.
@@ -581,7 +692,7 @@ export const createLivenessChecker = (
581
692
  const queue: [number, number][] = [];
582
693
  for (let state = start, parent = -1, position = 0; ; position++) {
583
694
  for (const node of membersByState.get(state) ?? []) {
584
- for (const [edge, next] of check.successors[node].entries()) {
695
+ for (const [edge, next] of getSuccessors(check, node).entries()) {
585
696
  if (next === node || !isAllowedEdge(node, edge)) continue;
586
697
  if (next === root) {
587
698
  const path: number[] = [];
@@ -634,7 +745,7 @@ export const createLivenessChecker = (
634
745
  stack.push(lowLink, node, SCC_MARKER);
635
746
  components.push(node);
636
747
  const nextLowLink = { value: counter.link++ };
637
- check.successors[node].forEach((next, edge) => {
748
+ getSuccessors(check, node).forEach((next, edge) => {
638
749
  if (!isWritten(check, next)) return;
639
750
  if (!isAllowed(node, edge)) {
640
751
  if (links[next] === UNVISITED) queue.push(next);
@@ -650,37 +761,48 @@ export const createLivenessChecker = (
650
761
  };
651
762
 
652
763
  return {
653
- addInitialState: (index, state) => {
764
+ branches: checks.length,
765
+ addInitialState: (index, state, tracing) => {
766
+ evaluation.environment = tracing ?? environment;
654
767
  shared.states.clear();
655
768
  shared.actions.clear();
656
- for (const check of checks) {
657
- const tableau = check.solution.tableau;
658
- if (!tableau) {
659
- check.initial.push(index);
660
- continue;
661
- }
662
- for (let node = 0; node < tableau.initialCount; node++) {
663
- if (!isConsistent(tableau, node, undefined, state)) continue;
664
- check.initial.push(getNodeId(check, index, node) ?? recordNode(check, index, node));
769
+ try {
770
+ for (const check of checks) {
771
+ const tableau = check.solution.tableau;
772
+ if (!tableau) {
773
+ check.initial.push(index);
774
+ continue;
775
+ }
776
+ for (let node = 0; node < tableau.initialCount; node++) {
777
+ if (!isConsistent(tableau, node, undefined, state)) continue;
778
+ check.initial.push(getNodeId(check, index, node) ?? recordNode(check, index, node));
779
+ }
665
780
  }
781
+ } finally {
782
+ evaluation.environment = environment;
666
783
  }
667
784
  },
668
- addState: (index, state, successors) => {
785
+ addState: (index, state, successors, tracing) => {
786
+ evaluation.environment = tracing ?? environment;
669
787
  shared.states.clear();
670
788
  shared.actions.clear();
671
- const set = getSuccessorSet(index, state, successors);
672
- for (const check of checks) {
673
- const actionResults = set.map((successor) =>
674
- checkAction(check, index, state, successor.state),
675
- );
676
- const stateResults = checkState(check, index, state);
677
- const tableau = check.solution.tableau;
678
- const accepted = tableau
679
- ? addTableauState(check, tableau, set, actionResults, stateResults, index)
680
- : addPlainState(check, set, actionResults, stateResults, index);
681
- if (accepted) return accepted;
789
+ try {
790
+ const set = getSuccessorSet(index, state, successors);
791
+ for (const check of checks) {
792
+ const actionResults = set.map((successor) =>
793
+ checkAction(check, index, state, successor.state),
794
+ );
795
+ const stateResults = checkState(check, index, state);
796
+ const tableau = check.solution.tableau;
797
+ const accepted = tableau
798
+ ? addTableauState(check, tableau, set, actionResults, stateResults, index)
799
+ : addPlainState(check, set, actionResults, stateResults, index);
800
+ if (accepted) return accepted;
801
+ }
802
+ return undefined;
803
+ } finally {
804
+ evaluation.environment = environment;
682
805
  }
683
- return undefined;
684
806
  },
685
807
  findViolation: () => {
686
808
  for (const check of checks) {