tla-ts 0.0.3-dev.974cfcb → 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 +212 -124
  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,56 +69,116 @@ 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: NodeTable;
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[];
59
86
  isDone: boolean[];
60
87
  errorNode: number | undefined;
61
88
  }
62
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
+
63
116
  const isSameState = (left: Value[], right: Value[]) =>
64
117
  left.every((value, position) => isSameValue(value, right[position]));
65
118
 
66
119
  const removeRepeats = (path: number[]) =>
67
120
  path.filter((node, position) => position === 0 || path[position - 1] !== node);
68
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
+
69
159
  // A node owns one entry in each of its check's per-node arrays.
70
160
  const pushNode = (check: Check, state: number, tableauNode: number) => {
71
161
  check.nodeStates.push(state);
72
162
  check.nodeTableaux.push(tableauNode);
73
- check.successors.push([]);
74
- check.offsets.push(-1);
163
+ check.edgeStarts.push(UNWRITTEN);
164
+ check.edgeCounts.push(0);
165
+ check.nextSiblings.push(NO_NODE);
75
166
  return check.nodeStates.length - 1;
76
167
  };
77
168
 
78
- // A Map holds at most 2^24 entries, so each tableau node of a state finds its node in an
79
- // open-addressing table of (state plus one, tableau node, node) triples.
80
- interface NodeTable {
81
- slots: Int32Array;
82
- size: number;
83
- shift: number;
84
- }
85
-
86
- const getNodeSlot = (table: NodeTable, state: number, tableauNode: number) => {
87
- const mask = table.slots.length / 3 - 1;
88
- const hash = Math.imul(Math.imul(state, 0x9e3779b1) ^ tableauNode, 0x85ebca6b) >>> table.shift;
89
- for (let index = hash; ; index = (index + 1) & mask) {
90
- const slot = index * 3;
91
- const stored = table.slots[slot];
92
- if (stored === 0 || (stored === state + 1 && table.slots[slot + 1] === tableauNode))
93
- return slot;
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);
94
178
  }
179
+ return nodes;
95
180
  };
96
181
 
97
- const isWritten = (check: Check, node: number) => check.offsets[node] !== -1;
98
-
99
- const getStateResult = (check: Check, node: number, position: number) =>
100
- check.results.bytes[check.offsets[node] + position] === 1;
101
-
102
182
  const SUCCESSOR_CAPACITY = 16;
103
183
 
104
184
  const SCC_MARKER = -42;
@@ -125,7 +205,7 @@ export const createLivenessChecker = (
125
205
  fairness.length === 0 ? violation : createJunction("And", [...fairness, violation]);
126
206
  const solutions = getSolutions(formula);
127
207
  if (solutions.length === 0) {
128
- throw new TlaEvaluationError(TAUTOLOGY_MESSAGE);
208
+ throw createTautologyError();
129
209
  }
130
210
  const actionIds = new Map<string, number>();
131
211
  const checks = solutions.map((solution): Check => ({
@@ -138,11 +218,15 @@ export const createLivenessChecker = (
138
218
  }),
139
219
  nodeStates: [],
140
220
  nodeTableaux: [],
141
- successors: [],
142
- offsets: [],
143
- 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)),
144
226
  initial: [],
145
- nodeIds: { slots: new Int32Array(3 << 10), size: 0, shift: 22 },
227
+ firstNodes: createPool(createNodes),
228
+ lastNodes: createPool(createNodes),
229
+ nextSiblings: [],
146
230
  isDone: [],
147
231
  errorNode: undefined,
148
232
  }));
@@ -151,6 +235,7 @@ export const createLivenessChecker = (
151
235
  // TLC evaluates every check on its own. Without side effects the order can't show, so the
152
236
  // checks of one state share their results.
153
237
  const isShared = !hasRepeatedEffects(environment);
238
+ const evaluation = { environment };
154
239
  const shared = {
155
240
  states: new Map<Value[], Map<LiveExpression, boolean>>(),
156
241
  actions: new Map<Value[], Map<Value[], Int8Array>>(),
@@ -172,7 +257,7 @@ export const createLivenessChecker = (
172
257
  predicate,
173
258
  state,
174
259
  undefined,
175
- environment,
260
+ evaluation.environment,
176
261
  isShared ? getStateCache(state) : new Map(),
177
262
  );
178
263
  const checkState = (check: Check, source: number, state: Value[]) =>
@@ -186,7 +271,7 @@ export const createLivenessChecker = (
186
271
  const predicates = check.solution.actionChecks;
187
272
  if (!isShared) {
188
273
  return Uint8Array.from(predicates, (predicate) =>
189
- evaluateLive(predicate, state, successor, environment, new Map()) ? 1 : 0,
274
+ evaluateLive(predicate, state, successor, evaluation.environment, new Map()) ? 1 : 0,
190
275
  );
191
276
  }
192
277
  const stateCache = getStateCache(state);
@@ -196,7 +281,13 @@ export const createLivenessChecker = (
196
281
  results.set(successor, known);
197
282
  return Uint8Array.from(check.actionIds, (id, position) => {
198
283
  if (known[id] === -1) {
199
- 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
+ )
200
291
  ? 1
201
292
  : 0;
202
293
  }
@@ -212,7 +303,10 @@ export const createLivenessChecker = (
212
303
  evaluateFrom(source, () =>
213
304
  tableau.nodes[node].statePredicates.every((predicate) => evaluateState(predicate, state)),
214
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.
215
308
  const isAccepting = (tableau: Tableau, node: number) => {
309
+ if (environment.runtime.version === "1.7.4") return false;
216
310
  const tableauNode = tableau.nodes[node];
217
311
  return (
218
312
  tableauNode.particle.length === 0 &&
@@ -228,57 +322,34 @@ export const createLivenessChecker = (
228
322
  model.infinitelyOftenActions.length === 0,
229
323
  );
230
324
 
231
- const getNodeId = (check: Check, state: number, tableauNode: number) => {
232
- if (!check.solution.tableau) return state;
233
- const slots = check.nodeIds.slots;
234
- const slot = getNodeSlot(check.nodeIds, state, tableauNode);
235
- return slots[slot] === 0 ? undefined : slots[slot + 2];
236
- };
325
+ const getNodeId = (check: Check, state: number, tableauNode: number) =>
326
+ check.solution.tableau
327
+ ? getStateNodes(check, state).find((node) => check.nodeTableaux[node] === tableauNode)
328
+ : state;
237
329
  const recordNode = (check: Check, state: number, tableauNode: number) => {
238
330
  const node = pushNode(check, state, tableauNode);
239
- const table = check.nodeIds;
240
- if (++table.size * 2 > table.slots.length / 3) {
241
- const old = table.slots;
242
- table.slots = new Int32Array(old.length * 2);
243
- table.shift--;
244
- for (let slot = 0; slot < old.length; slot += 3) {
245
- if (old[slot] !== 0)
246
- table.slots.set(
247
- old.subarray(slot, slot + 3),
248
- getNodeSlot(table, old[slot] - 1, old[slot + 1]),
249
- );
250
- }
251
- }
252
- table.slots.set([state + 1, tableauNode, node], getNodeSlot(table, state, tableauNode));
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]);
253
335
  return node;
254
336
  };
255
- // A state's nodes in the order they were recorded, which is the order of their ids.
256
- const getStateNodes = (check: Check, tableau: Tableau, state: number) =>
257
- tableau.nodes
258
- .flatMap((_, tableauNode) => getNodeId(check, state, tableauNode) ?? [])
259
- .sort((left, right) => left - right);
260
337
  const writeNode = (
261
338
  check: Check,
262
339
  node: number,
340
+ targets: number[],
263
341
  actions: Uint8Array[],
264
342
  stateResults: Uint8Array,
265
343
  ) => {
344
+ const start = check.edgeTargets.length;
266
345
  const actionCount = check.solution.actionChecks.length;
267
- const results = check.results;
268
- const offset = results.length;
269
- results.length += stateResults.length + actions.length * actionCount;
270
- if (results.length > results.bytes.length) {
271
- const grown = new Uint8Array(Math.max(2 * results.bytes.length, results.length));
272
- grown.set(results.bytes);
273
- results.bytes = grown;
274
- }
275
- results.bytes.set(stateResults, offset);
276
- actions.forEach((edge, position) =>
277
- 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),
278
349
  );
279
- check.offsets[node] = offset;
280
- // A node gets no successors once written, so it keeps them without spare capacity.
281
- 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;
282
353
  };
283
354
 
284
355
  // TLC collects a state's successors and the state itself in a SetOfStates, a hash set it
@@ -293,7 +364,7 @@ export const createLivenessChecker = (
293
364
  };
294
365
  const insert = (slots: (LiveSuccessor | undefined)[], successor: LiveSuccessor) => {
295
366
  for (
296
- let slot = (graph.getFingerprint(successor.index) & 0x7fffffff) % slots.length;
367
+ let slot = (graph.getFingerprint(successor) & 0x7fffffff) % slots.length;
297
368
  ;
298
369
  slot = (slot + 1) % slots.length
299
370
  ) {
@@ -331,7 +402,7 @@ export const createLivenessChecker = (
331
402
  const stateResults = checkState(check, index, state);
332
403
  const tableauNode = tableau.nodes[check.nodeTableaux[node]];
333
404
  const actions: Uint8Array[] = [];
334
- const successors = check.successors[node];
405
+ const successors: number[] = [];
335
406
  const selfActions =
336
407
  tableauNode.successors.length > 0
337
408
  ? checkAction(check, index, state, state)
@@ -349,11 +420,14 @@ export const createLivenessChecker = (
349
420
  actions.push(selfActions);
350
421
  if (existing === undefined) expandLate(check, tableau, state, index, target);
351
422
  }
352
- for (const successor of graph.getSuccessors(state)) {
423
+ for (const successor of graph.getSuccessors(index, state)) {
353
424
  const successorActions = checkAction(check, index, state, successor.state);
354
425
  const isDone = check.isDone[successor.index] === true;
355
426
  for (const next of tableauNode.successors) {
356
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;
357
431
  const existing = getNodeId(check, successor.index, next);
358
432
  if (existing !== undefined && successors.includes(existing)) continue;
359
433
  const target = existing ?? recordNode(check, successor.index, next);
@@ -364,7 +438,7 @@ export const createLivenessChecker = (
364
438
  }
365
439
  }
366
440
  }
367
- if (successors.length > 0) writeNode(check, node, actions, stateResults);
441
+ if (successors.length > 0) writeNode(check, node, successors, actions, stateResults);
368
442
  };
369
443
 
370
444
  const addTableauState = (
@@ -380,8 +454,8 @@ export const createLivenessChecker = (
380
454
  );
381
455
  check.isDone[index] = true;
382
456
  // TLC expands the nodes recorded before the loop, not the ones the loop records.
383
- for (const node of getStateNodes(check, tableau, index)) {
384
- const successors = check.successors[node];
457
+ for (const node of getStateNodes(check, index)) {
458
+ const successors: number[] = [];
385
459
  const actions: Uint8Array[] = [];
386
460
  set.forEach((successor, position) => {
387
461
  const isDone = check.isDone[successor.index] === true;
@@ -397,7 +471,7 @@ export const createLivenessChecker = (
397
471
  }
398
472
  }
399
473
  });
400
- writeNode(check, node, actions, stateResults);
474
+ writeNode(check, node, successors, actions, stateResults);
401
475
  }
402
476
  if (check.errorNode === undefined) return undefined;
403
477
  return removeRepeats(
@@ -415,14 +489,14 @@ export const createLivenessChecker = (
415
489
  index: number,
416
490
  ) => {
417
491
  while (check.nodeStates.length <= index) pushNode(check, check.nodeStates.length, -1);
418
- const successors = check.successors[index];
492
+ const successors: number[] = [];
419
493
  const actions: Uint8Array[] = [];
420
494
  set.forEach((successor, position) => {
421
495
  if (isWritten(check, successor.index) && successors.includes(successor.index)) return;
422
496
  successors.push(successor.index);
423
497
  actions.push(actionResults[position]);
424
498
  });
425
- writeNode(check, index, actions, stateResults);
499
+ writeNode(check, index, successors, actions, stateResults);
426
500
  return undefined;
427
501
  };
428
502
 
@@ -438,7 +512,7 @@ export const createLivenessChecker = (
438
512
  }
439
513
  for (let position = 0; position < queue.length; position++) {
440
514
  const current = queue[position];
441
- for (const next of check.successors[current]) {
515
+ for (const next of getSuccessors(check, current)) {
442
516
  if (next === current && check.solution.tableau) continue;
443
517
  if (next === target) {
444
518
  const path = [target];
@@ -457,9 +531,8 @@ export const createLivenessChecker = (
457
531
  const findInModel = (check: Check, model: Solution["models"][number]): Lasso | undefined => {
458
532
  const solution = check.solution;
459
533
  const actionCount = solution.actionChecks.length;
460
- const stateCount = solution.stateChecks.length;
461
534
  const getAction = (node: number, edge: number, position: number) =>
462
- check.results.bytes[check.offsets[node] + stateCount + edge * actionCount + position] === 1;
535
+ check.edgeActions.data[(check.edgeStarts[node] + edge) * actionCount + position] === 1;
463
536
  const isAllowed = (node: number, edge: number) =>
464
537
  model.eventuallyAlways.every((position) => getAction(node, edge, position));
465
538
  const links = new Float64Array(check.nodeStates.length).fill(UNVISITED);
@@ -467,7 +540,7 @@ export const createLivenessChecker = (
467
540
  const components: number[] = [];
468
541
 
469
542
  const isStuttering = (node: number) => {
470
- const edge = check.successors[node].indexOf(node);
543
+ const edge = getSuccessors(check, node).indexOf(node);
471
544
  return edge !== -1 && isAllowed(node, edge);
472
545
  };
473
546
  const isFulfilled = (node: number, promise: Solution["promises"][number]) =>
@@ -495,7 +568,7 @@ export const createLivenessChecker = (
495
568
  );
496
569
  const isActionSatisfied = model.infinitelyOftenActions.every((position) =>
497
570
  [...members].some((node) =>
498
- check.successors[node].some(
571
+ getSuccessors(check, node).some(
499
572
  (next, edge) =>
500
573
  members.has(next) && isAllowed(node, edge) && getAction(node, edge, position),
501
574
  ),
@@ -550,8 +623,7 @@ export const createLivenessChecker = (
550
623
  if (remaining.count <= 0) break;
551
624
  const step = { last: -1, unvisited: -1 };
552
625
  const countBeforeActions = remaining.count;
553
- const successors = check.successors[current.node];
554
- const taken = successors.some((next, edge) => {
626
+ const taken = getSuccessors(check, current.node).some((next, edge) => {
555
627
  if (membersByState.has(check.nodeStates[next])) {
556
628
  if (!isMember(next) || !isAllowed(current.node, edge)) return false;
557
629
  step.last = next;
@@ -585,7 +657,8 @@ export const createLivenessChecker = (
585
657
  }
586
658
  current.node = previous;
587
659
  step.unvisited =
588
- check.successors[previous].find((next) => isMember(next) && !seen.has(next)) ?? -1;
660
+ getSuccessors(check, previous).find((next) => isMember(next) && !seen.has(next)) ??
661
+ -1;
589
662
  }
590
663
  take(step.unvisited);
591
664
  seen.add(step.unvisited);
@@ -598,7 +671,11 @@ export const createLivenessChecker = (
598
671
  }
599
672
  const cycleState = prefix[prefix.length - 1];
600
673
  if (postfix[postfix.length - 1] === cycleState) postfix.pop();
601
- 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
+ };
602
679
  };
603
680
 
604
681
  // TLC's LiveWorker#bfsPostFix, the states from the walk's end back to the root, last first.
@@ -615,7 +692,7 @@ export const createLivenessChecker = (
615
692
  const queue: [number, number][] = [];
616
693
  for (let state = start, parent = -1, position = 0; ; position++) {
617
694
  for (const node of membersByState.get(state) ?? []) {
618
- for (const [edge, next] of check.successors[node].entries()) {
695
+ for (const [edge, next] of getSuccessors(check, node).entries()) {
619
696
  if (next === node || !isAllowedEdge(node, edge)) continue;
620
697
  if (next === root) {
621
698
  const path: number[] = [];
@@ -668,7 +745,7 @@ export const createLivenessChecker = (
668
745
  stack.push(lowLink, node, SCC_MARKER);
669
746
  components.push(node);
670
747
  const nextLowLink = { value: counter.link++ };
671
- check.successors[node].forEach((next, edge) => {
748
+ getSuccessors(check, node).forEach((next, edge) => {
672
749
  if (!isWritten(check, next)) return;
673
750
  if (!isAllowed(node, edge)) {
674
751
  if (links[next] === UNVISITED) queue.push(next);
@@ -684,37 +761,48 @@ export const createLivenessChecker = (
684
761
  };
685
762
 
686
763
  return {
687
- addInitialState: (index, state) => {
764
+ branches: checks.length,
765
+ addInitialState: (index, state, tracing) => {
766
+ evaluation.environment = tracing ?? environment;
688
767
  shared.states.clear();
689
768
  shared.actions.clear();
690
- for (const check of checks) {
691
- const tableau = check.solution.tableau;
692
- if (!tableau) {
693
- check.initial.push(index);
694
- continue;
695
- }
696
- for (let node = 0; node < tableau.initialCount; node++) {
697
- if (!isConsistent(tableau, node, undefined, state)) continue;
698
- 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
+ }
699
780
  }
781
+ } finally {
782
+ evaluation.environment = environment;
700
783
  }
701
784
  },
702
- addState: (index, state, successors) => {
785
+ addState: (index, state, successors, tracing) => {
786
+ evaluation.environment = tracing ?? environment;
703
787
  shared.states.clear();
704
788
  shared.actions.clear();
705
- const set = getSuccessorSet(index, state, successors);
706
- for (const check of checks) {
707
- const actionResults = set.map((successor) =>
708
- checkAction(check, index, state, successor.state),
709
- );
710
- const stateResults = checkState(check, index, state);
711
- const tableau = check.solution.tableau;
712
- const accepted = tableau
713
- ? addTableauState(check, tableau, set, actionResults, stateResults, index)
714
- : addPlainState(check, set, actionResults, stateResults, index);
715
- 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;
716
805
  }
717
- return undefined;
718
806
  },
719
807
  findViolation: () => {
720
808
  for (const check of checks) {