tla-ts 0.0.4-dev.2be6058 → 0.0.4-dev.5c7c024

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/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "tla-ts",
3
- "version": "0.0.4-dev.2be6058",
3
+ "version": "0.0.4-dev.5c7c024",
4
4
  "description": "A TLA+ interpreter and model checker in TypeScript, 2× faster than TLC",
5
5
  "keywords": [
6
6
  "formal verification",
package/src/check.ts CHANGED
@@ -641,6 +641,7 @@ const getSpecification = (config: ModelConfig, environment: Environment): Specif
641
641
  state: undefined,
642
642
  next: undefined,
643
643
  cache: undefined,
644
+ isStreamed: false,
644
645
  },
645
646
  parent,
646
647
  },
package/src/codegen.ts CHANGED
@@ -177,7 +177,7 @@ const generateQuantifier = (
177
177
  }, test);
178
178
  const parameters = outer.map((local) => `, ${local}`).join("");
179
179
  generator.helpers.push(
180
- `function ${name}(context, state, next${parameters}) { let primed; ${declarations.join(" ")} ${loops} return ${isForall}; }`,
180
+ `function ${name}(context, state, next${parameters}) { let primed; let applied; ${declarations.join(" ")} ${loops} return ${isForall}; }`,
181
181
  );
182
182
  return `${name}(${frame.context}, ${frame.state}, ${frame.isPrimed ? "undefined" : frame.next}${parameters})`;
183
183
  };
@@ -247,6 +247,23 @@ const isConstructionFree = (
247
247
  }
248
248
  };
249
249
 
250
+ // Whether the generated code evaluates an expression only in the context its frame names. A primed
251
+ // expression doesn't, since it shares the generated function's primed context.
252
+ const isReadOnly = (expression: Expression): boolean => {
253
+ switch (expression.kind) {
254
+ case "Identifier":
255
+ case "Number":
256
+ case "String":
257
+ return true;
258
+ case "FieldAccess":
259
+ return isReadOnly(expression.record);
260
+ case "FunctionApplication":
261
+ return [expression.function, ...expression.args].every(isReadOnly);
262
+ default:
263
+ return false;
264
+ }
265
+ };
266
+
250
267
  const generateExpression = (generator: Generator, expression: Expression, frame: Frame): string => {
251
268
  const generate = (node: Expression, nodeFrame = frame) =>
252
269
  generateExpression(generator, node, nodeFrame);
@@ -287,17 +304,19 @@ const generateExpression = (generator: Generator, expression: Expression, frame:
287
304
  case "FunctionApplication": {
288
305
  keepLazy(expression.function);
289
306
  // The interpreter evaluates a function that may construct one with EvalControl.KeepLazy.
307
+ const keepLazyFrame = { ...frame, context: `keepLazyContext(${frame.context})` };
290
308
  const evaluatedFunction = isConstructionFree(
291
309
  expression.function,
292
310
  frame,
293
311
  generator.environment,
294
312
  )
295
313
  ? generate(expression.function)
296
- : generateDelegate(generator, expression.function, {
297
- ...frame,
298
- context: `keepLazyContext(${frame.context})`,
299
- });
300
- const functionCode = `expectFunction(${evaluatedFunction}, ${addReference(generator, expression)})`;
314
+ : isReadOnly(expression.function)
315
+ ? generate(expression.function, keepLazyFrame)
316
+ : generateDelegate(generator, expression.function, keepLazyFrame);
317
+ // Tool#evalAppl checks that it applies a function before it evaluates the argument. The check
318
+ // is written out, as calling expectFunction for each application costs more.
319
+ const functionCode = `(applied = ${evaluatedFunction}, typeof applied === "object" && (applied.kind === "Function" || applied.kind === "LazyFunction") ? applied : expectFunction(applied, ${addReference(generator, expression)}))`;
301
320
  const describeMissing = getMissingArgumentDescriber(generator.environment.runtime.version);
302
321
  const error = describeMissing ? `, ${addReference(generator, describeMissing)}` : "";
303
322
  if (expression.args.length === 1)
@@ -370,7 +389,7 @@ export const generateEvaluator = (
370
389
  };
371
390
  const body = generateExpression(generator, expression, frame);
372
391
  const referenceNames = generator.references.map((_, index) => `reference${index}`);
373
- const source = `${generator.helpers.join("\n")}\nreturn (context) => { const state = context.state; const next = context.next; let primed; return ${body}; };`;
392
+ const source = `${generator.helpers.join("\n")}\nreturn (context) => { const state = context.state; const next = context.next; let primed; let applied; return ${body}; };`;
374
393
  runtime.value ??= createRuntime();
375
394
  const helpers = runtime.value;
376
395
  const helperNames = Object.keys(helpers);
package/src/evaluate.ts CHANGED
@@ -21,7 +21,7 @@ import type { CheckerRuntime } from "./runtime";
21
21
  import { getReadVariables } from "./dependencies";
22
22
  import { contextualApplications, mapChildren, substitutedExpressions } from "./instances";
23
23
  import { prettyPrint } from "./pretty-print";
24
- import { isEnabled } from "./successors";
24
+ import { getReadLocals, isEnabled } from "./successors";
25
25
  import {
26
26
  applyFunction,
27
27
  describeMissingArgument,
@@ -54,6 +54,7 @@ import {
54
54
  markLambdaFunction,
55
55
  isReducibleSet,
56
56
  isSetValue,
57
+ isSettledValue,
57
58
  MAXIMUM_INTEGER,
58
59
  MINIMUM_INTEGER,
59
60
  toFiniteFunction,
@@ -113,6 +114,9 @@ export interface Thunk {
113
114
  state: State | undefined;
114
115
  next: State | undefined;
115
116
  cache: Value | undefined;
117
+ // Whether the expression may build a set that streams until TLC caches it, so that the thunk
118
+ // caches only a settled value.
119
+ isStreamed: boolean;
116
120
  }
117
121
 
118
122
  type Binding = { kind: "Value"; value: Value } | Thunk | { kind: "Operator"; operator: Operator };
@@ -380,7 +384,15 @@ export const expectFunction = (value: Value, application: Expression) => {
380
384
  };
381
385
 
382
386
  export const toKeepLazyContext = (context: Context): Context =>
383
- context.isKeepLazy ? context : { ...context, isKeepLazy: true };
387
+ context.isKeepLazy
388
+ ? context
389
+ : {
390
+ environment: context.environment,
391
+ scope: context.scope,
392
+ state: context.state,
393
+ next: context.next,
394
+ isKeepLazy: true,
395
+ };
384
396
 
385
397
  const withScope = (context: Context, scope: Scope | undefined): Context => ({
386
398
  environment: context.environment,
@@ -839,7 +851,7 @@ const forceThunk = (thunk: Thunk, context: Context) => {
839
851
  const isSameState = thunk.state === context.state && thunk.next === context.next;
840
852
  if (isSameState && thunk.cache !== undefined) return thunk.cache;
841
853
  const value = evaluate(thunk.expression, withScope(context, thunk.scope));
842
- if (isSameState) thunk.cache = value;
854
+ if (isSameState && (!thunk.isStreamed || isSettledValue(value))) thunk.cache = value;
843
855
  return value;
844
856
  };
845
857
 
@@ -960,6 +972,7 @@ const createThunk = (expression: Expression, context: Context): Thunk => ({
960
972
  state: context.state,
961
973
  next: context.next,
962
974
  cache: undefined,
975
+ isStreamed: false,
963
976
  });
964
977
 
965
978
  export const findGlobalName = (name: string, environment: Environment): GlobalName | undefined => {
@@ -1056,10 +1069,16 @@ const callOperator = (operator: Operator, args: Expression[], context: Context)
1056
1069
  );
1057
1070
  };
1058
1071
 
1072
+ // The LET definitions that a reference evaluates again, and those that cache only a settled value.
1073
+ interface ReevaluatedDefinitions {
1074
+ impure: ReadonlySet<Definition>;
1075
+ streamed: ReadonlySet<Definition>;
1076
+ }
1077
+
1059
1078
  export const bindDefinitions = (
1060
1079
  definitions: Definition[],
1061
1080
  context: Context,
1062
- reevaluated?: ReadonlySet<Definition>,
1081
+ reevaluated?: ReevaluatedDefinitions,
1063
1082
  ): Scope | undefined =>
1064
1083
  definitions.reduce<Scope | undefined>((scope, definition) => {
1065
1084
  const node: Scope = {
@@ -1081,10 +1100,11 @@ export const bindDefinitions = (
1081
1100
  state: context.state,
1082
1101
  next: context.next,
1083
1102
  cache: undefined,
1103
+ isStreamed: false,
1084
1104
  };
1085
1105
  return node;
1086
1106
  }
1087
- if (definition.params.length > 0 || reevaluated?.has(definition)) {
1107
+ if (definition.params.length > 0 || reevaluated?.impure.has(definition)) {
1088
1108
  node.binding = {
1089
1109
  kind: "Operator",
1090
1110
  operator: {
@@ -1104,6 +1124,7 @@ export const bindDefinitions = (
1104
1124
  state: context.state,
1105
1125
  next: context.next,
1106
1126
  cache: undefined,
1127
+ isStreamed: reevaluated?.streamed.has(definition) ?? false,
1107
1128
  };
1108
1129
  return node;
1109
1130
  }, context.scope);
@@ -1220,14 +1241,15 @@ const STREAMED_SET: Impurity = {
1220
1241
  // TLC's next-state generator does not bind LET definitions to values, so each reference to one
1221
1242
  // evaluates it again: one that calls an impure builtin repeats its effects, and a set one builds
1222
1243
  // with UNION or \cup starts out uncached.
1223
- export const getReevaluatedDefinitions = (definitions: Definition[], environment: Environment) =>
1224
- new Set(
1225
- definitions.filter(
1226
- (definition) =>
1227
- isImpureDefinition(definition, environment) ||
1228
- isImpureDefinition(definition, environment, STREAMED_SET),
1229
- ),
1230
- );
1244
+ export const getReevaluatedDefinitions = (
1245
+ definitions: Definition[],
1246
+ environment: Environment,
1247
+ ): ReevaluatedDefinitions => ({
1248
+ impure: new Set(definitions.filter((definition) => isImpureDefinition(definition, environment))),
1249
+ streamed: new Set(
1250
+ definitions.filter((definition) => isImpureDefinition(definition, environment, STREAMED_SET)),
1251
+ ),
1252
+ });
1231
1253
 
1232
1254
  export const isImpure = (environment: Environment) =>
1233
1255
  [...environment.definitions.values()].some((definition) =>
@@ -1685,52 +1707,180 @@ export const compileArgumentScope = (
1685
1707
  };
1686
1708
 
1687
1709
  interface MemoizedCall {
1710
+ sources: (Expression | undefined)[];
1688
1711
  args: Value[];
1689
1712
  value: Value;
1690
1713
  }
1691
1714
 
1692
1715
  const MEMOIZED_CALL_LIMIT = 1 << 16;
1693
1716
 
1694
- const callMemos = new WeakMap<Closure, { calls: Map<number, MemoizedCall[]>; size: number }>();
1717
+ // A call site that finds fewer than half its calls in a state's memo after this many new ones
1718
+ // stops paying for the lookups.
1719
+ const MEMOIZED_TRIAL_CALLS = 1 << 10;
1695
1720
 
1696
- const getCallMemo = (closure: Closure) => {
1721
+ interface CallMemo {
1722
+ calls: Map<number, MemoizedCall[]>;
1723
+ size: number;
1724
+ state: Context["state"];
1725
+ }
1726
+
1727
+ interface CallMemos {
1728
+ constant: CallMemo;
1729
+ state: CallMemo;
1730
+ }
1731
+
1732
+ const createCallMemo = (): CallMemo => ({ calls: new Map(), size: 0, state: undefined });
1733
+
1734
+ const callMemos = new WeakMap<Closure, CallMemos>();
1735
+
1736
+ const getCallMemos = (closure: Closure) => {
1697
1737
  const cached = callMemos.get(closure);
1698
1738
  if (cached) return cached;
1699
- const memo = { calls: new Map<number, MemoizedCall[]>(), size: 0 };
1700
- callMemos.set(closure, memo);
1701
- return memo;
1739
+ const memos = { constant: createCallMemo(), state: createCallMemo() };
1740
+ callMemos.set(closure, memos);
1741
+ return memos;
1742
+ };
1743
+
1744
+ const readsExceptAt = (expression: Expression): boolean =>
1745
+ expression.kind === "ExceptAt" || getChildren(expression).some(readsExceptAt);
1746
+
1747
+ // The locals an argument expression reads, when the state and their values decide its value. An @
1748
+ // reads the value its EXCEPT binds.
1749
+ const argumentLocals = new WeakMap<Expression, string[] | false>();
1750
+
1751
+ const getArgumentLocals = (expression: Expression, environment: Environment) => {
1752
+ const cached = argumentLocals.get(expression);
1753
+ if (cached !== undefined) return cached;
1754
+ const locals =
1755
+ getReadVariables(expression, environment) !== undefined &&
1756
+ getReadLocals(expression, NO_BOUND_NAMES);
1757
+ const unique = locals && [
1758
+ ...new Set(readsExceptAt(expression) ? [...locals, EXCEPT_AT] : locals),
1759
+ ];
1760
+ argumentLocals.set(expression, unique ?? false);
1761
+ return unique ?? false;
1762
+ };
1763
+
1764
+ // Hashing a lazy set or function would enumerate it, which TLC does only when it has to.
1765
+ const isEagerValue = (value: Value) =>
1766
+ typeof value !== "object" ||
1767
+ value.kind === "ModelValue" ||
1768
+ value.kind === "Set" ||
1769
+ value.kind === "Function" ||
1770
+ value.kind === "Interval";
1771
+
1772
+ // The key of the call being looked up, copied into the memo only when the call is new. Counts
1773
+ // mark its ends, since shortening an array is slow.
1774
+ const callKey = {
1775
+ sources: [] as (Expression | undefined)[],
1776
+ sourceCount: 0,
1777
+ args: [] as Value[],
1778
+ argCount: 0,
1779
+ hash: 0,
1780
+ isStateKeyed: false,
1781
+ };
1782
+
1783
+ // A model value's rank tells it apart without hashing its name.
1784
+ const getKeyHash = (value: Value) =>
1785
+ typeof value === "object" && value.kind === "ModelValue" ? value.rank : getValueHash(value);
1786
+
1787
+ const pushKeyValue = (value: Value) => {
1788
+ if (!isEagerValue(value)) return false;
1789
+ callKey.sources[callKey.sourceCount++] = undefined;
1790
+ callKey.args[callKey.argCount++] = value;
1791
+ callKey.hash = combineHash(callKey.hash, getKeyHash(value));
1792
+ return true;
1793
+ };
1794
+
1795
+ // An argument TLC has not evaluated yet stands for its expression and the values of the locals it
1796
+ // reads, so a call keeps the laziness of its arguments.
1797
+ const pushKeyExpression = (
1798
+ expression: Expression,
1799
+ locals: string[] | false,
1800
+ scope: Scope | undefined,
1801
+ ) => {
1802
+ if (!locals) return false;
1803
+ callKey.sources[callKey.sourceCount++] = expression;
1804
+ callKey.isStateKeyed = true;
1805
+ for (let index = 0; index < locals.length; index++) {
1806
+ const local = lookupScope(scope, locals[index]);
1807
+ if (local?.kind !== "Value" || !isEagerValue(local.value)) return false;
1808
+ callKey.args[callKey.argCount++] = local.value;
1809
+ callKey.hash = combineHash(callKey.hash, getKeyHash(local.value));
1810
+ }
1811
+ return true;
1812
+ };
1813
+
1814
+ // Each argument adds to the key what compileArgumentBinder would bind its parameter to.
1815
+ const compileArgumentKey = (
1816
+ argument: Expression,
1817
+ environment: Environment,
1818
+ ): ((context: Context) => boolean) => {
1819
+ const isLiteral =
1820
+ argument.kind === "String" || (argument.kind === "Number" && isTlcInteger(argument.value));
1821
+ if (isLiteral) return () => pushKeyValue(argument.value);
1822
+ if (argument.kind === "Identifier") {
1823
+ const global = isLocallyResolved(argument)
1824
+ ? undefined
1825
+ : findGlobalName(argument.name, environment);
1826
+ if (global?.kind === "Value") return () => pushKeyValue(global.value);
1827
+ if (global === undefined) {
1828
+ return (context) => {
1829
+ const binding = lookupScope(context.scope, argument.name);
1830
+ if (binding?.kind === "Value") return pushKeyValue(binding.value);
1831
+ if (binding?.kind !== "Thunk" || binding.state !== context.state) return false;
1832
+ return pushKeyExpression(
1833
+ binding.expression,
1834
+ getArgumentLocals(binding.expression, environment),
1835
+ binding.scope,
1836
+ );
1837
+ };
1838
+ }
1839
+ }
1840
+ const locals = getArgumentLocals(argument, environment);
1841
+ return (context) => pushKeyExpression(argument, locals, context.scope);
1702
1842
  };
1703
1843
 
1704
- const getArgumentValues = (scope: Scope | undefined, arity: number) => {
1705
- const values: Value[] = [];
1706
- for (let current = scope; values.length < arity; current = current?.parent) {
1707
- if (current?.binding.kind !== "Value") return undefined;
1708
- values.push(current.binding.value);
1844
+ const isKnownCall = (call: MemoizedCall) => {
1845
+ if (call.args.length !== callKey.argCount || call.sources.length !== callKey.sourceCount) {
1846
+ return false;
1847
+ }
1848
+ for (let index = 0; index < callKey.sourceCount; index++) {
1849
+ if (call.sources[index] !== callKey.sources[index]) return false;
1709
1850
  }
1710
- return values;
1851
+ for (let index = 0; index < callKey.argCount; index++) {
1852
+ if (!isSameValue(call.args[index], callKey.args[index])) return false;
1853
+ }
1854
+ return true;
1711
1855
  };
1712
1856
 
1713
- const isSameArguments = (left: Value[], right: Value[]) =>
1714
- left.every((value, index) => isSameValue(value, right[index]));
1857
+ const findCall = (bucket: MemoizedCall[] | undefined) => {
1858
+ if (bucket === undefined) return undefined;
1859
+ for (let index = 0; index < bucket.length; index++) {
1860
+ if (isKnownCall(bucket[index])) return bucket[index];
1861
+ }
1862
+ return undefined;
1863
+ };
1715
1864
 
1716
- // A constant-level operator without side effects yields the same value for the same arguments,
1717
- // so its calls with evaluated arguments share one result.
1718
- const isMemoizable = (expression: Expression & { kind: "Apply" }, environment: Environment) => {
1865
+ // An operator without side effects yields the same value for the same arguments, a state-level one
1866
+ // in the same state, so its calls share one result.
1867
+ const getMemoizedLevel = (expression: Expression & { kind: "Apply" }, environment: Environment) => {
1719
1868
  const definition = getDefinition(expression.operator, environment);
1720
- return (
1869
+ const isMemoizable =
1721
1870
  definition?.kind === "Operator" &&
1722
1871
  definition.params.length > 0 &&
1723
1872
  definition.params.every((param) => param.arity === 0) &&
1724
- isConstantLevel(definition, environment) &&
1725
- !isImpureDefinition(definition, environment)
1726
- );
1873
+ !isImpureDefinition(definition, environment);
1874
+ if (!isMemoizable) return undefined;
1875
+ if (isConstantLevel(definition, environment)) return "constant";
1876
+ return isStatePure(definition, environment) ? "state" : undefined;
1727
1877
  };
1728
1878
 
1729
1879
  const compileClosureCall = (
1730
1880
  closure: Closure,
1731
1881
  args: Expression[],
1732
1882
  environment: Environment,
1733
- isMemoized: boolean,
1883
+ memoizedLevel: "constant" | "state" | undefined,
1734
1884
  ): Evaluator => {
1735
1885
  const bindArguments = compileArgumentScope(closure, args, environment);
1736
1886
  const compiled = { body: undefined as Evaluator | undefined };
@@ -1744,23 +1894,49 @@ const compileClosureCall = (
1744
1894
  isKeepLazy: context.isKeepLazy,
1745
1895
  });
1746
1896
  };
1747
- if (!isMemoized) return (context) => evaluateBody(bindArguments(context), context);
1748
- const memo = getCallMemo(closure);
1897
+ if (!memoizedLevel || args.length !== closure.params.length) {
1898
+ return (context) => evaluateBody(bindArguments(context), context);
1899
+ }
1900
+ const memos = getCallMemos(closure);
1901
+ const keys = args.map((arg) => compileArgumentKey(arg, environment));
1902
+ const usage = { hits: 0, misses: 0 };
1749
1903
  return (context) => {
1750
- const scope = bindArguments(context);
1751
- const values = getArgumentValues(scope, args.length);
1752
1904
  // A call TLC evaluates with EvalControl.KeepLazy builds what a memoized one wouldn't.
1753
- if (!values || context.isKeepLazy) return evaluateBody(scope, context);
1754
- let hash = values.length;
1755
- for (const value of values) hash = combineHash(hash, getValueHash(value));
1905
+ if (context.isKeepLazy) return evaluateBody(bindArguments(context), context);
1906
+ callKey.sourceCount = 0;
1907
+ callKey.argCount = 0;
1908
+ callKey.hash = args.length;
1909
+ callKey.isStateKeyed = false;
1910
+ for (let index = 0; index < keys.length; index++) {
1911
+ if (!keys[index](context)) return evaluateBody(bindArguments(context), context);
1912
+ }
1913
+ const isStateKeyed = memoizedLevel === "state" || callKey.isStateKeyed;
1914
+ if (isStateKeyed && usage.misses > MEMOIZED_TRIAL_CALLS && usage.hits < usage.misses) {
1915
+ return evaluateBody(bindArguments(context), context);
1916
+ }
1917
+ const memo = isStateKeyed ? memos.state : memos.constant;
1918
+ if (isStateKeyed && memo.state !== context.state) {
1919
+ memo.state = context.state;
1920
+ memo.calls.clear();
1921
+ memo.size = 0;
1922
+ }
1923
+ // A small integer key keeps the Map from boxing it.
1924
+ const hash = callKey.hash & 0x3fffffff;
1756
1925
  const bucket = memo.calls.get(hash);
1757
- const known = bucket?.find((call) => isSameArguments(call.args, values));
1758
- if (known) return known.value;
1759
- const value = evaluateBody(scope, context);
1926
+ const known = findCall(bucket);
1927
+ if (known) {
1928
+ if (isStateKeyed) usage.hits++;
1929
+ return known.value;
1930
+ }
1931
+ if (isStateKeyed) usage.misses++;
1932
+ const sources = callKey.sources.slice(0, callKey.sourceCount);
1933
+ const keyArgs = callKey.args.slice(0, callKey.argCount);
1934
+ const value = evaluateBody(bindArguments(context), context);
1760
1935
  if (memo.size < MEMOIZED_CALL_LIMIT) {
1761
1936
  memo.size++;
1762
- if (bucket) bucket.push({ args: values, value });
1763
- else memo.calls.set(hash, [{ args: values, value }]);
1937
+ const call = { sources, args: keyArgs, value };
1938
+ if (bucket) bucket.push(call);
1939
+ else memo.calls.set(hash, [call]);
1764
1940
  }
1765
1941
  return value;
1766
1942
  };
@@ -1788,8 +1964,10 @@ const compileApply = (
1788
1964
  : resolveGlobalOperator(expression.operator, environment);
1789
1965
  if (global?.kind === "Closure") {
1790
1966
  // The replay records the evaluation of each call, which TLC repeats.
1791
- const isMemoized = !environment.callStack && isMemoizable(expression, environment);
1792
- return compileClosureCall(global, args, environment, isMemoized);
1967
+ const memoizedLevel = environment.callStack
1968
+ ? undefined
1969
+ : getMemoizedLevel(expression, environment);
1970
+ return compileClosureCall(global, args, environment, memoizedLevel);
1793
1971
  }
1794
1972
  if (global?.kind === "Builtin" && global.name === "DOMAIN") {
1795
1973
  const operand = getEvaluator(args[0], environment);
@@ -162,8 +162,11 @@ export const CORE_OPERATORS: Builtin[] = [
162
162
  : differenceSorted;
163
163
  // The merge compares the elements, which TLC tests for membership one by one instead.
164
164
  return computeLikeTlcOnFailure(
165
- () => merge(toFiniteSet(left), toFiniteSet(right)),
166
- () => combineReducible(operator, left, right),
165
+ (finiteLeft, finiteRight) => merge(toFiniteSet(finiteLeft), toFiniteSet(finiteRight)),
166
+ (reducibleLeft, reducibleRight) =>
167
+ combineReducible(operator, reducibleLeft, reducibleRight),
168
+ left,
169
+ right,
167
170
  );
168
171
  }
169
172
  if (isReducibleSet(left)) return combineReducible(operator, left, right);
package/src/successors.ts CHANGED
@@ -265,7 +265,7 @@ const NO_NAMES: ReadonlySet<string> = new Set();
265
265
 
266
266
  // The local names an expression reads from enclosing scopes, or undefined when it applies a local
267
267
  // operator, whose body may assign variables.
268
- const getReadLocals = (
268
+ export const getReadLocals = (
269
269
  expression: Expression,
270
270
  bound: ReadonlySet<string>,
271
271
  ): string[] | undefined => {
package/src/tlc-random.ts CHANGED
@@ -182,24 +182,14 @@ const createShiftTable = (length: number) => {
182
182
 
183
183
  // Extending a fingerprint by a byte is linear over GF(2), so extending it by a value's bytes
184
184
  // XORs the value's own fingerprint from zero into the fingerprint shifted by their length.
185
- // The fingerprinter caches each distinct variable value for one pass over the stored states. It
186
- // reads a state's variables in `order` and writes each fingerprint's low and high words into
187
- // `words`, an Int32Array over a little-endian BigInt64Array.
185
+ // The fingerprinter caches each distinct function or set it meets, nested ones included, for one
186
+ // pass over the stored states, as states share most of their values. It reads a state's variables
187
+ // in `order` and writes each fingerprint's low and high words into `words`, an Int32Array over a
188
+ // little-endian BigInt64Array.
188
189
  export const createTlcFingerprinter = (order: number[], words: Int32Array) => {
189
190
  const shiftTables = new Map<number, Int32Array>();
190
191
  const indices = new Map<Value, number>();
191
192
  const contributions: number[] = [];
192
- const getContribution = (value: Value) => {
193
- const cached = indices.get(value);
194
- if (cached !== undefined) return cached;
195
- const length = getFingerprintLength(value);
196
- high = 0;
197
- low = 0;
198
- extendValue(value);
199
- indices.set(value, contributions.length);
200
- contributions.push(length, high, low);
201
- return contributions.length - 3;
202
- };
203
193
  const getShiftTable = (length: number) => {
204
194
  const cached = shiftTables.get(length);
205
195
  if (cached) return cached;
@@ -207,29 +197,62 @@ export const createTlcFingerprinter = (order: number[], words: Int32Array) => {
207
197
  shiftTables.set(length, table);
208
198
  return table;
209
199
  };
210
- return (state: Value[], position: number) => {
200
+ // Extends the fingerprint by a value's bytes and returns how many there are.
201
+ const extendElement = (value: Value): number => {
202
+ if (typeof value !== "object" || isModelValue(value)) {
203
+ extendValue(value);
204
+ return getFingerprintLength(value);
205
+ }
206
+ const contribution = getContribution(value);
207
+ const shifted = { high, low };
208
+ const table = getShiftTable(contributions[contribution]);
209
+ high = contributions[contribution + 1];
210
+ low = contributions[contribution + 2];
211
+ for (let position = 0; position < 8; position++) {
212
+ const word = position < 4 ? shifted.low : shifted.high;
213
+ const entry = (position * 256 + ((word >>> ((position & 3) * 8)) & 0xff)) * 2;
214
+ high ^= table[entry];
215
+ low ^= table[entry + 1];
216
+ }
217
+ return contributions[contribution];
218
+ };
219
+ const getContribution = (value: Value) => {
220
+ const cached = indices.get(value);
221
+ if (cached !== undefined) return cached;
211
222
  const outer = { high, low };
212
- const fingerprint = { high: INITIAL_HIGH, low: INITIAL_LOW };
213
- for (const index of order) {
214
- const contribution = getContribution(state[index]);
215
- const table = getShiftTable(contributions[contribution]);
216
- const extended = {
217
- high: contributions[contribution + 1],
218
- low: contributions[contribution + 2],
219
- };
220
- for (let position = 0; position < 8; position++) {
221
- const word = position < 4 ? fingerprint.low : fingerprint.high;
222
- const entry = (position * 256 + ((word >>> ((position & 3) * 8)) & 0xff)) * 2;
223
- extended.high ^= table[entry];
224
- extended.low ^= table[entry + 1];
223
+ high = 0;
224
+ low = 0;
225
+ const length = { value: 5 };
226
+ if (isFunctionValue(value)) {
227
+ const functionValue = toFiniteFunction(value);
228
+ extendByte(FCN_RCD_VALUE);
229
+ extendInt(functionValue.domain.length);
230
+ for (let index = 0; index < functionValue.domain.length; index++) {
231
+ length.value += extendElement(functionValue.domain[index]);
232
+ length.value += extendElement(functionValue.range[index]);
225
233
  }
226
- fingerprint.high = extended.high;
227
- fingerprint.low = extended.low;
234
+ } else {
235
+ const elements = toFiniteSet(value).elements;
236
+ extendByte(SET_ENUM_VALUE);
237
+ extendInt(elements.length);
238
+ for (const element of elements) length.value += extendElement(element);
228
239
  }
240
+ const contribution = contributions.length;
241
+ indices.set(value, contribution);
242
+ contributions.push(length.value, high, low);
243
+ high = outer.high;
244
+ low = outer.low;
245
+ return contribution;
246
+ };
247
+ return (state: Value[], position: number) => {
248
+ const outer = { high, low };
249
+ high = INITIAL_HIGH;
250
+ low = INITIAL_LOW;
251
+ for (const index of order) extendElement(state[index]);
252
+ words[2 * position] = low;
253
+ words[2 * position + 1] = high;
229
254
  high = outer.high;
230
255
  low = outer.low;
231
- words[2 * position] = fingerprint.low;
232
- words[2 * position + 1] = fingerprint.high;
233
256
  };
234
257
  };
235
258