tla-ts 0.0.3-dev.e9d8347 → 0.0.3-dev.eed6eb1
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 +150 -8
- package/dist/index.d.ts +150 -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 +57 -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 +1348 -227
- package/src/cli.ts +8 -1
- package/src/codegen.ts +68 -21
- package/src/config.ts +254 -181
- package/src/environment.ts +437 -123
- package/src/errors.ts +210 -5
- package/src/evaluate.ts +716 -141
- 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 +122 -29
- package/src/live-check.ts +204 -146
- 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 +6 -1
- package/src/parallel.ts +57 -6
- package/src/parser.ts +445 -147
- 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 +1465 -411
- package/src/run-cli.ts +1179 -155
- package/src/runtime.ts +16 -0
- package/src/sany-builtins.ts +147 -0
- package/src/sany-generator.ts +3128 -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 +356 -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 +162 -114
- package/src/symmetry.ts +168 -50
- package/src/tableau.ts +3 -1
- package/src/tlc-ext.ts +13 -17
- package/src/tlc-messages.ts +329 -0
- package/src/tlc-module.ts +49 -21
- package/src/tlc-modules.ts +0 -4
- package/src/tlc-order.ts +55 -9
- package/src/tlc-random.ts +28 -3
- package/src/tlc-replay.ts +655 -0
- package/src/tlc-version.ts +18 -0
- package/src/transfer.ts +15 -3
- package/src/value-sources.ts +29 -0
- package/src/values.ts +699 -256
package/src/live-check.ts
CHANGED
|
@@ -1,9 +1,8 @@
|
|
|
1
1
|
import { TlaEvaluationError } from "./errors";
|
|
2
|
-
import { EXIT_STATUS, setExitCode } from "./exit-codes";
|
|
3
2
|
import { hasRepeatedEffects, type Environment } from "./evaluate";
|
|
4
3
|
import {
|
|
4
|
+
createTautologyError,
|
|
5
5
|
evaluateLive,
|
|
6
|
-
TAUTOLOGY_MESSAGE,
|
|
7
6
|
evaluateOnLasso,
|
|
8
7
|
toLiveExpression,
|
|
9
8
|
type ScopedExpression,
|
|
@@ -29,18 +28,38 @@ export interface LiveSuccessor {
|
|
|
29
28
|
export interface Lasso {
|
|
30
29
|
prefix: number[];
|
|
31
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;
|
|
32
34
|
}
|
|
33
35
|
|
|
34
36
|
export interface LivenessChecker {
|
|
35
|
-
|
|
36
|
-
|
|
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;
|
|
37
48
|
findViolation: () => Lasso | undefined;
|
|
38
49
|
getViolatedProperties: (path: Value[][], cycleStart: number) => string[];
|
|
39
50
|
}
|
|
40
51
|
|
|
41
52
|
export interface LiveGraph {
|
|
42
|
-
getFingerprint: (
|
|
43
|
-
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;
|
|
44
63
|
}
|
|
45
64
|
|
|
46
65
|
// TLC's behavior graph for one solution: a node per state, or per state and tableau node.
|
|
@@ -50,67 +69,115 @@ interface Check {
|
|
|
50
69
|
actionIds: Int32Array;
|
|
51
70
|
nodeStates: number[];
|
|
52
71
|
nodeTableaux: number[];
|
|
53
|
-
//
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
results
|
|
59
|
-
//
|
|
60
|
-
|
|
61
|
-
|
|
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>;
|
|
62
81
|
initial: number[];
|
|
63
|
-
|
|
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[];
|
|
64
86
|
isDone: boolean[];
|
|
65
87
|
errorNode: number | undefined;
|
|
66
88
|
}
|
|
67
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
|
+
|
|
68
116
|
const isSameState = (left: Value[], right: Value[]) =>
|
|
69
117
|
left.every((value, position) => isSameValue(value, right[position]));
|
|
70
118
|
|
|
71
119
|
const removeRepeats = (path: number[]) =>
|
|
72
120
|
path.filter((node, position) => position === 0 || path[position - 1] !== node);
|
|
73
121
|
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
|
|
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);
|
|
82
139
|
};
|
|
83
140
|
|
|
84
|
-
|
|
85
|
-
// open-addressing table of (state plus one, tableau node, node) triples.
|
|
86
|
-
interface NodeTable {
|
|
87
|
-
slots: Int32Array;
|
|
88
|
-
size: number;
|
|
89
|
-
shift: number;
|
|
90
|
-
}
|
|
141
|
+
const NO_NODE = -1;
|
|
91
142
|
|
|
92
|
-
const
|
|
93
|
-
const mask = table.slots.length / 3 - 1;
|
|
94
|
-
const hash = Math.imul(Math.imul(state, 0x9e3779b1) ^ tableauNode, 0x85ebca6b) >>> table.shift;
|
|
95
|
-
for (let index = hash; ; index = (index + 1) & mask) {
|
|
96
|
-
const slot = index * 3;
|
|
97
|
-
const stored = table.slots[slot];
|
|
98
|
-
if (stored === 0 || (stored === state + 1 && table.slots[slot + 1] === tableauNode))
|
|
99
|
-
return slot;
|
|
100
|
-
}
|
|
101
|
-
};
|
|
143
|
+
const createNodes = (length: number) => new Int32Array(length).fill(NO_NODE);
|
|
102
144
|
|
|
103
|
-
const
|
|
145
|
+
const UNWRITTEN = -1;
|
|
104
146
|
|
|
105
|
-
const
|
|
147
|
+
const isWritten = (check: Check, node: number) =>
|
|
148
|
+
(check.edgeStarts[node] ?? UNWRITTEN) !== UNWRITTEN;
|
|
106
149
|
|
|
107
150
|
const getSuccessors = (check: Check, node: number) => {
|
|
108
|
-
const
|
|
109
|
-
return check.
|
|
151
|
+
const start = check.edgeStarts[node];
|
|
152
|
+
return check.edgeTargets.data.subarray(start, start + check.edgeCounts[node]);
|
|
110
153
|
};
|
|
111
154
|
|
|
112
155
|
const getStateResult = (check: Check, node: number, position: number) =>
|
|
113
|
-
check.
|
|
156
|
+
check.stateResults.data[check.nodeStates[node] * check.solution.stateChecks.length + position] ===
|
|
157
|
+
1;
|
|
158
|
+
|
|
159
|
+
// A node owns one entry in each of its check's per-node arrays.
|
|
160
|
+
const pushNode = (check: Check, state: number, tableauNode: number) => {
|
|
161
|
+
check.nodeStates.push(state);
|
|
162
|
+
check.nodeTableaux.push(tableauNode);
|
|
163
|
+
check.edgeStarts.push(UNWRITTEN);
|
|
164
|
+
check.edgeCounts.push(0);
|
|
165
|
+
check.nextSiblings.push(NO_NODE);
|
|
166
|
+
return check.nodeStates.length - 1;
|
|
167
|
+
};
|
|
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
|
+
};
|
|
114
181
|
|
|
115
182
|
const SUCCESSOR_CAPACITY = 16;
|
|
116
183
|
|
|
@@ -138,10 +205,7 @@ export const createLivenessChecker = (
|
|
|
138
205
|
fairness.length === 0 ? violation : createJunction("And", [...fairness, violation]);
|
|
139
206
|
const solutions = getSolutions(formula);
|
|
140
207
|
if (solutions.length === 0) {
|
|
141
|
-
throw
|
|
142
|
-
new TlaEvaluationError(TAUTOLOGY_MESSAGE),
|
|
143
|
-
EXIT_STATUS.livenessEvaluationFailure,
|
|
144
|
-
);
|
|
208
|
+
throw createTautologyError();
|
|
145
209
|
}
|
|
146
210
|
const actionIds = new Map<string, number>();
|
|
147
211
|
const checks = solutions.map((solution): Check => ({
|
|
@@ -154,13 +218,15 @@ export const createLivenessChecker = (
|
|
|
154
218
|
}),
|
|
155
219
|
nodeStates: [],
|
|
156
220
|
nodeTableaux: [],
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
|
|
161
|
-
|
|
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)),
|
|
162
226
|
initial: [],
|
|
163
|
-
|
|
227
|
+
firstNodes: createPool(createNodes),
|
|
228
|
+
lastNodes: createPool(createNodes),
|
|
229
|
+
nextSiblings: [],
|
|
164
230
|
isDone: [],
|
|
165
231
|
errorNode: undefined,
|
|
166
232
|
}));
|
|
@@ -169,6 +235,7 @@ export const createLivenessChecker = (
|
|
|
169
235
|
// TLC evaluates every check on its own. Without side effects the order can't show, so the
|
|
170
236
|
// checks of one state share their results.
|
|
171
237
|
const isShared = !hasRepeatedEffects(environment);
|
|
238
|
+
const evaluation = { environment };
|
|
172
239
|
const shared = {
|
|
173
240
|
states: new Map<Value[], Map<LiveExpression, boolean>>(),
|
|
174
241
|
actions: new Map<Value[], Map<Value[], Int8Array>>(),
|
|
@@ -190,7 +257,7 @@ export const createLivenessChecker = (
|
|
|
190
257
|
predicate,
|
|
191
258
|
state,
|
|
192
259
|
undefined,
|
|
193
|
-
environment,
|
|
260
|
+
evaluation.environment,
|
|
194
261
|
isShared ? getStateCache(state) : new Map(),
|
|
195
262
|
);
|
|
196
263
|
const checkState = (check: Check, source: number, state: Value[]) =>
|
|
@@ -204,7 +271,7 @@ export const createLivenessChecker = (
|
|
|
204
271
|
const predicates = check.solution.actionChecks;
|
|
205
272
|
if (!isShared) {
|
|
206
273
|
return Uint8Array.from(predicates, (predicate) =>
|
|
207
|
-
evaluateLive(predicate, state, successor, environment, new Map()) ? 1 : 0,
|
|
274
|
+
evaluateLive(predicate, state, successor, evaluation.environment, new Map()) ? 1 : 0,
|
|
208
275
|
);
|
|
209
276
|
}
|
|
210
277
|
const stateCache = getStateCache(state);
|
|
@@ -214,7 +281,13 @@ export const createLivenessChecker = (
|
|
|
214
281
|
results.set(successor, known);
|
|
215
282
|
return Uint8Array.from(check.actionIds, (id, position) => {
|
|
216
283
|
if (known[id] === -1) {
|
|
217
|
-
known[id] = evaluateLive(
|
|
284
|
+
known[id] = evaluateLive(
|
|
285
|
+
predicates[position],
|
|
286
|
+
state,
|
|
287
|
+
successor,
|
|
288
|
+
evaluation.environment,
|
|
289
|
+
stateCache,
|
|
290
|
+
)
|
|
218
291
|
? 1
|
|
219
292
|
: 0;
|
|
220
293
|
}
|
|
@@ -230,7 +303,10 @@ export const createLivenessChecker = (
|
|
|
230
303
|
evaluateFrom(source, () =>
|
|
231
304
|
tableau.nodes[node].statePredicates.every((predicate) => evaluateState(predicate, state)),
|
|
232
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.
|
|
233
308
|
const isAccepting = (tableau: Tableau, node: number) => {
|
|
309
|
+
if (environment.runtime.version === "1.7.4") return false;
|
|
234
310
|
const tableauNode = tableau.nodes[node];
|
|
235
311
|
return (
|
|
236
312
|
tableauNode.particle.length === 0 &&
|
|
@@ -246,68 +322,34 @@ export const createLivenessChecker = (
|
|
|
246
322
|
model.infinitelyOftenActions.length === 0,
|
|
247
323
|
);
|
|
248
324
|
|
|
249
|
-
const getNodeId = (check: Check, state: number, tableauNode: number) =>
|
|
250
|
-
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
return slots[slot] === 0 ? undefined : slots[slot + 2];
|
|
254
|
-
};
|
|
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;
|
|
255
329
|
const recordNode = (check: Check, state: number, tableauNode: number) => {
|
|
256
330
|
const node = pushNode(check, state, tableauNode);
|
|
257
|
-
const
|
|
258
|
-
if (
|
|
259
|
-
|
|
260
|
-
|
|
261
|
-
table.shift--;
|
|
262
|
-
for (let slot = 0; slot < old.length; slot += 3) {
|
|
263
|
-
if (old[slot] !== 0)
|
|
264
|
-
table.slots.set(
|
|
265
|
-
old.subarray(slot, slot + 3),
|
|
266
|
-
getNodeSlot(table, old[slot] - 1, old[slot + 1]),
|
|
267
|
-
);
|
|
268
|
-
}
|
|
269
|
-
}
|
|
270
|
-
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]);
|
|
271
335
|
return node;
|
|
272
336
|
};
|
|
273
|
-
// A state's nodes in the order they were recorded, which is the order of their ids.
|
|
274
|
-
const getStateNodes = (check: Check, tableau: Tableau, state: number) =>
|
|
275
|
-
tableau.nodes
|
|
276
|
-
.flatMap((_, tableauNode) => getNodeId(check, state, tableauNode) ?? [])
|
|
277
|
-
.sort((left, right) => left - right);
|
|
278
337
|
const writeNode = (
|
|
279
338
|
check: Check,
|
|
280
339
|
node: number,
|
|
340
|
+
targets: number[],
|
|
281
341
|
actions: Uint8Array[],
|
|
282
342
|
stateResults: Uint8Array,
|
|
283
343
|
) => {
|
|
344
|
+
const start = check.edgeTargets.length;
|
|
284
345
|
const actionCount = check.solution.actionChecks.length;
|
|
285
|
-
|
|
286
|
-
|
|
287
|
-
|
|
288
|
-
if (results.length > results.bytes.length) {
|
|
289
|
-
const grown = new Uint8Array(Math.max(2 * results.bytes.length, results.length));
|
|
290
|
-
grown.set(results.bytes);
|
|
291
|
-
results.bytes = grown;
|
|
292
|
-
}
|
|
293
|
-
results.bytes.set(stateResults, offset);
|
|
294
|
-
actions.forEach((edge, position) =>
|
|
295
|
-
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),
|
|
296
349
|
);
|
|
297
|
-
check.
|
|
298
|
-
|
|
299
|
-
|
|
300
|
-
const edgeOffset = edges.length;
|
|
301
|
-
edges.length += successors.length + 1;
|
|
302
|
-
if (edges.length > edges.ids.length) {
|
|
303
|
-
const grown = new Int32Array(Math.max(2 * edges.ids.length, edges.length));
|
|
304
|
-
grown.set(edges.ids);
|
|
305
|
-
edges.ids = grown;
|
|
306
|
-
}
|
|
307
|
-
edges.ids[edgeOffset] = successors.length;
|
|
308
|
-
edges.ids.set(successors, edgeOffset + 1);
|
|
309
|
-
check.edgeOffsets[node] = edgeOffset;
|
|
310
|
-
check.pending[node] = undefined;
|
|
350
|
+
writeToPool(check.stateResults, check.nodeStates[node] * stateResults.length, stateResults);
|
|
351
|
+
check.edgeStarts[node] = start;
|
|
352
|
+
check.edgeCounts[node] = targets.length;
|
|
311
353
|
};
|
|
312
354
|
|
|
313
355
|
// TLC collects a state's successors and the state itself in a SetOfStates, a hash set it
|
|
@@ -322,7 +364,7 @@ export const createLivenessChecker = (
|
|
|
322
364
|
};
|
|
323
365
|
const insert = (slots: (LiveSuccessor | undefined)[], successor: LiveSuccessor) => {
|
|
324
366
|
for (
|
|
325
|
-
let slot = (graph.getFingerprint(successor
|
|
367
|
+
let slot = (graph.getFingerprint(successor) & 0x7fffffff) % slots.length;
|
|
326
368
|
;
|
|
327
369
|
slot = (slot + 1) % slots.length
|
|
328
370
|
) {
|
|
@@ -360,7 +402,7 @@ export const createLivenessChecker = (
|
|
|
360
402
|
const stateResults = checkState(check, index, state);
|
|
361
403
|
const tableauNode = tableau.nodes[check.nodeTableaux[node]];
|
|
362
404
|
const actions: Uint8Array[] = [];
|
|
363
|
-
const successors =
|
|
405
|
+
const successors: number[] = [];
|
|
364
406
|
const selfActions =
|
|
365
407
|
tableauNode.successors.length > 0
|
|
366
408
|
? checkAction(check, index, state, state)
|
|
@@ -378,11 +420,14 @@ export const createLivenessChecker = (
|
|
|
378
420
|
actions.push(selfActions);
|
|
379
421
|
if (existing === undefined) expandLate(check, tableau, state, index, target);
|
|
380
422
|
}
|
|
381
|
-
for (const successor of graph.getSuccessors(state)) {
|
|
423
|
+
for (const successor of graph.getSuccessors(index, state)) {
|
|
382
424
|
const successorActions = checkAction(check, index, state, successor.state);
|
|
383
425
|
const isDone = check.isDone[successor.index] === true;
|
|
384
426
|
for (const next of tableauNode.successors) {
|
|
385
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;
|
|
386
431
|
const existing = getNodeId(check, successor.index, next);
|
|
387
432
|
if (existing !== undefined && successors.includes(existing)) continue;
|
|
388
433
|
const target = existing ?? recordNode(check, successor.index, next);
|
|
@@ -393,7 +438,7 @@ export const createLivenessChecker = (
|
|
|
393
438
|
}
|
|
394
439
|
}
|
|
395
440
|
}
|
|
396
|
-
if (successors.length > 0) writeNode(check, node, actions, stateResults);
|
|
441
|
+
if (successors.length > 0) writeNode(check, node, successors, actions, stateResults);
|
|
397
442
|
};
|
|
398
443
|
|
|
399
444
|
const addTableauState = (
|
|
@@ -409,8 +454,8 @@ export const createLivenessChecker = (
|
|
|
409
454
|
);
|
|
410
455
|
check.isDone[index] = true;
|
|
411
456
|
// TLC expands the nodes recorded before the loop, not the ones the loop records.
|
|
412
|
-
for (const node of getStateNodes(check,
|
|
413
|
-
const successors =
|
|
457
|
+
for (const node of getStateNodes(check, index)) {
|
|
458
|
+
const successors: number[] = [];
|
|
414
459
|
const actions: Uint8Array[] = [];
|
|
415
460
|
set.forEach((successor, position) => {
|
|
416
461
|
const isDone = check.isDone[successor.index] === true;
|
|
@@ -426,7 +471,7 @@ export const createLivenessChecker = (
|
|
|
426
471
|
}
|
|
427
472
|
}
|
|
428
473
|
});
|
|
429
|
-
writeNode(check, node, actions, stateResults);
|
|
474
|
+
writeNode(check, node, successors, actions, stateResults);
|
|
430
475
|
}
|
|
431
476
|
if (check.errorNode === undefined) return undefined;
|
|
432
477
|
return removeRepeats(
|
|
@@ -444,14 +489,14 @@ export const createLivenessChecker = (
|
|
|
444
489
|
index: number,
|
|
445
490
|
) => {
|
|
446
491
|
while (check.nodeStates.length <= index) pushNode(check, check.nodeStates.length, -1);
|
|
447
|
-
const successors =
|
|
492
|
+
const successors: number[] = [];
|
|
448
493
|
const actions: Uint8Array[] = [];
|
|
449
494
|
set.forEach((successor, position) => {
|
|
450
495
|
if (isWritten(check, successor.index) && successors.includes(successor.index)) return;
|
|
451
496
|
successors.push(successor.index);
|
|
452
497
|
actions.push(actionResults[position]);
|
|
453
498
|
});
|
|
454
|
-
writeNode(check, index, actions, stateResults);
|
|
499
|
+
writeNode(check, index, successors, actions, stateResults);
|
|
455
500
|
return undefined;
|
|
456
501
|
};
|
|
457
502
|
|
|
@@ -486,9 +531,8 @@ export const createLivenessChecker = (
|
|
|
486
531
|
const findInModel = (check: Check, model: Solution["models"][number]): Lasso | undefined => {
|
|
487
532
|
const solution = check.solution;
|
|
488
533
|
const actionCount = solution.actionChecks.length;
|
|
489
|
-
const stateCount = solution.stateChecks.length;
|
|
490
534
|
const getAction = (node: number, edge: number, position: number) =>
|
|
491
|
-
check.
|
|
535
|
+
check.edgeActions.data[(check.edgeStarts[node] + edge) * actionCount + position] === 1;
|
|
492
536
|
const isAllowed = (node: number, edge: number) =>
|
|
493
537
|
model.eventuallyAlways.every((position) => getAction(node, edge, position));
|
|
494
538
|
const links = new Float64Array(check.nodeStates.length).fill(UNVISITED);
|
|
@@ -579,8 +623,7 @@ export const createLivenessChecker = (
|
|
|
579
623
|
if (remaining.count <= 0) break;
|
|
580
624
|
const step = { last: -1, unvisited: -1 };
|
|
581
625
|
const countBeforeActions = remaining.count;
|
|
582
|
-
const
|
|
583
|
-
const taken = successors.some((next, edge) => {
|
|
626
|
+
const taken = getSuccessors(check, current.node).some((next, edge) => {
|
|
584
627
|
if (membersByState.has(check.nodeStates[next])) {
|
|
585
628
|
if (!isMember(next) || !isAllowed(current.node, edge)) return false;
|
|
586
629
|
step.last = next;
|
|
@@ -628,7 +671,11 @@ export const createLivenessChecker = (
|
|
|
628
671
|
}
|
|
629
672
|
const cycleState = prefix[prefix.length - 1];
|
|
630
673
|
if (postfix[postfix.length - 1] === cycleState) postfix.pop();
|
|
631
|
-
return {
|
|
674
|
+
return {
|
|
675
|
+
prefix: prefix.slice(0, -1),
|
|
676
|
+
cycle: [cycleState, ...postfix.reverse()],
|
|
677
|
+
isCycleConstrained: isCycleConstrained(solution),
|
|
678
|
+
};
|
|
632
679
|
};
|
|
633
680
|
|
|
634
681
|
// TLC's LiveWorker#bfsPostFix, the states from the walk's end back to the root, last first.
|
|
@@ -714,37 +761,48 @@ export const createLivenessChecker = (
|
|
|
714
761
|
};
|
|
715
762
|
|
|
716
763
|
return {
|
|
717
|
-
|
|
764
|
+
branches: checks.length,
|
|
765
|
+
addInitialState: (index, state, tracing) => {
|
|
766
|
+
evaluation.environment = tracing ?? environment;
|
|
718
767
|
shared.states.clear();
|
|
719
768
|
shared.actions.clear();
|
|
720
|
-
|
|
721
|
-
const
|
|
722
|
-
|
|
723
|
-
|
|
724
|
-
|
|
725
|
-
|
|
726
|
-
|
|
727
|
-
|
|
728
|
-
|
|
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
|
+
}
|
|
729
780
|
}
|
|
781
|
+
} finally {
|
|
782
|
+
evaluation.environment = environment;
|
|
730
783
|
}
|
|
731
784
|
},
|
|
732
|
-
addState: (index, state, successors) => {
|
|
785
|
+
addState: (index, state, successors, tracing) => {
|
|
786
|
+
evaluation.environment = tracing ?? environment;
|
|
733
787
|
shared.states.clear();
|
|
734
788
|
shared.actions.clear();
|
|
735
|
-
|
|
736
|
-
|
|
737
|
-
const
|
|
738
|
-
|
|
739
|
-
|
|
740
|
-
|
|
741
|
-
|
|
742
|
-
|
|
743
|
-
|
|
744
|
-
|
|
745
|
-
|
|
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;
|
|
746
805
|
}
|
|
747
|
-
return undefined;
|
|
748
806
|
},
|
|
749
807
|
findViolation: () => {
|
|
750
808
|
for (const check of checks) {
|