tla-ts 0.0.1 → 0.0.3-dev.3cf2ad0

package/src/symmetry.ts

@@ -5,9 +5,11 @@ import {
   createFunction,
   createSet,
   createSortedFunction,
+  createSortedSet,
   isEnumerable,
   isFunctionValue,
   isModelValue,
+  isSameValue,
   isSetValue,
   toFiniteFunction,
   toFiniteSet,
@@ -18,6 +20,9 @@ import {
 
 type Images = Map<string, ModelValue>;
 
+const CACHE_LIMIT = 1 << 22;
+const CACHED_SIZE_LIMIT = 64;
+
 interface Permutation {
   images: Images;
   cache: WeakMap<ObjectValue, Value>;
@@ -31,7 +36,7 @@ const getPermutationKey = (permutation: Images) =>
     .sort()
     .join(",");
 
-const composePermutations = (first: Images, second: Images): Images => {
+const composePermutations = (first: Images, second: Images) => {
   const composed: Images = new Map();
   const names = new Set([...first.keys(), ...second.keys()]);
   names.forEach((name) => {
@@ -42,14 +47,14 @@ const composePermutations = (first: Images, second: Images): Images => {
   return composed;
 };
 
-const toImages = (value: Value, name: string): Images => {
+const toImages = (value: Value, name: string) => {
   if (!isFunctionValue(value)) {
     throw new TlaConfigError(`The symmetry values of ${name} must be functions`);
   }
-  const fn = toFiniteFunction(value);
+  const functionValue = toFiniteFunction(value);
   const permutation: Images = new Map();
-  fn.domain.forEach((key, index) => {
-    const image = fn.range[index];
+  functionValue.domain.forEach((key, index) => {
+    const image = functionValue.range[index];
     if (!isModelValue(key) || !isModelValue(image)) {
       throw new TlaConfigError("Symmetry function must have model values as domain and range");
     }
@@ -103,7 +108,7 @@ export const getSymmetryGroup = (name: string, environment: Environment): Permut
   }));
 };
 
-const permuteElements = (elements: Value[], permutation: Permutation): Value[] | undefined => {
+const permuteElements = (elements: Value[], permutation: Permutation) => {
   for (let index = 0; index < elements.length; index++) {
     const element = elements[index];
     const permuted = permuteValue(element, permutation);
@@ -118,8 +123,32 @@ const permuteElements = (elements: Value[], permutation: Permutation): Value[] |
   return undefined;
 };
 
-const CACHE_LIMIT = 1 << 22;
-const CACHED_SIZE_LIMIT = 16;
+// A permutation maps distinct elements to distinct elements and keeps the elements it doesn't move
+// in order, so it sorts only the moved ones and merges them back.
+const permuteSortedElements = (elements: Value[], permutation: Permutation) => {
+  const kept: Value[] = [];
+  const moved: Value[] = [];
+  for (const element of elements) {
+    const permuted = permuteValue(element, permutation);
+    if (permuted === element) kept.push(element);
+    else moved.push(permuted);
+  }
+  if (moved.length === 0) return undefined;
+  moved.sort(compareValues);
+  const merged: Value[] = [];
+  let keptIndex = 0;
+  let movedIndex = 0;
+  while (keptIndex < kept.length && movedIndex < moved.length) {
+    merged.push(
+      compareValues(kept[keptIndex], moved[movedIndex]) < 0
+        ? kept[keptIndex++]
+        : moved[movedIndex++],
+    );
+  }
+  while (keptIndex < kept.length) merged.push(kept[keptIndex++]);
+  while (movedIndex < moved.length) merged.push(moved[movedIndex++]);
+  return merged;
+};
 
 const getSize = (value: ObjectValue) =>
   value.kind === "Set"
@@ -135,7 +164,10 @@ const permuteValue = (value: Value, permutation: Permutation): Value => {
   if (size === 0 || size > CACHED_SIZE_LIMIT) return computePermutedValue(value, permutation);
   const cached = permutation.cache.get(value);
   if (cached !== undefined) return cached;
-  const permuted = computePermutedValue(value, permutation);
+  const computed = computePermutedValue(value, permutation);
+  // A permutation often maps a value to an equal one. Keeping the original lets the comparison
+  // with the smallest state so far stop at identity.
+  const permuted = computed !== value && isSameValue(computed, value) ? value : computed;
   if (permutation.cacheSize >= permutation.cacheLimit) {
     permutation.cache = new WeakMap();
     permutation.cacheSize = 0;
@@ -145,20 +177,22 @@ const permuteValue = (value: Value, permutation: Permutation): Value => {
   return permuted;
 };
 
-const computePermutedValue = (value: ObjectValue, permutation: Permutation): Value => {
+const computePermutedValue = (value: ObjectValue, permutation: Permutation) => {
   const kind = value.kind;
   if (kind === "Set") {
-    const elements = permuteElements(value.elements, permutation);
-    return elements ? createSet(elements) : value;
+    const elements = permuteSortedElements(value.elements, permutation);
+    return elements ? createSortedSet(elements) : value;
   }
   if (kind === "Function" || (kind === "LazyFunction" && isEnumerable(value.domain))) {
-    const fn = toFiniteFunction(value);
-    const domain = permuteElements(fn.domain, permutation);
-    const range = permuteElements(fn.range, permutation) ?? fn.range;
+    const functionValue = toFiniteFunction(value);
+    const domain = permuteElements(functionValue.domain, permutation);
+    const range = permuteElements(functionValue.range, permutation) ?? functionValue.range;
     if (domain) {
       return createFunction(domain.map((key, index): [Value, Value] => [key, range[index]]));
     }
-    return range === fn.range ? fn : createSortedFunction(fn.domain, range);
+    return range === functionValue.range
+      ? functionValue
+      : createSortedFunction(functionValue.domain, range);
   }
   if (kind === "Interval" || !isSetValue(value) || !isEnumerable(value)) return value;
   const set = toFiniteSet(value);
@@ -173,20 +207,34 @@ const permuteRemaining = (state: Value[], permuted: Value[], permutation: Permut
   return permuted;
 };
 
-const getSmallerPermutation = (state: Value[], minimum: Value[], permutation: Permutation) => {
+const getSmallerPermutation = (
+  state: Value[],
+  minimum: Value[],
+  permutation: Permutation,
+  order: number[] | undefined,
+) => {
   const permuted: Value[] = [];
-  for (let index = 0; index < state.length; index++) {
+  for (let position = 0; position < state.length; position++) {
+    const index = order ? order[position] : position;
     const value = permuteValue(state[index], permutation);
     const comparison = compareValues(value, minimum[index]);
     if (comparison > 0) return undefined;
-    permuted.push(value);
-    if (comparison < 0) return permuteRemaining(state, permuted, permutation);
+    if (!order) permuted.push(value);
+    if (comparison < 0) {
+      return order
+        ? state.map((item) => permuteValue(item, permutation))
+        : permuteRemaining(state, permuted, permutation);
+    }
   }
   return undefined;
 };
 
-export const getRepresentative = (state: Value[], group: Permutation[]): Value[] =>
+export const getRepresentative = (
+  state: Value[],
+  group: Permutation[],
+  order?: number[],
+): Value[] =>
   group.reduce(
-    (minimum, permutation) => getSmallerPermutation(state, minimum, permutation) ?? minimum,
+    (minimum, permutation) => getSmallerPermutation(state, minimum, permutation, order) ?? minimum,
     state,
   );

package/src/tableau.ts

@@ -1,13 +1,14 @@
 import type { Expression } from "./ast";
 import { TlaEvaluationError } from "./errors";
 import type { Scope } from "./evaluate";
+import { ACTION_LEVEL, TEMPORAL_LEVEL } from "./levels";
 
-export interface LiveBoolean {
+interface LiveBoolean {
   kind: "Boolean";
   value: boolean;
 }
 
-export interface LiveState {
+interface LiveState {
   kind: "State";
   expression: Expression;
   scope: Scope | undefined;
@@ -19,7 +20,7 @@ export interface LiveEnabled {
   scope: Scope | undefined;
 }
 
-export interface LiveAction {
+interface LiveAction {
   kind: "Action";
   expression: Expression;
   unchanged: Expression | undefined;
@@ -27,12 +28,12 @@ export interface LiveAction {
   enabled?: LiveEnabled;
 }
 
-export interface LiveUnary {
+interface LiveUnary {
   kind: "Not" | "Always" | "Eventually" | "Next";
   body: LiveExpression;
 }
 
-export interface LiveJunction {
+interface LiveJunction {
   kind: "And" | "Or";
   operands: LiveExpression[];
 }
@@ -45,7 +46,7 @@ export type LiveExpression =
   | LiveUnary
   | LiveJunction;
 
-export interface TableauNode {
+interface TableauNode {
   particle: LiveExpression[];
   successors: number[];
   statePredicates: LiveExpression[];
@@ -56,7 +57,7 @@ export interface Tableau {
   initialCount: number;
 }
 
-export interface ErrorModel {
+interface ErrorModel {
   eventuallyAlways: number[];
   infinitelyOftenStates: number[];
   infinitelyOftenActions: number[];
@@ -84,14 +85,12 @@ interface Triple {
 }
 
 const STATE_LEVEL = 1;
-const ACTION_LEVEL = 2;
-const TEMPORAL_LEVEL = 3;
 const MAXIMUM_DISJUNCTS = 2147483647;
 
-export const TRUE: LiveBoolean = { kind: "Boolean", value: true };
-export const FALSE: LiveBoolean = { kind: "Boolean", value: false };
+const TRUE: LiveBoolean = { kind: "Boolean", value: true };
+const FALSE: LiveBoolean = { kind: "Boolean", value: false };
 
-const createBoolean = (value: boolean) => (value ? TRUE : FALSE);
+export const createBoolean = (value: boolean) => (value ? TRUE : FALSE);
 
 const isAtom = (expression: LiveExpression) =>
   expression.kind === "State" || expression.kind === "Enabled" || expression.kind === "Action";
@@ -265,6 +264,10 @@ const toDisjunctiveNormalForm = (expression: LiveExpression): LiveExpression =>
       const total = { value: 1 };
       for (const operand of expression.operands) {
         const normal = toDisjunctiveNormalForm(operand);
+        if (normal.kind === "And") {
+          items.push(...normal.operands);
+          continue;
+        }
         if (normal.kind === "Or") {
           total.value *= normal.operands.length;
           if (total.value > MAXIMUM_DISJUNCTS) {
@@ -272,12 +275,8 @@ const toDisjunctiveNormalForm = (expression: LiveExpression): LiveExpression =>
               "TLC cannot handle the temporal formula because it exceeds the maximum supported size in disjunctive normal form",
             );
           }
-          items.push(normal);
-        } else if (normal.kind === "And") {
-          items.push(...normal.operands);
-        } else {
-          items.push(normal);
         }
+        items.push(normal);
       }
       if (total.value === 1) return { kind: "And", operands: items };
       const conjunctions = Array.from({ length: total.value }, (): LiveExpression[] => []);
@@ -427,9 +426,13 @@ const getExpansion = (
   term: LiveExpression,
   repeated: "Always" | "Eventually",
   junction: "And" | "Or",
-): [LiveExpression, LiveExpression] | undefined => {
-  if (term.kind === repeated && "body" in term) return [term.body, createUnary("Next", term)];
-  if (term.kind === junction && "operands" in term) return [term.operands[0], term.operands[1]];
+) => {
+  if (term.kind === repeated && "body" in term) {
+    return { first: term.body, second: createUnary("Next", term) };
+  }
+  if (term.kind === junction && "operands" in term) {
+    return { first: term.operands[0], second: term.operands[1] };
+  }
   return undefined;
 };
 
@@ -437,10 +440,10 @@ const getTriples = (
   closure: LiveExpression[],
   repeated: "Always" | "Eventually",
   junction: "And" | "Or",
-): Triple[] =>
+) =>
   closure.flatMap((term): Triple[] => {
     const parts = getExpansion(term, repeated, junction);
-    return parts ? [{ whole: term, first: parts[0], second: parts[1] }] : [];
+    return parts ? [{ whole: term, first: parts.first, second: parts.second }] : [];
   });
 
 const isSameParticle = (left: LiveExpression[], right: LiveExpression[]) =>
@@ -451,7 +454,7 @@ const unionParticles = (left: LiveExpression[][], right: LiveExpression[][]) =>
   ...right,
 ];
 
-const getParticleClosure = (terms: LiveExpression[]): LiveExpression[][] => {
+const getParticleClosure = (terms: LiveExpression[]) => {
   const closure = getPositiveClosure(terms);
   const alphas = getTriples(closure, "Always", "And");
   const betas = getTriples(closure, "Eventually", "Or");
@@ -460,9 +463,11 @@ const getParticleClosure = (terms: LiveExpression[]): LiveExpression[][] => {
     for (const term of particle) {
       const parts = getExpansion(term, "Eventually", "Or");
       if (!parts) continue;
-      const [first, second] = parts;
-      if (isMember(particle, first) || isMember(particle, second)) continue;
-      return unionParticles(expand([...particle, first]), expand([...particle, second]));
+      if (isMember(particle, parts.first) || isMember(particle, parts.second)) continue;
+      return unionParticles(
+        expand([...particle, parts.first]),
+        expand([...particle, parts.second]),
+      );
     }
     const beta = betas.find(
       (triple) =>
@@ -478,9 +483,8 @@ const getParticleClosure = (terms: LiveExpression[]): LiveExpression[][] => {
     for (let index = 0; index < expanded.length; index++) {
       const parts = getExpansion(expanded[index], "Always", "And");
       if (!parts) continue;
-      const [first, second] = parts;
-      if (!isMember(expanded, first)) expanded.push(first);
-      if (!isMember(expanded, second)) expanded.push(second);
+      if (!isMember(expanded, parts.first)) expanded.push(parts.first);
+      if (!isMember(expanded, parts.second)) expanded.push(parts.second);
     }
     const state = { isChanged: true };
     while (state.isChanged) {
@@ -509,7 +513,7 @@ const createTableauNode = (particle: LiveExpression[]): TableauNode => ({
   statePredicates: particle.filter((term) => getLiveLevel(term) <= STATE_LEVEL),
 });
 
-const createTableau = (formula: LiveExpression): Tableau => {
+const createTableau = (formula: LiveExpression) => {
   const nodes = getParticleClosure([formula]).map(createTableauNode);
   const initialCount = nodes.length;
   for (let index = 0; index < nodes.length; index++) {
@@ -529,11 +533,13 @@ export const isFulfilling = (particle: LiveExpression[], promise: LiveUnary) =>
   !isMember(particle, promise) || isMember(particle, promise.body);
 
 const classify = (expression: LiveExpression, classification: Classification) => {
-  if (expression.kind === "Eventually" && expression.body.kind === "Always") {
-    if (getLiveLevel(expression.body.body) < TEMPORAL_LEVEL) {
-      classification.eventuallyAlways.push(expression.body.body);
-      return;
-    }
+  if (
+    expression.kind === "Eventually" &&
+    expression.body.kind === "Always" &&
+    getLiveLevel(expression.body.body) < TEMPORAL_LEVEL
+  ) {
+    classification.eventuallyAlways.push(expression.body.body);
+    return;
   }
   const infinitelyOften = getInfinitelyOftenBody(expression);
   if (infinitelyOften) {
@@ -592,13 +598,13 @@ export const getSolutions = (formula: LiveExpression): Solution[] => {
     if (group) group.classifications.push(classification);
     else groups.push({ formula: temporal, classifications: [classification] });
   }
-  return groups.map((group): Solution => {
+  return groups.map((group) => {
     const binary = group.formula && makeBinary(group.formula);
     const promises: LiveUnary[] = [];
     if (binary) extractPromises(binary, promises);
     const stateChecks: LiveExpression[] = [];
     const actionChecks: LiveExpression[] = [];
-    const models = group.classifications.map((classification): ErrorModel => ({
+    const models = group.classifications.map((classification) => ({
       infinitelyOftenActions: classification.infinitelyOftenActions.map((check) =>
         addToBin(actionChecks, check),
       ),

package/src/tlc-ext.ts

@@ -1,5 +1,5 @@
 import {
-  defineConstant,
+  createJavaOverrideError,
   defineHigherOrderOperator,
   defineLazyOperator,
   defineOperator,
@@ -8,9 +8,11 @@ import {
   getThunk,
   getValue,
 } from "./builtins";
-import { TlaEvaluationError } from "./errors";
+import { TlaEvaluationError, TlaModuleError, TlaUnsupportedError } from "./errors";
+import { getTlcFingerprint } from "./tlc-random";
 import {
   evaluate,
+  expectBoolean,
   getChildren,
   getDefinition,
   isLocallyResolved,
@@ -18,6 +20,7 @@ import {
   type Environment,
 } from "./evaluate";
 import type { Definition, Expression } from "./ast";
+import type { TraceStep } from "./check";
 import {
   getNamedRegisters,
   getPossibleCounts,
@@ -31,18 +34,74 @@ import {
   createSet,
   createTuple,
   formatValue,
+  getDomain,
   getSequenceElements,
-  getValueHash,
   getValueKey,
+  isFunctionValue,
   toFiniteSet,
   valuesEqual,
   type Value,
 } from "./values";
 
-const EMPTY_COUNTER_EXAMPLE = createRecord([
-  ["action", createSet([])],
-  ["state", createSet([])],
-]);
+const OVERRIDE_PARAMETERS =
+  "tlc2.tool.impl.Tool,tla2sany.semantic.ExprOrOpArgNode[],tlc2.util.Context,tlc2.tool.TLCState,tlc2.tool.TLCState,int,tlc2.tool.coverage.CostModel";
+
+const ASSERT_ERROR_METHOD = `public static synchronized tlc2.value.impl.Value tlc2.module.TLCExt.assertError(${OVERRIDE_PARAMETERS})`;
+
+const TRACE_METHOD = `public static tlc2.value.impl.TupleValue tlc2.module.TLCExt.getTrace(${OVERRIDE_PARAMETERS}) throws java.io.IOException`;
+
+const PICK_SUCCESSOR_METHOD = `public static synchronized tlc2.value.impl.Value tlc2.module.TLCExt.pickSuccessor(${OVERRIDE_PARAMETERS})`;
+
+const createEmptyCounterExample = () =>
+  createRecord([
+    ["action", createSet([])],
+    ["state", createSet([])],
+  ]);
+
+const createBuiltinLocation = () =>
+  createRecord([
+    ["beginLine", 0],
+    ["beginColumn", 0],
+    ["endLine", 0],
+    ["endColumn", 0],
+    ["module", "--TLA+ BUILTINS--"],
+  ]);
+
+// TLC's record for an action it doesn't store, such as every action in breadth-first search.
+export const createActionRecord = (action: string | undefined) =>
+  createRecord([
+    ["name", action ?? "UnnamedAction"],
+    ["location", createBuiltinLocation()],
+  ]);
+
+// TLC's CounterExample is a graph of the violating behavior: the states numbered from 1, an edge
+// for each step, and for a lasso an edge from the last state back to where the loop starts.
+export const createCounterExample = (
+  trace: TraceStep[],
+  loop: { start: number; action: string | undefined } | undefined,
+) => {
+  const states = trace.map((step, index) =>
+    createTuple([index + 1, createRecord(Object.entries(step.state))]),
+  );
+  const steps = states
+    .slice(1)
+    .map((state, index) =>
+      createTuple([states[index], createActionRecord(trace[index + 1].action), state]),
+    );
+  const closing = loop
+    ? [
+        createTuple([
+          states[states.length - 1],
+          createActionRecord(loop.action),
+          states[loop.start],
+        ]),
+      ]
+    : [];
+  return createRecord([
+    ["action", createSet([...steps, ...closing])],
+    ["state", createSet(states)],
+  ]);
+};
 
 const getRegister = (runtime: CheckerRuntime, key: Value) => {
   if (typeof key === "number") return runtime.registers.get(key);
@@ -61,7 +120,7 @@ const setRegister = (runtime: CheckerRuntime, key: Value, value: Value) => {
     runtime.namedRegisters.set(key, value);
     return;
   }
-  throw new TlaEvaluationError(
+  throw new TlaModuleError(
     `The first argument of TLCSet should be a nonnegative integer, but instead it is:\n${formatValue(key)}`,
   );
 };
@@ -112,13 +171,20 @@ export const createTlcExtOperators = (
       const right = getValue(args, 1, "AssertEq");
       const isEqual = valuesEqual(left, right);
       if (!isEqual) {
-        print("Assertion failed");
+        print(formatValue("Assertion failed", true));
         print(formatValue(left, true));
         print(formatValue(right, true));
       }
       return isEqual;
     }),
     defineLazyOperator("AssertError", 2, (args) => {
+      const message = getOperator(args, 0, "AssertError").expression;
+      if (message && message.kind !== "String") {
+        throw createJavaOverrideError(
+          ASSERT_ERROR_METHOD,
+          `In computing AssertError, a non-string expression (line ${message.location.line}, col ${message.location.column}) was used as the err of an AssertError(err, exp).`,
+        );
+      }
       const expected = getThunk(args, 0, "AssertError")();
       try {
         getThunk(args, 1, "AssertError")();
@@ -144,46 +210,68 @@ export const createTlcExtOperators = (
     },
     defineStateOperator("Trace", 0, (_, context) => {
       const state = context?.state;
-      if (!state || !isCompleteState(state)) {
-        throw new TlaEvaluationError(
-          "In evaluating TLCExt!Trace, the state is not completely specified yet",
+      if (!context || !state || !isCompleteState(state)) {
+        const unassigned = (context?.environment.variables ?? []).filter(
+          (_, index) => state?.[index] === undefined,
+        );
+        throw createJavaOverrideError(
+          TRACE_METHOD,
+          `In evaluating TLCExt!Trace, the state is not completely specified yet (variable${unassigned.length > 1 ? "s" : ""} ${unassigned.join(", ")} undefined).`,
         );
       }
       return createTuple(
         runtime.getBehavior(state).map((step) => toStateRecord(step, context.environment)),
       );
     }),
-    defineConstant("CounterExample", EMPTY_COUNTER_EXAMPLE),
+    defineStateOperator(
+      "CounterExample",
+      0,
+      () => runtime.counterExample ?? createEmptyCounterExample(),
+    ),
     defineOperator("ToTrace", 1, (args) => {
       const counterExample = getValue(args, 0, "ToTrace");
+      if (
+        !isFunctionValue(counterExample) ||
+        !valuesEqual(getDomain(counterExample), createSet(["action", "state"]))
+      ) {
+        throw new TlaEvaluationError(
+          `The argument of ToTrace should be a CounterExample, but instead it is:\n${formatValue(counterExample)}`,
+        );
+      }
       const states = toFiniteSet(applyFunction(counterExample, "state")).elements.map(
         (pair) => getSequenceElements(pair) ?? [],
       );
       return createTuple(
-        [...states]
-          .sort((left, right) => Number(left[0]) - Number(right[0]))
-          .map((pair) => pair[1]),
+        states.sort((left, right) => Number(left[0]) - Number(right[0])).map((pair) => pair[1]),
       );
     }),
     defineOperator("TLCModelValue", 1, (args) => {
       const name = getValue(args, 0, "TLCModelValue");
       if (typeof name !== "string") {
-        throw new TlaEvaluationError(
+        throw new TlaModuleError(
           `The argument of ModelValue should be a string, but instead it is:\n${formatValue(name)}`,
         );
       }
       return createModelValue(name);
     }),
-    defineLazyOperator("TLCDefer", 1, (args) => {
-      getThunk(args, 0, "TLCDefer")();
-      return true;
-    }),
+    // TLC runs the deferred expression only in simulation, when it extends a behavior.
+    defineLazyOperator("TLCDefer", 1, () => true),
     defineOperator("TLCNoOp", 1, (args) => getValue(args, 0, "TLCNoOp")),
     defineLazyOperator("PickSuccessor", 1, (args, context) => {
-      if (getThunk(args, 0, "PickSuccessor")() === true) return true;
       const next = context?.next;
-      if (!next || !isCompleteState(next)) return true;
-      throw new TlaEvaluationError("PickSuccessor needs interactive input to extend the behavior");
+      if (!next || !isCompleteState(next)) {
+        throw createJavaOverrideError(
+          PICK_SUCCESSOR_METHOD,
+          'Cannot invoke "tlc2.value.IValue.fingerPrint(long)" because "minVals[i]" is null',
+        );
+      }
+      if (runtime.isSeen(next)) return true;
+      if (expectBoolean(getThunk(args, 0, "PickSuccessor")(), "the condition of PickSuccessor")) {
+        return true;
+      }
+      throw new TlaUnsupportedError(
+        "PickSuccessor needs interactive input to extend the behavior with a new state",
+      );
     }),
     defineLazyOperator("TLCCache", 2, (args, context) => {
       const expression = getOperator(args, 0, "TLCCache");
@@ -200,18 +288,20 @@ export const createTlcExtOperators = (
       cache.set(closure, value);
       return value;
     }),
-    defineOperator("TLCFP", 1, (args) => getValueHash(getValue(args, 0, "TLCFP")) | 0),
+    defineOperator("TLCFP", 1, (args) =>
+      Number(BigInt.asIntN(32, getTlcFingerprint([getValue(args, 0, "TLCFP")]))),
+    ),
     defineStateOperator("TLCEvalDefinition", 1, (args, context) => {
       const name = getValue(args, 0, "TLCEvalDefinition");
       const definition =
         typeof name === "string" && context ? getDefinition(name, context.environment) : undefined;
       if (!definition || typeof name !== "string" || !context) {
-        throw new TlaEvaluationError(
+        throw new TlaModuleError(
           `The argument of TLCEvalDefinition should be a name of a definition reachable from the root module, but instead it is:\n${formatValue(name)}`,
         );
       }
       if (definition.kind === "Operator" && definition.params.length > 0) {
-        throw new TlaEvaluationError(
+        throw new TlaModuleError(
           `The argument of TLCEvalDefinition should be a zero-arity definition, but instead it is:\n${name}`,
         );
       }
@@ -225,12 +315,9 @@ export const createPossibleOperators = (
   runtime: CheckerRuntime,
 ): Builtin[] => [
   defineStateOperator("_Track", 2, (args) => {
-    const name = getValue(args, 1, "_Track");
-    const count = runtime.possibleCounts.get(String(name)) ?? 0;
-    runtime.possibleCounts.set(
-      String(name),
-      getValue(args, 0, "_Track") === true ? count + 1 : count,
-    );
+    const name = String(getValue(args, 1, "_Track"));
+    const count = runtime.possibleCounts.get(name) ?? 0;
+    runtime.possibleCounts.set(name, getValue(args, 0, "_Track") === true ? count + 1 : count);
     return true;
   }),
   defineStateOperator("_Counts", 0, () => getPossibleCounts(runtime)),