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.
- package/dist/cli.cjs +1 -1
- package/dist/cli.js +1 -1
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +148 -8
- package/dist/index.d.ts +148 -8
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +2 -2
- package/dist/parallel.cjs +1 -1
- package/dist/parallel.js +2 -2
- package/dist/run-cli.cjs +1351 -20
- package/dist/run-cli.js +1351 -20
- package/dist/transfer.cjs +86 -28
- package/dist/transfer.js +86 -28
- package/package.json +5 -1
- package/src/ast.ts +52 -6
- package/src/bags.ts +4 -7
- package/src/builtins.ts +29 -11
- package/src/bundled-modules.ts +3 -3
- package/src/canonical.ts +4 -3
- package/src/check.ts +1358 -219
- package/src/cli.ts +8 -1
- package/src/codegen.ts +68 -18
- package/src/config.ts +252 -179
- package/src/environment.ts +451 -129
- package/src/errors.ts +217 -3
- package/src/evaluate.ts +723 -116
- package/src/exit-codes.ts +5 -4
- package/src/index.ts +1 -0
- package/src/instances.ts +4 -2
- package/src/java-overrides.ts +104 -25
- package/src/levels.ts +183 -37
- package/src/lexer.ts +32 -4
- package/src/live-check.ts +220 -103
- package/src/liveness.ts +192 -65
- package/src/obligation-expression.ts +2 -2
- package/src/obligation-source.ts +2 -0
- package/src/parallel-worker.ts +8 -3
- package/src/parallel.ts +56 -5
- package/src/parser.ts +436 -128
- package/src/pcal-ast.ts +770 -0
- package/src/pcal-parse.ts +1523 -0
- package/src/pcal-tokenize.ts +516 -0
- package/src/pcal-translate.ts +1230 -0
- package/src/pcal-validate.ts +454 -0
- package/src/randomization.ts +24 -7
- package/src/resolve.ts +1364 -405
- package/src/run-cli.ts +1167 -155
- package/src/runtime.ts +16 -0
- package/src/sany-builtins.ts +147 -0
- package/src/sany-generator.ts +3112 -0
- package/src/sany-levels.ts +1208 -0
- package/src/sany-lexer.ts +545 -0
- package/src/sany-linter.ts +122 -0
- package/src/sany-modules.ts +1398 -0
- package/src/sany-nodes.ts +463 -0
- package/src/sany-parse-error.ts +2161 -0
- package/src/sany-report.ts +354 -0
- package/src/sany-selectors.ts +738 -0
- package/src/sany-source.ts +248 -0
- package/src/sany-xml.ts +1017 -0
- package/src/spec-description.ts +26 -7
- package/src/standard-modules.ts +203 -146
- package/src/standard-ranges.ts +116 -0
- package/src/state-graph.ts +29 -6
- package/src/subexpressions.ts +221 -161
- package/src/substitution-levels.ts +38 -17
- package/src/successors.ts +160 -105
- package/src/symmetry.ts +180 -52
- package/src/tableau.ts +54 -25
- package/src/tlc-ext.ts +13 -17
- package/src/tlc-messages.ts +329 -0
- package/src/tlc-module.ts +46 -18
- package/src/tlc-order.ts +56 -6
- package/src/tlc-random.ts +37 -9
- package/src/tlc-replay.ts +655 -0
- package/src/tlc-summary.ts +20 -5
- package/src/tlc-version.ts +18 -0
- package/src/transfer.ts +15 -3
- package/src/value-sources.ts +29 -0
- 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
|
-
|
|
34
|
-
|
|
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: (
|
|
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
|
-
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
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
|
-
|
|
57
|
-
|
|
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
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
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.
|
|
93
|
-
check.
|
|
94
|
-
check.
|
|
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
|
|
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 =
|
|
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
|
-
|
|
139
|
-
|
|
140
|
-
|
|
141
|
-
|
|
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
|
-
|
|
144
|
-
|
|
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(
|
|
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.
|
|
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
|
-
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
|
|
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
|
-
|
|
250
|
-
actions.forEach((results, position) =>
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
check.
|
|
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
|
|
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 =
|
|
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
|
|
356
|
-
const successors =
|
|
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 =
|
|
492
|
+
const successors: number[] = [];
|
|
391
493
|
const actions: Uint8Array[] = [];
|
|
392
494
|
set.forEach((successor, position) => {
|
|
393
|
-
if (check
|
|
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
|
|
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
|
|
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
|
|
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.
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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 {
|
|
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
|
|
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
|
|
643
|
-
if (!check
|
|
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
|
-
|
|
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
|
-
|
|
662
|
-
const
|
|
663
|
-
|
|
664
|
-
|
|
665
|
-
|
|
666
|
-
|
|
667
|
-
|
|
668
|
-
|
|
669
|
-
|
|
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
|
-
|
|
677
|
-
|
|
678
|
-
const
|
|
679
|
-
|
|
680
|
-
|
|
681
|
-
|
|
682
|
-
|
|
683
|
-
|
|
684
|
-
|
|
685
|
-
|
|
686
|
-
|
|
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) {
|