tla-ts 0.0.1 → 0.0.2

package/src/values.ts

@@ -1,4 +1,5 @@
-import { TlaEvaluationError } from "./errors";
+import { TlaEvaluationError, TlaModuleError } from "./errors";
+import { prettyPrint } from "./pretty-print";
 
 export interface ModelValue {
   kind: "ModelValue";
@@ -12,12 +13,20 @@ export interface SetValue {
   fingerprint: number;
 }
 
+// A set enumeration whose elements TLC can't sort, such as {1, "a"}. TLC sorts a set enumeration
+// only when it has to, so it still checks membership in one element by element.
+export interface MixedSetValue {
+  kind: "MixedSet";
+  elements: Value[];
+}
+
 export interface FunctionValue {
   kind: "Function";
   domain: Value[];
   range: Value[];
   hash: number;
   fingerprint: number;
+  writtenKeys: Value[] | undefined;
 }
 
 export interface IntervalValue {
@@ -71,10 +80,27 @@ export interface FilteredSetValue {
   test: (element: Value) => boolean;
 }
 
+// UNION S when some element of S isn't a set enumeration. TLC enumerates it only when it has to.
+export interface UnionValue {
+  kind: "Union";
+  base: Value;
+}
+
+interface LazyFunctionParameter {
+  name: string;
+  domain: Value;
+}
+
+export interface LazyFunctionSource {
+  parameters: LazyFunctionParameter[];
+  body: string;
+}
+
 export interface LazyFunctionValue {
   kind: "LazyFunction";
   domain: Value;
   apply: (argument: Value) => Value;
+  source?: LazyFunctionSource;
 }
 
 export type Value =
@@ -83,6 +109,7 @@ export type Value =
   | string
   | ModelValue
   | SetValue
+  | MixedSetValue
   | FunctionValue
   | IntervalValue
   | InfiniteSetValue
@@ -93,12 +120,13 @@ export type Value =
   | SequenceSetValue
   | SetOperationValue
   | FilteredSetValue
+  | UnionValue
   | LazyFunctionValue;
 
 export type ObjectValue = Exclude<Value, boolean | number | string>;
 
-const MAXIMUM_INTEGER = 2147483647;
-const MINIMUM_INTEGER = -2147483648;
+export const MAXIMUM_INTEGER = 2147483647;
+export const MINIMUM_INTEGER = -2147483648;
 const MAXIMUM_ENUMERATED_SUBSET_BASE = 30;
 
 export const isSetValue = (value: Value) =>
@@ -113,7 +141,7 @@ export const isFunctionValue = (value: Value): value is FunctionValue | LazyFunc
 export const isModelValue = (value: Value): value is ModelValue =>
   typeof value === "object" && value.kind === "ModelValue";
 
-const describeKind = (value: Value) => {
+export const describeKind = (value: Value) => {
   if (typeof value === "boolean") return "boolean";
   if (typeof value === "number") return "integer";
   if (typeof value === "string") return "string";
@@ -123,15 +151,59 @@ const describeKind = (value: Value) => {
 
 export const checkInteger = (value: number) => {
   if (!Number.isInteger(value) || value > MAXIMUM_INTEGER || value < MINIMUM_INTEGER) {
-    throw new TlaEvaluationError(`Integer overflow: ${value} is outside TLC's 32-bit range`);
+    throw new TlaModuleError(`Integer overflow: ${value} is outside TLC's 32-bit range`);
   }
   return value;
 };
 
-const compareFunctions = (left: FunctionValue, right: FunctionValue): number => {
+// TLC keeps a record, or a function with string keys that @@ builds, in the order the spec writes
+// it until it sorts the value to compare or fingerprint it. ToString, Assert, and error messages
+// show that order.
+const writtenOrderUse = { isUsed: false };
+
+const setWrittenOrder = (functionValue: FunctionValue, keys: Value[]) => {
+  writtenOrderUse.isUsed = true;
+  functionValue.writtenKeys = keys;
+  return functionValue;
+};
+
+export const getWrittenPairs = (functionValue: FunctionValue): [Value, Value][] => {
+  const keys = functionValue.writtenKeys ?? functionValue.domain;
+  return keys.map((key) => [key, functionValue.range[findIndex(functionValue.domain, key)]]);
+};
+
+export const createWrittenRecord = (names: Value[], range: Value[], writtenNames: Value[]) =>
+  setWrittenOrder(createSortedFunction(names, range), writtenNames);
+
+// TLC sorts a value it compares even with itself, and every value inside it, so a value it has
+// hashed or fingerprinted is already sorted.
+const forgetWrittenOrder = (value: Value): void => {
+  if (typeof value !== "object" || (value.kind !== "Function" && value.kind !== "Set")) return;
+  if (value.hash !== 0 || value.fingerprint !== 0) return;
+  if (value.kind === "Set") return value.elements.forEach(forgetWrittenOrder);
+  value.writtenKeys = undefined;
+  value.range.forEach(forgetWrittenOrder);
+};
+
+const isRecordDomain = (domain: Value[]) => domain.every((key) => typeof key === "string");
+
+// TLC compares a record only with another record, so comparing one with a function of another size
+// can fail before the sizes decide.
+const isRecordMismatch = (left: Value[], right: Value[]) =>
+  left.length > 0 && right.length > 0 && isRecordDomain(left) !== isRecordDomain(right);
+
+const compareFunctions = (left: FunctionValue, right: FunctionValue) => {
+  if (writtenOrderUse.isUsed) {
+    left.writtenKeys = undefined;
+    right.writtenKeys = undefined;
+  }
   const leftDomain = left.domain;
   const rightDomain = right.domain;
-  if (leftDomain.length !== rightDomain.length) return leftDomain.length - rightDomain.length;
+  if (leftDomain.length !== rightDomain.length) {
+    return isRecordMismatch(leftDomain, rightDomain)
+      ? compareLikeTlc(left, right)
+      : leftDomain.length - rightDomain.length;
+  }
   if (leftDomain !== rightDomain) {
     for (let index = 0; index < leftDomain.length; index++) {
       const keyComparison = compareValues(leftDomain[index], rightDomain[index]);
@@ -148,7 +220,7 @@ const compareFunctions = (left: FunctionValue, right: FunctionValue): number =>
   return 0;
 };
 
-const compareSets = (left: SetValue, right: SetValue): number => {
+const compareSets = (left: SetValue, right: SetValue) => {
   const leftElements = left.elements;
   const rightElements = right.elements;
   if (leftElements.length !== rightElements.length)
@@ -185,41 +257,120 @@ const checkModelValueTypes = (left: Value, right: Value, isEquality: boolean) =>
   );
 };
 
-export const compareValues = (left: Value, right: Value): number => {
+// TLC orders strings and model value names by when it first interned the text, so every
+// check sets the order of its spec's strings before it builds any value.
+const stringOrder = { ranks: Object.create(null) as Record<string, number>, size: 0 };
+
+export const setStringOrder = (texts: Iterable<string>) => {
+  stringOrder.ranks = Object.create(null);
+  stringOrder.size = 0;
+  for (const text of texts) rankString(text);
+};
+
+export const rankString = (text: string) => {
+  if (stringOrder.ranks[text] === undefined) stringOrder.ranks[text] = stringOrder.size++;
+  return text;
+};
+
+export const getRankedStringCount = () => stringOrder.size;
+
+export const getStringRank = (text: string) => stringOrder.ranks[rankString(text)];
+
+const compareStrings = (left: string, right: string) => {
   if (left === right) return 0;
+  const ranks = stringOrder.ranks;
+  const leftRank = ranks[left];
+  const rightRank = ranks[right];
+  if (leftRank !== undefined && rightRank !== undefined) return leftRank - rightRank;
+  if (leftRank !== undefined) return -1;
+  if (rightRank !== undefined) return 1;
+  return left < right ? -1 : 1;
+};
+
+export const isOverriddenSet = (value: Value): value is InfiniteSetValue | SequenceSetValue =>
+  typeof value === "object" && (value.kind === "InfiniteSet" || value.kind === "SequenceSet");
+
+const isOverriddenComparison = (left: Value, right: Value) =>
+  (isOverriddenSet(left) || isOverriddenSet(right)) &&
+  !(
+    typeof left === "object" &&
+    left.kind === "SequenceSet" &&
+    typeof right === "object" &&
+    right.kind === "SequenceSet"
+  );
+
+// TLC implements Nat, Int, STRING, Seq(S), and Any in Java classes that compare only with each
+// other and with model values. Comparing one with any other set is an error, worded by the class of
+// the left operand.
+const compareOverriddenSets = (
+  left: Value,
+  right: Value,
+  verb: "compare" | "check equality of",
+) => {
+  if (!isOverriddenSet(left)) {
+    throw new TlaEvaluationError(
+      `Attempted to ${verb} the set ${formatValue(isEnumerable(left) ? toFiniteSet(left) : left, true)} with the value:\n${formatValue(right, true)}`,
+    );
+  }
+  if (!isOverriddenSet(right)) {
+    throw new TlaEvaluationError(
+      `Attempted to compare overridden value ${formatValue(left, true)} with non-overridden value:\n${formatValue(right, true)}`,
+    );
+  }
+  const leftName = left.kind === "InfiniteSet" ? left.name : undefined;
+  const rightName = right.kind === "InfiniteSet" ? right.name : undefined;
+  if (leftName !== undefined && leftName === rightName) return 0;
+  if ((leftName === "Nat" && rightName === "Int") || (leftName === "Int" && rightName === "Nat")) {
+    return leftName === "Nat" ? -1 : 1;
+  }
+  throw new TlaEvaluationError(
+    `Attempted to compare ${formatValue(left, true)} with the value\n${formatValue(right, true)}`,
+  );
+};
+
+export const ANY_SET: InfiniteSetValue = { kind: "InfiniteSet", name: "Any" };
+
+const compareAny = (other: Value): never => {
+  throw new TlaEvaluationError(`Attempted to compare ANY with the value\n${formatValue(other)}`);
+};
+
+export const compareValues = (left: Value, right: Value): number => {
+  if (left === right) {
+    if (writtenOrderUse.isUsed) forgetWrittenOrder(left);
+    return left === ANY_SET ? compareAny(left) : 0;
+  }
   if (typeof left === "object" && typeof right === "object") {
     const leftKind = left.kind;
     const rightKind = right.kind;
     if (leftKind === "Function" && rightKind === "Function") return compareFunctions(left, right);
     if (leftKind === "Set" && rightKind === "Set") return compareSets(left, right);
+    if (leftKind === "Interval" && rightKind === "Interval") {
+      const size = Math.max(0, left.high - left.low + 1);
+      const otherSize = Math.max(0, right.high - right.low + 1);
+      return size !== otherSize || size === 0 ? size - otherSize : left.low - right.low;
+    }
     if (leftKind === "ModelValue" || rightKind === "ModelValue") {
       checkModelValueTypes(left, right, false);
       if (leftKind === "ModelValue" && rightKind === "ModelValue") {
-        return left.name < right.name ? -1 : left.name > right.name ? 1 : 0;
+        return compareStrings(left.name, right.name);
       }
       return leftKind === "ModelValue" ? -1 : 1;
     }
-    const isAny = (value: ObjectValue) => value.kind === "InfiniteSet" && value.name === "Any";
-    if (isAny(left) || isAny(right)) {
-      throw new TlaEvaluationError(
-        `Attempted to compare ANY with ${formatValue(isAny(left) ? right : left)}`,
-      );
-    }
-    if (leftKind === "InfiniteSet" && rightKind === "InfiniteSet") {
-      if (left.name === right.name) return 0;
-      if (left.name !== "STRING" && right.name !== "STRING") return left.name === "Nat" ? -1 : 1;
+    if (left === ANY_SET || right === ANY_SET) return compareAny(left === ANY_SET ? right : left);
+    if (isSetValue(left) && isSetValue(right) && isOverriddenComparison(left, right)) {
+      return compareOverriddenSets(left, right, "compare");
     }
-    const leftIsSet = isSetValue(left);
-    if (leftIsSet !== isSetValue(right)) {
+    const isLeftSet = isSetValue(left);
+    if (isLeftSet !== isSetValue(right)) {
       throw new TlaEvaluationError(
         `Attempted to compare ${describeKind(left)} ${formatValue(left)} with ${describeKind(right)} ${formatValue(right)}`,
       );
     }
-    if (leftIsSet) return compareSets(toFiniteSet(left), toFiniteSet(right));
+    if (isLeftSet) return compareSets(toFiniteSet(left), toFiniteSet(right));
     return compareFunctions(toFiniteFunction(left), toFiniteFunction(right));
   }
   if (typeof left === "number" && typeof right === "number") return left - right;
-  if (typeof left === "string" && typeof right === "string") return left < right ? -1 : 1;
+  if (typeof left === "string" && typeof right === "string") return compareStrings(left, right);
   if (typeof left === "boolean" && typeof right === "boolean") return left < right ? -1 : 1;
   checkModelValueTypes(left, right, false);
   if (isModelValue(left)) return -1;
@@ -232,6 +383,7 @@ export const compareValues = (left: Value, right: Value): number => {
 const modelValues = new Map<string, ModelValue>();
 
 export const createModelValue = (name: string): ModelValue => {
+  rankString(name);
   const known = modelValues.get(name);
   if (known) return known;
   const value: ModelValue = { kind: "ModelValue", name };
@@ -252,10 +404,14 @@ export const createSortedFunction = (domain: Value[], range: Value[]): FunctionV
   range,
   hash: 0,
   fingerprint: 0,
+  writtenKeys: undefined,
 });
 
 export const valuesEqual = (left: Value, right: Value): boolean => {
-  if (left === right) return true;
+  if (left === right) {
+    if (writtenOrderUse.isUsed) forgetWrittenOrder(left);
+    return left !== ANY_SET || compareAny(left);
+  }
   if (typeof left !== "object" || typeof right !== "object") {
     if (typeof left === typeof right) return false;
     if (typeof left === "object" || typeof right === "object") {
@@ -276,9 +432,52 @@ export const valuesEqual = (left: Value, right: Value): boolean => {
     checkModelValueTypes(left, right, true);
     return isModelValue(left) && isModelValue(right) && left.name === right.name;
   }
+  if (left.kind === "Subset" && right.kind === "Subset") return valuesEqual(left.base, right.base);
+  if (left.kind === "FunctionSet" && right.kind === "FunctionSet") {
+    const isUnit = isEmptySet(left.domain);
+    const isOtherUnit = isEmptySet(right.domain);
+    if (isUnit || isOtherUnit) return isUnit === isOtherUnit;
+    const isEmpty = isEmptySet(left.range);
+    const isOtherEmpty = isEmptySet(right.range);
+    if (isEmpty || isOtherEmpty) return isEmpty === isOtherEmpty;
+    return valuesEqual(left.domain, right.domain) && valuesEqual(left.range, right.range);
+  }
+  if (left.kind === "RecordSet" && right.kind === "RecordSet") {
+    if (isEmptySet(left)) return isEmptySet(right);
+    if (isEmptySet(right)) return false;
+    const getFields = (set: RecordSetValue) =>
+      set.names
+        .map((name, index): [string, Value] => [name, set.sets[index]])
+        .sort((first, second) => (first[0] < second[0] ? -1 : 1));
+    const otherFields = getFields(right);
+    return (
+      left.names.length === right.names.length &&
+      getFields(left).every(
+        (field, index) =>
+          field[0] === otherFields[index][0] && valuesEqual(field[1], otherFields[index][1]),
+      )
+    );
+  }
+  if (left.kind === "ProductSet" && right.kind === "ProductSet") {
+    if (isEmptySet(left)) return isEmptySet(right);
+    if (isEmptySet(right)) return false;
+    return (
+      left.factors.length === right.factors.length &&
+      left.factors.every((factor, index) => valuesEqual(factor, right.factors[index]))
+    );
+  }
   const isInfiniteComparison =
     isSetValue(left) && isSetValue(right) && !(isEnumerable(left) && isEnumerable(right));
-  if (isInfiniteComparison) return getValueKey(left) === getValueKey(right);
+  if (isInfiniteComparison && isOverriddenComparison(left, right)) {
+    return compareOverriddenSets(left, right, "check equality of") === 0;
+  }
+  if (isInfiniteComparison) {
+    if (!isOverriddenSet(left)) {
+      const elements = toFiniteSet(left);
+      if (!isOverriddenSet(right)) return compareSets(elements, toFiniteSet(right)) === 0;
+    }
+    return getValueKey(left) === getValueKey(right);
+  }
   return compareValues(left, right) === 0;
 };
 
@@ -304,6 +503,357 @@ export const isSameValue = (left: Value, right: Value): boolean => {
   return getValueKey(left) === getValueKey(right);
 };
 
+// The comparisons above fail with their own messages. These follow the compareTo and equals
+// methods of TLC's Java value classes, which word a failure by the class of the left operand, so a
+// failed comparison runs again through them to fail as TLC does.
+interface TlcFunction {
+  domain: Value[];
+  range: Value[];
+  low: number | undefined;
+}
+
+const getIntervalLow = (domain: Value[]) => {
+  const first = domain.length === 0 ? 1 : domain[0];
+  return typeof first === "number" && domain.every((key, index) => key === first + index)
+    ? first
+    : undefined;
+};
+
+const toTlcFunction = (value: Value) => {
+  if (!isFunctionValue(value)) return undefined;
+  const functionValue = toFiniteFunction(value);
+  return {
+    domain: functionValue.domain,
+    range: functionValue.range,
+    low: getIntervalLow(functionValue.domain),
+  };
+};
+
+const toTlcRecord = (value: Value) => {
+  if (!isFunctionValue(value)) return undefined;
+  const functionValue = toFiniteFunction(value);
+  return functionValue.domain.every((key) => typeof key === "string") ? functionValue : undefined;
+};
+
+const compareModelValueWith = (modelValue: ModelValue, other: Value) => {
+  if (getModelValueType(modelValue) !== undefined) {
+    throw new TlaEvaluationError(
+      `Attempted to compare the typed model value ${formatValue(modelValue)} and the non-model value\n${formatValue(other)}`,
+    );
+  }
+  return 1;
+};
+
+const equalsModelValueWith = (modelValue: ModelValue, other: Value) => {
+  if (getModelValueType(modelValue) !== undefined) {
+    throw new TlaEvaluationError(
+      `Attempted to check equality of the typed model value ${formatValue(modelValue)} and the non-model value\n${formatValue(other)}`,
+    );
+  }
+  return false;
+};
+
+const compareModelValue = (left: ModelValue, right: Value) => {
+  const type = getModelValueType(left);
+  if (type === undefined) return isModelValue(right) ? compareStrings(left.name, right.name) : -1;
+  if (!isModelValue(right)) {
+    throw new TlaEvaluationError(
+      `Attempted to compare the typed model value ${formatValue(left)} and non-model value\n${formatValue(right)}`,
+    );
+  }
+  const otherType = getModelValueType(right);
+  if (otherType !== undefined && otherType !== type) {
+    throw new TlaEvaluationError(
+      `Attempted to compare the differently-typed model values ${formatValue(left)} and ${formatValue(right)}`,
+    );
+  }
+  return compareStrings(left.name, right.name);
+};
+
+const equalsModelValue = (left: ModelValue, right: Value) => {
+  const type = getModelValueType(left);
+  if (type === undefined) return isModelValue(right) && left.name === right.name;
+  if (!isModelValue(right)) {
+    throw new TlaEvaluationError(
+      `Attempted to check equality of typed model value ${formatValue(left)} and non-model value\n${formatValue(right)}`,
+    );
+  }
+  const otherType = getModelValueType(right);
+  if (otherType !== undefined && otherType !== type) {
+    throw new TlaEvaluationError(
+      `Attempted to check equality of the differently-typed model values ${formatValue(left)} and ${formatValue(right)}`,
+    );
+  }
+  return left.name === right.name;
+};
+
+const SCALAR_KINDS = {
+  number: { name: "integer", other: "non-integer", equality: "check equality of" },
+  string: { name: "string", other: "non-string", equality: "check equality of" },
+  boolean: { name: "boolean", other: "non-boolean", equality: "compare equality of" },
+};
+
+const describeScalarMismatch = (
+  left: number | string | boolean,
+  right: Value,
+  isEquality: boolean,
+) => {
+  const kind =
+    SCALAR_KINDS[
+      typeof left === "number" ? "number" : typeof left === "string" ? "string" : "boolean"
+    ];
+  return `Attempted to ${isEquality ? kind.equality : "compare"} ${kind.name} ${formatValue(left)} with ${kind.other}:\n${formatValue(right)}`;
+};
+
+const compareTlcFunctions = (functionValue: TlcFunction, left: Value, right: Value) => {
+  const other = toTlcFunction(right);
+  if (!other) {
+    if (isModelValue(right)) return compareModelValueWith(right, left);
+    throw new TlaEvaluationError(
+      `Attempted to compare the function ${formatValue(left)} with the value:\n${formatValue(right)}`,
+    );
+  }
+  if (functionValue.range.length !== other.range.length)
+    return functionValue.range.length - other.range.length;
+  const compareRanges = () => compareElementsLikeTlc(functionValue.range, other.range);
+  if (functionValue.low !== undefined && functionValue.range.length === 0) return 0;
+  if (functionValue.low !== undefined && other.low !== undefined) {
+    return functionValue.low === other.low ? compareRanges() : functionValue.low - other.low;
+  }
+  const intervalLow = functionValue.low ?? other.low;
+  if (intervalLow === undefined) {
+    return compareElementsLikeTlc(functionValue.domain, other.domain) || compareRanges();
+  }
+  const keys = functionValue.low === undefined ? functionValue.domain : other.domain;
+  for (let index = 0; index < keys.length; index++) {
+    const key = keys[index];
+    if (typeof key !== "number") {
+      throw new TlaEvaluationError(
+        `Attempted to compare integer with non-integer${functionValue.low === undefined ? "" : ":"}\n${formatValue(key)}.`,
+      );
+    }
+    const difference =
+      functionValue.low === undefined ? key - (intervalLow + index) : intervalLow + index - key;
+    if (difference !== 0) return difference;
+  }
+  return compareRanges();
+};
+
+const compareElementsLikeTlc = (left: Value[], right: Value[]) => {
+  for (let index = 0; index < left.length; index++) {
+    const comparison = compareLikeTlc(left[index], right[index]);
+    if (comparison !== 0) return comparison;
+  }
+  return 0;
+};
+
+const compareFunctionLikeTlc = (left: FunctionValue | LazyFunctionValue, right: Value) => {
+  const functionValue = toFiniteFunction(left);
+  const isTuple = left.kind === "Function" && getSequenceElements(functionValue) !== undefined;
+  if (isTuple) {
+    const tuple = isFunctionValue(right) ? getSequenceElements(right) : undefined;
+    if (!tuple) return compareTlcFunctions({ ...functionValue, low: 1 }, left, right);
+    return (
+      functionValue.range.length - tuple.length ||
+      compareElementsLikeTlc(functionValue.range, tuple)
+    );
+  }
+  if (left.kind === "Function" && functionValue.domain.every((key) => typeof key === "string")) {
+    const record = toTlcRecord(right);
+    if (!record) {
+      if (isModelValue(right)) return compareModelValueWith(right, left);
+      throw new TlaEvaluationError(
+        `Attempted to compare record:\n${formatValue(left)}\nwith non-record\n${formatValue(right)}`,
+      );
+    }
+    return (
+      functionValue.domain.length - record.domain.length ||
+      compareElementsLikeTlc(functionValue.domain, record.domain) ||
+      compareElementsLikeTlc(functionValue.range, record.range)
+    );
+  }
+  return compareTlcFunctions(
+    { ...functionValue, low: getIntervalLow(functionValue.domain) },
+    left,
+    right,
+  );
+};
+
+export const isEnumeratedSet = (value: Value): value is SetValue | MixedSetValue =>
+  typeof value === "object" && (value.kind === "Set" || value.kind === "MixedSet");
+
+// TLC compares a lazy set, or a set it overrides in Java, through its own class before it compares
+// elements. The comparisons above already fail as those classes do.
+const isComparedByClass = (left: ObjectValue, right: Value) =>
+  isOverriddenSet(left) ||
+  isOverriddenSet(right) ||
+  (typeof right === "object" &&
+    left.kind === right.kind &&
+    (left.kind === "Interval" ||
+      left.kind === "Subset" ||
+      left.kind === "FunctionSet" ||
+      left.kind === "RecordSet" ||
+      left.kind === "ProductSet"));
+
+const getSetElementsLikeTlc = (left: SetValue | MixedSetValue, right: Value) => {
+  const other = isEnumeratedSet(right) ? right : toFiniteSet(right);
+  return { elements: toFiniteSet(left).elements, otherElements: toFiniteSet(other).elements };
+};
+
+const compareSetLikeTlc = (left: ObjectValue, right: Value): number => {
+  if (isComparedByClass(left, right)) return compareValues(left, right);
+  if (!isEnumeratedSet(left)) return compareSetLikeTlc(toFiniteSet(left), right);
+  if (!isSetValue(right)) {
+    if (isModelValue(right)) return compareModelValueWith(right, left);
+    throw new TlaEvaluationError(
+      `Attempted to compare the set ${formatValue(left)} with the value:\n${formatValue(right)}`,
+    );
+  }
+  const sets = getSetElementsLikeTlc(left, right);
+  return (
+    sets.elements.length - sets.otherElements.length ||
+    compareElementsLikeTlc(sets.elements, sets.otherElements)
+  );
+};
+
+const compareLikeTlc = (left: Value, right: Value): number => {
+  if (typeof left !== "object") {
+    if (typeof right === typeof left) return compareValues(left, right);
+    if (isModelValue(right)) return compareModelValueWith(right, left);
+    throw new TlaEvaluationError(describeScalarMismatch(left, right, false));
+  }
+  if (left.kind === "ModelValue") return compareModelValue(left, right);
+  if (isFunctionValue(left)) return compareFunctionLikeTlc(left, right);
+  return compareSetLikeTlc(left, right);
+};
+
+const equalsElementsLikeTlc = (left: Value[], right: Value[]) =>
+  left.every((element, index) => equalsLikeTlc(element, right[index]));
+
+const equalsTlcFunctions = (functionValue: TlcFunction, left: Value, right: Value) => {
+  const other = toTlcFunction(right);
+  if (!other) {
+    if (isModelValue(right)) return equalsModelValueWith(right, left);
+    throw new TlaEvaluationError(
+      `Attempted to check equality of the function ${formatValue(left)} with the value:\n${formatValue(right)}`,
+    );
+  }
+  if (functionValue.range.length !== other.range.length) return false;
+  if (functionValue.low !== undefined && other.low !== undefined) {
+    return (
+      (functionValue.range.length === 0 || functionValue.low === other.low) &&
+      equalsElementsLikeTlc(functionValue.range, other.range)
+    );
+  }
+  const intervalLow = functionValue.low ?? other.low;
+  if (intervalLow === undefined) {
+    return (
+      equalsElementsLikeTlc(functionValue.domain, other.domain) &&
+      equalsElementsLikeTlc(functionValue.range, other.range)
+    );
+  }
+  const keys = functionValue.low === undefined ? functionValue.domain : other.domain;
+  return (
+    keys.every((key, index) => {
+      if (typeof key !== "number") {
+        throw new TlaEvaluationError(
+          `Attempted to compare an integer with non-integer:\n${formatValue(key)}.`,
+        );
+      }
+      return key === intervalLow + index;
+    }) && equalsElementsLikeTlc(functionValue.range, other.range)
+  );
+};
+
+const equalsFunctionLikeTlc = (left: FunctionValue | LazyFunctionValue, right: Value) => {
+  const functionValue = toFiniteFunction(left);
+  const isTuple = left.kind === "Function" && getSequenceElements(functionValue) !== undefined;
+  if (isTuple) {
+    const tuple = isFunctionValue(right) ? getSequenceElements(right) : undefined;
+    if (!tuple) return equalsTlcFunctions({ ...functionValue, low: 1 }, left, right);
+    return (
+      functionValue.range.length === tuple.length &&
+      equalsElementsLikeTlc(functionValue.range, tuple)
+    );
+  }
+  if (left.kind === "Function" && functionValue.domain.every((key) => typeof key === "string")) {
+    const record = toTlcRecord(right);
+    if (!record) {
+      if (isModelValue(right)) return equalsModelValueWith(right, left);
+      throw new TlaEvaluationError(
+        `Attempted to check equality of record:\n${formatValue(left)}\nwith non-record\n${formatValue(right)}`,
+      );
+    }
+    return (
+      functionValue.domain.length === record.domain.length &&
+      equalsElementsLikeTlc(functionValue.domain, record.domain) &&
+      equalsElementsLikeTlc(functionValue.range, record.range)
+    );
+  }
+  return equalsTlcFunctions(
+    { ...functionValue, low: getIntervalLow(functionValue.domain) },
+    left,
+    right,
+  );
+};
+
+const equalsSetLikeTlc = (left: ObjectValue, right: Value): boolean => {
+  if (isComparedByClass(left, right)) return valuesEqual(left, right);
+  if (!isEnumeratedSet(left)) return equalsSetLikeTlc(toFiniteSet(left), right);
+  if (!isSetValue(right)) {
+    if (isModelValue(right)) return equalsModelValueWith(right, left);
+    throw new TlaEvaluationError(
+      `Attempted to check equality of the set ${formatValue(left)} with the value:\n${formatValue(right)}`,
+    );
+  }
+  const sets = getSetElementsLikeTlc(left, right);
+  return (
+    sets.elements.length === sets.otherElements.length &&
+    equalsElementsLikeTlc(sets.elements, sets.otherElements)
+  );
+};
+
+const equalsLikeTlc = (left: Value, right: Value): boolean => {
+  if (typeof left !== "object") {
+    if (typeof right === typeof left) return left === right;
+    if (isModelValue(right)) return equalsModelValueWith(right, left);
+    throw new TlaEvaluationError(describeScalarMismatch(left, right, true));
+  }
+  if (left.kind === "ModelValue") return equalsModelValue(left, right);
+  if (isFunctionValue(left)) return equalsFunctionLikeTlc(left, right);
+  return equalsSetLikeTlc(left, right);
+};
+
+// TLC's ValueVec.sort, which inserts each element into the sorted prefix by binary search.
+const sortLikeTlc = (elements: Value[]) => {
+  const sorted: Value[] = [];
+  for (const element of elements) {
+    const bounds = { low: 0, high: sorted.length, comparison: 1 };
+    while (bounds.low < bounds.high) {
+      const middle = bounds.low + ((bounds.high - bounds.low) >> 1);
+      bounds.comparison = compareLikeTlc(element, sorted[middle]);
+      if (bounds.comparison === 0) break;
+      if (bounds.comparison < 0) bounds.high = middle;
+      else bounds.low = middle + 1;
+    }
+    if (bounds.comparison !== 0) sorted.splice(bounds.low, 0, element);
+  }
+  return sorted;
+};
+
+// TLC checks membership in a set enumeration it hasn't sorted element by element.
+const isElementOfLikeTlc = (element: Value, elements: Value[]) =>
+  elements.some((member) => equalsLikeTlc(member, element));
+
+export const isEqualLikeTlc = (left: Value, right: Value) => {
+  try {
+    return valuesEqual(left, right);
+  } catch (error) {
+    if (!(error instanceof TlaEvaluationError)) throw error;
+    return equalsLikeTlc(left, right);
+  }
+};
+
 const isStrictlySorted = (elements: Value[]) => {
   for (let index = 1; index < elements.length; index++) {
     if (compareValues(elements[index - 1], elements[index]) >= 0) return false;
@@ -321,6 +871,17 @@ export const createSet = (elements: Value[]): SetValue => {
   return createSortedSet(unique);
 };
 
+// TLC builds a set enumeration without sorting it, so one whose elements it can't compare still
+// evaluates.
+export const createEnumeratedSet = (elements: Value[]): SetValue | MixedSetValue => {
+  try {
+    return createSet(elements);
+  } catch (error) {
+    if (!(error instanceof TlaEvaluationError)) throw error;
+    return { kind: "MixedSet", elements };
+  }
+};
+
 export const EMPTY_SET = createSortedSet([]);
 
 export const differenceSorted = (left: SetValue, right: SetValue): SetValue => {
@@ -428,18 +989,99 @@ export const createFunction = (pairs: [Value, Value][]): FunctionValue => {
   return createSortedFunction(domain, range);
 };
 
+export const createWrittenFunction = (pairs: [Value, Value][]) => {
+  const functionValue = createFunction(pairs);
+  const isWrittenSorted =
+    functionValue.domain.length !== pairs.length ||
+    pairs.some((pair) => typeof pair[0] !== "string") ||
+    pairs.every((pair, index) => pair[0] === functionValue.domain[index]);
+  return isWrittenSorted
+    ? functionValue
+    : setWrittenOrder(
+        functionValue,
+        pairs.map((pair) => pair[0]),
+      );
+};
+
+const intervalDomains: Value[][] = [];
+const intervalValues: IntervalValue[] = [];
+const intervalArrays = new WeakMap<Value[], IntervalValue>();
+
+// TLC keeps the domain of a tuple, or of a function built over an interval, as an interval. Every
+// function over 1..n shares one domain array per length, and the elements of any other interval
+// map to it, so the array's identity records it. Callers must not mutate the returned array.
+const getIntervalDomain = (length: number): Value[] => {
+  const cached = intervalDomains[length];
+  if (cached) return cached;
+  const domain = Array.from({ length }, (_, index) => index + 1);
+  intervalDomains[length] = domain;
+  return domain;
+};
+
+// The elements of an interval for a caller that only iterates them, so they need not record
+// the interval for DOMAIN.
+export const getIntervalElements = (value: IntervalValue): Value[] => {
+  getCardinality(value);
+  if (value.low === 1 && value.high >= 1) return getIntervalDomain(value.high);
+  const elements: number[] = [];
+  for (let element = value.low; element <= value.high; element++) elements.push(element);
+  return elements;
+};
+
+const isIntervalDomain = (domain: Value[]) =>
+  domain.length > 0 && (domain === intervalDomains[domain.length] || intervalArrays.has(domain));
+
+// TLC keeps an interval domain only for a function built over an interval itself, so a set
+// such as (1..2) \cap S, whose elements are the shared array, gets a copy.
+export const getFunctionDomain = (set: Value): Value[] => {
+  const elements = toFiniteSet(set).elements;
+  return isIntervalDomain(elements) && !(typeof set === "object" && set.kind === "Interval")
+    ? [...elements]
+    : elements;
+};
+
+const getIntervalValue = (high: number): IntervalValue => {
+  const cached = intervalValues[high];
+  if (cached) return cached;
+  const interval: IntervalValue = { kind: "Interval", low: 1, high };
+  intervalValues[high] = interval;
+  return interval;
+};
+
 export const createTuple = (elements: Value[]): FunctionValue =>
-  createSortedFunction(
-    elements.map((_, index) => index + 1),
-    elements,
-  );
+  createSortedFunction(getIntervalDomain(elements.length), elements);
 
 export const createRecord = (fields: [string, Value][]): FunctionValue => createFunction(fields);
 
+// TLC's Enumerable classes: every set except the ones it implements in Java.
+const isTlcEnumerable = (value: Value) => isSetValue(value) && !isOverriddenSet(value);
+
+const formatUnion = (value: UnionValue, isStrict = false) =>
+  `UNION(${formatValue(value.base, isStrict)})`;
+
+const getUnionSets = (value: UnionValue) => {
+  if (!isTlcEnumerable(value.base)) {
+    throw new TlaEvaluationError(
+      `Attempted to enumerate the nonenumerable set:\n${formatUnion(value)}`,
+    );
+  }
+  return toFiniteSet(value.base).elements;
+};
+
+const getUnionSet = (set: Value, index: number, union: UnionValue) => {
+  if (isTlcEnumerable(set)) return set;
+  throw new TlaEvaluationError(
+    index === 0
+      ? "Attempted to enumerate UNION(s), but some element of s is nonenumerable."
+      : `Attempted to enumerate the nonenumerable set:\n${formatValue(set)}\nwhen enumerating:\n${formatUnion(union)}`,
+  );
+};
+
 export const isEnumerable = (value: Value): boolean => {
   if (typeof value !== "object") return false;
   switch (value.kind) {
     case "Set":
+    case "MixedSet":
     case "Interval":
       return true;
     case "InfiniteSet":
@@ -449,11 +1091,17 @@ export const isEnumerable = (value: Value): boolean => {
     case "FilteredSet":
       return isEnumerable(value.base);
     case "FunctionSet":
-      return isEnumerable(value.domain) && isEnumerable(value.range);
+      return (
+        (isEnumerable(value.domain) && isEnumerable(value.range)) ||
+        getEmptiness(value.domain) === true ||
+        getEmptiness(value) === true
+      );
     case "RecordSet":
-      return value.sets.every(isEnumerable);
+      return value.sets.every(isEnumerable) || getEmptiness(value) === true;
     case "ProductSet":
-      return value.factors.every(isEnumerable);
+      return value.factors.every(isEnumerable) || getEmptiness(value) === true;
+    case "Union":
+      return isEnumerable(value.base) && toFiniteSet(value.base).elements.every(isEnumerable);
     case "SetOperation":
       if (value.operator === "\\cup") return isEnumerable(value.left) && isEnumerable(value.right);
       if (value.operator === "\\cap") return isEnumerable(value.left) || isEnumerable(value.right);
@@ -463,7 +1111,42 @@ export const isEnumerable = (value: Value): boolean => {
   }
 };
 
-const getCartesianProduct = (lists: Value[][]): Value[][] => {
+const getEmptiness = (value: Value): boolean | undefined => {
+  if (typeof value !== "object") return undefined;
+  switch (value.kind) {
+    case "Set":
+    case "MixedSet":
+      return value.elements.length === 0;
+    case "Interval":
+      return value.low > value.high;
+    case "InfiniteSet":
+      return value.name === "Any" ? undefined : false;
+    case "Subset":
+    case "SequenceSet":
+      return false;
+    case "FunctionSet": {
+      const isUnit = getEmptiness(value.domain);
+      if (isUnit === undefined) return undefined;
+      return isUnit ? false : getEmptiness(value.range);
+    }
+    case "RecordSet":
+    case "ProductSet": {
+      for (const part of value.kind === "RecordSet" ? value.sets : value.factors) {
+        const isEmpty = getEmptiness(part);
+        if (isEmpty !== false) return isEmpty;
+      }
+      return false;
+    }
+    case "SetOperation":
+    case "FilteredSet":
+    case "Union":
+      return isEnumerable(value) ? toFiniteSet(value).elements.length === 0 : undefined;
+    default:
+      return undefined;
+  }
+};
+
+const getCartesianProduct = (lists: Value[][]) => {
   const total = lists.reduce((product, list) => product * list.length, 1);
   const combinations: Value[][] = [];
   const positions = lists.map(() => 0);
@@ -491,7 +1174,7 @@ const advanceCombination = (indices: number[], length: number) => {
   return false;
 };
 
-const getSortedSubsets = (base: Value[]): Value[] => {
+const getSortedSubsets = (base: Value[]) => {
   const subsets: Value[] = [];
   for (let size = 0; size <= base.length; size++) {
     const indices = Array.from({ length: size }, (_, index) => index);
@@ -508,12 +1191,15 @@ const enumerateSet = (value: Value): Value[] => {
   switch (value.kind) {
     case "Set":
       return value.elements;
-    case "Interval":
-      return Array.from(
-        { length: Math.max(0, value.high - value.low + 1) },
-        (_, index) => value.low + index,
-      );
+    case "MixedSet":
+      return sortLikeTlc(value.elements);
+    case "Interval": {
+      const elements = getIntervalElements(value);
+      if (elements !== intervalDomains[elements.length]) intervalArrays.set(elements, value);
+      return elements;
+    }
     case "Subset": {
+      if (isOverriddenSet(value.base)) getCardinality(value.base);
       const base = toFiniteSet(value.base).elements;
       if (base.length > MAXIMUM_ENUMERATED_SUBSET_BASE) {
         throw new TlaEvaluationError(
@@ -523,29 +1209,83 @@ const enumerateSet = (value: Value): Value[] => {
       return getSortedSubsets(base);
     }
     case "FunctionSet": {
-      const domain = toFiniteSet(value.domain).elements;
-      const range = toFiniteSet(value.range).elements;
+      if (isEmptySet(value)) return [];
+      if (isOverriddenSet(value.domain)) {
+        throw new TlaEvaluationError(
+          `Attempted to enumerate a set of the form [D -> R],but the domain D:\n${formatValue(value.domain)}\ncannot be enumerated.`,
+        );
+      }
+      const domain = getFunctionDomain(value.domain);
+      if (domain.length > 0 && isOverriddenSet(value.range)) {
+        throw new TlaEvaluationError(
+          `Attempted to enumerate a set of the form [D -> R],but the range R:\n${formatValue(value.range)}\ncannot be enumerated.`,
+        );
+      }
+      const range = domain.length === 0 ? [] : toFiniteSet(value.range).elements;
       return getCartesianProduct(domain.map(() => range)).map((combination): Value =>
         createSortedFunction(domain, combination),
       );
     }
-    case "RecordSet":
-      return getCartesianProduct(value.sets.map((set) => toFiniteSet(set).elements)).map(
-        (combination) =>
-          createRecord(
-            value.names.map((name, index): [string, Value] => [name, combination[index]]),
-          ),
-      );
-    case "ProductSet":
-      return getCartesianProduct(value.factors.map((factor) => toFiniteSet(factor).elements)).map(
-        createTuple,
+    case "RecordSet": {
+      if (isEmptySet(value)) return [];
+      const fields = value.sets.map((set, index) => {
+        if (isOverriddenSet(set)) {
+          throw new TlaEvaluationError(
+            `Attempted to enumerate a set of the form [l1 : v1, ..., ln : vn],\nbut can't enumerate the value of the \`${value.names[index]}' field:\n${formatValue(set)}`,
+          );
+        }
+        return toFiniteSet(set).elements;
+      });
+      return getCartesianProduct(fields).map((combination) =>
+        createRecord(value.names.map((name, index): [string, Value] => [name, combination[index]])),
       );
+    }
+    case "ProductSet": {
+      if (isEmptySet(value)) return [];
+      const factors = value.factors.map((factor, index) => {
+        if (isOverriddenSet(factor)) {
+          throw new TlaEvaluationError(
+            `Attempted to enumerate a set of the form s1 \\X s2 ... \\X sn,\nbut can't enumerate s${index}:\n${formatValue(factor)}`,
+          );
+        }
+        return toFiniteSet(factor).elements;
+      });
+      return getCartesianProduct(factors).map(createTuple);
+    }
     case "FilteredSet":
+      if (isOverriddenSet(value.base)) {
+        throw new TlaEvaluationError(
+          `Attempted to enumerate { x \\in S : p(x) } when S:\n${formatValue(value.base)}\nis not enumerable`,
+        );
+      }
       return toFiniteSet(value.base).elements.filter(value.test);
+    case "Union": {
+      const elements = getUnionSets(value).flatMap(
+        (set, index) => toFiniteSet(getUnionSet(set, index, value)).elements,
+      );
+      return toFiniteSet(createEnumeratedSet(elements)).elements;
+    }
     case "SetOperation": {
-      if (!isEnumerable(value)) {
+      if (
+        value.operator === "\\cup" &&
+        (isOverriddenSet(value.left) || isOverriddenSet(value.right))
+      ) {
+        throw new TlaEvaluationError(
+          `Attempted to enumerate S \\cup T when S:\n${formatValue(value.left)}\nand T:\n${formatValue(value.right)}\nare not both enumerable`,
+        );
+      }
+      if (
+        value.operator === "\\cap" &&
+        isOverriddenSet(value.left) &&
+        isOverriddenSet(value.right)
+      ) {
         throw new TlaEvaluationError(
-          `Attempted to enumerate the non-enumerable set ${formatValue(value)}`,
+          `Attempted to enumerate S \\cap T when neither S:\n${formatValue(value.left)}\nnor T:\n${formatValue(value.right)}\nis enumerable`,
+        );
+      }
+      if (value.operator === "\\" && isOverriddenSet(value.left)) {
+        throw new TlaEvaluationError(
+          `Attempted to enumerate S \\ T when S:\n${formatValue(value.left)}\nis not enumerable.`,
         );
       }
       if (value.operator === "\\cup")
@@ -571,12 +1311,16 @@ const finiteSets = new WeakMap<ObjectValue, SetValue>();
 
 export const toFiniteSet = (value: Value): SetValue => {
   if (typeof value === "object" && value.kind === "Set") return value;
+  if (typeof value === "object" && value.kind === "Interval") {
+    return createSortedSet(enumerateSet(value));
+  }
   const cached = typeof value === "object" ? finiteSets.get(value) : undefined;
   if (cached) return cached;
   const elements = enumerateSet(value);
   const isSorted =
     typeof value === "object" &&
-    (value.kind === "Interval" ||
+    (value.kind === "MixedSet" ||
+      value.kind === "Union" ||
       value.kind === "SetOperation" ||
       value.kind === "FilteredSet" ||
       value.kind === "ProductSet" ||
@@ -587,23 +1331,48 @@ export const toFiniteSet = (value: Value): SetValue => {
   return set;
 };
 
-const checkCardinality = (cardinality: number, set: Value) => {
-  if (cardinality > MAXIMUM_INTEGER) {
-    throw new TlaEvaluationError(
-      `Overflow when computing the number of elements in ${formatValue(set)}`,
+// TLC's Enumerator for a lazy set streams the sets it combines until the set caches its elements,
+// so an element that two of them share comes up once for each.
+export const getStreamedElements = (value: Value): Value[] => {
+  if (typeof value !== "object" || finiteSets.has(value)) return toFiniteSet(value).elements;
+  if (value.kind === "Union") {
+    return getUnionSets(value).flatMap((set, index) =>
+      getStreamedElements(getUnionSet(set, index, value)),
     );
   }
-  return cardinality;
+  if (value.kind === "FilteredSet" && !isOverriddenSet(value.base)) {
+    return getStreamedElements(value.base).filter(value.test);
+  }
+  if (value.kind !== "SetOperation") return toFiniteSet(value).elements;
+  if (value.operator === "\\cup") {
+    return isOverriddenSet(value.left) || isOverriddenSet(value.right)
+      ? toFiniteSet(value).elements
+      : [...getStreamedElements(value.left), ...getStreamedElements(value.right)];
+  }
+  const isLeftEnumerated = value.operator === "\\" || isEnumerable(value.left);
+  const enumerated = isLeftEnumerated ? value.left : value.right;
+  const other = isLeftEnumerated ? value.right : value.left;
+  if (isOverriddenSet(enumerated)) return toFiniteSet(value).elements;
+  return getStreamedElements(enumerated).filter(
+    (element) => isElementOf(element, other) === (value.operator === "\\cap"),
+  );
 };
 
 export const isEmptySet = (value: Value): boolean => {
-  if (typeof value !== "object") return toFiniteSet(value).elements.length === 0;
+  if (typeof value !== "object" || !isSetValue(value)) {
+    throw new TlaEvaluationError(`Shouldn't call isEmpty() on value ${formatValue(value)}`);
+  }
   switch (value.kind) {
     case "Set":
+    case "MixedSet":
       return value.elements.length === 0;
     case "Interval":
       return value.low > value.high;
     case "InfiniteSet":
+      if (value.name === "Any") {
+        throw new TlaEvaluationError("Shouldn't call isEmpty() on value ANY");
+      }
+      return false;
     case "Subset":
     case "SequenceSet":
       return false;
@@ -612,41 +1381,143 @@ export const isEmptySet = (value: Value): boolean => {
     case "RecordSet":
       return value.sets.some(isEmptySet);
     case "FunctionSet":
-      return isEmptySet(value.range) && !isEmptySet(value.domain);
+      return !isEmptySet(value.domain) && isEmptySet(value.range);
+    case "Union":
+      return getUnionSets(value).every((set, index) => isEmptySet(getUnionSet(set, index, value)));
     default:
       return toFiniteSet(value).elements.length === 0;
   }
 };
 
-const getProductCardinality = (sets: Value[], set: Value) => {
-  if (sets.some(isEmptySet)) return 0;
-  return sets
-    .map(getCardinality)
-    .reduce((product, size) => checkCardinality(product * size, set), 1);
-};
+const getProductCardinality = (sets: Value[], describe: () => string) =>
+  sets.reduce<number>((product, set) => {
+    const size = product * getCardinality(set);
+    if (size > MAXIMUM_INTEGER) throw new TlaEvaluationError(describe());
+    return size;
+  }, 1);
+
+const describeOverflow = (value: Value) =>
+  `Overflow when computing the number of elements in:\n${formatValue(value)}`;
 
 export const getCardinality = (value: Value): number => {
   if (typeof value !== "object") return toFiniteSet(value).elements.length;
   switch (value.kind) {
-    case "Interval":
-      return Math.max(0, value.high - value.low + 1);
-    case "Subset":
-      return checkCardinality(2 ** getCardinality(value.base), value);
-    case "FunctionSet":
-      if (isEmptySet(value)) return 0;
-      return getProductCardinality(
-        Array.from({ length: getCardinality(value.domain) }, () => value.range),
-        value,
+    case "Interval": {
+      const size = Math.max(0, value.high - value.low + 1);
+      if (size > MAXIMUM_INTEGER) {
+        throw new TlaEvaluationError(
+          `Size of interval value exceeds the maximum representable size (32bits): ${value.low}..${value.high}.`,
+        );
+      }
+      return size;
+    }
+    case "InfiniteSet":
+    case "SequenceSet":
+      throw new TlaEvaluationError(
+        `Attempted to compute the number of elements in the overridden value ${formatValue(value)}.`,
       );
+    case "Subset": {
+      const size = getCardinality(value.base);
+      if (size >= 31) throw new TlaEvaluationError(describeOverflow(value));
+      return 2 ** size;
+    }
+    case "FunctionSet": {
+      if (isEmptySet(value.domain)) return 1;
+      if (isEmptySet(value.range)) return 0;
+      const rangeSize = getCardinality(value.range);
+      if (rangeSize === 1) return 1;
+      const domainSize = getCardinality(value.domain);
+      const size = { value: 1 };
+      for (let index = 0; index < domainSize; index++) {
+        size.value *= rangeSize;
+        if (size.value > MAXIMUM_INTEGER) throw new TlaEvaluationError(describeOverflow(value));
+      }
+      return size.value;
+    }
     case "RecordSet":
-      return getProductCardinality(value.sets, value);
+      if (isEmptySet(value)) return 0;
+      return getProductCardinality(value.sets, () => describeOverflow(value));
     case "ProductSet":
-      return getProductCardinality(value.factors, value);
+      if (isEmptySet(value)) return 0;
+      return getProductCardinality(
+        value.factors,
+        () => `Overflow when computing the number of elements in ${formatValue(value)}`,
+      );
     default:
       return toFiniteSet(value).elements.length;
   }
 };
 
+const describeInfiniteCheck = (value: Value) =>
+  `Attempted to check if the set ${formatValue(value)}is finite.`;
+
+export const isFiniteSet = (value: Value): boolean => {
+  if (typeof value !== "object" || value.kind === "ModelValue") {
+    throw new TlaEvaluationError(
+      `Attempted to check if the ${describeKind(value)} ${formatValue(value)} is a finite set.`,
+    );
+  }
+  switch (value.kind) {
+    case "Set":
+    case "MixedSet":
+    case "Interval":
+    case "Function":
+      return true;
+    case "LazyFunction":
+      throw new TlaEvaluationError(
+        `Attempted to check if the function:\n${formatValue(value)}\nis a finite set.`,
+      );
+    case "InfiniteSet":
+      return false;
+    case "SequenceSet":
+      return isFiniteSet(value.base) && isEmptySet(value.base);
+    case "Subset":
+      return isFiniteSet(value.base);
+    case "FunctionSet": {
+      const isFiniteDomain = isFiniteSet(value.domain);
+      if (isFiniteDomain && isEmptySet(value.domain)) return true;
+      const isFiniteRange = isFiniteSet(value.range);
+      if (isFiniteRange && isEmptySet(value.range)) return true;
+      return isFiniteRange && (isFiniteDomain || getCardinality(value.range) === 1);
+    }
+    case "RecordSet":
+    case "ProductSet": {
+      const parts = value.kind === "RecordSet" ? value.sets : value.factors;
+      const finiteness = { isAllFinite: true };
+      for (const part of parts) {
+        if (!isFiniteSet(part)) finiteness.isAllFinite = false;
+        else if (isEmptySet(part)) return true;
+      }
+      return finiteness.isAllFinite;
+    }
+    case "Union":
+      if (!isTlcEnumerable(value.base)) {
+        throw new TlaEvaluationError(
+          `Attempted to check if the nonenumerable set:\n${formatUnion(value)}\nis a finite set.`,
+        );
+      }
+      return toFiniteSet(value.base).elements.every(isFiniteSet);
+    case "SetOperation":
+      if (value.operator === "\\cup") return isFiniteSet(value.left) && isFiniteSet(value.right);
+      if (value.operator === "\\cap") {
+        if (!isFiniteSet(value.left) && !isFiniteSet(value.right)) {
+          throw new TlaEvaluationError(describeInfiniteCheck(value));
+        }
+        return true;
+      }
+      if (isFiniteSet(value.left)) return true;
+      if (!isFiniteSet(value.right)) throw new TlaEvaluationError(describeInfiniteCheck(value));
+      return false;
+    case "FilteredSet":
+      if (!isFiniteSet(value.base)) {
+        throw new TlaEvaluationError(
+          `Attempted to check if expression of form {x \\in S : p(x)} is a finite set, but cannot check if S:\n${formatValue(value.base)}\nis finite.`,
+        );
+      }
+      return true;
+  }
+};
+
 const findIndex = (sortedValues: Value[], target: Value) => {
   const bounds = { low: 0, high: sortedValues.length - 1 };
   while (bounds.low <= bounds.high) {
@@ -661,30 +1532,59 @@ const findIndex = (sortedValues: Value[], target: Value) => {
 
 export const getSequenceElements = (value: Value): Value[] | undefined => {
   if (typeof value !== "object" || !isFunctionValue(value)) return undefined;
-  const fn = toFiniteFunction(value);
-  return fn.domain.every((key, index) => key === index + 1) ? fn.range : undefined;
+  const functionValue = toFiniteFunction(value);
+  return functionValue.domain.every((key, index) => key === index + 1)
+    ? functionValue.range
+    : undefined;
 };
 
 const describeMembership = (element: Value, set: Value) =>
   `Attempted to check if the value ${formatValue(element)} is an element of ${formatValue(set)}`;
 
+const describeNonSetMembership = (element: Value, value: Value) => {
+  const prefix = `Attempted to check if the value:\n${formatValue(element)}\nis an element of the`;
+  if (!isFunctionValue(value)) return `${prefix} ${describeKind(value)} ${formatValue(value)}`;
+  const domain =
+    value.kind === "Function" || isEnumerable(value.domain) ? toFiniteFunction(value).domain : [];
+  if (domain.length > 0 && domain.every((key) => typeof key === "string")) {
+    return `Attempted to check if element:\n${formatValue(element)}\nis in the record:\n${formatValue(value)}`;
+  }
+  if (domain.every((key, index) => key === index + 1)) {
+    return "Attempted to check set membership in a tuple value.";
+  }
+  return `${prefix} function ${formatValue(value)}`;
+};
+
 export const isElementOf = (element: Value, set: Value): boolean => {
-  if (typeof set !== "object")
-    throw new TlaEvaluationError(`Expected a set but found ${formatValue(set)}`);
+  if (!isSetValue(set)) throw new TlaEvaluationError(describeNonSetMembership(element, set));
   switch (set.kind) {
     case "Set":
-      return findIndex(set.elements, element) !== -1;
+      try {
+        return findIndex(set.elements, element) !== -1;
+      } catch (error) {
+        if (!(error instanceof TlaEvaluationError)) throw error;
+        return isElementOfLikeTlc(element, set.elements);
+      }
+    case "MixedSet":
+      return isElementOfLikeTlc(element, set.elements);
     case "Interval":
       if (typeof element === "number") return element >= set.low && element <= set.high;
-      if (set.low <= set.high && !isModelValue(element))
-        throw new TlaEvaluationError(describeMembership(element, set));
+      if (set.low <= set.high && !isModelValue(element)) {
+        throw new TlaEvaluationError(
+          `Attempted to check if the value:\n${formatValue(element)}\nis in the integer interval ${formatValue(set)}`,
+        );
+      }
       return false;
     case "InfiniteSet": {
       if (set.name === "Any") return true;
       if (isModelValue(element)) return false;
       const isMemberType =
         set.name === "STRING" ? typeof element === "string" : typeof element === "number";
-      if (!isMemberType) throw new TlaEvaluationError(describeMembership(element, set));
+      if (!isMemberType) {
+        throw new TlaEvaluationError(
+          `Attempted to check if the value:\n${formatValue(element)}\nis an element of ${set.name}.`,
+        );
+      }
       return set.name !== "Nat" || (typeof element === "number" && element >= 0);
     }
     case "Subset":
@@ -695,40 +1595,58 @@ export const isElementOf = (element: Value, set: Value): boolean => {
         if (isModelValue(element)) return false;
         throw new TlaEvaluationError(describeMembership(element, set));
       }
-      const fn = toFiniteFunction(element);
-      return (
-        valuesEqual(createSortedSet(fn.domain), set.domain) &&
-        fn.range.every((item) => isElementOf(item, set.range))
-      );
+      const functionValue = toFiniteFunction(element);
+      const low = getIntervalLow(functionValue.domain);
+      const isDomain =
+        low === undefined
+          ? isEqualLikeTlc(set.domain, createSortedSet(functionValue.domain))
+          : isEqualLikeTlc(
+              { kind: "Interval", low, high: low + functionValue.domain.length - 1 },
+              set.domain,
+            );
+      return isDomain && functionValue.range.every((item) => isElementOf(item, set.range));
     }
     case "RecordSet": {
-      if (!isFunctionValue(element)) {
+      const functionValue = isFunctionValue(element) ? toFiniteFunction(element) : undefined;
+      if (!functionValue || !isRecordDomain(functionValue.domain)) {
         if (isModelValue(element)) return false;
-        throw new TlaEvaluationError(describeMembership(element, set));
+        throw new TlaEvaluationError(
+          `Attempted to check if non-record\n${formatValue(element)}\nis in the set of records:\n${formatValue(set)}`,
+        );
       }
-      const fn = toFiniteFunction(element);
       return (
-        fn.domain.length === set.names.length &&
+        functionValue.domain.length === set.names.length &&
         set.names.every((name, index) => {
-          const position = findIndex(fn.domain, name);
-          return position !== -1 && isElementOf(fn.range[position], set.sets[index]);
+          const position = findIndex(functionValue.domain, name);
+          return position !== -1 && isElementOf(functionValue.range[position], set.sets[index]);
         })
       );
     }
     case "ProductSet": {
-      if (!isFunctionValue(element)) {
-        if (isModelValue(element)) return false;
-        throw new TlaEvaluationError(describeMembership(element, set));
+      const elements = isFunctionValue(element) ? getSequenceElements(element) : undefined;
+      if (elements === undefined) {
+        const isFunction =
+          isFunctionValue(element) &&
+          toFiniteFunction(element).domain.every((key) => typeof key === "number");
+        if (isFunction || isModelValue(element)) return false;
+        throw new TlaEvaluationError(
+          `Attempted to check if non-tuple\n${formatValue(element)}\nis in the set of tuples:\n${formatValue(set)}`,
+        );
       }
-      const elements = getSequenceElements(element);
       return (
-        elements !== undefined &&
         elements.length === set.factors.length &&
         elements.every((item, index) => isElementOf(item, set.factors[index]))
       );
     }
     case "FilteredSet":
       return isElementOf(element, set.base) && set.test(element);
+    case "Union":
+      if (!isTlcEnumerable(set.base)) {
+        throw new TlaEvaluationError(
+          `Attempted to check if:\n ${formatValue(element)}\nis an element of the non-enumerable set:\n ${formatUnion(set)}`,
+        );
+      }
+      return toFiniteSet(set.base).elements.some((inner) => isElementOf(element, inner));
     case "SetOperation":
       if (set.operator === "\\cup")
         return isElementOf(element, set.left) || isElementOf(element, set.right);
@@ -745,14 +1663,15 @@ export const isElementOf = (element: Value, set: Value): boolean => {
       return elements.every((item) => isElementOf(item, set.base));
     }
     default:
-      throw new TlaEvaluationError(`Expected a set but found ${formatValue(set)}`);
+      throw new TlaEvaluationError(describeNonSetMembership(element, set));
   }
 };
 
 export const toFiniteFunction = (value: Value): FunctionValue => {
   if (typeof value === "object" && value.kind === "Function") return value;
   if (typeof value === "object" && value.kind === "LazyFunction") {
-    const domain = toFiniteSet(value.domain).elements;
+    if (!isEnumerable(value.domain)) getCardinality(value.domain);
+    const domain = getFunctionDomain(value.domain);
     return createSortedFunction(
       domain,
       domain.map((key) => value.apply(key)),
@@ -761,57 +1680,88 @@ export const toFiniteFunction = (value: Value): FunctionValue => {
   throw new TlaEvaluationError(`Expected a function but found ${formatValue(value)}`);
 };
 
-export const applyFunction = (fn: Value, argument: Value): Value => {
-  if (typeof fn === "object" && fn.kind === "LazyFunction") {
-    if (!isElementOf(argument, fn.domain)) {
+const lambdaFunctions = new WeakSet<ObjectValue>();
+
+export const markLambdaFunction = <FunctionLike extends FunctionValue | LazyFunctionValue>(
+  functionValue: FunctionLike,
+) => {
+  lambdaFunctions.add(functionValue);
+  return functionValue;
+};
+
+const describeMissingArgument = (functionValue: Value, argument: Value) =>
+  typeof functionValue === "object" && lambdaFunctions.has(functionValue)
+    ? `In applying the function\n${prettyPrint(formatValue(functionValue))},\nthe first argument is:\n${prettyPrint(formatValue(argument))}\nwhich is not in its domain.\n`
+    : `Attempted to apply function ${formatValue(functionValue)} to ${formatValue(argument)}, which is not in its domain`;
+
+export const applyFunction = (
+  functionValue: Value,
+  argument: Value,
+  describeMissing?: (functionValue: FunctionValue) => string,
+): Value => {
+  if (typeof functionValue === "object" && functionValue.kind === "LazyFunction") {
+    if (!isElementOf(argument, functionValue.domain)) {
       throw new TlaEvaluationError(
-        `Attempted to apply a function to ${formatValue(argument)}, which is not in its domain`,
+        lambdaFunctions.has(functionValue)
+          ? describeMissingArgument(functionValue, argument)
+          : `Attempted to apply a function to ${formatValue(argument)}, which is not in its domain`,
       );
     }
-    return fn.apply(argument);
+    return functionValue.apply(argument);
   }
-  if (typeof fn !== "object" || fn.kind !== "Function") {
-    throw new TlaEvaluationError(`Attempted to apply ${formatValue(fn)}, which is not a function`);
+  if (typeof functionValue !== "object" || functionValue.kind !== "Function") {
+    throw new TlaEvaluationError(
+      `Attempted to apply ${formatValue(functionValue)}, which is not a function`,
+    );
   }
-  const domain = fn.domain;
+  const domain = functionValue.domain;
   const first = domain[0];
   if (typeof argument === "number" && typeof first === "number") {
     const offset = argument - first;
-    if (domain[offset] === argument) return fn.range[offset];
+    if (domain[offset] === argument) return functionValue.range[offset];
   }
   if (domain.length <= 8) {
     for (let index = 0; index < domain.length; index++)
-      if (domain[index] === argument) return fn.range[index];
+      if (domain[index] === argument) return functionValue.range[index];
   }
   const position = findIndex(domain, argument);
   if (position === -1) {
     throw new TlaEvaluationError(
-      `Attempted to apply function ${formatValue(fn)} to ${formatValue(argument)}, which is not in its domain`,
+      describeMissing?.(functionValue) ?? describeMissingArgument(functionValue, argument),
     );
   }
-  return fn.range[position];
+  return functionValue.range[position];
 };
 
-export const getDomain = (fn: Value): Value => {
-  if (typeof fn === "object" && fn.kind === "LazyFunction") return fn.domain;
-  return createSortedSet(toFiniteFunction(fn).domain);
+export const getDomain = (functionValue: Value): Value => {
+  if (typeof functionValue === "object" && functionValue.kind === "LazyFunction")
+    return functionValue.domain;
+  const domain = toFiniteFunction(functionValue).domain;
+  if (!isIntervalDomain(domain)) return createSortedSet(domain);
+  return intervalArrays.get(domain) ?? getIntervalValue(domain.length);
 };
 
 export const updateFunction = (
-  fn: Value,
+  functionValue: Value,
   argument: Value,
   update: (previous: Value) => Value,
+  isKeptLazy = false,
 ): Value => {
-  if (typeof fn === "object" && fn.kind === "LazyFunction" && !isEnumerable(fn.domain)) {
-    if (!isElementOf(argument, fn.domain)) return fn;
-    const updated = update(fn.apply(argument));
+  const isLazy =
+    typeof functionValue === "object" &&
+    functionValue.kind === "LazyFunction" &&
+    (isKeptLazy || !isEnumerable(functionValue.domain));
+  if (isLazy) {
+    if (!isElementOf(argument, functionValue.domain)) return functionValue;
+    const updated = update(functionValue.apply(argument));
     return {
       kind: "LazyFunction",
-      domain: fn.domain,
-      apply: (key) => (valuesEqual(key, argument) ? updated : fn.apply(key)),
+      domain: functionValue.domain,
+      apply: (key) => (isEqualLikeTlc(argument, key) ? updated : functionValue.apply(key)),
+      source: functionValue.source,
     };
   }
-  const finite = toFiniteFunction(fn);
+  const finite = toFiniteFunction(functionValue);
   const position = findIndex(finite.domain, argument);
   if (position === -1) return finite;
   const range = [...finite.range];
@@ -819,6 +1769,7 @@ export const updateFunction = (
   const next = update(previous);
   range[position] = next;
   const updated = createSortedFunction(finite.domain, range);
+  updated.writtenKeys = finite.writtenKeys;
   if (finite.hash !== 0) {
     const key = finite.domain[position];
     updated.hash =
@@ -867,7 +1818,7 @@ const getElementContribution = (element: Value) =>
 const getEntryContribution = (key: Value, value: Value) =>
   finalizeHash((Math.imul(getValueHash(key), 0x27d4eb2d) + getValueHash(value)) | 0);
 
-const computeValueHash = (value: ObjectValue): number => {
+const computeValueHash = (value: ObjectValue) => {
   if (value.kind === "ModelValue") return finalizeHash(combineHash(hashString(value.name), 0x6d));
   if (isSetValue(value)) {
     if (!isEnumerable(value)) return hashString(getValueKey(value));
@@ -878,10 +1829,11 @@ const computeValueHash = (value: ObjectValue): number => {
     }
     return hash;
   }
-  const fn = toFiniteFunction(value);
+  const functionValue = toFiniteFunction(value);
   let hash = FUNCTION_HASH_SEED;
-  for (let index = 0; index < fn.domain.length; index++) {
-    hash = (hash + getEntryContribution(fn.domain[index], fn.range[index])) | 0;
+  for (let index = 0; index < functionValue.domain.length; index++) {
+    hash =
+      (hash + getEntryContribution(functionValue.domain[index], functionValue.range[index])) | 0;
   }
   return hash;
 };
@@ -924,7 +1876,7 @@ const getEntryFingerprint = (key: Value, value: Value) =>
     (Math.imul(getValueFingerprint(key), 0x165667b1) + getValueFingerprint(value)) | 0,
   );
 
-const computeValueFingerprint = (value: ObjectValue): number => {
+const computeValueFingerprint = (value: ObjectValue) => {
   if (value.kind === "ModelValue") return finalizeFingerprint(fingerprintString(value.name) ^ 0x3c);
   if (isSetValue(value)) {
     if (!isEnumerable(value)) return fingerprintString(getValueKey(value));
@@ -935,10 +1887,12 @@ const computeValueFingerprint = (value: ObjectValue): number => {
     }
     return fingerprint;
   }
-  const fn = toFiniteFunction(value);
+  const functionValue = toFiniteFunction(value);
   let fingerprint = 0x4cf5ad43;
-  for (let index = 0; index < fn.domain.length; index++) {
-    fingerprint = (fingerprint + getEntryFingerprint(fn.domain[index], fn.range[index])) | 0;
+  for (let index = 0; index < functionValue.domain.length; index++) {
+    fingerprint =
+      (fingerprint + getEntryFingerprint(functionValue.domain[index], functionValue.range[index])) |
+      0;
   }
   return fingerprint;
 };
@@ -971,7 +1925,7 @@ export const getValueKey = (value: Value): string => {
   return key;
 };
 
-const computeValueKey = (value: ObjectValue): string => {
+const computeValueKey = (value: ObjectValue) => {
   if (value.kind === "ModelValue") return `@${value.name}`;
   if (value.kind === "InfiniteSet") return `<${value.name}>`;
   if (value.kind === "SequenceSet") return `<Seq ${getValueKey(value.base)}>`;
@@ -984,42 +1938,95 @@ const computeValueKey = (value: ObjectValue): string => {
     if (!isEnumerable(value)) return `<${value.kind} ${formatValue(value)}>`;
     return `{${toFiniteSet(value).elements.map(getValueKey).join(",")}}`;
   }
-  const fn = toFiniteFunction(value);
-  return `(${fn.domain.map((key, index) => `${getValueKey(key)}:${getValueKey(fn.range[index])}`).join(",")})`;
+  const functionValue = toFiniteFunction(value);
+  return `(${functionValue.domain.map((key, index) => `${getValueKey(key)}:${getValueKey(functionValue.range[index])}`).join(",")})`;
 };
 
 const formatString = (value: string) =>
   `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\t/g, "\\t")}"`;
 
-const formatLazySet = (
-  value:
-    | SubsetValue
-    | FunctionSetValue
-    | RecordSetValue
-    | ProductSetValue
-    | SetOperationValue
-    | FilteredSetValue,
-  isExpanded: boolean,
-): string => {
-  const format = (inner: Value) => formatValue(inner, isExpanded);
+type LazySetValue =
+  | SubsetValue
+  | FunctionSetValue
+  | RecordSetValue
+  | ProductSetValue
+  | SetOperationValue
+  | FilteredSetValue
+  | UnionValue;
+
+const MAXIMUM_EXPANDED_SUBSET_BASE = 6;
+const MAXIMUM_EXPANDED_PRODUCT = 1999;
+
+const getProductSize = (sets: Value[]) =>
+  sets.reduce<number>((size, set) => (size === 0 ? 0 : size * getCardinality(set)), 1);
+
+const expandLazySet = (value: LazySetValue) => {
+  if (value.kind === "Subset") {
+    return getCardinality(value.base) <= MAXIMUM_EXPANDED_SUBSET_BASE
+      ? toFiniteSet(value)
+      : undefined;
+  }
+  if (value.kind === "SetOperation" || value.kind === "FilteredSet" || value.kind === "Union") {
+    return toFiniteSet(value);
+  }
+  if (
+    value.kind === "FunctionSet" &&
+    isEnumerable(value.domain) &&
+    getCardinality(value.domain) === 0
+  ) {
+    return createSortedSet([createSortedFunction([], [])]);
+  }
+  const size =
+    value.kind === "FunctionSet"
+      ? getCardinality(value.range) ** getCardinality(value.domain)
+      : getProductSize(value.kind === "RecordSet" ? value.sets : value.factors);
+  if (size === 0) return EMPTY_SET;
+  return size <= MAXIMUM_EXPANDED_PRODUCT ? toFiniteSet(value) : undefined;
+};
+
+const getExpandedLazySet = (value: LazySetValue, isStrict: boolean) => {
+  if (isStrict) return expandLazySet(value);
+  // TLC prints a set it can't enumerate symbolically, except in Print, PrintT, and ToString.
+  if (!isEnumerable(value)) return undefined;
+  try {
+    return expandLazySet(value);
+  } catch (error) {
+    if (error instanceof TlaEvaluationError) return undefined;
+    throw error;
+  }
+};
+
+const formatLazySet = (value: LazySetValue, isStrict: boolean): string => {
+  const format = (inner: Value) => formatValue(inner, isStrict);
   switch (value.kind) {
     case "Subset":
-      return `SUBSET ${format(value.base)}`;
+      return typeof value.base === "object" && value.base.kind === "Interval"
+        ? `SUBSET (${format(value.base)})`
+        : `SUBSET ${format(value.base)}`;
     case "FunctionSet":
       return `[${format(value.domain)} -> ${format(value.range)}]`;
     case "RecordSet":
-      return `[${value.names.map((name, index) => `${name} : ${format(value.sets[index])}`).join(", ")}]`;
+      return `[${value.names.map((name, index) => `${name}: ${format(value.sets[index])}`).join(", ")}]`;
     case "ProductSet":
-      return value.factors.map(format).join(" \\X ");
+      return `(${value.factors.map(format).join(" \\X ")})`;
     case "SetOperation":
       return `${format(value.left)} ${value.operator} ${format(value.right)}`;
     case "FilteredSet":
       return `{x \\in ${format(value.base)} : ...}`;
+    case "Union":
+      return formatUnion(value, isStrict);
   }
 };
 
-export const formatValue = (value: Value, isExpanded = false): string => {
-  const format = (inner: Value) => formatValue(inner, isExpanded);
+// FcnRcdValue#isName: TLC prints a function as a record when every key consists of letters,
+// decimal digits, and underscores, with at least one letter.
+const isFieldName = (name: string) =>
+  /^[\p{L}\p{Nd}_]*$/u.test(name) &&
+  /\p{L}/u.test(name) &&
+  (name.length < 4 || !/^[WS]F_/.test(name));
+
+export const formatValue = (value: Value, isStrict = false, isNormalized = false): string => {
+  const format = (inner: Value) => formatValue(inner, isStrict, isNormalized);
   if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
   if (typeof value === "number") return String(value);
   if (typeof value === "string") return formatString(value);
@@ -1028,8 +2035,10 @@ export const formatValue = (value: Value, isExpanded = false): string => {
       return value.name;
     case "Set":
       return `{${value.elements.map(format).join(", ")}}`;
+    case "MixedSet":
+      return format(toFiniteSet(value));
     case "Interval":
-      return `${value.low}..${value.high}`;
+      return value.low <= value.high ? `${value.low}..${value.high}` : "{}";
     case "InfiniteSet":
       return value.name === "Any" ? "ANY" : value.name;
     case "Subset":
@@ -1038,23 +2047,36 @@ export const formatValue = (value: Value, isExpanded = false): string => {
     case "ProductSet":
     case "SetOperation":
     case "FilteredSet":
-      return isExpanded && isEnumerable(value)
-        ? format(toFiniteSet(value))
-        : formatLazySet(value, isExpanded);
+    case "Union": {
+      const expanded = getExpandedLazySet(value, isStrict);
+      return expanded ? format(expanded) : formatLazySet(value, isStrict);
+    }
 
     case "SequenceSet":
       return `Seq(${format(value.base)})`;
     case "Function":
     case "LazyFunction": {
-      if (value.kind === "LazyFunction" && !isEnumerable(value.domain)) return "<function>";
-      const fn = toFiniteFunction(value);
-      if (fn.domain.every((key, index) => key === index + 1)) {
-        return `<<${fn.range.map(format).join(", ")}>>`;
+      if (value.kind === "LazyFunction" && !isEnumerable(value.domain)) {
+        const source = value.source;
+        if (!source) return "<function>";
+        const parameters = source.parameters
+          .map((parameter) => `${parameter.name} \\in ${formatValue(parameter.domain)}`)
+          .join(", ");
+        return `[${parameters} |-> <expression ${source.body}>]`;
+      }
+      const functionValue = toFiniteFunction(value);
+      if (functionValue.domain.every((key, index) => key === index + 1)) {
+        return `<<${functionValue.range.map(format).join(", ")}>>`;
       }
-      if (fn.domain.every((key) => typeof key === "string" && key.length > 0)) {
-        return `[${fn.domain.map((key, index) => `${String(key)} |-> ${format(fn.range[index])}`).join(", ")}]`;
+      if (functionValue.domain.every((key) => typeof key === "string" && isFieldName(key))) {
+        const isSorted =
+          isNormalized || functionValue.hash !== 0 || functionValue.fingerprint !== 0;
+        const pairs = isSorted
+          ? functionValue.domain.map((key, index) => [key, functionValue.range[index]])
+          : getWrittenPairs(functionValue);
+        return `[${pairs.map((pair) => `${String(pair[0])} |-> ${format(pair[1])}`).join(", ")}]`;
       }
-      return `(${fn.domain.map((key, index) => `${format(key)} :> ${format(fn.range[index])}`).join(" @@ ")})`;
+      return `(${functionValue.domain.map((key, index) => `${format(key)} :> ${format(functionValue.range[index])}`).join(" @@ ")})`;
     }
   }
 };