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/values.ts
CHANGED
|
@@ -1,10 +1,12 @@
|
|
|
1
1
|
import { TlaEvaluationError, TlaModuleError } from "./errors";
|
|
2
2
|
import { prettyPrint } from "./pretty-print";
|
|
3
|
+
import { valueSources, withSource } from "./value-sources";
|
|
3
4
|
|
|
4
5
|
export interface ModelValue {
|
|
5
6
|
kind: "ModelValue";
|
|
6
7
|
name: string;
|
|
7
8
|
type: string | undefined;
|
|
9
|
+
rank: number;
|
|
8
10
|
}
|
|
9
11
|
|
|
10
12
|
export interface SetValue {
|
|
@@ -136,6 +138,13 @@ export const isSetValue = (value: Value) =>
|
|
|
136
138
|
value.kind !== "Function" &&
|
|
137
139
|
value.kind !== "LazyFunction";
|
|
138
140
|
|
|
141
|
+
export type ReducibleSet = SetValue | MixedSetValue | IntervalValue;
|
|
142
|
+
|
|
143
|
+
// TLC reduces a set enumeration or an interval eagerly, and keeps every other set lazy.
|
|
144
|
+
export const isReducible = (value: Value): value is ReducibleSet =>
|
|
145
|
+
typeof value === "object" &&
|
|
146
|
+
(value.kind === "Set" || value.kind === "MixedSet" || value.kind === "Interval");
|
|
147
|
+
|
|
139
148
|
export const isFunctionValue = (value: Value): value is FunctionValue | LazyFunctionValue =>
|
|
140
149
|
typeof value === "object" && (value.kind === "Function" || value.kind === "LazyFunction");
|
|
141
150
|
|
|
@@ -264,6 +273,7 @@ const stringOrder = { ranks: Object.create(null) as Record<string, number>, size
|
|
|
264
273
|
export const setStringOrder = (texts: Iterable<string>) => {
|
|
265
274
|
stringOrder.ranks = Object.create(null);
|
|
266
275
|
stringOrder.size = 0;
|
|
276
|
+
modelValues.clear();
|
|
267
277
|
for (const text of texts) rankString(text);
|
|
268
278
|
};
|
|
269
279
|
|
|
@@ -353,7 +363,7 @@ export const compareValues = (left: Value, right: Value): number => {
|
|
|
353
363
|
if (left.type !== undefined && right.type !== undefined) {
|
|
354
364
|
checkModelValueTypes(left, right, false);
|
|
355
365
|
}
|
|
356
|
-
return
|
|
366
|
+
return left.rank - right.rank;
|
|
357
367
|
}
|
|
358
368
|
if (leftKind === "ModelValue" || rightKind === "ModelValue") {
|
|
359
369
|
checkModelValueTypes(left, right, false);
|
|
@@ -369,7 +379,7 @@ export const compareValues = (left: Value, right: Value): number => {
|
|
|
369
379
|
`Attempted to compare ${describeKind(left)} ${formatValue(left)} with ${describeKind(right)} ${formatValue(right)}`,
|
|
370
380
|
);
|
|
371
381
|
}
|
|
372
|
-
if (isLeftSet) return compareSets(toFiniteSet(left),
|
|
382
|
+
if (isLeftSet) return compareSets(toFiniteSet(left), toComparedSet(right));
|
|
373
383
|
return compareFunctions(toFiniteFunction(left), toFiniteFunction(right));
|
|
374
384
|
}
|
|
375
385
|
if (typeof left === "number" && typeof right === "number") return left - right;
|
|
@@ -385,14 +395,15 @@ export const compareValues = (left: Value, right: Value): number => {
|
|
|
385
395
|
|
|
386
396
|
const modelValues = new Map<string, ModelValue>();
|
|
387
397
|
|
|
398
|
+
// A check ranks every model value's name when it creates the value, and creates its own values.
|
|
388
399
|
export const createModelValue = (name: string): ModelValue => {
|
|
389
|
-
rankString(name);
|
|
390
400
|
const known = modelValues.get(name);
|
|
391
401
|
if (known) return known;
|
|
392
402
|
const value: ModelValue = {
|
|
393
403
|
kind: "ModelValue",
|
|
394
404
|
name,
|
|
395
405
|
type: name.length > 2 && name[1] === "_" ? name[0] : undefined,
|
|
406
|
+
rank: getStringRank(name),
|
|
396
407
|
};
|
|
397
408
|
modelValues.set(name, value);
|
|
398
409
|
return value;
|
|
@@ -562,7 +573,7 @@ const equalsModelValueWith = (modelValue: ModelValue, other: Value) => {
|
|
|
562
573
|
|
|
563
574
|
const compareModelValue = (left: ModelValue, right: Value) => {
|
|
564
575
|
const type = getModelValueType(left);
|
|
565
|
-
if (type === undefined) return isModelValue(right) ?
|
|
576
|
+
if (type === undefined) return isModelValue(right) ? left.rank - right.rank : -1;
|
|
566
577
|
if (!isModelValue(right)) {
|
|
567
578
|
throw new TlaEvaluationError(
|
|
568
579
|
`Attempted to compare the typed model value ${formatValue(left)} and non-model value\n${formatValue(right)}`,
|
|
@@ -574,7 +585,7 @@ const compareModelValue = (left: ModelValue, right: Value) => {
|
|
|
574
585
|
`Attempted to compare the differently-typed model values ${formatValue(left)} and ${formatValue(right)}`,
|
|
575
586
|
);
|
|
576
587
|
}
|
|
577
|
-
return
|
|
588
|
+
return left.rank - right.rank;
|
|
578
589
|
};
|
|
579
590
|
|
|
580
591
|
const equalsModelValue = (left: ModelValue, right: Value) => {
|
|
@@ -723,16 +734,17 @@ const compareSetLikeTlc = (left: ObjectValue, right: Value): number => {
|
|
|
723
734
|
);
|
|
724
735
|
};
|
|
725
736
|
|
|
726
|
-
const compareLikeTlc = (left: Value, right: Value): number =>
|
|
727
|
-
|
|
728
|
-
if (typeof
|
|
729
|
-
|
|
730
|
-
|
|
731
|
-
|
|
732
|
-
|
|
733
|
-
|
|
734
|
-
|
|
735
|
-
|
|
737
|
+
const compareLikeTlc = (left: Value, right: Value): number =>
|
|
738
|
+
withSource(left, () => {
|
|
739
|
+
if (typeof left !== "object") {
|
|
740
|
+
if (typeof right === typeof left) return compareValues(left, right);
|
|
741
|
+
if (isModelValue(right)) return compareModelValueWith(right, left);
|
|
742
|
+
throw new TlaEvaluationError(describeScalarMismatch(left, right, false));
|
|
743
|
+
}
|
|
744
|
+
if (left.kind === "ModelValue") return compareModelValue(left, right);
|
|
745
|
+
if (isFunctionValue(left)) return compareFunctionLikeTlc(left, right);
|
|
746
|
+
return compareSetLikeTlc(left, right);
|
|
747
|
+
});
|
|
736
748
|
|
|
737
749
|
const equalsElementsLikeTlc = (left: Value[], right: Value[]) =>
|
|
738
750
|
left.every((element, index) => equalsLikeTlc(element, right[index]));
|
|
@@ -820,16 +832,17 @@ const equalsSetLikeTlc = (left: ObjectValue, right: Value): boolean => {
|
|
|
820
832
|
);
|
|
821
833
|
};
|
|
822
834
|
|
|
823
|
-
const equalsLikeTlc = (left: Value, right: Value): boolean =>
|
|
824
|
-
|
|
825
|
-
if (typeof
|
|
826
|
-
|
|
827
|
-
|
|
828
|
-
|
|
829
|
-
|
|
830
|
-
|
|
831
|
-
|
|
832
|
-
|
|
835
|
+
const equalsLikeTlc = (left: Value, right: Value): boolean =>
|
|
836
|
+
withSource(left, () => {
|
|
837
|
+
if (typeof left !== "object") {
|
|
838
|
+
if (typeof right === typeof left) return left === right;
|
|
839
|
+
if (isModelValue(right)) return equalsModelValueWith(right, left);
|
|
840
|
+
throw new TlaEvaluationError(describeScalarMismatch(left, right, true));
|
|
841
|
+
}
|
|
842
|
+
if (left.kind === "ModelValue") return equalsModelValue(left, right);
|
|
843
|
+
if (isFunctionValue(left)) return equalsFunctionLikeTlc(left, right);
|
|
844
|
+
return equalsSetLikeTlc(left, right);
|
|
845
|
+
});
|
|
833
846
|
|
|
834
847
|
// TLC's ValueVec.sort, which inserts each element into the sorted prefix by binary search.
|
|
835
848
|
const sortLikeTlc = (elements: Value[]) => {
|
|
@@ -861,9 +874,11 @@ export const isEqualLikeTlc = (left: Value, right: Value) => {
|
|
|
861
874
|
}
|
|
862
875
|
};
|
|
863
876
|
|
|
877
|
+
// TLC sorts a set by comparing each element with the ones before it, so the later element converts
|
|
878
|
+
// a lazy set it compares and caches it.
|
|
864
879
|
const isStrictlySorted = (elements: Value[]) => {
|
|
865
880
|
for (let index = 1; index < elements.length; index++) {
|
|
866
|
-
if (compareValues(elements[index
|
|
881
|
+
if (compareValues(elements[index], elements[index - 1]) <= 0) return false;
|
|
867
882
|
}
|
|
868
883
|
return true;
|
|
869
884
|
};
|
|
@@ -1066,13 +1081,16 @@ const isTlcEnumerable = (value: Value) => isSetValue(value) && !isOverriddenSet(
|
|
|
1066
1081
|
const formatUnion = (value: UnionValue, isStrict = false) =>
|
|
1067
1082
|
`UNION(${formatValue(value.base, isStrict)})`;
|
|
1068
1083
|
|
|
1069
|
-
const getUnionSets = (
|
|
1084
|
+
const getUnionSets = (
|
|
1085
|
+
value: UnionValue,
|
|
1086
|
+
getElements = (set: Value) => toFiniteSet(set).elements,
|
|
1087
|
+
) => {
|
|
1070
1088
|
if (!isTlcEnumerable(value.base)) {
|
|
1071
1089
|
throw new TlaEvaluationError(
|
|
1072
1090
|
`Attempted to enumerate the nonenumerable set:\n${formatUnion(value)}`,
|
|
1073
1091
|
);
|
|
1074
1092
|
}
|
|
1075
|
-
return
|
|
1093
|
+
return getElements(value.base);
|
|
1076
1094
|
};
|
|
1077
1095
|
|
|
1078
1096
|
const getUnionSet = (set: Value, index: number, union: UnionValue) => {
|
|
@@ -1108,7 +1126,7 @@ export const isEnumerable = (value: Value): boolean => {
|
|
|
1108
1126
|
case "ProductSet":
|
|
1109
1127
|
return value.factors.every(isEnumerable) || getEmptiness(value) === true;
|
|
1110
1128
|
case "Union":
|
|
1111
|
-
return isEnumerable(value.base) &&
|
|
1129
|
+
return isEnumerable(value.base) && getStreamedElements(value.base).every(isEnumerable);
|
|
1112
1130
|
case "SetOperation":
|
|
1113
1131
|
if (value.operator === "\\cup") return isEnumerable(value.left) && isEnumerable(value.right);
|
|
1114
1132
|
if (value.operator === "\\cap") return isEnumerable(value.left) || isEnumerable(value.right);
|
|
@@ -1181,6 +1199,41 @@ const advanceCombination = (indices: number[], length: number) => {
|
|
|
1181
1199
|
return false;
|
|
1182
1200
|
};
|
|
1183
1201
|
|
|
1202
|
+
// TLC enumerates SUBSET S lazily, by size and then in the order of S, so a quantifier that finds
|
|
1203
|
+
// its witness early never builds the rest. For a power set too large to build, the elements are
|
|
1204
|
+
// computed in that order as a loop reads them.
|
|
1205
|
+
export const getLazySubsets = (value: Value): Value[] | undefined => {
|
|
1206
|
+
if (typeof value !== "object" || value.kind !== "Subset" || isOverriddenSet(value.base)) {
|
|
1207
|
+
return undefined;
|
|
1208
|
+
}
|
|
1209
|
+
const base = toFiniteSet(value.base).elements;
|
|
1210
|
+
if (base.length <= MAXIMUM_ENUMERATED_SUBSET_BASE) return undefined;
|
|
1211
|
+
const cursor = { index: -1, indices: [0] };
|
|
1212
|
+
const getSubset = (index: number) => {
|
|
1213
|
+
if (index <= cursor.index) cursor.index = -1;
|
|
1214
|
+
while (cursor.index < index) {
|
|
1215
|
+
if (cursor.index === -1) cursor.indices = [];
|
|
1216
|
+
else if (!advanceCombination(cursor.indices, base.length)) {
|
|
1217
|
+
cursor.indices = Array.from({ length: cursor.indices.length + 1 }, (_, item) => item);
|
|
1218
|
+
}
|
|
1219
|
+
cursor.index++;
|
|
1220
|
+
}
|
|
1221
|
+
return createSortedSet(cursor.indices.map((item) => base[item]));
|
|
1222
|
+
};
|
|
1223
|
+
const length = 2 ** base.length;
|
|
1224
|
+
const isIndex = (property: string | symbol) =>
|
|
1225
|
+
typeof property === "string" && /^\d+$/.test(property) && Number(property) < length;
|
|
1226
|
+
return new Proxy<Value[]>([], {
|
|
1227
|
+
get: (target, property, receiver) => {
|
|
1228
|
+
if (property === "length") return length;
|
|
1229
|
+
return isIndex(property)
|
|
1230
|
+
? getSubset(Number(property))
|
|
1231
|
+
: Reflect.get(target, property, receiver);
|
|
1232
|
+
},
|
|
1233
|
+
has: (target, property) => isIndex(property) || Reflect.has(target, property),
|
|
1234
|
+
});
|
|
1235
|
+
};
|
|
1236
|
+
|
|
1184
1237
|
const getSortedSubsets = (base: Value[]) => {
|
|
1185
1238
|
const subsets: Value[] = [];
|
|
1186
1239
|
for (let size = 0; size <= base.length; size++) {
|
|
@@ -1209,9 +1262,7 @@ const enumerateSet = (value: Value): Value[] => {
|
|
|
1209
1262
|
if (isOverriddenSet(value.base)) getCardinality(value.base);
|
|
1210
1263
|
const base = toFiniteSet(value.base).elements;
|
|
1211
1264
|
if (base.length > MAXIMUM_ENUMERATED_SUBSET_BASE) {
|
|
1212
|
-
throw new TlaEvaluationError(
|
|
1213
|
-
`SUBSET of a set with ${base.length} elements is too large to enumerate`,
|
|
1214
|
-
);
|
|
1265
|
+
throw new TlaEvaluationError(describeOverflow(value));
|
|
1215
1266
|
}
|
|
1216
1267
|
return getSortedSubsets(base);
|
|
1217
1268
|
}
|
|
@@ -1275,7 +1326,7 @@ const enumerateSet = (value: Value): Value[] => {
|
|
|
1275
1326
|
case "SetOperation": {
|
|
1276
1327
|
if (
|
|
1277
1328
|
value.operator === "\\cup" &&
|
|
1278
|
-
(
|
|
1329
|
+
(!isTlcEnumerable(value.left) || !isTlcEnumerable(value.right))
|
|
1279
1330
|
) {
|
|
1280
1331
|
throw new TlaEvaluationError(
|
|
1281
1332
|
`Attempted to enumerate S \\cup T when S:\n${formatValue(value.left)}\nand T:\n${formatValue(value.right)}\nare not both enumerable`,
|
|
@@ -1283,14 +1334,14 @@ const enumerateSet = (value: Value): Value[] => {
|
|
|
1283
1334
|
}
|
|
1284
1335
|
if (
|
|
1285
1336
|
value.operator === "\\cap" &&
|
|
1286
|
-
|
|
1287
|
-
|
|
1337
|
+
!isTlcEnumerable(value.left) &&
|
|
1338
|
+
!isTlcEnumerable(value.right)
|
|
1288
1339
|
) {
|
|
1289
1340
|
throw new TlaEvaluationError(
|
|
1290
1341
|
`Attempted to enumerate S \\cap T when neither S:\n${formatValue(value.left)}\nnor T:\n${formatValue(value.right)}\nis enumerable`,
|
|
1291
1342
|
);
|
|
1292
1343
|
}
|
|
1293
|
-
if (value.operator === "\\" &&
|
|
1344
|
+
if (value.operator === "\\" && !isTlcEnumerable(value.left)) {
|
|
1294
1345
|
throw new TlaEvaluationError(
|
|
1295
1346
|
`Attempted to enumerate S \\ T when S:\n${formatValue(value.left)}\nis not enumerable.`,
|
|
1296
1347
|
);
|
|
@@ -1315,6 +1366,7 @@ const enumerateSet = (value: Value): Value[] => {
|
|
|
1315
1366
|
};
|
|
1316
1367
|
|
|
1317
1368
|
const finiteSets = new WeakMap<ObjectValue, SetValue>();
|
|
1369
|
+
const comparedSets = new WeakMap<ObjectValue, SetValue>();
|
|
1318
1370
|
|
|
1319
1371
|
export const toFiniteSet = (value: Value): SetValue => {
|
|
1320
1372
|
if (typeof value === "object" && value.kind === "Set") return value;
|
|
@@ -1323,6 +1375,16 @@ export const toFiniteSet = (value: Value): SetValue => {
|
|
|
1323
1375
|
}
|
|
1324
1376
|
const cached = typeof value === "object" ? finiteSets.get(value) : undefined;
|
|
1325
1377
|
if (cached) return cached;
|
|
1378
|
+
const set =
|
|
1379
|
+
(typeof value === "object" ? comparedSets.get(value) : undefined) ??
|
|
1380
|
+
(valueSources.current
|
|
1381
|
+
? withSource(value, () => enumerateFiniteSet(value))
|
|
1382
|
+
: enumerateFiniteSet(value));
|
|
1383
|
+
if (typeof value === "object") finiteSets.set(value, set);
|
|
1384
|
+
return set;
|
|
1385
|
+
};
|
|
1386
|
+
|
|
1387
|
+
const enumerateFiniteSet = (value: Value) => {
|
|
1326
1388
|
const elements = enumerateSet(value);
|
|
1327
1389
|
const isSorted =
|
|
1328
1390
|
typeof value === "object" &&
|
|
@@ -1333,8 +1395,20 @@ export const toFiniteSet = (value: Value): SetValue => {
|
|
|
1333
1395
|
value.kind === "ProductSet" ||
|
|
1334
1396
|
value.kind === "FunctionSet" ||
|
|
1335
1397
|
value.kind === "Subset");
|
|
1336
|
-
|
|
1337
|
-
|
|
1398
|
+
return isSorted ? createSortedSet(elements) : createSet(elements);
|
|
1399
|
+
};
|
|
1400
|
+
|
|
1401
|
+
// TLC converts the set a comparison receives as its argument without caching it, so a lazy set
|
|
1402
|
+
// compared that way still streams the sets it combines.
|
|
1403
|
+
const toComparedSet = (value: Value) => {
|
|
1404
|
+
const isStreamed =
|
|
1405
|
+
typeof value === "object" &&
|
|
1406
|
+
(value.kind === "Union" || value.kind === "SetOperation" || value.kind === "FilteredSet");
|
|
1407
|
+
if (!isStreamed || finiteSets.has(value)) return toFiniteSet(value);
|
|
1408
|
+
const compared = comparedSets.get(value);
|
|
1409
|
+
if (compared) return compared;
|
|
1410
|
+
const set = enumerateFiniteSet(value);
|
|
1411
|
+
comparedSets.set(value, set);
|
|
1338
1412
|
return set;
|
|
1339
1413
|
};
|
|
1340
1414
|
|
|
@@ -1342,8 +1416,10 @@ export const toFiniteSet = (value: Value): SetValue => {
|
|
|
1342
1416
|
// so an element that two of them share comes up once for each.
|
|
1343
1417
|
export const getStreamedElements = (value: Value): Value[] => {
|
|
1344
1418
|
if (typeof value !== "object" || finiteSets.has(value)) return toFiniteSet(value).elements;
|
|
1419
|
+
// TLC streams the sets of a UNION it hasn't enumerated, so a set that appears twice there yields
|
|
1420
|
+
// its elements twice.
|
|
1345
1421
|
if (value.kind === "Union") {
|
|
1346
|
-
return getUnionSets(value).flatMap((set, index) =>
|
|
1422
|
+
return getUnionSets(value, getStreamedElements).flatMap((set, index) =>
|
|
1347
1423
|
getStreamedElements(getUnionSet(set, index, value)),
|
|
1348
1424
|
);
|
|
1349
1425
|
}
|
|
@@ -1352,14 +1428,14 @@ export const getStreamedElements = (value: Value): Value[] => {
|
|
|
1352
1428
|
}
|
|
1353
1429
|
if (value.kind !== "SetOperation") return toFiniteSet(value).elements;
|
|
1354
1430
|
if (value.operator === "\\cup") {
|
|
1355
|
-
return
|
|
1431
|
+
return !isTlcEnumerable(value.left) || !isTlcEnumerable(value.right)
|
|
1356
1432
|
? toFiniteSet(value).elements
|
|
1357
1433
|
: [...getStreamedElements(value.left), ...getStreamedElements(value.right)];
|
|
1358
1434
|
}
|
|
1359
1435
|
const isLeftEnumerated = value.operator === "\\" || isEnumerable(value.left);
|
|
1360
1436
|
const enumerated = isLeftEnumerated ? value.left : value.right;
|
|
1361
1437
|
const other = isLeftEnumerated ? value.right : value.left;
|
|
1362
|
-
if (
|
|
1438
|
+
if (!isTlcEnumerable(enumerated)) return toFiniteSet(value).elements;
|
|
1363
1439
|
return getStreamedElements(enumerated).filter(
|
|
1364
1440
|
(element) => isElementOf(element, other) === (value.operator === "\\cap"),
|
|
1365
1441
|
);
|
|
@@ -1562,6 +1638,12 @@ const describeNonSetMembership = (element: Value, value: Value) => {
|
|
|
1562
1638
|
return `${prefix} function ${formatValue(value)}`;
|
|
1563
1639
|
};
|
|
1564
1640
|
|
|
1641
|
+
// TLC checks membership in a set that another set holds through the inner set's own method.
|
|
1642
|
+
const isElementOfSet = (element: Value, set: Value) =>
|
|
1643
|
+
valueSources.current
|
|
1644
|
+
? withSource(set, () => isElementOf(element, set))
|
|
1645
|
+
: isElementOf(element, set);
|
|
1646
|
+
|
|
1565
1647
|
export const isElementOf = (element: Value, set: Value): boolean => {
|
|
1566
1648
|
if (!isSetValue(set)) throw new TlaEvaluationError(describeNonSetMembership(element, set));
|
|
1567
1649
|
switch (set.kind) {
|
|
@@ -1570,10 +1652,10 @@ export const isElementOf = (element: Value, set: Value): boolean => {
|
|
|
1570
1652
|
return findIndex(set.elements, element) !== -1;
|
|
1571
1653
|
} catch (error) {
|
|
1572
1654
|
if (!(error instanceof TlaEvaluationError)) throw error;
|
|
1573
|
-
return isElementOfLikeTlc(element, set.elements);
|
|
1655
|
+
return withSource(set, () => isElementOfLikeTlc(element, set.elements));
|
|
1574
1656
|
}
|
|
1575
1657
|
case "MixedSet":
|
|
1576
|
-
return isElementOfLikeTlc(element, set.elements);
|
|
1658
|
+
return withSource(set, () => isElementOfLikeTlc(element, set.elements));
|
|
1577
1659
|
case "Interval":
|
|
1578
1660
|
if (typeof element === "number") return element >= set.low && element <= set.high;
|
|
1579
1661
|
if (set.low <= set.high && !isModelValue(element)) {
|
|
@@ -1595,12 +1677,18 @@ export const isElementOf = (element: Value, set: Value): boolean => {
|
|
|
1595
1677
|
return set.name !== "Nat" || (typeof element === "number" && element >= 0);
|
|
1596
1678
|
}
|
|
1597
1679
|
case "Subset":
|
|
1598
|
-
if (!
|
|
1599
|
-
|
|
1680
|
+
if (!isTlcEnumerable(element)) {
|
|
1681
|
+
throw new TlaEvaluationError(
|
|
1682
|
+
`Attempted to check if the non-enumerable value\n${prettyPrint(formatValue(element))}\nis element of\n${prettyPrint(formatValue(set))}`,
|
|
1683
|
+
);
|
|
1684
|
+
}
|
|
1685
|
+
return toFiniteSet(element).elements.every((item) => isElementOfSet(item, set.base));
|
|
1600
1686
|
case "FunctionSet": {
|
|
1601
1687
|
if (!isFunctionValue(element)) {
|
|
1602
1688
|
if (isModelValue(element)) return false;
|
|
1603
|
-
throw new TlaEvaluationError(
|
|
1689
|
+
throw new TlaEvaluationError(
|
|
1690
|
+
`Attempted to check if \n${formatValue(element)}\nwhich is not a TLC function value, is in the set of functions:\n${prettyPrint(formatValue(set))}`,
|
|
1691
|
+
);
|
|
1604
1692
|
}
|
|
1605
1693
|
const functionValue = toFiniteFunction(element);
|
|
1606
1694
|
const low = getIntervalLow(functionValue.domain);
|
|
@@ -1611,7 +1699,7 @@ export const isElementOf = (element: Value, set: Value): boolean => {
|
|
|
1611
1699
|
{ kind: "Interval", low, high: low + functionValue.domain.length - 1 },
|
|
1612
1700
|
set.domain,
|
|
1613
1701
|
);
|
|
1614
|
-
return isDomain && functionValue.range.every((item) =>
|
|
1702
|
+
return isDomain && functionValue.range.every((item) => isElementOfSet(item, set.range));
|
|
1615
1703
|
}
|
|
1616
1704
|
case "RecordSet": {
|
|
1617
1705
|
const functionValue = isFunctionValue(element) ? toFiniteFunction(element) : undefined;
|
|
@@ -1625,7 +1713,7 @@ export const isElementOf = (element: Value, set: Value): boolean => {
|
|
|
1625
1713
|
functionValue.domain.length === set.names.length &&
|
|
1626
1714
|
set.names.every((name, index) => {
|
|
1627
1715
|
const position = findIndex(functionValue.domain, name);
|
|
1628
|
-
return position !== -1 &&
|
|
1716
|
+
return position !== -1 && isElementOfSet(functionValue.range[position], set.sets[index]);
|
|
1629
1717
|
})
|
|
1630
1718
|
);
|
|
1631
1719
|
}
|
|
@@ -1642,24 +1730,24 @@ export const isElementOf = (element: Value, set: Value): boolean => {
|
|
|
1642
1730
|
}
|
|
1643
1731
|
return (
|
|
1644
1732
|
elements.length === set.factors.length &&
|
|
1645
|
-
elements.every((item, index) =>
|
|
1733
|
+
elements.every((item, index) => isElementOfSet(item, set.factors[index]))
|
|
1646
1734
|
);
|
|
1647
1735
|
}
|
|
1648
1736
|
case "FilteredSet":
|
|
1649
|
-
return
|
|
1737
|
+
return isElementOfSet(element, set.base) && set.test(element);
|
|
1650
1738
|
case "Union":
|
|
1651
1739
|
if (!isTlcEnumerable(set.base)) {
|
|
1652
1740
|
throw new TlaEvaluationError(
|
|
1653
1741
|
`Attempted to check if:\n ${formatValue(element)}\nis an element of the non-enumerable set:\n ${formatUnion(set)}`,
|
|
1654
1742
|
);
|
|
1655
1743
|
}
|
|
1656
|
-
return toFiniteSet(set.base).elements.some((inner) =>
|
|
1744
|
+
return toFiniteSet(set.base).elements.some((inner) => isElementOfSet(element, inner));
|
|
1657
1745
|
case "SetOperation":
|
|
1658
1746
|
if (set.operator === "\\cup")
|
|
1659
|
-
return
|
|
1747
|
+
return isElementOfSet(element, set.left) || isElementOfSet(element, set.right);
|
|
1660
1748
|
return (
|
|
1661
|
-
|
|
1662
|
-
|
|
1749
|
+
isElementOfSet(element, set.left) &&
|
|
1750
|
+
isElementOfSet(element, set.right) === (set.operator === "\\cap")
|
|
1663
1751
|
);
|
|
1664
1752
|
case "SequenceSet": {
|
|
1665
1753
|
const elements = getSequenceElements(element);
|
|
@@ -1715,10 +1803,61 @@ export const markLambdaFunction = <FunctionLike extends FunctionValue | LazyFunc
|
|
|
1715
1803
|
return functionValue;
|
|
1716
1804
|
};
|
|
1717
1805
|
|
|
1718
|
-
|
|
1719
|
-
|
|
1720
|
-
|
|
1721
|
-
|
|
1806
|
+
// TLC applies a tuple, a record and a function over an interval with their own classes, and each
|
|
1807
|
+
// reports a missing argument in its own words.
|
|
1808
|
+
const getFunctionClass = (functionValue: FunctionValue) => {
|
|
1809
|
+
const domain = functionValue.domain;
|
|
1810
|
+
if (domain.length === 0) return lambdaFunctions.has(functionValue) ? "FcnRcdValue" : "TupleValue";
|
|
1811
|
+
if (domain === intervalDomains[domain.length]) return "TupleValue";
|
|
1812
|
+
if (intervalArrays.has(domain)) return "IntervalFcnRcdValue";
|
|
1813
|
+
return domain.every((key) => typeof key === "string") ? "RecordValue" : "FcnRcdValue";
|
|
1814
|
+
};
|
|
1815
|
+
|
|
1816
|
+
const describeNotInDomain = (functionValue: FunctionValue, argument: Value) =>
|
|
1817
|
+
`Attempted to apply function:\n${prettyPrint(formatValue(functionValue))}\nto argument ${prettyPrint(formatValue(argument))}, which is not in the domain of the function.`;
|
|
1818
|
+
|
|
1819
|
+
const describeNonIntegerArgument = (argument: Value) =>
|
|
1820
|
+
`Attempted to apply function with integer domain to the non-integer argument ${prettyPrint(formatValue(argument))}`;
|
|
1821
|
+
|
|
1822
|
+
const describeMissingArgument = (
|
|
1823
|
+
functionValue: FunctionValue | LazyFunctionValue,
|
|
1824
|
+
argument: Value,
|
|
1825
|
+
) => {
|
|
1826
|
+
if (lambdaFunctions.has(functionValue) || functionValue.kind === "LazyFunction")
|
|
1827
|
+
return `In applying the function\n${prettyPrint(formatValue(functionValue))},\nthe first argument is:\n${prettyPrint(formatValue(argument))}\nwhich is not in its domain.\n`;
|
|
1828
|
+
const functionClass = getFunctionClass(functionValue);
|
|
1829
|
+
if (functionClass === "TupleValue")
|
|
1830
|
+
return typeof argument === "number"
|
|
1831
|
+
? `Attempted to access index ${argument} of tuple\n${prettyPrint(formatValue(functionValue))}\nwhich is out of bounds.`
|
|
1832
|
+
: `Attempted to access tuple at a non integral index: ${prettyPrint(formatValue(argument))}`;
|
|
1833
|
+
if (functionClass === "RecordValue")
|
|
1834
|
+
return typeof argument === "string"
|
|
1835
|
+
? `Attempted to access nonexistent field '${argument}' of record\n${prettyPrint(formatValue(functionValue))}`
|
|
1836
|
+
: `Attempted to access record by a non-string argument: ${prettyPrint(formatValue(argument))}`;
|
|
1837
|
+
return functionClass === "IntervalFcnRcdValue" && typeof argument !== "number"
|
|
1838
|
+
? describeNonIntegerArgument(argument)
|
|
1839
|
+
: describeNotInDomain(functionValue, argument);
|
|
1840
|
+
};
|
|
1841
|
+
|
|
1842
|
+
// TLC selects a field of a value that isn't a record from the function the value converts to,
|
|
1843
|
+
// which keeps a tuple's domain as an interval.
|
|
1844
|
+
export const describeMissingField = (functionValue: FunctionValue, field: string) =>
|
|
1845
|
+
getFunctionClass(functionValue) === "FcnRcdValue"
|
|
1846
|
+
? describeNotInDomain(functionValue, field)
|
|
1847
|
+
: describeNonIntegerArgument(field);
|
|
1848
|
+
|
|
1849
|
+
export const isRecordValue = (functionValue: FunctionValue) =>
|
|
1850
|
+
getFunctionClass(functionValue) === "RecordValue";
|
|
1851
|
+
|
|
1852
|
+
// TLC checks the type of an argument to a tuple or a record before it looks the argument up, so
|
|
1853
|
+
// it never compares the argument with a key of another type.
|
|
1854
|
+
const isForeignKey = (domain: Value[], argument: Value) => {
|
|
1855
|
+
const first = domain[0];
|
|
1856
|
+
return typeof first === "number"
|
|
1857
|
+
? typeof argument !== "number" &&
|
|
1858
|
+
(domain === intervalDomains[domain.length] || intervalArrays.has(domain))
|
|
1859
|
+
: typeof first === "string" && typeof argument !== "string";
|
|
1860
|
+
};
|
|
1722
1861
|
|
|
1723
1862
|
const findKeyIndex = (domain: Value[], argument: Value) => {
|
|
1724
1863
|
const first = domain[0];
|
|
@@ -1737,6 +1876,7 @@ export const applyFunction = (
|
|
|
1737
1876
|
functionValue: Value,
|
|
1738
1877
|
argument: Value,
|
|
1739
1878
|
describeMissing?: (functionValue: FunctionValue) => string,
|
|
1879
|
+
describeNonFunction?: (value: Value) => string,
|
|
1740
1880
|
): Value => {
|
|
1741
1881
|
if (typeof functionValue === "object" && functionValue.kind === "LazyFunction") {
|
|
1742
1882
|
if (!isElementOf(argument, functionValue.domain)) {
|
|
@@ -1750,10 +1890,13 @@ export const applyFunction = (
|
|
|
1750
1890
|
}
|
|
1751
1891
|
if (typeof functionValue !== "object" || functionValue.kind !== "Function") {
|
|
1752
1892
|
throw new TlaEvaluationError(
|
|
1753
|
-
|
|
1893
|
+
describeNonFunction?.(functionValue) ??
|
|
1894
|
+
`Attempted to apply ${formatValue(functionValue)}, which is not a function`,
|
|
1754
1895
|
);
|
|
1755
1896
|
}
|
|
1756
|
-
const position =
|
|
1897
|
+
const position = isForeignKey(functionValue.domain, argument)
|
|
1898
|
+
? -1
|
|
1899
|
+
: findKeyIndex(functionValue.domain, argument);
|
|
1757
1900
|
if (position === -1) {
|
|
1758
1901
|
throw new TlaEvaluationError(
|
|
1759
1902
|
describeMissing?.(functionValue) ?? describeMissingArgument(functionValue, argument),
|
|
@@ -1851,10 +1994,15 @@ const getElementContribution = (element: Value) =>
|
|
|
1851
1994
|
const getEntryContribution = (key: Value, value: Value) =>
|
|
1852
1995
|
finalizeHash((Math.imul(getValueHash(key), 0x27d4eb2d) + getValueHash(value)) | 0);
|
|
1853
1996
|
|
|
1997
|
+
const unenumeratedSets = { isHashed: false };
|
|
1998
|
+
|
|
1854
1999
|
const computeValueHash = (value: ObjectValue) => {
|
|
1855
2000
|
if (value.kind === "ModelValue") return finalizeHash(combineHash(hashString(value.name), 0x6d));
|
|
1856
2001
|
if (isSetValue(value)) {
|
|
1857
|
-
if (!isEnumerable(value))
|
|
2002
|
+
if (!isEnumerable(value)) {
|
|
2003
|
+
unenumeratedSets.isHashed = true;
|
|
2004
|
+
return hashString(getValueKey(value));
|
|
2005
|
+
}
|
|
1858
2006
|
const elements = toFiniteSet(value).elements;
|
|
1859
2007
|
let hash = SET_HASH_SEED;
|
|
1860
2008
|
for (let index = 0; index < elements.length; index++) {
|
|
@@ -1886,6 +2034,25 @@ export const getValueHash = (value: Value): number => {
|
|
|
1886
2034
|
return hash;
|
|
1887
2035
|
};
|
|
1888
2036
|
|
|
2037
|
+
const fingerprintLikeTlc = (value: Value): void => {
|
|
2038
|
+
if (typeof value !== "object" || value.kind === "ModelValue") return;
|
|
2039
|
+
if (isOverriddenSet(value)) {
|
|
2040
|
+
throw new TlaEvaluationError(
|
|
2041
|
+
`TLC has found a state in which the value of a variable contains ${formatValue(value)}`,
|
|
2042
|
+
);
|
|
2043
|
+
}
|
|
2044
|
+
if (isSetValue(value)) return toFiniteSet(value).elements.forEach(fingerprintLikeTlc);
|
|
2045
|
+
const functionValue = toFiniteFunction(value);
|
|
2046
|
+
functionValue.domain.forEach(fingerprintLikeTlc);
|
|
2047
|
+
functionValue.range.forEach(fingerprintLikeTlc);
|
|
2048
|
+
};
|
|
2049
|
+
|
|
2050
|
+
// TLC enumerates every set in a state to fingerprint it, so it fails on a set it can't enumerate.
|
|
2051
|
+
// A state holds one only if hashing it met one, so states go unchecked until then.
|
|
2052
|
+
export const assertFingerprintable = (state: Value[]) => {
|
|
2053
|
+
if (unenumeratedSets.isHashed) state.forEach(fingerprintLikeTlc);
|
|
2054
|
+
};
|
|
2055
|
+
|
|
1889
2056
|
const valueFingerprints = new WeakMap<ObjectValue, number>();
|
|
1890
2057
|
|
|
1891
2058
|
const finalizeFingerprint = (hash: number) => {
|
|
@@ -1912,7 +2079,10 @@ const getEntryFingerprint = (key: Value, value: Value) =>
|
|
|
1912
2079
|
const computeValueFingerprint = (value: ObjectValue) => {
|
|
1913
2080
|
if (value.kind === "ModelValue") return finalizeFingerprint(fingerprintString(value.name) ^ 0x3c);
|
|
1914
2081
|
if (isSetValue(value)) {
|
|
1915
|
-
if (!isEnumerable(value))
|
|
2082
|
+
if (!isEnumerable(value)) {
|
|
2083
|
+
unenumeratedSets.isHashed = true;
|
|
2084
|
+
return fingerprintString(getValueKey(value));
|
|
2085
|
+
}
|
|
1916
2086
|
const elements = toFiniteSet(value).elements;
|
|
1917
2087
|
let fingerprint = 0x1b873593;
|
|
1918
2088
|
for (let index = 0; index < elements.length; index++) {
|
|
@@ -2098,8 +2268,11 @@ export const formatValue = (value: Value, isStrict = false, isNormalized = false
|
|
|
2098
2268
|
return `[${parameters} |-> <expression ${source.body}>]`;
|
|
2099
2269
|
}
|
|
2100
2270
|
const functionValue = toFiniteFunction(value);
|
|
2271
|
+
// TLC normalizes a lambda's domain to print it, but evaluates its body afterward.
|
|
2272
|
+
const formatRange = (inner: Value) =>
|
|
2273
|
+
formatValue(inner, isStrict, isNormalized && value.kind === "Function");
|
|
2101
2274
|
if (functionValue.domain.every((key, index) => key === index + 1)) {
|
|
2102
|
-
return `<<${functionValue.range.map(
|
|
2275
|
+
return `<<${functionValue.range.map(formatRange).join(", ")}>>`;
|
|
2103
2276
|
}
|
|
2104
2277
|
if (functionValue.domain.every((key) => typeof key === "string" && isFieldName(key))) {
|
|
2105
2278
|
const isSorted =
|
|
@@ -2107,9 +2280,20 @@ export const formatValue = (value: Value, isStrict = false, isNormalized = false
|
|
|
2107
2280
|
const pairs = isSorted
|
|
2108
2281
|
? functionValue.domain.map((key, index) => [key, functionValue.range[index]])
|
|
2109
2282
|
: getWrittenPairs(functionValue);
|
|
2110
|
-
return `[${pairs.map((pair) => `${String(pair[0])} |-> ${
|
|
2283
|
+
return `[${pairs.map((pair) => `${String(pair[0])} |-> ${formatRange(pair[1])}`).join(", ")}]`;
|
|
2111
2284
|
}
|
|
2112
|
-
return `(${functionValue.domain.map((key, index) => `${format(key)} :> ${
|
|
2285
|
+
return `(${functionValue.domain.map((key, index) => `${format(key)} :> ${formatRange(functionValue.range[index])}`).join(" @@ ")})`;
|
|
2113
2286
|
}
|
|
2114
2287
|
}
|
|
2115
2288
|
};
|
|
2289
|
+
|
|
2290
|
+
// TLC's TLCState.toString: a line per variable, as a conjunction when there are several.
|
|
2291
|
+
export const formatState = (state: Record<string, Value>) => {
|
|
2292
|
+
const entries = Object.entries(state);
|
|
2293
|
+
return entries
|
|
2294
|
+
.map(
|
|
2295
|
+
([name, value]) =>
|
|
2296
|
+
`${entries.length === 1 ? "" : "/\\ "}${name} = ${prettyPrint(formatValue(value))}\n`,
|
|
2297
|
+
)
|
|
2298
|
+
.join("");
|
|
2299
|
+
};
|