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.
- package/dist/cli.cjs +1 -1
- package/dist/cli.js +1 -1
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +146 -8
- package/dist/index.d.ts +146 -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 +48 -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 +1352 -215
- 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 +724 -117
- 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 +14 -1
- package/src/live-check.ts +212 -124
- 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 +423 -126
- 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 +1363 -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 +162 -114
- package/src/symmetry.ts +180 -52
- package/src/tableau.ts +4 -2
- 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 +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 +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
|
-
|
|
35
|
-
|
|
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: (
|
|
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
|
-
|
|
53
|
-
//
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
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
|
-
|
|
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.
|
|
74
|
-
check.
|
|
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
|
-
//
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
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
|
|
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
|
-
|
|
142
|
-
|
|
143
|
-
|
|
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
|
-
|
|
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(
|
|
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
|
-
|
|
233
|
-
|
|
234
|
-
|
|
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
|
|
240
|
-
if (
|
|
241
|
-
|
|
242
|
-
|
|
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
|
-
|
|
268
|
-
|
|
269
|
-
|
|
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.
|
|
280
|
-
|
|
281
|
-
check.
|
|
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
|
|
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 =
|
|
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,
|
|
384
|
-
const successors =
|
|
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 =
|
|
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
|
|
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.
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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 {
|
|
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
|
|
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
|
|
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
|
-
|
|
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
|
-
|
|
691
|
-
const
|
|
692
|
-
|
|
693
|
-
|
|
694
|
-
|
|
695
|
-
|
|
696
|
-
|
|
697
|
-
|
|
698
|
-
|
|
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
|
-
|
|
706
|
-
|
|
707
|
-
const
|
|
708
|
-
|
|
709
|
-
|
|
710
|
-
|
|
711
|
-
|
|
712
|
-
|
|
713
|
-
|
|
714
|
-
|
|
715
|
-
|
|
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) {
|