tla-ts 0.0.3-dev.e946acb → 0.0.3-dev.eba78ea

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/src/run-cli.ts CHANGED
@@ -19,20 +19,22 @@ import {
19
19
  TlaError,
20
20
  TlaEvaluationError,
21
21
  TlaProofError,
22
+ TlaSyntaxError,
22
23
  } from "./errors";
23
24
  import { EXIT_STATUS } from "./exit-codes";
24
25
  import type { LineRange } from "./obligation-generate";
25
26
  import { getAtPrefix, getLocusText } from "./obligation-expression";
26
27
  import { formatSummary, getObligations, WHOLE_MODULE, type ModuleObligations } from "./obligations";
27
28
  import { check } from "./parallel";
28
- import { prettyPrint } from "./pretty-print";
29
+ import { parseModule } from "./parser";
30
+ import type { StateDump } from "./state-graph";
29
31
  import {
30
32
  formatProbability,
31
33
  getActualProbability,
32
34
  getOptimisticProbability,
33
35
  getOutDegreeSummary,
34
36
  } from "./tlc-summary";
35
- import { formatValue, type Value } from "./values";
37
+ import { formatState, type Value } from "./values";
36
38
 
37
39
  const EXIT_CODES: Record<CheckStatus, number> = {
38
40
  success: EXIT_STATUS.success,
@@ -48,6 +50,11 @@ const EXIT_CODES: Record<CheckStatus, number> = {
48
50
  const CHECK_COMMAND = defineCommand("tla-ts <Spec.tla|Spec.cfg|glob>... {options}", [
49
51
  { flag: "-config <Spec.cfg>" },
50
52
  { flag: "-deadlock" },
53
+ // Like TLC, -dump takes a format only when the next argument starts with dot and a file follows.
54
+ {
55
+ flag: "-dump [<format>] <file>",
56
+ getArity: (rest) => (rest.length > 1 && rest[0].startsWith("dot") ? 2 : 1),
57
+ },
51
58
  { flag: "-lncheck <final|default>" },
52
59
  { flag: "-seed <num>" },
53
60
  { flag: "-workers <count|auto>" },
@@ -95,14 +102,24 @@ const getWorkerCount = (values: string[] | undefined) => {
95
102
  : Math.max(1, Number.parseInt(values[0], 10) || 1);
96
103
  };
97
104
 
98
- const printState = (state: Record<string, Value>) => {
99
- const entries = Object.entries(state);
100
- entries.forEach(([name, value]) =>
101
- console.log(
102
- `${entries.length === 1 ? "" : "/\\ "}${name} = ${prettyPrint(formatValue(value))}`,
103
- ),
104
- );
105
- console.log("");
105
+ const printState = (state: Record<string, Value>) => console.log(formatState(state));
106
+
107
+ const UNSUPPORTED_DUMP_FORMATS = ["constrained", "stuttering", "strict"];
108
+
109
+ // TLC names the file of a -dump by its format unless the name already ends that way.
110
+ const getDumpPath = (path: string, extension: string) =>
111
+ path.endsWith(extension) ? path : `${path}${extension}`;
112
+
113
+ const getDump = (values: string[]): StateDump => {
114
+ if (values.length === 1) return { path: getDumpPath(values[0], ".dump") };
115
+ const format = values[0].toLowerCase();
116
+ return {
117
+ path: getDumpPath(values[1], ".dot"),
118
+ dot: true,
119
+ colorize: format.includes("colorize"),
120
+ actionLabels: format.includes("actionlabels"),
121
+ snapshot: format.includes("snapshot"),
122
+ };
106
123
  };
107
124
 
108
125
  const printTrace = (trace: TraceStep[], heading = "Error: The behavior up to this point is:") => {
@@ -113,6 +130,11 @@ const printTrace = (trace: TraceStep[], heading = "Error: The behavior up to thi
113
130
  });
114
131
  };
115
132
 
133
+ const getTemporalHeadline = (names: string[]) =>
134
+ names.length === 1
135
+ ? `Error: Temporal property ${names[0]} was violated.\n`
136
+ : `Error: Temporal properties ${names.slice(0, -1).join(", ")}${names.length > 2 ? "," : ""} and ${names[names.length - 1]} were violated.\n`;
137
+
116
138
  const printResult = (result: CheckResult) => {
117
139
  if (result.failure) {
118
140
  console.log(`Error: ${result.failure.message}`);
@@ -140,10 +162,10 @@ const printResult = (result: CheckResult) => {
140
162
  "invariant-violation": isInitial
141
163
  ? `Error: Invariant ${name} is violated by the initial state:`
142
164
  : `Error: Invariant ${name} is violated.`,
143
- "property-violation": `Error: Property ${name} is violated.`,
165
+ "property-violation": getTemporalHeadline(violation.properties ?? [name]),
144
166
  "liveness-violation":
145
167
  loopStart !== undefined
146
- ? `Error: Temporal property ${name} was violated.\n`
168
+ ? getTemporalHeadline(violation.properties ?? [name])
147
169
  : isInitial
148
170
  ? `Error: Property ${name} is violated by the initial state:`
149
171
  : `Error: Action property ${name} is violated.`,
@@ -152,6 +174,8 @@ const printResult = (result: CheckResult) => {
152
174
  if (violation.counts) console.log(violation.counts);
153
175
  console.log(headline);
154
176
  if (isInitial) printState(violation.trace[0].state);
177
+ else if (result.status === "property-violation")
178
+ printTrace(violation.trace, "Error: The following behavior constitutes a counter-example:\n");
155
179
  else if (loopStart === undefined) printTrace(violation.trace);
156
180
  else {
157
181
  printTrace(violation.trace, "Error: The following behavior constitutes a counter-example:\n");
@@ -191,6 +215,14 @@ const checkSpec = async (specPath: string, args: ParsedArgs) => {
191
215
  console.error(`Cannot find the specification file ${specPath}`);
192
216
  return EXIT_STATUS.configParseError;
193
217
  }
218
+ const source = readFileSync(specPath, "utf8");
219
+ const fileName = basename(specPath, ".tla");
220
+ const moduleName = parseModule(source).name;
221
+ if (moduleName !== fileName) {
222
+ throw new TlaSyntaxError(
223
+ `File name '${fileName}' does not match the name '${moduleName}' of the top level module it contains.`,
224
+ );
225
+ }
194
226
  const configPath =
195
227
  args.get("-config")?.[0] ??
196
228
  (args.has("-config") ? undefined : specPath.replace(/\.tla$/, ".cfg"));
@@ -214,13 +246,26 @@ const checkSpec = async (specPath: string, args: ParsedArgs) => {
214
246
  console.error("Error: expect a strategy such as final for -lncheck option.");
215
247
  return 1;
216
248
  }
249
+ const dumpValues = args.get("-dump");
250
+ if (dumpValues?.length === 0) {
251
+ console.error("Error: A file name for dumping states required.");
252
+ return 1;
253
+ }
254
+ const unsupportedFormat =
255
+ dumpValues?.length === 2 &&
256
+ UNSUPPORTED_DUMP_FORMATS.find((format) => dumpValues[0].toLowerCase().includes(format));
257
+ if (unsupportedFormat) {
258
+ console.error(`Error: tla-ts does not support the -dump format ${unsupportedFormat}.`);
259
+ return 1;
260
+ }
217
261
  const directory = dirname(specPath);
218
262
  console.log(`Checking ${basename(specPath)} with ${basename(configPath)}`);
219
263
  const result = await check({
220
264
  workers: getWorkerCount(args.get("-workers")),
221
265
  livenessCheck: ["final", "seqfinal", "off"].includes(livenessCheck) ? "final" : "default",
222
266
  seed: BigInt(seed),
223
- source: readFileSync(specPath, "utf8"),
267
+ dump: dumpValues && getDump(dumpValues),
268
+ source,
224
269
  config,
225
270
  onPause: () => readSync(0, Buffer.alloc(1)),
226
271
  loadModule: (name) => {
package/src/runtime.ts CHANGED
@@ -6,7 +6,7 @@ export interface CheckerRuntime {
6
6
  getBehavior: (state: Value[]) => Value[][];
7
7
  getSpecification: () => Value;
8
8
  counterExample: Value | undefined;
9
- setLivenessSource: (index: number) => void;
9
+ setLivenessSource: (index: number | undefined) => void;
10
10
  getCurrentState: () => Value[] | undefined;
11
11
  getFingerprint: (state: Value[]) => bigint;
12
12
  getRandom: () => JavaRandom;
@@ -24,6 +24,7 @@ export interface CheckerRuntime {
24
24
  properties: Map<string, string>;
25
25
  possibleCounts: Map<string, number>;
26
26
  isStopped: boolean;
27
+ isStarted: boolean;
27
28
  checkDeadlock: boolean;
28
29
  startedAt: number;
29
30
  }
@@ -75,6 +76,7 @@ export const createRuntime = (checkDeadlock: boolean, seed = 0n): CheckerRuntime
75
76
  properties: new Map(),
76
77
  possibleCounts: new Map(),
77
78
  isStopped: false,
79
+ isStarted: false,
78
80
  checkDeadlock,
79
81
  startedAt: Date.now(),
80
82
  };
@@ -1,4 +1,10 @@
1
- import type { Definition, Expression, SourceLocation, SourceRange } from "./ast";
1
+ import {
2
+ isLocallyResolved,
3
+ type Definition,
4
+ type Expression,
5
+ type SourceLocation,
6
+ type SourceRange,
7
+ } from "./ast";
2
8
  import type { ModelConfig } from "./config";
3
9
  import type { InstanceAction } from "./environment";
4
10
  import { TlaError } from "./errors";
@@ -10,7 +16,6 @@ import {
10
16
  formatRange,
11
17
  getDefinition,
12
18
  isConstantLevel,
13
- isLocallyResolved,
14
19
  lookupScope,
15
20
  resolveGlobalOperator,
16
21
  type Closure,
@@ -464,10 +469,17 @@ export const getNextActions = (
464
469
  instanceActions: Map<string, InstanceAction>,
465
470
  ) => describe(config, environment, instanceActions).actions;
466
471
 
467
- export const getActionLabel = (action: SpecAction) => {
468
- const parameters = action.parameters.map((parameter) => formatValue(parameter[1]));
469
- return `${action.name === UNNAMED_ACTION ? "Action" : action.name}${parameters.length === 0 ? "" : `(${parameters.join(",")})`} ${formatRange(action.location.range ?? BUILTIN_RANGE)}`;
470
- };
472
+ const formatParameters = (action: SpecAction) =>
473
+ action.parameters.length === 0
474
+ ? ""
475
+ : `(${action.parameters.map((parameter) => formatValue(parameter[1])).join(",")})`;
476
+
477
+ export const getActionLabel = (action: SpecAction) =>
478
+ `${action.name === UNNAMED_ACTION ? "Action" : action.name}${formatParameters(action)} ${formatRange(action.location.range ?? BUILTIN_RANGE)}`;
479
+
480
+ // TLC's Action.getInvocationSignature, which names the action and the values of its parameters.
481
+ export const getActionSignature = (action: SpecAction) =>
482
+ `${action.name}${formatParameters(action)}`;
471
483
 
472
484
  export const getSpecificationValue = (
473
485
  config: ModelConfig,
@@ -40,6 +40,7 @@ import {
40
40
  isEnumerable,
41
41
  isFiniteSet,
42
42
  isFunctionValue,
43
+ isReducible,
43
44
  isSetValue,
44
45
  toFiniteSet,
45
46
  unionSorted,
@@ -47,7 +48,7 @@ import {
47
48
  createEnumeratedSet,
48
49
  EMPTY_SET,
49
50
  isEnumeratedSet,
50
- type IntervalValue,
51
+ type ReducibleSet,
51
52
  type MixedSetValue,
52
53
  type SetOperationValue,
53
54
  type SetValue,
@@ -75,12 +76,6 @@ const unionInTree = (sets: SetValue[], start: number, end: number): SetValue =>
75
76
 
76
77
  const SET_OPERATORS: SetOperationValue["operator"][] = ["\\cup", "\\cap", "\\"];
77
78
 
78
- type ReducibleSet = SetValue | MixedSetValue | IntervalValue;
79
-
80
- const isReducible = (value: Value): value is ReducibleSet =>
81
- typeof value === "object" &&
82
- (value.kind === "Set" || value.kind === "MixedSet" || value.kind === "Interval");
83
-
84
79
  const isMixedSet = (value: Value) => typeof value === "object" && value.kind === "MixedSet";
85
80
 
86
81
  const getReducibleElements = (set: ReducibleSet) =>
@@ -0,0 +1,157 @@
1
+ // A port of TLC's -dump writers, tlc2.util.StateWriter and tlc2.util.DotStateWriter.
2
+
3
+ export interface StateDump {
4
+ path: string;
5
+ dot?: boolean;
6
+ colorize?: boolean;
7
+ actionLabels?: boolean;
8
+ snapshot?: boolean;
9
+ }
10
+
11
+ export interface GraphState {
12
+ fingerprint: bigint;
13
+ level: number;
14
+ // The state as TLC prints it after evaluating the alias, and as it prints it without the alias.
15
+ getLabel: () => string;
16
+ getText: () => string;
17
+ }
18
+
19
+ export interface GraphAction {
20
+ name: string;
21
+ signature: string;
22
+ }
23
+
24
+ export interface StateWriter {
25
+ writeInitialState: (state: GraphState) => void;
26
+ writeSuccessor: (
27
+ state: GraphState,
28
+ successor: GraphState,
29
+ isSeen: boolean,
30
+ action: GraphAction | undefined,
31
+ ) => void;
32
+ close: () => void;
33
+ }
34
+
35
+ type WriteFile = ((path: string, content: string) => void) | undefined;
36
+
37
+ const COLOR_SCHEME = "paired12";
38
+ const LOAD_FACTOR = 0.75;
39
+ const INITIAL_CAPACITY = 16;
40
+
41
+ const getCapacity = (size: number, capacity = INITIAL_CAPACITY): number =>
42
+ size <= capacity * LOAD_FACTOR ? capacity : getCapacity(size, capacity * 2);
43
+
44
+ // The order in which a java.util.HashMap iterates over keys put in this order: by bucket, and in
45
+ // insertion order within a bucket. A bucket only becomes a tree once 8 keys collide in it.
46
+ const getJavaHashOrder = <Key>(keys: Key[], getHash: (key: Key) => number) => {
47
+ const mask = getCapacity(keys.length) - 1;
48
+ const getBucket = (key: Key) => {
49
+ const hash = getHash(key);
50
+ return (hash ^ (hash >>> 16)) & mask;
51
+ };
52
+ return keys
53
+ .map((key, position) => ({ key, position, bucket: getBucket(key) }))
54
+ .sort((left, right) => left.bucket - right.bucket || left.position - right.position)
55
+ .map((entry) => entry.key);
56
+ };
57
+
58
+ const getLongHash = (value: bigint) =>
59
+ Number(BigInt.asIntN(32, value ^ (BigInt.asUintN(64, value) >> 32n)));
60
+
61
+ const getStringHash = (text: string) =>
62
+ [...Array(text.length).keys()].reduce(
63
+ (hash, index) => (Math.imul(31, hash) + text.charCodeAt(index)) | 0,
64
+ 0,
65
+ );
66
+
67
+ const escape = (text: string) => text.replaceAll("\\", "\\\\").replaceAll('"', '\\"').trim();
68
+
69
+ const toDot = (text: string) => escape(text).replaceAll("\n", "\\n");
70
+
71
+ const createPlainWriter = (dump: StateDump, writeFile: WriteFile): StateWriter => {
72
+ const states: string[] = [];
73
+ const writeState = (state: GraphState) =>
74
+ states.push(`State ${states.length + 1}:\n${state.getText()}\n`);
75
+ return {
76
+ writeInitialState: writeState,
77
+ writeSuccessor: (_state, successor, isSeen) => {
78
+ if (!isSeen) writeState(successor);
79
+ },
80
+ close: () => writeFile?.(dump.path, states.join("")),
81
+ };
82
+ };
83
+
84
+ const createDotWriter = (dump: StateDump, writeFile: WriteFile): StateWriter => {
85
+ const lines = [
86
+ "strict digraph DiskGraph {\n",
87
+ "node [shape=box,style=rounded]\n",
88
+ dump.colorize ? `edge [colorscheme="${COLOR_SCHEME}"]\n` : "",
89
+ "nodesep=0.35;\n",
90
+ "subgraph cluster_graph {\n",
91
+ 'color="white";\n',
92
+ ];
93
+ const ranks = new Map<number, Set<bigint>>();
94
+ const colors = new Map<string, number>();
95
+ const addRank = (state: GraphState) => {
96
+ const rank = ranks.get(state.level) ?? new Set();
97
+ ranks.set(state.level, rank.add(state.fingerprint));
98
+ };
99
+ // TLC colors an edge by the name of its action, numbering the names from 2 as it finds them.
100
+ const getColor = (action: GraphAction | undefined) => {
101
+ if (!action) return 1;
102
+ const color = colors.get(action.name) ?? colors.size + 2;
103
+ colors.set(action.name, color);
104
+ return color;
105
+ };
106
+ const getLegend = () =>
107
+ [
108
+ `subgraph cluster_legend {graph[style=bold];label = "Next State Actions" style="solid"\n`,
109
+ `node [ labeljust="l",colorscheme="${COLOR_SCHEME}",style=filled,shape=record ]\n`,
110
+ ...getJavaHashOrder([...colors.keys()], getStringHash).map(
111
+ (name) => `${name.replaceAll("!", ":")} [label="${name}",fillcolor=${colors.get(name)}]\n`,
112
+ ),
113
+ "}",
114
+ ].join("");
115
+ const getEnding = () =>
116
+ [
117
+ ...getJavaHashOrder([...ranks], (rank) => rank[0]).map(
118
+ (rank) =>
119
+ `{rank = same; ${getJavaHashOrder([...rank[1]], getLongHash)
120
+ .map((fingerprint) => `${fingerprint};`)
121
+ .join("")}}\n`,
122
+ ),
123
+ "}\n",
124
+ dump.colorize && colors.size > 1 ? getLegend() : "",
125
+ "}",
126
+ ].join("");
127
+ const writeSnapshot = () => {
128
+ if (dump.snapshot) {
129
+ writeFile?.(dump.path.replaceAll(".dot", "_snapshot.dot"), lines.join("") + getEnding());
130
+ }
131
+ };
132
+ return {
133
+ writeInitialState: (state) => {
134
+ lines.push(`${state.fingerprint} [label="${toDot(state.getLabel())}",style = filled]\n`);
135
+ addRank(state);
136
+ writeSnapshot();
137
+ },
138
+ writeSuccessor: (state, successor, isSeen, action) => {
139
+ const color = dump.colorize ? String(getColor(action)) : "black";
140
+ const label = dump.actionLabels && action ? escape(action.signature) : "";
141
+ lines.push(
142
+ `${state.fingerprint} -> ${successor.fingerprint} [label="${label}",color="${color}",fontcolor="${color}"];\n`,
143
+ );
144
+ if (!isSeen) {
145
+ lines.push(
146
+ `${successor.fingerprint} [label="${toDot(successor.getLabel())}",tooltip="${toDot(successor.getText())}"];\n`,
147
+ );
148
+ }
149
+ addRank(state);
150
+ writeSnapshot();
151
+ },
152
+ close: () => writeFile?.(dump.path, lines.join("") + getEnding()),
153
+ };
154
+ };
155
+
156
+ export const createStateWriter = (dump: StateDump, writeFile: WriteFile) =>
157
+ dump.dot ? createDotWriter(dump, writeFile) : createPlainWriter(dump, writeFile);
@@ -1,15 +1,15 @@
1
- import type {
2
- Bound,
3
- Definition,
4
- Expression,
5
- Instance,
6
- Module,
7
- OperatorParam,
8
- Selector,
9
- SourceLocation,
1
+ import {
2
+ getChildren,
3
+ type Bound,
4
+ type Definition,
5
+ type Expression,
6
+ type Instance,
7
+ type Module,
8
+ type OperatorParam,
9
+ type Selector,
10
+ type SourceLocation,
10
11
  } from "./ast";
11
12
  import { TlaSyntaxError } from "./errors";
12
- import { getChildren } from "./evaluate";
13
13
  import { getSourceName, mapChildren, mapDefinition } from "./instances";
14
14
  import { getArity, getBoundNames, getPatternNames, LOCAL_RESOLUTION } from "./resolve";
15
15
 
package/src/successors.ts CHANGED
@@ -1,9 +1,17 @@
1
- import type { Bound, Definition, Expression } from "./ast";
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 { TlaEvaluationError } from "./errors";
10
+ import { TlaEvaluationError, UNEXPECTED_EXCEPTION } from "./errors";
4
11
  import { EXIT_STATUS, setExitCode } from "./exit-codes";
5
12
  import {
6
13
  describeLocation,
14
+ describeRange,
7
15
  bindArgument,
8
16
  bindDefinitions,
9
17
  bindOperatorArguments,
@@ -13,14 +21,12 @@ import {
13
21
  expectBoolean,
14
22
  forEachBinding,
15
23
  getBoundsDomain,
16
- getChildren,
17
24
  getDefinition,
18
25
  getEnumeratedElements,
19
26
  getReevaluatedDefinitions,
20
27
  lookupScope,
21
28
  resolveApplyOperator,
22
29
  resolveGlobalOperator,
23
- isLocallyResolved,
24
30
  type Context,
25
31
  type Environment,
26
32
  type Scope,
@@ -287,6 +293,27 @@ const toConjunct = (
287
293
  return { kind: "Branch", expression, runner: getRunner(expression, environment, isInit) };
288
294
  };
289
295
 
296
+ // The leading guards of `\E x \in S, y \in T : P /\ Q` that read no inner bound hold for every inner
297
+ // binding alike, so they can run once for each element of the outermost bound.
298
+ const getHoistedGuards = (expression: QuantifierExpression, environment: Environment) => {
299
+ if (expression.bounds.length < 2 || expression.body.kind !== "And") return undefined;
300
+ const names = expression.bounds.flatMap((bound) =>
301
+ bound.pattern.kind === "Name" ? [bound.pattern.name] : [],
302
+ );
303
+ if (names.length !== expression.bounds.length) return undefined;
304
+ const innerNames = new Set(names.slice(0, -1));
305
+ const operands = expression.body.operands;
306
+ const index = operands.findIndex((operand) => {
307
+ if (getReadVariables(operand, environment) === undefined) return true;
308
+ if (hasBranches(operand, environment, new Set())) return true;
309
+ const readLocals = getReadLocals(operand, NO_NAMES);
310
+ return !readLocals || readLocals.some((name) => innerNames.has(name));
311
+ });
312
+ const count = index === -1 ? operands.length : index;
313
+ if (count === 0) return undefined;
314
+ return { names, guards: operands.slice(0, count), rest: operands.slice(count) };
315
+ };
316
+
290
317
  const compileConjunction = (
291
318
  operands: Expression[],
292
319
  environment: Environment,
@@ -729,6 +756,33 @@ const compileAction = (
729
756
  }
730
757
  };
731
758
  }
759
+ const hoisted = isInit ? undefined : getHoistedGuards(expression, environment);
760
+ if (hoisted) {
761
+ const rest = compileConjunction(hoisted.rest, environment, isInit);
762
+ return (run, scope, partial, action, isFixed, onComplete) => {
763
+ const context = getContext(run, scope, partial);
764
+ const sets = expression.bounds.map((innerBound) =>
765
+ getEnumeratedElements(evaluate(innerBound.set, context), innerBound.set),
766
+ );
767
+ if (sets.some((elements) => elements.length === 0)) return;
768
+ const visit = (index: number, boundScope: Scope | undefined): void => {
769
+ if (index < 0) {
770
+ rest(run, boundScope, partial, action, isFixed, onComplete);
771
+ return;
772
+ }
773
+ for (const element of sets[index]) {
774
+ if (run.isStopped) return;
775
+ const elementScope = bindValue(boundScope, hoisted.names[index], element);
776
+ if (index === sets.length - 1) {
777
+ const guardContext = getContext(run, elementScope, partial);
778
+ if (!hoisted.guards.every((guard) => holds(guard, guardContext))) continue;
779
+ }
780
+ visit(index - 1, elementScope);
781
+ }
782
+ };
783
+ visit(sets.length - 1, scope);
784
+ };
785
+ }
732
786
  return (run, scope, partial, action, isFixed, onComplete) => {
733
787
  forEachBinding(expression.bounds, getContext(run, scope, partial), (boundScope) => {
734
788
  body(run, boundScope, partial, action, isFixed, onComplete);
@@ -804,7 +858,9 @@ const compileAction = (
804
858
  );
805
859
  const body = arm?.body ?? other;
806
860
  if (!body)
807
- throw new TlaEvaluationError(`No CASE guard is true at ${describeLocation(expression)}`);
861
+ throw new TlaEvaluationError(
862
+ `${UNEXPECTED_EXCEPTION}In computing next states, TLC encountered a CASE with no conditions true.\n${describeRange(expression)}`,
863
+ );
808
864
  body(run, scope, partial, action, isFixed, onComplete);
809
865
  };
810
866
  }
@@ -913,18 +969,19 @@ export const isEnabled = (expression: Expression, context: Context): boolean =>
913
969
  );
914
970
  }
915
971
  const environment = context.environment;
916
- const found = { value: false };
972
+ const run: Run = { environment, isInit: false, current: state, isStopped: false };
973
+ // TLC stops computing ENABLED at the first successor, so it skips the rest of the action.
917
974
  getRunner(expression, environment, false)(
918
- { environment, isInit: false, current: state, isStopped: false },
975
+ run,
919
976
  context.scope,
920
977
  getEmptyState(environment),
921
978
  undefined,
922
979
  false,
923
980
  () => {
924
- found.value = true;
981
+ run.isStopped = true;
925
982
  },
926
983
  );
927
- return found.value;
984
+ return run.isStopped;
928
985
  };
929
986
 
930
987
  export const forEachInitialState = (
package/src/symmetry.ts CHANGED
@@ -9,6 +9,7 @@ import {
9
9
  isEnumerable,
10
10
  isFunctionValue,
11
11
  isModelValue,
12
+ isSameValue,
12
13
  isSetValue,
13
14
  toFiniteFunction,
14
15
  toFiniteSet,
@@ -163,7 +164,10 @@ const permuteValue = (value: Value, permutation: Permutation): Value => {
163
164
  if (size === 0 || size > CACHED_SIZE_LIMIT) return computePermutedValue(value, permutation);
164
165
  const cached = permutation.cache.get(value);
165
166
  if (cached !== undefined) return cached;
166
- const permuted = computePermutedValue(value, permutation);
167
+ const computed = computePermutedValue(value, permutation);
168
+ // A permutation often maps a value to an equal one. Keeping the original lets the comparison
169
+ // with the smallest state so far stop at identity.
170
+ const permuted = computed !== value && isSameValue(computed, value) ? value : computed;
167
171
  if (permutation.cacheSize >= permutation.cacheLimit) {
168
172
  permutation.cache = new WeakMap();
169
173
  permutation.cacheSize = 0;
@@ -184,7 +188,15 @@ const computePermutedValue = (value: ObjectValue, permutation: Permutation) => {
184
188
  const domain = permuteElements(functionValue.domain, permutation);
185
189
  const range = permuteElements(functionValue.range, permutation) ?? functionValue.range;
186
190
  if (domain) {
187
- return createFunction(domain.map((key, index): [Value, Value] => [key, range[index]]));
191
+ const permuted = createFunction(
192
+ domain.map((key, index): [Value, Value] => [key, range[index]]),
193
+ );
194
+ // A permutation often maps the domain to itself, such as a function over the symmetric set.
195
+ // Sharing the original domain array lets comparisons with other images skip the domain.
196
+ const isSameDomain = permuted.domain.every(
197
+ (key, index) => key === functionValue.domain[index],
198
+ );
199
+ return isSameDomain ? createSortedFunction(functionValue.domain, permuted.range) : permuted;
188
200
  }
189
201
  return range === functionValue.range
190
202
  ? functionValue
package/src/tlc-ext.ts CHANGED
@@ -10,16 +10,8 @@ import {
10
10
  } from "./builtins";
11
11
  import { TlaEvaluationError, TlaModuleError, TlaUnsupportedError } from "./errors";
12
12
  import { getTlcFingerprint } from "./tlc-random";
13
- import {
14
- evaluate,
15
- expectBoolean,
16
- getChildren,
17
- getDefinition,
18
- isLocallyResolved,
19
- type Builtin,
20
- type Environment,
21
- } from "./evaluate";
22
- import type { Definition, Expression } from "./ast";
13
+ import { evaluate, expectBoolean, getDefinition, type Builtin, type Environment } from "./evaluate";
14
+ import { getChildren, isLocallyResolved, type Definition, type Expression } from "./ast";
23
15
  import type { TraceStep } from "./check";
24
16
  import {
25
17
  getNamedRegisters,
@@ -111,15 +103,35 @@ const getRegister = (runtime: CheckerRuntime, key: Value) => {
111
103
  return undefined;
112
104
  };
113
105
 
114
- const setRegister = (runtime: CheckerRuntime, key: Value, value: Value) => {
106
+ // TLC's TLCSet. TLCExt's TLCGetAndSet is a TLA+ definition that calls it.
107
+ export const setTlcValue = (
108
+ runtime: CheckerRuntime,
109
+ print: (text: string) => void,
110
+ key: Value,
111
+ value: Value,
112
+ ) => {
115
113
  if (typeof key === "number" && key >= 0) {
116
114
  runtime.registers.set(key, value);
117
115
  return;
118
116
  }
117
+ if (key === "exit") {
118
+ if (value === true) runtime.isStopped = true;
119
+ return;
120
+ }
121
+ if (key === "pause") {
122
+ if (value !== true) return;
123
+ print("Press enter to resume model checking.");
124
+ runtime.pause();
125
+ return;
126
+ }
119
127
  if (typeof key === "string" && key.startsWith(NAMED_REGISTER_PREFIX)) {
120
128
  runtime.namedRegisters.set(key, value);
121
129
  return;
122
130
  }
131
+ if (typeof key === "string" && key.startsWith("-D")) {
132
+ runtime.properties.set(key.slice(2), formatValue(value));
133
+ return;
134
+ }
123
135
  throw new TlaModuleError(
124
136
  `The first argument of TLCSet should be a nonnegative integer, but instead it is:\n${formatValue(key)}`,
125
137
  );
@@ -203,7 +215,12 @@ export const createTlcExtOperators = (
203
215
  const key = getValue(args, 0, "TLCGetAndSet");
204
216
  const previous = getRegister(runtime, key) ?? getValue(args, 3, "TLCGetAndSet");
205
217
  const update = getOperator(args, 1, "TLCGetAndSet");
206
- setRegister(runtime, key, update.call([previous, getValue(args, 2, "TLCGetAndSet")]));
218
+ setTlcValue(
219
+ runtime,
220
+ print,
221
+ key,
222
+ update.call([previous, getValue(args, 2, "TLCGetAndSet")]),
223
+ );
207
224
  return previous;
208
225
  }),
209
226
  isStateLevel: true,