tla-ts 0.0.3-dev.6979965 → 0.0.3-dev.6ac5593
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/README.md +16 -2
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +72 -22
- package/dist/index.d.ts +72 -22
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +2 -2
- package/dist/parallel-worker.js +2 -2
- package/dist/parallel.cjs +1 -1
- package/dist/parallel.js +2 -2
- package/dist/run-cli.cjs +20 -17
- package/dist/run-cli.js +22 -19
- package/dist/transfer.cjs +46 -16
- package/dist/transfer.js +46 -16
- package/package.json +1 -1
- package/src/ast.ts +121 -4
- package/src/builtins.ts +9 -3
- package/src/check.ts +521 -105
- package/src/cli-options.ts +11 -5
- package/src/codegen.ts +15 -22
- package/src/config.ts +224 -170
- package/src/dependencies.ts +2 -2
- package/src/environment.ts +410 -130
- package/src/errors.ts +109 -3
- package/src/evaluate.ts +443 -194
- package/src/exit-codes.ts +39 -42
- package/src/fingerprints.ts +2 -1
- package/src/instances.ts +17 -16
- package/src/levels.ts +185 -44
- package/src/lexer.ts +5 -1
- package/src/live-check.ts +772 -0
- package/src/liveness.ts +120 -543
- package/src/parallel-worker.ts +102 -115
- package/src/parallel.ts +34 -23
- package/src/parser.ts +184 -54
- package/src/resolve.ts +1378 -420
- package/src/run-cli.ts +115 -20
- package/src/runtime.ts +3 -1
- package/src/sany-lexer.ts +615 -0
- package/src/sany-parse-error.ts +3143 -0
- package/src/spec-description.ts +19 -8
- package/src/standard-modules.ts +54 -45
- package/src/standard-ranges.ts +116 -0
- package/src/state-graph.ts +157 -0
- package/src/subexpressions.ts +231 -171
- package/src/substitution-levels.ts +38 -17
- package/src/successors.ts +184 -40
- package/src/symmetry.ts +123 -43
- package/src/tableau.ts +51 -24
- package/src/tlc-ext.ts +29 -12
- package/src/tlc-module.ts +14 -33
- package/src/tlc-modules.ts +4 -0
- package/src/tlc-order.ts +25 -7
- package/src/tlc-random.ts +9 -6
- package/src/tlc-summary.ts +20 -5
- package/src/value-sources.ts +29 -0
- package/src/values.ts +249 -65
package/src/successors.ts
CHANGED
|
@@ -1,28 +1,41 @@
|
|
|
1
|
-
import
|
|
1
|
+
import {
|
|
2
|
+
getChildren,
|
|
3
|
+
isLocallyResolved,
|
|
4
|
+
type Bound,
|
|
5
|
+
type Definition,
|
|
6
|
+
type Expression,
|
|
7
|
+
type QuantifierExpression,
|
|
8
|
+
} from "./ast";
|
|
2
9
|
import { getReadVariables } from "./dependencies";
|
|
3
|
-
import {
|
|
10
|
+
import {
|
|
11
|
+
TlaEvaluationError,
|
|
12
|
+
TlaIllegalStateError,
|
|
13
|
+
TlaIncompleteStateError,
|
|
14
|
+
TlaUnassignedError,
|
|
15
|
+
} from "./errors";
|
|
4
16
|
import { EXIT_STATUS, setExitCode } from "./exit-codes";
|
|
5
17
|
import {
|
|
6
18
|
describeLocation,
|
|
19
|
+
describeRange,
|
|
7
20
|
bindArgument,
|
|
8
21
|
bindDefinitions,
|
|
9
22
|
bindOperatorArguments,
|
|
10
23
|
bindValue,
|
|
11
24
|
compileArgumentScope,
|
|
12
25
|
evaluate,
|
|
26
|
+
getEntryEvaluator,
|
|
13
27
|
expectBoolean,
|
|
14
28
|
forEachBinding,
|
|
15
29
|
getBoundsDomain,
|
|
16
|
-
getChildren,
|
|
17
30
|
getDefinition,
|
|
18
31
|
getEnumeratedElements,
|
|
19
32
|
getReevaluatedDefinitions,
|
|
20
33
|
lookupScope,
|
|
21
34
|
resolveApplyOperator,
|
|
22
35
|
resolveGlobalOperator,
|
|
23
|
-
isLocallyResolved,
|
|
24
36
|
type Context,
|
|
25
37
|
type Environment,
|
|
38
|
+
type Evaluator,
|
|
26
39
|
type Scope,
|
|
27
40
|
type State,
|
|
28
41
|
} from "./evaluate";
|
|
@@ -45,6 +58,7 @@ export interface Successor {
|
|
|
45
58
|
interface Run {
|
|
46
59
|
environment: Environment;
|
|
47
60
|
isInit: boolean;
|
|
61
|
+
isEnabled: boolean;
|
|
48
62
|
current: Value[] | undefined;
|
|
49
63
|
isStopped: boolean;
|
|
50
64
|
}
|
|
@@ -81,25 +95,54 @@ const assign = (partial: State, index: number, value: Value) => {
|
|
|
81
95
|
return copy;
|
|
82
96
|
};
|
|
83
97
|
|
|
84
|
-
|
|
85
|
-
|
|
98
|
+
// TLC's Tool.getInitStates and Tool.getNextStates report a value where they expect a formula.
|
|
99
|
+
const expectFormula = (expression: Expression, value: Value, isInit: boolean) => {
|
|
86
100
|
if (typeof value === "boolean") return value;
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
101
|
+
throw new TlaEvaluationError(
|
|
102
|
+
`In computing ${isInit ? "initial" : "next"} states, TLC expected a boolean expression,\nbut instead found ${formatValue(value)}.\n${describeRange(expression)}`,
|
|
103
|
+
);
|
|
104
|
+
};
|
|
105
|
+
|
|
106
|
+
const holds = (expression: Expression, context: Context, value = evaluate(expression, context)) => {
|
|
107
|
+
// TLC rejects a number in the next-state relation when it splits the relation into actions.
|
|
108
|
+
if (context.next !== undefined && expression.kind === "Number") {
|
|
109
|
+
throw setExitCode(
|
|
110
|
+
new TlaEvaluationError(
|
|
111
|
+
`The next state relation is not a boolean expression.\n${expression.text ?? expression.value}`,
|
|
112
|
+
),
|
|
113
|
+
EXIT_STATUS.error,
|
|
114
|
+
);
|
|
92
115
|
}
|
|
116
|
+
return expectFormula(expression, value, context.next === undefined);
|
|
93
117
|
};
|
|
94
118
|
|
|
95
119
|
const isAssignmentOperator = (operator: string) =>
|
|
96
120
|
operator === "=" || operator === "\\in" || operator === "\\subseteq";
|
|
97
121
|
|
|
122
|
+
const tracedRunners = new WeakMap<Environment, WeakMap<Expression, Runner>[]>();
|
|
123
|
+
|
|
124
|
+
const getRunners = (environment: Environment, isInit: boolean) => {
|
|
125
|
+
if (!environment.trace) return isInit ? initRunners : nextRunners;
|
|
126
|
+
const runners = tracedRunners.get(environment) ?? [new WeakMap(), new WeakMap()];
|
|
127
|
+
tracedRunners.set(environment, runners);
|
|
128
|
+
return runners[isInit ? 0 : 1];
|
|
129
|
+
};
|
|
130
|
+
|
|
98
131
|
const getRunner = (expression: Expression, environment: Environment, isInit: boolean): Runner => {
|
|
99
|
-
const runners = isInit
|
|
132
|
+
const runners = getRunners(environment, isInit);
|
|
100
133
|
const cached = runners.get(expression);
|
|
101
134
|
if (cached) return cached;
|
|
102
|
-
const
|
|
135
|
+
const compiled = compileAction(expression, environment, isInit);
|
|
136
|
+
const trace = environment.trace;
|
|
137
|
+
// TLC's CallStackTool keeps an action's expression on the stack while the rest of the action runs.
|
|
138
|
+
const runner: Runner = trace
|
|
139
|
+
? (run, scope, partial, action, isFixed, onComplete) => {
|
|
140
|
+
const depth = trace.length;
|
|
141
|
+
trace.push(expression);
|
|
142
|
+
compiled(run, scope, partial, action, isFixed, onComplete);
|
|
143
|
+
trace.length = depth;
|
|
144
|
+
}
|
|
145
|
+
: compiled;
|
|
103
146
|
runners.set(expression, runner);
|
|
104
147
|
return runner;
|
|
105
148
|
};
|
|
@@ -183,6 +226,23 @@ const getUnchangedIndices = (
|
|
|
183
226
|
return getUnchangedIndices(definition.body, environment, visited);
|
|
184
227
|
};
|
|
185
228
|
|
|
229
|
+
// TLC's CallStackTool keeps each expression that UNCHANGED takes apart on the stack.
|
|
230
|
+
const getUnchangedFrames = (expression: Expression, environment: Environment): Expression[] => {
|
|
231
|
+
if (expression.kind === "Tuple") {
|
|
232
|
+
return [
|
|
233
|
+
expression,
|
|
234
|
+
...expression.elements.flatMap((element) => getUnchangedFrames(element, environment)),
|
|
235
|
+
];
|
|
236
|
+
}
|
|
237
|
+
const definition =
|
|
238
|
+
expression.kind === "Identifier" && !environment.variableIndex.has(expression.name)
|
|
239
|
+
? getZeroArityBody(expression.name, environment)
|
|
240
|
+
: undefined;
|
|
241
|
+
return definition
|
|
242
|
+
? [expression, ...getUnchangedFrames(definition.body, environment)]
|
|
243
|
+
: [expression];
|
|
244
|
+
};
|
|
245
|
+
|
|
186
246
|
const ACTION_KINDS = new Set([
|
|
187
247
|
"Label",
|
|
188
248
|
"And",
|
|
@@ -222,7 +282,7 @@ const NO_NAMES: ReadonlySet<string> = new Set();
|
|
|
222
282
|
|
|
223
283
|
// The local names an expression reads from enclosing scopes, or undefined when it applies a local
|
|
224
284
|
// operator, whose body may assign variables.
|
|
225
|
-
const getReadLocals = (
|
|
285
|
+
export const getReadLocals = (
|
|
226
286
|
expression: Expression,
|
|
227
287
|
bound: ReadonlySet<string>,
|
|
228
288
|
): string[] | undefined => {
|
|
@@ -287,12 +347,35 @@ const toConjunct = (
|
|
|
287
347
|
return { kind: "Branch", expression, runner: getRunner(expression, environment, isInit) };
|
|
288
348
|
};
|
|
289
349
|
|
|
350
|
+
// The leading guards of `\E x \in S, y \in T : P /\ Q` that read no inner bound hold for every inner
|
|
351
|
+
// binding alike, so they can run once for each element of the outermost bound.
|
|
352
|
+
const getHoistedGuards = (expression: QuantifierExpression, environment: Environment) => {
|
|
353
|
+
if (expression.bounds.length < 2 || expression.body.kind !== "And") return undefined;
|
|
354
|
+
const names = expression.bounds.flatMap((bound) =>
|
|
355
|
+
bound.pattern.kind === "Name" ? [bound.pattern.name] : [],
|
|
356
|
+
);
|
|
357
|
+
if (names.length !== expression.bounds.length) return undefined;
|
|
358
|
+
const innerNames = new Set(names.slice(0, -1));
|
|
359
|
+
const operands = expression.body.operands;
|
|
360
|
+
const index = operands.findIndex((operand) => {
|
|
361
|
+
if (getReadVariables(operand, environment) === undefined) return true;
|
|
362
|
+
if (hasBranches(operand, environment, new Set())) return true;
|
|
363
|
+
const readLocals = getReadLocals(operand, NO_NAMES);
|
|
364
|
+
return !readLocals || readLocals.some((name) => innerNames.has(name));
|
|
365
|
+
});
|
|
366
|
+
const count = index === -1 ? operands.length : index;
|
|
367
|
+
if (count === 0) return undefined;
|
|
368
|
+
return { names, guards: operands.slice(0, count), rest: operands.slice(count) };
|
|
369
|
+
};
|
|
370
|
+
|
|
290
371
|
const compileConjunction = (
|
|
291
372
|
operands: Expression[],
|
|
292
373
|
environment: Environment,
|
|
293
374
|
isInit: boolean,
|
|
294
375
|
): Runner => {
|
|
295
376
|
const conjuncts = operands.map((operand) => toConjunct(operand, environment, isInit));
|
|
377
|
+
const evaluators: (Evaluator | undefined)[] = conjuncts.map(() => undefined);
|
|
378
|
+
const trace = environment.trace;
|
|
296
379
|
const runFrom = (
|
|
297
380
|
start: number,
|
|
298
381
|
run: Run,
|
|
@@ -313,14 +396,25 @@ const compileConjunction = (
|
|
|
313
396
|
return;
|
|
314
397
|
}
|
|
315
398
|
const conjunct = conjuncts[index];
|
|
399
|
+
if (trace) {
|
|
400
|
+
trace.push(conjunct.expression);
|
|
401
|
+
if (conjunct.expression.kind === "Unchanged") {
|
|
402
|
+
trace.push(...getUnchangedFrames(conjunct.expression.expression, environment));
|
|
403
|
+
}
|
|
404
|
+
}
|
|
316
405
|
if (conjunct.kind === "Guard") {
|
|
317
406
|
context ??= getContext(run, scope, current);
|
|
318
|
-
|
|
407
|
+
const evaluator = (evaluators[index] ??= getEntryEvaluator(
|
|
408
|
+
conjunct.expression,
|
|
409
|
+
environment,
|
|
410
|
+
));
|
|
411
|
+
if (!holds(conjunct.expression, context, evaluator(context))) return;
|
|
319
412
|
continue;
|
|
320
413
|
}
|
|
321
414
|
if (conjunct.kind === "Assign") {
|
|
322
415
|
context ??= getContext(run, scope, current);
|
|
323
|
-
const
|
|
416
|
+
const evaluator = (evaluators[index] ??= getEntryEvaluator(conjunct.value, environment));
|
|
417
|
+
const value = evaluator(context);
|
|
324
418
|
const assigned = current[conjunct.index];
|
|
325
419
|
if (assigned === undefined) {
|
|
326
420
|
current = assign(current, conjunct.index, value);
|
|
@@ -357,10 +451,7 @@ const compileConjunction = (
|
|
|
357
451
|
};
|
|
358
452
|
|
|
359
453
|
const holdsInInit = (expression: Expression, context: Context) =>
|
|
360
|
-
|
|
361
|
-
evaluate(expression, context),
|
|
362
|
-
`the initial predicate at ${describeLocation(expression)}`,
|
|
363
|
-
);
|
|
454
|
+
expectFormula(expression, evaluate(expression, context), true);
|
|
364
455
|
|
|
365
456
|
const compileGuard =
|
|
366
457
|
(expression: Expression): Runner =>
|
|
@@ -385,7 +476,7 @@ const compileMembership = (
|
|
|
385
476
|
expression.operator === "\\subseteq" ? { kind: "Subset", base: evaluated } : evaluated;
|
|
386
477
|
if (!isEnumerable(value)) {
|
|
387
478
|
throw new TlaEvaluationError(
|
|
388
|
-
`In computing next states, the right side of \\
|
|
479
|
+
`In computing ${run.isInit ? "initial" : "next"} states, the right side of \\IN is not enumerable.\n${describeRange(expression)}`,
|
|
389
480
|
);
|
|
390
481
|
}
|
|
391
482
|
const elements = getStreamedElements(value);
|
|
@@ -729,6 +820,34 @@ const compileAction = (
|
|
|
729
820
|
}
|
|
730
821
|
};
|
|
731
822
|
}
|
|
823
|
+
const hoisted =
|
|
824
|
+
isInit || environment.trace ? undefined : getHoistedGuards(expression, environment);
|
|
825
|
+
if (hoisted) {
|
|
826
|
+
const rest = compileConjunction(hoisted.rest, environment, isInit);
|
|
827
|
+
return (run, scope, partial, action, isFixed, onComplete) => {
|
|
828
|
+
const context = getContext(run, scope, partial);
|
|
829
|
+
const sets = expression.bounds.map((innerBound) =>
|
|
830
|
+
getEnumeratedElements(evaluate(innerBound.set, context), innerBound.set),
|
|
831
|
+
);
|
|
832
|
+
if (sets.some((elements) => elements.length === 0)) return;
|
|
833
|
+
const visit = (index: number, boundScope: Scope | undefined): void => {
|
|
834
|
+
if (index < 0) {
|
|
835
|
+
rest(run, boundScope, partial, action, isFixed, onComplete);
|
|
836
|
+
return;
|
|
837
|
+
}
|
|
838
|
+
for (const element of sets[index]) {
|
|
839
|
+
if (run.isStopped) return;
|
|
840
|
+
const elementScope = bindValue(boundScope, hoisted.names[index], element);
|
|
841
|
+
if (index === sets.length - 1) {
|
|
842
|
+
const guardContext = getContext(run, elementScope, partial);
|
|
843
|
+
if (!hoisted.guards.every((guard) => holds(guard, guardContext))) continue;
|
|
844
|
+
}
|
|
845
|
+
visit(index - 1, elementScope);
|
|
846
|
+
}
|
|
847
|
+
};
|
|
848
|
+
visit(sets.length - 1, scope);
|
|
849
|
+
};
|
|
850
|
+
}
|
|
732
851
|
return (run, scope, partial, action, isFixed, onComplete) => {
|
|
733
852
|
forEachBinding(expression.bounds, getContext(run, scope, partial), (boundScope) => {
|
|
734
853
|
body(run, boundScope, partial, action, isFixed, onComplete);
|
|
@@ -804,7 +923,9 @@ const compileAction = (
|
|
|
804
923
|
);
|
|
805
924
|
const body = arm?.body ?? other;
|
|
806
925
|
if (!body)
|
|
807
|
-
throw new TlaEvaluationError(
|
|
926
|
+
throw new TlaEvaluationError(
|
|
927
|
+
`In computing ${run.isInit ? "initial" : "next"} states, TLC encountered a CASE with no conditions true.\n${describeRange(expression)}`,
|
|
928
|
+
);
|
|
808
929
|
body(run, scope, partial, action, isFixed, onComplete);
|
|
809
930
|
};
|
|
810
931
|
}
|
|
@@ -835,8 +956,17 @@ const compileAction = (
|
|
|
835
956
|
const unchanged = getUnchangedWrapper(expression.subscript);
|
|
836
957
|
return (run, scope, partial, action, isFixed, onComplete) =>
|
|
837
958
|
body(run, scope, partial, action, isFixed, (nextPartial, nextAction) => {
|
|
838
|
-
|
|
839
|
-
|
|
959
|
+
// ENABLED evaluates the subscript on the successor that the action specifies. TLC names
|
|
960
|
+
// a variable that the action leaves without a value.
|
|
961
|
+
try {
|
|
962
|
+
if (!holds(unchanged, getContext(run, scope, nextPartial)))
|
|
963
|
+
onComplete(nextPartial, nextAction);
|
|
964
|
+
} catch (error) {
|
|
965
|
+
if (!run.isEnabled || !(error instanceof TlaUnassignedError)) throw error;
|
|
966
|
+
throw new TlaEvaluationError(
|
|
967
|
+
`The action formula A appearing in a WF_v(A) or SF_v(A) operator does not specify the primed value of the variable ${error.variable} occurring in the state formula v.\n`,
|
|
968
|
+
);
|
|
969
|
+
}
|
|
840
970
|
});
|
|
841
971
|
}
|
|
842
972
|
case "BoxAction":
|
|
@@ -913,18 +1043,25 @@ export const isEnabled = (expression: Expression, context: Context): boolean =>
|
|
|
913
1043
|
);
|
|
914
1044
|
}
|
|
915
1045
|
const environment = context.environment;
|
|
916
|
-
const
|
|
1046
|
+
const run: Run = {
|
|
1047
|
+
environment,
|
|
1048
|
+
isInit: false,
|
|
1049
|
+
isEnabled: true,
|
|
1050
|
+
current: state,
|
|
1051
|
+
isStopped: false,
|
|
1052
|
+
};
|
|
1053
|
+
// TLC stops computing ENABLED at the first successor, so it skips the rest of the action.
|
|
917
1054
|
getRunner(expression, environment, false)(
|
|
918
|
-
|
|
1055
|
+
run,
|
|
919
1056
|
context.scope,
|
|
920
1057
|
getEmptyState(environment),
|
|
921
1058
|
undefined,
|
|
922
1059
|
false,
|
|
923
1060
|
() => {
|
|
924
|
-
|
|
1061
|
+
run.isStopped = true;
|
|
925
1062
|
},
|
|
926
1063
|
);
|
|
927
|
-
return
|
|
1064
|
+
return run.isStopped;
|
|
928
1065
|
};
|
|
929
1066
|
|
|
930
1067
|
export const forEachInitialState = (
|
|
@@ -933,7 +1070,13 @@ export const forEachInitialState = (
|
|
|
933
1070
|
onState: (state: Value[]) => boolean,
|
|
934
1071
|
scope?: Scope,
|
|
935
1072
|
) => {
|
|
936
|
-
const run: Run = {
|
|
1073
|
+
const run: Run = {
|
|
1074
|
+
environment,
|
|
1075
|
+
isInit: true,
|
|
1076
|
+
isEnabled: false,
|
|
1077
|
+
current: undefined,
|
|
1078
|
+
isStopped: false,
|
|
1079
|
+
};
|
|
937
1080
|
getRunner(expression, environment, true)(
|
|
938
1081
|
run,
|
|
939
1082
|
scope,
|
|
@@ -943,14 +1086,7 @@ export const forEachInitialState = (
|
|
|
943
1086
|
(partial) => {
|
|
944
1087
|
if (run.isStopped) return;
|
|
945
1088
|
if (!isComplete(partial)) {
|
|
946
|
-
|
|
947
|
-
// an evaluation failure.
|
|
948
|
-
throw setExitCode(
|
|
949
|
-
new TlaEvaluationError(
|
|
950
|
-
`The initial predicate does not assign ${getMissingVariables(partial, environment).join(", ")}`,
|
|
951
|
-
),
|
|
952
|
-
EXIT_STATUS.error,
|
|
953
|
-
);
|
|
1089
|
+
throw setExitCode(new TlaIllegalStateError(partial), EXIT_STATUS.error);
|
|
954
1090
|
}
|
|
955
1091
|
run.isStopped = onState(partial);
|
|
956
1092
|
},
|
|
@@ -982,7 +1118,13 @@ export const forEachSuccessor = (
|
|
|
982
1118
|
onSuccessor: (successor: Successor) => boolean,
|
|
983
1119
|
scope?: Scope,
|
|
984
1120
|
) => {
|
|
985
|
-
const run: Run = {
|
|
1121
|
+
const run: Run = {
|
|
1122
|
+
environment,
|
|
1123
|
+
isInit: false,
|
|
1124
|
+
isEnabled: false,
|
|
1125
|
+
current: state,
|
|
1126
|
+
isStopped: false,
|
|
1127
|
+
};
|
|
986
1128
|
const counter = { successors: 0 };
|
|
987
1129
|
getRunner(expression, environment, false)(
|
|
988
1130
|
run,
|
|
@@ -993,8 +1135,10 @@ export const forEachSuccessor = (
|
|
|
993
1135
|
(partial, action) => {
|
|
994
1136
|
if (run.isStopped) return;
|
|
995
1137
|
if (!isComplete(partial)) {
|
|
996
|
-
throw new
|
|
997
|
-
|
|
1138
|
+
throw new TlaIncompleteStateError(
|
|
1139
|
+
partial,
|
|
1140
|
+
action,
|
|
1141
|
+
getMissingVariables(partial, environment).sort(),
|
|
998
1142
|
);
|
|
999
1143
|
}
|
|
1000
1144
|
counter.successors++;
|
package/src/symmetry.ts
CHANGED
|
@@ -1,5 +1,6 @@
|
|
|
1
|
-
import { TlaConfigError } from "./errors";
|
|
1
|
+
import { TlaConfigError, TlaEvaluationError, UNEXPECTED_EXCEPTION } from "./errors";
|
|
2
2
|
import { evaluate, type Environment } from "./evaluate";
|
|
3
|
+
import { EXIT_STATUS, setExitCode } from "./exit-codes";
|
|
3
4
|
import {
|
|
4
5
|
compareValues,
|
|
5
6
|
createFunction,
|
|
@@ -9,6 +10,7 @@ import {
|
|
|
9
10
|
isEnumerable,
|
|
10
11
|
isFunctionValue,
|
|
11
12
|
isModelValue,
|
|
13
|
+
isSameValue,
|
|
12
14
|
isSetValue,
|
|
13
15
|
toFiniteFunction,
|
|
14
16
|
toFiniteSet,
|
|
@@ -29,6 +31,20 @@ interface Permutation {
|
|
|
29
31
|
cacheLimit: number;
|
|
30
32
|
}
|
|
31
33
|
|
|
34
|
+
// The images of one value under every permutation, the identity first, and how each image compares
|
|
35
|
+
// with the image of each permutation the search has held as the smallest.
|
|
36
|
+
interface Orbit {
|
|
37
|
+
images: Value[];
|
|
38
|
+
comparisons: (Int8Array | undefined)[];
|
|
39
|
+
}
|
|
40
|
+
|
|
41
|
+
interface SymmetryGroup {
|
|
42
|
+
permutations: Permutation[];
|
|
43
|
+
orbits: WeakMap<ObjectValue, Orbit>;
|
|
44
|
+
orbitCount: number;
|
|
45
|
+
orbitLimit: number;
|
|
46
|
+
}
|
|
47
|
+
|
|
32
48
|
const getPermutationKey = (permutation: Images) =>
|
|
33
49
|
[...permutation]
|
|
34
50
|
.map(([name, image]) => `${name}>${image.name}`)
|
|
@@ -46,9 +62,13 @@ const composePermutations = (first: Images, second: Images) => {
|
|
|
46
62
|
return composed;
|
|
47
63
|
};
|
|
48
64
|
|
|
49
|
-
|
|
65
|
+
// TLC checks the symmetry set outside any phase that reports an error itself.
|
|
66
|
+
const createSymmetryError = (message: string) =>
|
|
67
|
+
setExitCode(new TlaEvaluationError(`${UNEXPECTED_EXCEPTION}${message}`), EXIT_STATUS.error);
|
|
68
|
+
|
|
69
|
+
const toImages = (value: Value) => {
|
|
50
70
|
if (!isFunctionValue(value)) {
|
|
51
|
-
throw
|
|
71
|
+
throw createSymmetryError("The symmetry values must be function records.");
|
|
52
72
|
}
|
|
53
73
|
const functionValue = toFiniteFunction(value);
|
|
54
74
|
const permutation: Images = new Map();
|
|
@@ -62,10 +82,18 @@ const toImages = (value: Value, name: string) => {
|
|
|
62
82
|
return permutation;
|
|
63
83
|
};
|
|
64
84
|
|
|
65
|
-
export const getSymmetryGroup = (
|
|
85
|
+
export const getSymmetryGroup = (
|
|
86
|
+
name: string,
|
|
87
|
+
environment: Environment,
|
|
88
|
+
): SymmetryGroup | undefined => {
|
|
66
89
|
const definition = environment.definitions.get(name);
|
|
90
|
+
if (definition === undefined && !environment.constants.has(name)) {
|
|
91
|
+
throw new TlaConfigError(
|
|
92
|
+
`The symmetry function ${name} specified in the configuration file\nis not defined in the specification.`,
|
|
93
|
+
);
|
|
94
|
+
}
|
|
67
95
|
if (definition?.kind !== "Operator" || definition.params.length > 0) {
|
|
68
|
-
throw
|
|
96
|
+
throw createSymmetryError(`The symmetry function ${name} must specify a set of permutations.`);
|
|
69
97
|
}
|
|
70
98
|
const value = evaluate(definition.body, {
|
|
71
99
|
environment,
|
|
@@ -74,12 +102,12 @@ export const getSymmetryGroup = (name: string, environment: Environment): Permut
|
|
|
74
102
|
next: undefined,
|
|
75
103
|
});
|
|
76
104
|
if (!isSetValue(value) || !isEnumerable(value)) {
|
|
77
|
-
throw
|
|
105
|
+
throw createSymmetryError("The symmetry operator must specify a set of functions.");
|
|
78
106
|
}
|
|
79
|
-
const permutations = toFiniteSet(value).elements.map(
|
|
107
|
+
const permutations = toFiniteSet(value).elements.map(toImages);
|
|
80
108
|
const isDisabled =
|
|
81
109
|
definition.body.kind === "Apply" && definition.body.args.length >= permutations.length;
|
|
82
|
-
if (isDisabled) return
|
|
110
|
+
if (isDisabled) return undefined;
|
|
83
111
|
const group = new Map<string, Images>();
|
|
84
112
|
permutations.forEach((permutation) => {
|
|
85
113
|
if (permutation.size > 0) group.set(getPermutationKey(permutation), permutation);
|
|
@@ -98,13 +126,19 @@ export const getSymmetryGroup = (name: string, environment: Environment): Permut
|
|
|
98
126
|
);
|
|
99
127
|
frontier.start = end;
|
|
100
128
|
}
|
|
129
|
+
if (group.size === 0) return undefined;
|
|
101
130
|
const cacheLimit = Math.max(256, Math.floor(CACHE_LIMIT / group.size));
|
|
102
|
-
return
|
|
103
|
-
images
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
131
|
+
return {
|
|
132
|
+
permutations: [...group.values()].map((images) => ({
|
|
133
|
+
images,
|
|
134
|
+
cache: new WeakMap<ObjectValue, Value>(),
|
|
135
|
+
cacheSize: 0,
|
|
136
|
+
cacheLimit,
|
|
137
|
+
})),
|
|
138
|
+
orbits: new WeakMap(),
|
|
139
|
+
orbitCount: 0,
|
|
140
|
+
orbitLimit: cacheLimit,
|
|
141
|
+
};
|
|
108
142
|
};
|
|
109
143
|
|
|
110
144
|
const permuteElements = (elements: Value[], permutation: Permutation) => {
|
|
@@ -163,7 +197,10 @@ const permuteValue = (value: Value, permutation: Permutation): Value => {
|
|
|
163
197
|
if (size === 0 || size > CACHED_SIZE_LIMIT) return computePermutedValue(value, permutation);
|
|
164
198
|
const cached = permutation.cache.get(value);
|
|
165
199
|
if (cached !== undefined) return cached;
|
|
166
|
-
const
|
|
200
|
+
const computed = computePermutedValue(value, permutation);
|
|
201
|
+
// A permutation often maps a value to an equal one. Keeping the original lets the comparison
|
|
202
|
+
// with the smallest state so far stop at identity.
|
|
203
|
+
const permuted = computed !== value && isSameValue(computed, value) ? value : computed;
|
|
167
204
|
if (permutation.cacheSize >= permutation.cacheLimit) {
|
|
168
205
|
permutation.cache = new WeakMap();
|
|
169
206
|
permutation.cacheSize = 0;
|
|
@@ -184,7 +221,15 @@ const computePermutedValue = (value: ObjectValue, permutation: Permutation) => {
|
|
|
184
221
|
const domain = permuteElements(functionValue.domain, permutation);
|
|
185
222
|
const range = permuteElements(functionValue.range, permutation) ?? functionValue.range;
|
|
186
223
|
if (domain) {
|
|
187
|
-
|
|
224
|
+
const permuted = createFunction(
|
|
225
|
+
domain.map((key, index): [Value, Value] => [key, range[index]]),
|
|
226
|
+
);
|
|
227
|
+
// A permutation often maps the domain to itself, such as a function over the symmetric set.
|
|
228
|
+
// Sharing the original domain array lets comparisons with other images skip the domain.
|
|
229
|
+
const isSameDomain = permuted.domain.every(
|
|
230
|
+
(key, index) => key === functionValue.domain[index],
|
|
231
|
+
);
|
|
232
|
+
return isSameDomain ? createSortedFunction(functionValue.domain, permuted.range) : permuted;
|
|
188
233
|
}
|
|
189
234
|
return range === functionValue.range
|
|
190
235
|
? functionValue
|
|
@@ -196,41 +241,76 @@ const computePermutedValue = (value: ObjectValue, permutation: Permutation) => {
|
|
|
196
241
|
return elements ? createSet(elements) : set;
|
|
197
242
|
};
|
|
198
243
|
|
|
199
|
-
const
|
|
200
|
-
|
|
201
|
-
|
|
244
|
+
const getOrbit = (value: ObjectValue, group: SymmetryGroup) => {
|
|
245
|
+
const cached = group.orbits.get(value);
|
|
246
|
+
if (cached !== undefined) return cached;
|
|
247
|
+
if (group.orbitCount >= group.orbitLimit) {
|
|
248
|
+
group.orbits = new WeakMap();
|
|
249
|
+
group.orbitCount = 0;
|
|
202
250
|
}
|
|
203
|
-
|
|
251
|
+
const orbit: Orbit = { images: [value], comparisons: [] };
|
|
252
|
+
group.orbits.set(value, orbit);
|
|
253
|
+
group.orbitCount++;
|
|
254
|
+
return orbit;
|
|
204
255
|
};
|
|
205
256
|
|
|
206
|
-
const
|
|
257
|
+
const getImage = (orbit: Orbit, permutation: number, group: SymmetryGroup) =>
|
|
258
|
+
(orbit.images[permutation] ??= permuteValue(
|
|
259
|
+
orbit.images[0],
|
|
260
|
+
group.permutations[permutation - 1],
|
|
261
|
+
));
|
|
262
|
+
|
|
263
|
+
// Two images of a value compare the same way every time, and comparing them again changes nothing,
|
|
264
|
+
// so an orbit compares each pair once.
|
|
265
|
+
const compareImages = (
|
|
266
|
+
value: ObjectValue,
|
|
267
|
+
permutation: number,
|
|
268
|
+
minimum: number,
|
|
269
|
+
group: SymmetryGroup,
|
|
270
|
+
) => {
|
|
271
|
+
const orbit = getOrbit(value, group);
|
|
272
|
+
const comparisons = (orbit.comparisons[minimum] ??= new Int8Array(group.permutations.length + 1));
|
|
273
|
+
if (comparisons[permutation] === 0) {
|
|
274
|
+
const comparison = compareValues(
|
|
275
|
+
getImage(orbit, permutation, group),
|
|
276
|
+
getImage(orbit, minimum, group),
|
|
277
|
+
);
|
|
278
|
+
comparisons[permutation] = Math.sign(comparison) + 2;
|
|
279
|
+
}
|
|
280
|
+
return comparisons[permutation] - 2;
|
|
281
|
+
};
|
|
282
|
+
|
|
283
|
+
const isSmallerImage = (
|
|
207
284
|
state: Value[],
|
|
208
|
-
|
|
209
|
-
|
|
210
|
-
|
|
285
|
+
permutation: number,
|
|
286
|
+
minimum: number,
|
|
287
|
+
group: SymmetryGroup,
|
|
288
|
+
order: number[],
|
|
211
289
|
) => {
|
|
212
|
-
const
|
|
213
|
-
|
|
214
|
-
const
|
|
215
|
-
|
|
216
|
-
|
|
217
|
-
if (comparison > 0) return undefined;
|
|
218
|
-
if (!order) permuted.push(value);
|
|
219
|
-
if (comparison < 0) {
|
|
220
|
-
return order
|
|
221
|
-
? state.map((item) => permuteValue(item, permutation))
|
|
222
|
-
: permuteRemaining(state, permuted, permutation);
|
|
223
|
-
}
|
|
290
|
+
for (const index of order) {
|
|
291
|
+
const value = state[index];
|
|
292
|
+
const comparison =
|
|
293
|
+
typeof value === "object" ? compareImages(value, permutation, minimum, group) : 0;
|
|
294
|
+
if (comparison !== 0) return comparison < 0;
|
|
224
295
|
}
|
|
225
|
-
return
|
|
296
|
+
return false;
|
|
226
297
|
};
|
|
227
298
|
|
|
299
|
+
// TLC keeps the smallest image of the state in its variable order, replacing it only with a
|
|
300
|
+
// strictly smaller one.
|
|
228
301
|
export const getRepresentative = (
|
|
229
302
|
state: Value[],
|
|
230
|
-
group:
|
|
231
|
-
order
|
|
232
|
-
): Value[] =>
|
|
233
|
-
group.reduce(
|
|
234
|
-
(
|
|
235
|
-
|
|
303
|
+
group: SymmetryGroup,
|
|
304
|
+
order: number[],
|
|
305
|
+
): Value[] => {
|
|
306
|
+
const minimum = group.permutations.reduce(
|
|
307
|
+
(smallest, _, index) =>
|
|
308
|
+
isSmallerImage(state, index + 1, smallest, group, order) ? index + 1 : smallest,
|
|
309
|
+
0,
|
|
236
310
|
);
|
|
311
|
+
return minimum === 0
|
|
312
|
+
? state
|
|
313
|
+
: state.map((value) =>
|
|
314
|
+
typeof value === "object" ? getImage(getOrbit(value, group), minimum, group) : value,
|
|
315
|
+
);
|
|
316
|
+
};
|