tla-ts 0.0.10-dev.a17d6d9fa → 0.0.10-dev.a5705bfbf

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 (78) hide show
  1. package/dist/deciders.cjs +31 -31
  2. package/dist/deciders.js +2 -2
  3. package/dist/index.cjs +1 -1
  4. package/dist/index.d.cts +12 -2
  5. package/dist/index.d.ts +12 -2
  6. package/dist/index.js +1 -1
  7. package/dist/parallel-worker.cjs +1 -1
  8. package/dist/parallel-worker.js +1 -1
  9. package/dist/prove.cjs +64 -64
  10. package/dist/prove.js +76 -76
  11. package/dist/run.cjs +42 -42
  12. package/dist/run.js +44 -44
  13. package/dist/transfer.cjs +37 -35
  14. package/dist/transfer.js +43 -41
  15. package/dist/worker.cjs +7 -7
  16. package/dist/worker.js +7 -7
  17. package/package.json +1 -1
  18. package/src/ast.ts +10 -1
  19. package/src/check-failure.ts +12 -10
  20. package/src/check-trace.ts +36 -23
  21. package/src/check.ts +182 -135
  22. package/src/cli/tlc-output.ts +17 -2
  23. package/src/cli/tlc.ts +2 -2
  24. package/src/codegen.ts +15 -19
  25. package/src/coverage.ts +190 -1
  26. package/src/dependencies.ts +19 -6
  27. package/src/dfid.ts +80 -27
  28. package/src/environment.ts +30 -1
  29. package/src/evaluate.ts +254 -59
  30. package/src/exit-codes.ts +25 -13
  31. package/src/instances.ts +11 -1
  32. package/src/levels.ts +48 -7
  33. package/src/liveness-checker.ts +98 -27
  34. package/src/liveness.ts +4 -1
  35. package/src/obligations/source.ts +2 -0
  36. package/src/parser.ts +3 -0
  37. package/src/prover/smt/solver/card2bv.ts +7 -4
  38. package/src/prover/smt/solver/context.ts +20 -4
  39. package/src/prover/smt/solver/dependent-expr-state.ts +18 -12
  40. package/src/prover/smt/solver/dt2bv-tactic.ts +36 -20
  41. package/src/prover/smt/solver/fd-solver.ts +146 -39
  42. package/src/prover/smt/solver/maxcore.ts +2 -1
  43. package/src/prover/smt/solver/maxsmt-base.ts +1 -0
  44. package/src/prover/smt/solver/model-checker.ts +1 -1
  45. package/src/prover/smt/solver/muz/dl-context.ts +12 -40
  46. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
  47. package/src/prover/smt/solver/muz/dl-rule.ts +6 -7
  48. package/src/prover/smt/solver/muz/hnf.ts +2 -2
  49. package/src/prover/smt/solver/muz/horn-tactic.ts +14 -1
  50. package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
  51. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
  52. package/src/prover/smt/solver/opt-context.ts +1 -0
  53. package/src/prover/smt/solver/opt-solver.ts +1 -1
  54. package/src/prover/smt/solver/parallel-tactic.ts +1 -1
  55. package/src/prover/smt/solver/qsat.ts +7 -2
  56. package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
  57. package/src/prover/smt/solver/sat/inc-sat-solver.ts +45 -26
  58. package/src/prover/smt/solver/sat/sat-tactic.ts +4 -2
  59. package/src/prover/smt/solver/sat/sat2goal.ts +10 -7
  60. package/src/prover/smt/solver/smt-consequences.ts +1 -1
  61. package/src/prover/smt/solver/smt-kernel.ts +9 -2
  62. package/src/prover/smt/solver/smtlib-parser.ts +6 -2
  63. package/src/prover/smt/solver/smtlib-script.ts +197 -73
  64. package/src/prover/smt/solver/tactic.ts +64 -37
  65. package/src/resolve.ts +143 -39
  66. package/src/sany/generator-expressions.ts +2 -0
  67. package/src/sany/generator-proofs.ts +1 -0
  68. package/src/search.ts +156 -37
  69. package/src/simulate.ts +143 -150
  70. package/src/spec-description.ts +3 -0
  71. package/src/standard-modules.ts +41 -16
  72. package/src/subexpressions.ts +168 -63
  73. package/src/successors.ts +33 -11
  74. package/src/symmetry.ts +1 -0
  75. package/src/tlc/replay.ts +64 -41
  76. package/src/trace-liveness.ts +529 -0
  77. package/src/typed-tier.ts +20 -6
  78. package/src/values.ts +15 -1
@@ -0,0 +1,529 @@
1
+ import { isSameState } from "./fingerprints";
2
+ import { evaluateLive, type LiveAtoms } from "./liveness";
3
+ import { isFulfilling, type LiveExpression, type Solution } from "./tableau";
4
+ import type { Value } from "./values";
5
+
6
+ interface GraphNode {
7
+ fingerprint: bigint;
8
+ tableau: number;
9
+ position: number;
10
+ stateChecks: boolean[];
11
+ successors: GraphNode[];
12
+ actionChecks: boolean[][];
13
+ stepPositions: number[];
14
+ number: number;
15
+ }
16
+
17
+ interface TraceChecks {
18
+ getStates: (position: number) => boolean[];
19
+ getSteps: (position: number) => boolean[];
20
+ getStutters: (position: number) => boolean[];
21
+ isConsistent: (tableauNode: number, position: number) => boolean;
22
+ }
23
+
24
+ interface BehaviorGraph {
25
+ initial: GraphNode[];
26
+ isPartial: boolean;
27
+ }
28
+
29
+ export interface TraceLasso {
30
+ positions: number[];
31
+ cyclePosition: number;
32
+ backPosition: number | undefined;
33
+ }
34
+
35
+ const MAX_FIRST = 2 ** 50;
36
+ const MAX_SECOND = 2 ** 51;
37
+
38
+ const createNode = (
39
+ fingerprint: bigint,
40
+ tableau: number,
41
+ position: number,
42
+ stateChecks: boolean[],
43
+ ): GraphNode => ({
44
+ fingerprint,
45
+ tableau,
46
+ position,
47
+ stateChecks,
48
+ successors: [],
49
+ actionChecks: [],
50
+ stepPositions: [],
51
+ number: 0,
52
+ });
53
+
54
+ const addTransition = (
55
+ source: GraphNode,
56
+ target: GraphNode,
57
+ actionChecks: boolean[],
58
+ position: number,
59
+ ) => {
60
+ source.successors.push(target);
61
+ source.actionChecks.push(actionChecks);
62
+ source.stepPositions.push(position);
63
+ };
64
+
65
+ const getStepTo = (source: GraphNode, target: GraphNode) =>
66
+ source.stepPositions[source.successors.indexOf(target)];
67
+
68
+ const pop = (nodes: GraphNode[]) => {
69
+ const top = nodes[nodes.length - 1];
70
+ nodes.length -= 1;
71
+ return top;
72
+ };
73
+
74
+ const createGraph = (
75
+ fingerprints: bigint[],
76
+ solution: Solution,
77
+ checks: TraceChecks,
78
+ isComplete: boolean,
79
+ ): BehaviorGraph => {
80
+ const graph: BehaviorGraph = { initial: [], isPartial: false };
81
+ const tableau = solution.tableau;
82
+ if (!tableau) {
83
+ const nodes = new Map<bigint, GraphNode>();
84
+ let source = createNode(fingerprints[0], -1, 0, checks.getStates(0));
85
+ addTransition(source, source, checks.getStutters(0), 0);
86
+ nodes.set(fingerprints[0], source);
87
+ graph.initial.push(source);
88
+ for (let position = 1; position < fingerprints.length; position++) {
89
+ const existing = nodes.get(fingerprints[position]);
90
+ if (existing === undefined) {
91
+ const target = createNode(fingerprints[position], -1, position, checks.getStates(position));
92
+ addTransition(target, target, checks.getStutters(position), position);
93
+ addTransition(source, target, checks.getSteps(position), position);
94
+ nodes.set(fingerprints[position], target);
95
+ source = target;
96
+ continue;
97
+ }
98
+ if (!source.successors.includes(existing)) {
99
+ addTransition(source, existing, checks.getSteps(position), position);
100
+ }
101
+ source = existing;
102
+ }
103
+ return graph;
104
+ }
105
+ const rows = new Map<bigint, GraphNode[]>();
106
+ const getRow = (fingerprint: bigint) => {
107
+ const row = rows.get(fingerprint) ?? [];
108
+ rows.set(fingerprint, row);
109
+ return row;
110
+ };
111
+ const extend = (
112
+ sources: GraphNode[],
113
+ targets: GraphNode[],
114
+ row: GraphNode[],
115
+ position: number,
116
+ stateChecks: boolean[],
117
+ actionChecks: boolean[],
118
+ ) => {
119
+ for (let index = 0; index < sources.length; index++) {
120
+ const source = sources[index];
121
+ const successors = tableau.nodes[source.tableau].successors;
122
+ for (let successor = 0; successor < successors.length; successor++) {
123
+ const tableauNode = successors[successor];
124
+ const existing = row[tableauNode];
125
+ if (existing === undefined) {
126
+ if (!checks.isConsistent(tableauNode, position)) continue;
127
+ const target = createNode(fingerprints[position], tableauNode, position, stateChecks);
128
+ addTransition(source, target, actionChecks, position);
129
+ targets.push(target);
130
+ row[tableauNode] = target;
131
+ continue;
132
+ }
133
+ if (!source.successors.includes(existing)) {
134
+ addTransition(source, existing, actionChecks, position);
135
+ }
136
+ if (existing.position === position) continue;
137
+ graph.isPartial = true;
138
+ if (isComplete && !targets.includes(existing)) targets.push(existing);
139
+ }
140
+ }
141
+ };
142
+ const initialRow = getRow(fingerprints[0]);
143
+ const initialChecks = checks.getStates(0);
144
+ const initialStutters = checks.getStutters(0);
145
+ for (let tableauNode = 0; tableauNode < tableau.initialCount; tableauNode++) {
146
+ if (!checks.isConsistent(tableauNode, 0)) continue;
147
+ const node = createNode(fingerprints[0], tableauNode, 0, initialChecks);
148
+ graph.initial.push(node);
149
+ initialRow[tableauNode] = node;
150
+ }
151
+ for (const source of graph.initial) {
152
+ for (const tableauNode of tableau.nodes[source.tableau].successors) {
153
+ const target = initialRow[tableauNode];
154
+ if (!target) {
155
+ graph.isPartial = true;
156
+ continue;
157
+ }
158
+ addTransition(source, target, initialStutters, 0);
159
+ }
160
+ }
161
+ let sources = [...graph.initial];
162
+ if (isComplete) extend(sources, sources, initialRow, 0, initialChecks, initialStutters);
163
+ for (let position = 1; position < fingerprints.length; position++) {
164
+ const row = getRow(fingerprints[position]);
165
+ const stateChecks = checks.getStates(position);
166
+ const targets: GraphNode[] = [];
167
+ extend(sources, targets, row, position, stateChecks, checks.getSteps(position));
168
+ extend(targets, targets, row, position, stateChecks, checks.getStutters(position));
169
+ sources = targets;
170
+ }
171
+ return graph;
172
+ };
173
+
174
+ const findLasso = (
175
+ fingerprints: bigint[],
176
+ solution: Solution,
177
+ initial: GraphNode[],
178
+ ): TraceLasso | undefined => {
179
+ const promises = solution.promises;
180
+ const tableauNodes = solution.tableau?.nodes ?? [];
181
+ const stack: GraphNode[] = [];
182
+ let firstNumber = 1;
183
+ let secondNumber = MAX_FIRST + 1;
184
+ let thirdNumber = MAX_SECOND + 1;
185
+ let startSecondNumber = secondNumber;
186
+ let startThirdNumber = thirdNumber;
187
+ let firstComponentNumber = secondNumber;
188
+ let secondComponentNumber = thirdNumber;
189
+ let model = solution.models[0];
190
+ let lasso: TraceLasso | undefined;
191
+
192
+ const isEventuallyAlways = (node: GraphNode, transition: number) => {
193
+ const actionChecks = node.actionChecks[transition];
194
+ const checks = model.eventuallyAlways;
195
+ for (let index = 0; index < checks.length; index++) {
196
+ if (!actionChecks[checks[index]]) return false;
197
+ }
198
+ return true;
199
+ };
200
+ const getLasso = (node: GraphNode): TraceLasso => {
201
+ const cycle: GraphNode[] = [];
202
+ const lowNumber = thirdNumber - 1;
203
+ const states = model.infinitelyOftenStates;
204
+ const actions = model.infinitelyOftenActions;
205
+ const isStateFound = states.map(() => false);
206
+ const isActionFound = actions.map(() => false);
207
+ const isPromiseFound = promises.map(() => false);
208
+ let count = states.length + actions.length + promises.length;
209
+ let current = node;
210
+ while (count > 0) {
211
+ current.number = thirdNumber;
212
+ const countBefore = count;
213
+ search: while (true) {
214
+ for (let index = 0; index < states.length; index++) {
215
+ if (!isStateFound[index] && current.stateChecks[states[index]]) {
216
+ isStateFound[index] = true;
217
+ count--;
218
+ }
219
+ }
220
+ for (let index = 0; index < promises.length; index++) {
221
+ if (
222
+ !isPromiseFound[index] &&
223
+ isFulfilling(tableauNodes[current.tableau].particle, promises[index])
224
+ ) {
225
+ isPromiseFound[index] = true;
226
+ count--;
227
+ }
228
+ }
229
+ if (count <= 0) break;
230
+ let inComponent: GraphNode | undefined;
231
+ let unvisited: GraphNode | undefined;
232
+ const countBeforeActions = count;
233
+ for (let index = 0; index < current.successors.length; index++) {
234
+ const target = current.successors[index];
235
+ const targetNumber = target.number;
236
+ if (lowNumber <= targetNumber && targetNumber <= thirdNumber) {
237
+ inComponent = target;
238
+ for (let action = 0; action < actions.length; action++) {
239
+ if (!isActionFound[action] && current.actionChecks[index][actions[action]]) {
240
+ isActionFound[action] = true;
241
+ count--;
242
+ }
243
+ }
244
+ }
245
+ if (count < countBeforeActions) {
246
+ cycle.push(current);
247
+ current = target;
248
+ thirdNumber++;
249
+ break search;
250
+ }
251
+ if (lowNumber <= targetNumber && targetNumber < thirdNumber) unvisited = target;
252
+ }
253
+ if (count < countBefore && inComponent) {
254
+ cycle.push(current);
255
+ current = inComponent;
256
+ thirdNumber++;
257
+ break;
258
+ }
259
+ while (unvisited === undefined) {
260
+ current = pop(cycle);
261
+ for (let index = 0; index < current.successors.length; index++) {
262
+ const target = current.successors[index];
263
+ if (lowNumber <= target.number && target.number < thirdNumber) {
264
+ cycle.push(current);
265
+ unvisited = target;
266
+ break;
267
+ }
268
+ }
269
+ }
270
+ cycle.push(current);
271
+ current = unvisited;
272
+ current.number = thirdNumber;
273
+ }
274
+ }
275
+ thirdNumber++;
276
+ current.number = thirdNumber;
277
+ close: while (current !== node) {
278
+ let isFound = false;
279
+ for (let index = 0; index < current.successors.length; index++) {
280
+ const target = current.successors[index];
281
+ if (lowNumber <= target.number && target.number < thirdNumber) {
282
+ cycle.push(current);
283
+ if (target === node) break close;
284
+ isFound = true;
285
+ current = target;
286
+ current.number = thirdNumber;
287
+ break;
288
+ }
289
+ }
290
+ if (!isFound) current = pop(cycle);
291
+ }
292
+ if (cycle.length === 0) cycle.push(current);
293
+ // Deviation from TLC: LiveCheck1#printErrorTrace shows the behavior's states in order, not those of the lasso it found, which differ once the behavior revisits a state.
294
+ const positions: number[] = [];
295
+ for (let position = 0; position <= node.position; position++) {
296
+ if (position === 0 || fingerprints[position] !== fingerprints[position - 1]) {
297
+ positions.push(position);
298
+ }
299
+ }
300
+ const cyclePosition = positions.length;
301
+ for (let index = 1; index < cycle.length; index++) {
302
+ if (cycle[index].fingerprint !== cycle[index - 1].fingerprint) {
303
+ positions.push(getStepTo(cycle[index - 1], cycle[index]));
304
+ }
305
+ }
306
+ const last = cycle[cycle.length - 1];
307
+ return {
308
+ positions,
309
+ cyclePosition,
310
+ backPosition: last.fingerprint === node.fingerprint ? undefined : getStepTo(last, node),
311
+ };
312
+ };
313
+ const checkSubcomponent = (node: GraphNode) => {
314
+ const states = model.infinitelyOftenStates;
315
+ const actions = model.infinitelyOftenActions;
316
+ const isStateFound = states.map(() => false);
317
+ const isActionFound = actions.map(() => false);
318
+ const isPromiseFound = promises.map(() => false);
319
+ const pending = [node];
320
+ node.number++;
321
+ while (pending.length > 0) {
322
+ const current = pop(pending);
323
+ for (let index = 0; index < states.length; index++) {
324
+ if (!isStateFound[index]) isStateFound[index] = current.stateChecks[states[index]];
325
+ }
326
+ for (let index = 0; index < current.successors.length; index++) {
327
+ const target = current.successors[index];
328
+ const targetNumber = target.number;
329
+ if (targetNumber >= thirdNumber) {
330
+ for (let action = 0; action < actions.length; action++) {
331
+ if (!isActionFound[action]) {
332
+ isActionFound[action] = current.actionChecks[index][actions[action]];
333
+ }
334
+ }
335
+ }
336
+ if (targetNumber === thirdNumber) {
337
+ target.number++;
338
+ pending.push(target);
339
+ }
340
+ }
341
+ for (let index = 0; index < promises.length; index++) {
342
+ if (isFulfilling(tableauNodes[current.tableau].particle, promises[index])) {
343
+ isPromiseFound[index] = true;
344
+ }
345
+ }
346
+ }
347
+ thirdNumber += 2;
348
+ if (
349
+ lasso === undefined &&
350
+ !isStateFound.includes(false) &&
351
+ !isActionFound.includes(false) &&
352
+ !isPromiseFound.includes(false)
353
+ ) {
354
+ lasso = getLasso(node);
355
+ }
356
+ };
357
+ const canStutter = (node: GraphNode) => {
358
+ const stutter = node.successors.indexOf(node);
359
+ return (
360
+ stutter !== -1 && firstComponentNumber <= node.number && isEventuallyAlways(node, stutter)
361
+ );
362
+ };
363
+ const extractSubcomponent = (node: GraphNode) => {
364
+ let popped = pop(stack);
365
+ if (popped === node && !canStutter(node)) {
366
+ node.number = thirdNumber++;
367
+ return false;
368
+ }
369
+ popped.number = thirdNumber;
370
+ while (popped !== node) {
371
+ popped = pop(stack);
372
+ popped.number = thirdNumber;
373
+ }
374
+ return true;
375
+ };
376
+ const checkSubcomponents = (node: GraphNode): number => {
377
+ let lowlink = secondNumber++;
378
+ node.number = lowlink;
379
+ stack.push(node);
380
+ for (let index = 0; index < node.successors.length; index++) {
381
+ const target = node.successors[index];
382
+ let targetNumber = target.number;
383
+ if (firstComponentNumber <= targetNumber && isEventuallyAlways(node, index)) {
384
+ if (
385
+ targetNumber < startSecondNumber ||
386
+ (secondComponentNumber <= targetNumber && targetNumber < startThirdNumber)
387
+ ) {
388
+ targetNumber = checkSubcomponents(target);
389
+ }
390
+ if (targetNumber < lowlink) lowlink = targetNumber;
391
+ }
392
+ }
393
+ if (lowlink === node.number && extractSubcomponent(node)) checkSubcomponent(node);
394
+ return lowlink;
395
+ };
396
+ const extractComponent = (node: GraphNode) => {
397
+ let popped = pop(stack);
398
+ if (popped === node && !node.successors.includes(node)) {
399
+ node.number = MAX_FIRST;
400
+ return undefined;
401
+ }
402
+ const nodes: GraphNode[] = [];
403
+ firstComponentNumber = secondNumber++;
404
+ secondComponentNumber = thirdNumber;
405
+ popped.number = firstComponentNumber;
406
+ nodes.push(popped);
407
+ while (popped !== node) {
408
+ popped = pop(stack);
409
+ popped.number = firstComponentNumber;
410
+ nodes.push(popped);
411
+ }
412
+ return nodes;
413
+ };
414
+ const checkComponent = (node: GraphNode) => {
415
+ const nodes = extractComponent(node);
416
+ if (!nodes) return;
417
+ for (const errorModel of solution.models) {
418
+ model = errorModel;
419
+ startSecondNumber = secondNumber;
420
+ startThirdNumber = thirdNumber;
421
+ for (let index = nodes.length - 1; index >= 0; index--) {
422
+ if (nodes[index].number < startThirdNumber) checkSubcomponents(nodes[index]);
423
+ }
424
+ }
425
+ };
426
+ const checkComponents = (node: GraphNode): number => {
427
+ let lowlink = firstNumber++;
428
+ node.number = lowlink;
429
+ stack.push(node);
430
+ for (let index = 0; index < node.successors.length; index++) {
431
+ const target = node.successors[index];
432
+ const targetNumber = target.number === 0 ? checkComponents(target) : target.number;
433
+ if (targetNumber < lowlink) lowlink = targetNumber;
434
+ }
435
+ if (lowlink === node.number) checkComponent(node);
436
+ return lowlink;
437
+ };
438
+ for (const node of initial) {
439
+ if (node.number === 0) checkComponents(node);
440
+ if (lasso) return lasso;
441
+ }
442
+ return undefined;
443
+ };
444
+
445
+ export const findTraceLasso = (
446
+ trace: Value[][],
447
+ fingerprints: bigint[],
448
+ solutions: Solution[],
449
+ atoms: LiveAtoms<Value[]>,
450
+ isShared: boolean,
451
+ ): TraceLasso | undefined => {
452
+ const stateCache = new Map<LiveExpression, boolean>();
453
+ const holds = (check: LiveExpression, position: number, next: number | undefined) => {
454
+ stateCache.clear();
455
+ return evaluateLive(
456
+ check,
457
+ trace[position],
458
+ next === undefined ? undefined : trace[next],
459
+ atoms,
460
+ stateCache,
461
+ );
462
+ };
463
+ const statePositions = trace.map((_state, position) => position);
464
+ const stepPositions = trace.map((_state, position) => position);
465
+ if (isShared) {
466
+ const firstStates = new Map<bigint, number>();
467
+ const firstSteps = new Map<number, number>();
468
+ for (let position = 0; position < trace.length; position++) {
469
+ const first = firstStates.get(fingerprints[position]) ?? position;
470
+ firstStates.set(fingerprints[position], first);
471
+ if (isSameState(trace[first], trace[position])) statePositions[position] = first;
472
+ if (position === 0) continue;
473
+ const key = statePositions[position - 1] * trace.length + statePositions[position];
474
+ stepPositions[position] = firstSteps.get(key) ?? position;
475
+ firstSteps.set(key, stepPositions[position]);
476
+ }
477
+ }
478
+ const solutionChecks = solutions.map((solution): TraceChecks => {
479
+ const states: boolean[][] = [];
480
+ const steps: boolean[][] = [];
481
+ const stutters: boolean[][] = [];
482
+ const consistent: boolean[][] = [];
483
+ const statePredicates = solution.tableau?.nodes.map((node) => node.statePredicates) ?? [];
484
+ return {
485
+ getStates: (position) => {
486
+ const first = statePositions[position];
487
+ return (states[first] ??= solution.stateChecks.map((check) =>
488
+ holds(check, first, undefined),
489
+ ));
490
+ },
491
+ getSteps: (position) => {
492
+ const first = stepPositions[position];
493
+ return (steps[first] ??= solution.actionChecks.map((check) =>
494
+ holds(check, first - 1, first),
495
+ ));
496
+ },
497
+ getStutters: (position) => {
498
+ const first = statePositions[position];
499
+ return (stutters[first] ??= solution.actionChecks.map((check) =>
500
+ holds(check, first, first),
501
+ ));
502
+ },
503
+ isConsistent: (tableauNode, position) => {
504
+ const first = statePositions[position];
505
+ const row = (consistent[first] ??= []);
506
+ const known = isShared ? row[tableauNode] : undefined;
507
+ if (known !== undefined) return known;
508
+ row[tableauNode] = statePredicates[tableauNode].every((predicate) =>
509
+ holds(predicate, first, undefined),
510
+ );
511
+ return row[tableauNode];
512
+ },
513
+ };
514
+ });
515
+ const partial: number[] = [];
516
+ for (let index = 0; index < solutions.length; index++) {
517
+ const graph = createGraph(fingerprints, solutions[index], solutionChecks[index], false);
518
+ const lasso = findLasso(fingerprints, solutions[index], graph.initial);
519
+ if (lasso) return lasso;
520
+ if (graph.isPartial) partial.push(index);
521
+ }
522
+ // Deviation from TLC: LiveCheck1#constructBEGraph gives the initial state no stuttering step to a tableau node that isn't initial and goes on from no node a revisited state reaches, so it misses a violation past them.
523
+ for (const index of partial) {
524
+ const graph = createGraph(fingerprints, solutions[index], solutionChecks[index], true);
525
+ const lasso = findLasso(fingerprints, solutions[index], graph.initial);
526
+ if (lasso) return lasso;
527
+ }
528
+ return undefined;
529
+ };
package/src/typed-tier.ts CHANGED
@@ -28,6 +28,7 @@ import {
28
28
  findGlobalName,
29
29
  getDefinition,
30
30
  getStartupValue,
31
+ isUniformPredicate,
31
32
  type Environment,
32
33
  type Scope,
33
34
  } from "./evaluate";
@@ -106,8 +107,7 @@ interface TupType {
106
107
  interface SeqType {
107
108
  kind: "Seq";
108
109
  element: Type;
109
- // The sparse function a sequence becomes when it meets one in the sparse pass.
110
- target?: MapType;
110
+ target?: SeqType | MapType;
111
111
  }
112
112
 
113
113
  // A record of several shapes starts with the position of its shape.
@@ -528,6 +528,7 @@ const unify = (left: Type, right: Type): void => {
528
528
  return unify(leftType.values, rightType.values);
529
529
  }
530
530
  if (leftType.kind === "Seq" && rightType.kind === "Seq") {
531
+ rightType.target = leftType;
531
532
  return unify(leftType.element, rightType.element);
532
533
  }
533
534
  if (leftType.kind === "Set" && rightType.kind === "Set") {
@@ -3261,6 +3262,8 @@ const compileBuiltin = (
3261
3262
 
3262
3263
  const compileValue = (program: Program, expression: Expression, frame: Frame): Compiled => {
3263
3264
  switch (expression.kind) {
3265
+ case "Selection":
3266
+ return compileValue(program, expression.expression, frame);
3264
3267
  case "Number":
3265
3268
  return expression.value <= MAXIMUM_INTEGER
3266
3269
  ? { type: createInt(), emit: () => String(expression.value) }
@@ -3406,13 +3409,16 @@ const compileValue = (program: Program, expression: Expression, frame: Frame): C
3406
3409
  compileValue(program, expression.predicate, { ...frame, scope: bounds.scope }),
3407
3410
  );
3408
3411
  const result = getName(program, "r");
3412
+ const stop = isUniformPredicate(expression, program.environment)
3413
+ ? ` else return ${result};`
3414
+ : "";
3409
3415
  const type: SetType = { kind: "Set", element: loop.element };
3410
3416
  return {
3411
3417
  type,
3412
3418
  emit: () =>
3413
3419
  isMask(type, program.plains)
3414
- ? `(() => { let ${result} = 0; ${bounds.getHeaders()} { if (${predicate.emit()}) ${result} |= H.bit(${loop.name}); } return ${result}; })()`
3415
- : `(() => { const ${result} = []; ${bounds.getHeaders()} { if (${predicate.emit()}) ${result}.push(${loop.name}); } return ${result}; })()`,
3420
+ ? `(() => { let ${result} = 0; ${bounds.getHeaders()} { if (${predicate.emit()}) ${result} |= H.bit(${loop.name});${stop} } return ${result}; })()`
3421
+ : `(() => { const ${result} = []; ${bounds.getHeaders()} { if (${predicate.emit()}) ${result}.push(${loop.name});${stop} } return ${result}; })()`,
3416
3422
  };
3417
3423
  }
3418
3424
  case "SetMap": {
@@ -3944,6 +3950,8 @@ const compileWays = (program: Program, expression: Expression, frame: Frame): Co
3944
3950
  compileWays(program, inner, { ...frame, scope });
3945
3951
  const counted = (emit: () => string): Compiled => ({ type: createInt(), emit });
3946
3952
  switch (expression.kind) {
3953
+ case "Selection":
3954
+ return getWays(expression.expression, frame.scope);
3947
3955
  case "Or": {
3948
3956
  const operands = expression.operands.map((operand) => getWays(operand, frame.scope));
3949
3957
  return counted(() => `(${operands.map((operand) => operand.emit()).join(" + ")})`);
@@ -4064,8 +4072,12 @@ const compileStep = (
4064
4072
  if (!isEnabled && primed.some((code) => code === undefined)) return () => "H.deopt();";
4065
4073
  return () => getEmitCode(primed);
4066
4074
  }
4067
- // With warnings on, TLC evaluates what is left once every variable is assigned, without branching.
4068
- if (program.environment.runtime.isWarningEnabled && primed.every((code) => code !== undefined)) {
4075
+ // With warnings on, TLC evaluates what is left of a step once every variable is assigned, without branching, but not under ENABLED.
4076
+ if (
4077
+ !isEnabled &&
4078
+ program.environment.runtime.isWarningEnabled &&
4079
+ primed.every((code) => code !== undefined)
4080
+ ) {
4069
4081
  const guards = pending.map((item) => {
4070
4082
  if (item.expression.kind !== "Unchanged") {
4071
4083
  return expectBool(
@@ -4103,6 +4115,8 @@ const compileStep = (
4103
4115
  ? unsupported()
4104
4116
  : continueWith(scope, [body], [...first.inlining, definition]);
4105
4117
  switch (expression.kind) {
4118
+ case "Selection":
4119
+ return continueWith(first.scope, [expression.expression]);
4106
4120
  case "And":
4107
4121
  return continueWith(first.scope, expression.operands);
4108
4122
  case "Or": {
package/src/values.ts CHANGED
@@ -107,6 +107,7 @@ export interface FilteredSetValue extends LazySet {
107
107
  kind: "FilteredSet";
108
108
  base: Value;
109
109
  test: (element: Value, isMember: boolean) => boolean;
110
+ startPass?: (isMaterialized: boolean) => (element: Value) => boolean;
110
111
  source?: FilteredSetSource;
111
112
  }
112
113
 
@@ -288,6 +289,13 @@ const forgetWrittenOrder = (value: Value): void => {
288
289
  value.range.forEach(forgetWrittenOrder);
289
290
  };
290
291
 
292
+ // TLC's SetOfRcdsValue#member and SetOfFcnsValue#member normalize the record or function they check in place.
293
+ const forgetOwnWrittenOrder = (value: Value) => {
294
+ if (isWrittenOrderUsed && typeof value === "object" && value.kind === "Function") {
295
+ value.writtenKeys = undefined;
296
+ }
297
+ };
298
+
291
299
  const isRecordDomain = (domain: Value[]) => domain.every((key) => typeof key === "string");
292
300
 
293
301
  const isRecordMismatch = (left: Value[], right: Value[]) =>
@@ -1588,7 +1596,9 @@ const enumerateSet = (
1588
1596
  }
1589
1597
  return toFiniteSet(
1590
1598
  createEnumeratedSet(
1591
- getStreamedElements(value.base).filter((element) => value.test(element, false)),
1599
+ getStreamedElements(value.base).filter(
1600
+ value.startPass?.(true) ?? ((element) => value.test(element, false)),
1601
+ ),
1592
1602
  ),
1593
1603
  ).elements;
1594
1604
  case "Union": {
@@ -1814,6 +1824,8 @@ const someElementOfStream = (value: ObjectValue, visit: (element: Value) => bool
1814
1824
  );
1815
1825
  }
1816
1826
  if (value.kind === "FilteredSet" && isTlcEnumerable(value.base)) {
1827
+ const test = value.startPass?.(false);
1828
+ if (test) return someStreamedElement(value.base, (element) => test(element) && visit(element));
1817
1829
  return someStreamedElement(
1818
1830
  value.base,
1819
1831
  (element) => value.test(element, false) && visit(element),
@@ -2213,6 +2225,7 @@ const isElementOfAnySet = (element: Value, set: Value): boolean => {
2213
2225
  `Attempted to check if \n${formatValue(element)}\nwhich is not a TLC function value, is in the set of functions:\n${prettyPrint(formatValue(set))}`,
2214
2226
  );
2215
2227
  }
2228
+ forgetOwnWrittenOrder(element);
2216
2229
  const functionValue = toFiniteFunction(element);
2217
2230
  const low = getIntervalLow(element, functionValue.domain);
2218
2231
  const isDomain =
@@ -2225,6 +2238,7 @@ const isElementOfAnySet = (element: Value, set: Value): boolean => {
2225
2238
  return isDomain && functionValue.range.every((item) => isElementOf(item, set.range));
2226
2239
  }
2227
2240
  case "RecordSet": {
2241
+ forgetOwnWrittenOrder(element);
2228
2242
  const functionValue = isFunctionValue(element) ? toFiniteFunction(element) : undefined;
2229
2243
  if (!functionValue || !isRecordDomain(functionValue.domain)) {
2230
2244
  if (isModelValue(element)) return isModelValueMember(element, set);