tla-ts 0.0.3-dev.a57ca4f → 0.0.3-dev.a91da46

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 (81) 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 +148 -8
  5. package/dist/index.d.ts +148 -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 +52 -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 +1358 -219
  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 +723 -116
  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 +32 -4
  34. package/src/live-check.ts +220 -103
  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 +436 -128
  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 +1364 -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 +160 -105
  69. package/src/symmetry.ts +180 -52
  70. package/src/tableau.ts +54 -25
  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 +37 -9
  76. package/src/tlc-replay.ts +655 -0
  77. package/src/tlc-summary.ts +20 -5
  78. package/src/tlc-version.ts +18 -0
  79. package/src/transfer.ts +15 -3
  80. package/src/value-sources.ts +29 -0
  81. package/src/values.ts +680 -178
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,
@@ -12,6 +12,7 @@ import {
12
12
  createJunction,
13
13
  createUnary,
14
14
  getSolutions,
15
+ getTermKey,
15
16
  isFulfilling,
16
17
  type LiveExpression,
17
18
  type Solution,
@@ -27,18 +28,38 @@ export interface LiveSuccessor {
27
28
  export interface Lasso {
28
29
  prefix: number[];
29
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;
30
34
  }
31
35
 
32
36
  export interface LivenessChecker {
33
- addInitialState: (index: number, state: Value[]) => void;
34
- 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;
35
48
  findViolation: () => Lasso | undefined;
36
49
  getViolatedProperties: (path: Value[][], cycleStart: number) => string[];
37
50
  }
38
51
 
39
52
  export interface LiveGraph {
40
- getFingerprint: (index: number) => number;
41
- 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;
42
63
  }
43
64
 
44
65
  // TLC's behavior graph for one solution: a node per state, or per state and tableau node.
@@ -48,54 +69,116 @@ interface Check {
48
69
  actionIds: Int32Array;
49
70
  nodeStates: number[];
50
71
  nodeTableaux: number[];
51
- successors: number[][];
52
- actions: Uint8Array[];
53
- stateResults: Uint8Array[];
54
- isWritten: boolean[];
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>;
55
81
  initial: number[];
56
- nodeIds: Map<number, number>;
57
- 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[];
58
86
  isDone: boolean[];
59
87
  errorNode: number | undefined;
60
88
  }
61
89
 
62
- const liveKeys = new WeakMap<LiveExpression, string>();
63
-
64
- const atomCount = { value: 0 };
65
-
66
- // Each solution builds its own junctions over shared atoms, so equal checks get equal keys.
67
- const getLiveKey = (expression: LiveExpression): string => {
68
- const cached = liveKeys.get(expression);
69
- if (cached !== undefined) return cached;
70
- const key =
71
- expression.kind === "Boolean"
72
- ? String(expression.value)
73
- : "body" in expression
74
- ? `${expression.kind}(${getLiveKey(expression.body)})`
75
- : "operands" in expression
76
- ? `${expression.kind}(${expression.operands.map(getLiveKey).join(",")})`
77
- : `${expression.kind}#${atomCount.value++}`;
78
- liveKeys.set(expression, key);
79
- return key;
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
+ }
80
104
  };
81
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
+
82
116
  const isSameState = (left: Value[], right: Value[]) =>
83
117
  left.every((value, position) => isSameValue(value, right[position]));
84
118
 
85
119
  const removeRepeats = (path: number[]) =>
86
120
  path.filter((node, position) => position === 0 || path[position - 1] !== node);
87
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
+
88
159
  // A node owns one entry in each of its check's per-node arrays.
89
160
  const pushNode = (check: Check, state: number, tableauNode: number) => {
90
161
  check.nodeStates.push(state);
91
162
  check.nodeTableaux.push(tableauNode);
92
- check.successors.push([]);
93
- check.actions.push(new Uint8Array(0));
94
- check.stateResults.push(new Uint8Array(0));
95
- check.isWritten.push(false);
163
+ check.edgeStarts.push(UNWRITTEN);
164
+ check.edgeCounts.push(0);
165
+ check.nextSiblings.push(NO_NODE);
96
166
  return check.nodeStates.length - 1;
97
167
  };
98
168
 
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
+ };
181
+
99
182
  const SUCCESSOR_CAPACITY = 16;
100
183
 
101
184
  const SCC_MARKER = -42;
@@ -122,26 +205,28 @@ export const createLivenessChecker = (
122
205
  fairness.length === 0 ? violation : createJunction("And", [...fairness, violation]);
123
206
  const solutions = getSolutions(formula);
124
207
  if (solutions.length === 0) {
125
- throw new TlaEvaluationError(TAUTOLOGY_MESSAGE);
208
+ throw createTautologyError();
126
209
  }
127
210
  const actionIds = new Map<string, number>();
128
211
  const checks = solutions.map((solution): Check => ({
129
212
  solution,
130
213
  actionIds: Int32Array.from(solution.actionChecks, (predicate) => {
131
- const key = getLiveKey(predicate);
214
+ const key = getTermKey(predicate);
132
215
  const id = actionIds.get(key) ?? actionIds.size;
133
216
  actionIds.set(key, id);
134
217
  return id;
135
218
  }),
136
219
  nodeStates: [],
137
220
  nodeTableaux: [],
138
- successors: [],
139
- actions: [],
140
- stateResults: [],
141
- isWritten: [],
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)),
142
226
  initial: [],
143
- nodeIds: new Map(),
144
- nodesByState: new Map(),
227
+ firstNodes: createPool(createNodes),
228
+ lastNodes: createPool(createNodes),
229
+ nextSiblings: [],
145
230
  isDone: [],
146
231
  errorNode: undefined,
147
232
  }));
@@ -150,6 +235,7 @@ export const createLivenessChecker = (
150
235
  // TLC evaluates every check on its own. Without side effects the order can't show, so the
151
236
  // checks of one state share their results.
152
237
  const isShared = !hasRepeatedEffects(environment);
238
+ const evaluation = { environment };
153
239
  const shared = {
154
240
  states: new Map<Value[], Map<LiveExpression, boolean>>(),
155
241
  actions: new Map<Value[], Map<Value[], Int8Array>>(),
@@ -171,7 +257,7 @@ export const createLivenessChecker = (
171
257
  predicate,
172
258
  state,
173
259
  undefined,
174
- environment,
260
+ evaluation.environment,
175
261
  isShared ? getStateCache(state) : new Map(),
176
262
  );
177
263
  const checkState = (check: Check, source: number, state: Value[]) =>
@@ -185,7 +271,7 @@ export const createLivenessChecker = (
185
271
  const predicates = check.solution.actionChecks;
186
272
  if (!isShared) {
187
273
  return Uint8Array.from(predicates, (predicate) =>
188
- evaluateLive(predicate, state, successor, environment, new Map()) ? 1 : 0,
274
+ evaluateLive(predicate, state, successor, evaluation.environment, new Map()) ? 1 : 0,
189
275
  );
190
276
  }
191
277
  const stateCache = getStateCache(state);
@@ -195,7 +281,13 @@ export const createLivenessChecker = (
195
281
  results.set(successor, known);
196
282
  return Uint8Array.from(check.actionIds, (id, position) => {
197
283
  if (known[id] === -1) {
198
- 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
+ )
199
291
  ? 1
200
292
  : 0;
201
293
  }
@@ -211,7 +303,10 @@ export const createLivenessChecker = (
211
303
  evaluateFrom(source, () =>
212
304
  tableau.nodes[node].statePredicates.every((predicate) => evaluateState(predicate, state)),
213
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.
214
308
  const isAccepting = (tableau: Tableau, node: number) => {
309
+ if (environment.runtime.version === "1.7.4") return false;
215
310
  const tableauNode = tableau.nodes[node];
216
311
  return (
217
312
  tableauNode.particle.length === 0 &&
@@ -229,28 +324,32 @@ export const createLivenessChecker = (
229
324
 
230
325
  const getNodeId = (check: Check, state: number, tableauNode: number) =>
231
326
  check.solution.tableau
232
- ? check.nodeIds.get(state * check.solution.tableau.nodes.length + tableauNode)
327
+ ? getStateNodes(check, state).find((node) => check.nodeTableaux[node] === tableauNode)
233
328
  : state;
234
329
  const recordNode = (check: Check, state: number, tableauNode: number) => {
235
330
  const node = pushNode(check, state, tableauNode);
236
- check.nodeIds.set(state * (check.solution.tableau?.nodes.length ?? 1) + tableauNode, node);
237
- const siblings = check.nodesByState.get(state);
238
- if (siblings) siblings.push(node);
239
- 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]);
240
335
  return node;
241
336
  };
242
337
  const writeNode = (
243
338
  check: Check,
244
339
  node: number,
340
+ targets: number[],
245
341
  actions: Uint8Array[],
246
342
  stateResults: Uint8Array,
247
343
  ) => {
344
+ const start = check.edgeTargets.length;
248
345
  const actionCount = check.solution.actionChecks.length;
249
- const packed = new Uint8Array(actions.length * actionCount);
250
- actions.forEach((results, position) => packed.set(results, position * actionCount));
251
- check.actions[node] = packed;
252
- check.stateResults[node] = stateResults;
253
- check.isWritten[node] = true;
346
+ writeToPool(check.edgeTargets, start, targets);
347
+ actions.forEach((results, position) =>
348
+ writeToPool(check.edgeActions, (start + position) * actionCount, results),
349
+ );
350
+ writeToPool(check.stateResults, check.nodeStates[node] * stateResults.length, stateResults);
351
+ check.edgeStarts[node] = start;
352
+ check.edgeCounts[node] = targets.length;
254
353
  };
255
354
 
256
355
  // TLC collects a state's successors and the state itself in a SetOfStates, a hash set it
@@ -265,7 +364,7 @@ export const createLivenessChecker = (
265
364
  };
266
365
  const insert = (slots: (LiveSuccessor | undefined)[], successor: LiveSuccessor) => {
267
366
  for (
268
- let slot = (graph.getFingerprint(successor.index) & 0x7fffffff) % slots.length;
367
+ let slot = (graph.getFingerprint(successor) & 0x7fffffff) % slots.length;
269
368
  ;
270
369
  slot = (slot + 1) % slots.length
271
370
  ) {
@@ -303,7 +402,7 @@ export const createLivenessChecker = (
303
402
  const stateResults = checkState(check, index, state);
304
403
  const tableauNode = tableau.nodes[check.nodeTableaux[node]];
305
404
  const actions: Uint8Array[] = [];
306
- const successors = check.successors[node];
405
+ const successors: number[] = [];
307
406
  const selfActions =
308
407
  tableauNode.successors.length > 0
309
408
  ? checkAction(check, index, state, state)
@@ -321,11 +420,14 @@ export const createLivenessChecker = (
321
420
  actions.push(selfActions);
322
421
  if (existing === undefined) expandLate(check, tableau, state, index, target);
323
422
  }
324
- for (const successor of graph.getSuccessors(state)) {
423
+ for (const successor of graph.getSuccessors(index, state)) {
325
424
  const successorActions = checkAction(check, index, state, successor.state);
326
425
  const isDone = check.isDone[successor.index] === true;
327
426
  for (const next of tableauNode.successors) {
328
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;
329
431
  const existing = getNodeId(check, successor.index, next);
330
432
  if (existing !== undefined && successors.includes(existing)) continue;
331
433
  const target = existing ?? recordNode(check, successor.index, next);
@@ -336,7 +438,7 @@ export const createLivenessChecker = (
336
438
  }
337
439
  }
338
440
  }
339
- if (successors.length > 0) writeNode(check, node, actions, stateResults);
441
+ if (successors.length > 0) writeNode(check, node, successors, actions, stateResults);
340
442
  };
341
443
 
342
444
  const addTableauState = (
@@ -352,8 +454,8 @@ export const createLivenessChecker = (
352
454
  );
353
455
  check.isDone[index] = true;
354
456
  // TLC expands the nodes recorded before the loop, not the ones the loop records.
355
- for (const node of (check.nodesByState.get(index) ?? []).slice()) {
356
- const successors = check.successors[node];
457
+ for (const node of getStateNodes(check, index)) {
458
+ const successors: number[] = [];
357
459
  const actions: Uint8Array[] = [];
358
460
  set.forEach((successor, position) => {
359
461
  const isDone = check.isDone[successor.index] === true;
@@ -369,7 +471,7 @@ export const createLivenessChecker = (
369
471
  }
370
472
  }
371
473
  });
372
- writeNode(check, node, actions, stateResults);
474
+ writeNode(check, node, successors, actions, stateResults);
373
475
  }
374
476
  if (check.errorNode === undefined) return undefined;
375
477
  return removeRepeats(
@@ -387,14 +489,14 @@ export const createLivenessChecker = (
387
489
  index: number,
388
490
  ) => {
389
491
  while (check.nodeStates.length <= index) pushNode(check, check.nodeStates.length, -1);
390
- const successors = check.successors[index];
492
+ const successors: number[] = [];
391
493
  const actions: Uint8Array[] = [];
392
494
  set.forEach((successor, position) => {
393
- if (check.isWritten[successor.index] && successors.includes(successor.index)) return;
495
+ if (isWritten(check, successor.index) && successors.includes(successor.index)) return;
394
496
  successors.push(successor.index);
395
497
  actions.push(actionResults[position]);
396
498
  });
397
- writeNode(check, index, actions, stateResults);
499
+ writeNode(check, index, successors, actions, stateResults);
398
500
  return undefined;
399
501
  };
400
502
 
@@ -404,20 +506,20 @@ export const createLivenessChecker = (
404
506
  const parents = new Map<number, number>();
405
507
  const queue: number[] = [];
406
508
  for (const node of check.initial) {
407
- if (!check.isWritten[node]) continue;
509
+ if (!isWritten(check, node)) continue;
408
510
  queue.push(node);
409
511
  parents.set(node, -1);
410
512
  }
411
513
  for (let position = 0; position < queue.length; position++) {
412
514
  const current = queue[position];
413
- for (const next of check.successors[current]) {
515
+ for (const next of getSuccessors(check, current)) {
414
516
  if (next === current && check.solution.tableau) continue;
415
517
  if (next === target) {
416
518
  const path = [target];
417
519
  for (let node = current; node !== -1; node = parents.get(node) ?? -1) path.push(node);
418
520
  return path;
419
521
  }
420
- if (!check.isWritten[next] || parents.has(next)) continue;
522
+ if (!isWritten(check, next) || parents.has(next)) continue;
421
523
  parents.set(next, current);
422
524
  queue.push(next);
423
525
  }
@@ -430,15 +532,15 @@ export const createLivenessChecker = (
430
532
  const solution = check.solution;
431
533
  const actionCount = solution.actionChecks.length;
432
534
  const getAction = (node: number, edge: number, position: number) =>
433
- check.actions[node][edge * actionCount + position] === 1;
535
+ check.edgeActions.data[(check.edgeStarts[node] + edge) * actionCount + position] === 1;
434
536
  const isAllowed = (node: number, edge: number) =>
435
537
  model.eventuallyAlways.every((position) => getAction(node, edge, position));
436
538
  const links = new Float64Array(check.nodeStates.length).fill(UNVISITED);
437
- const queue = check.initial.filter((node) => check.isWritten[node]);
539
+ const queue = check.initial.filter((node) => isWritten(check, node));
438
540
  const components: number[] = [];
439
541
 
440
542
  const isStuttering = (node: number) => {
441
- const edge = check.successors[node].indexOf(node);
543
+ const edge = getSuccessors(check, node).indexOf(node);
442
544
  return edge !== -1 && isAllowed(node, edge);
443
545
  };
444
546
  const isFulfilled = (node: number, promise: Solution["promises"][number]) =>
@@ -462,11 +564,11 @@ export const createLivenessChecker = (
462
564
  if (member === root) break;
463
565
  }
464
566
  const isStateSatisfied = model.infinitelyOftenStates.every((position) =>
465
- [...members].some((node) => check.stateResults[node][position] === 1),
567
+ [...members].some((node) => getStateResult(check, node, position)),
466
568
  );
467
569
  const isActionSatisfied = model.infinitelyOftenActions.every((position) =>
468
570
  [...members].some((node) =>
469
- check.successors[node].some(
571
+ getSuccessors(check, node).some(
470
572
  (next, edge) =>
471
573
  members.has(next) && isAllowed(node, edge) && getAction(node, edge, position),
472
574
  ),
@@ -507,7 +609,7 @@ export const createLivenessChecker = (
507
609
  const countAtStart = remaining.count;
508
610
  while (true) {
509
611
  model.infinitelyOftenStates.forEach((position, slot) => {
510
- if (!stateDone[slot] && check.stateResults[current.node][position] === 1) {
612
+ if (!stateDone[slot] && getStateResult(check, current.node, position)) {
511
613
  stateDone[slot] = true;
512
614
  remaining.count--;
513
615
  }
@@ -521,8 +623,7 @@ export const createLivenessChecker = (
521
623
  if (remaining.count <= 0) break;
522
624
  const step = { last: -1, unvisited: -1 };
523
625
  const countBeforeActions = remaining.count;
524
- const successors = check.successors[current.node];
525
- const taken = successors.some((next, edge) => {
626
+ const taken = getSuccessors(check, current.node).some((next, edge) => {
526
627
  if (membersByState.has(check.nodeStates[next])) {
527
628
  if (!isMember(next) || !isAllowed(current.node, edge)) return false;
528
629
  step.last = next;
@@ -556,7 +657,8 @@ export const createLivenessChecker = (
556
657
  }
557
658
  current.node = previous;
558
659
  step.unvisited =
559
- check.successors[previous].find((next) => isMember(next) && !seen.has(next)) ?? -1;
660
+ getSuccessors(check, previous).find((next) => isMember(next) && !seen.has(next)) ??
661
+ -1;
560
662
  }
561
663
  take(step.unvisited);
562
664
  seen.add(step.unvisited);
@@ -569,7 +671,11 @@ export const createLivenessChecker = (
569
671
  }
570
672
  const cycleState = prefix[prefix.length - 1];
571
673
  if (postfix[postfix.length - 1] === cycleState) postfix.pop();
572
- 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
+ };
573
679
  };
574
680
 
575
681
  // TLC's LiveWorker#bfsPostFix, the states from the walk's end back to the root, last first.
@@ -586,7 +692,7 @@ export const createLivenessChecker = (
586
692
  const queue: [number, number][] = [];
587
693
  for (let state = start, parent = -1, position = 0; ; position++) {
588
694
  for (const node of membersByState.get(state) ?? []) {
589
- for (const [edge, next] of check.successors[node].entries()) {
695
+ for (const [edge, next] of getSuccessors(check, node).entries()) {
590
696
  if (next === node || !isAllowedEdge(node, edge)) continue;
591
697
  if (next === root) {
592
698
  const path: number[] = [];
@@ -639,8 +745,8 @@ export const createLivenessChecker = (
639
745
  stack.push(lowLink, node, SCC_MARKER);
640
746
  components.push(node);
641
747
  const nextLowLink = { value: counter.link++ };
642
- check.successors[node].forEach((next, edge) => {
643
- if (!check.isWritten[next]) return;
748
+ getSuccessors(check, node).forEach((next, edge) => {
749
+ if (!isWritten(check, next)) return;
644
750
  if (!isAllowed(node, edge)) {
645
751
  if (links[next] === UNVISITED) queue.push(next);
646
752
  return;
@@ -655,37 +761,48 @@ export const createLivenessChecker = (
655
761
  };
656
762
 
657
763
  return {
658
- addInitialState: (index, state) => {
764
+ branches: checks.length,
765
+ addInitialState: (index, state, tracing) => {
766
+ evaluation.environment = tracing ?? environment;
659
767
  shared.states.clear();
660
768
  shared.actions.clear();
661
- for (const check of checks) {
662
- const tableau = check.solution.tableau;
663
- if (!tableau) {
664
- check.initial.push(index);
665
- continue;
666
- }
667
- for (let node = 0; node < tableau.initialCount; node++) {
668
- if (!isConsistent(tableau, node, undefined, state)) continue;
669
- 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
+ }
670
780
  }
781
+ } finally {
782
+ evaluation.environment = environment;
671
783
  }
672
784
  },
673
- addState: (index, state, successors) => {
785
+ addState: (index, state, successors, tracing) => {
786
+ evaluation.environment = tracing ?? environment;
674
787
  shared.states.clear();
675
788
  shared.actions.clear();
676
- const set = getSuccessorSet(index, state, successors);
677
- for (const check of checks) {
678
- const actionResults = set.map((successor) =>
679
- checkAction(check, index, state, successor.state),
680
- );
681
- const stateResults = checkState(check, index, state);
682
- const tableau = check.solution.tableau;
683
- const accepted = tableau
684
- ? addTableauState(check, tableau, set, actionResults, stateResults, index)
685
- : addPlainState(check, set, actionResults, stateResults, index);
686
- 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;
687
805
  }
688
- return undefined;
689
806
  },
690
807
  findViolation: () => {
691
808
  for (const check of checks) {