tla-ts 0.0.1 → 0.0.3-dev.a50fc89

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tla-ts",
-  "version": "0.0.1",
-  "description": "A TLA+ interpreter and model checker in TypeScript, 2.4× faster than TLC",
+  "version": "0.0.3-dev.a50fc89",
+  "description": "A TLA+ interpreter and model checker in TypeScript, 2× faster than TLC",
   "keywords": [
     "formal verification",
     "model checker",
@@ -68,7 +68,11 @@
     "bench:corpus": "pnpm build && tsx scripts/benchmark-corpus.ts",
     "conformance": "tsx scripts/conformance.ts",
     "conformance:fetch": "tsx scripts/fetch-corpora.ts",
+    "conformance:sany": "tsx scripts/proof-conformance.ts",
     "conformance:record": "tsx scripts/record-tlc.ts",
+    "conformance:record-sany": "tsx scripts/record-sany.ts",
+    "conformance:record-tlapm": "tsx scripts/record-tlapm.ts",
+    "conformance:tlapm": "tsx scripts/tlapm-conformance.ts",
     "publint": "publint",
     "test": "vp test",
     "typecheck": "tsc --noEmit"

package/src/ast.ts

@@ -5,11 +5,25 @@ export interface LocalResolution {
 export interface SourceLocation {
   line: number;
   column: number;
+  range?: SourceRange;
+}
+
+export interface SourceRange {
+  module: string;
+  start: SourceLocation;
+  end: SourceLocation;
 }
 
 export interface NumberExpression {
   kind: "Number";
   value: number;
+  text?: string;
+  location: SourceLocation;
+}
+
+export interface DecimalExpression {
+  kind: "Decimal";
+  text: string;
   location: SourceLocation;
 }
 
@@ -30,6 +44,9 @@ export interface ApplyExpression {
   kind: "Apply";
   operator: string;
   args: Expression[];
+  // The number of args each part of a name like F(x)!l(y) takes, when a part before the last takes
+  // some.
+  argumentCounts?: number[];
   location: SourceLocation;
   resolution?: LocalResolution;
 }
@@ -50,6 +67,7 @@ export interface LambdaExpression {
 export interface JunctionExpression {
   kind: "And" | "Or";
   operands: Expression[];
+  isBulleted?: boolean;
   location: SourceLocation;
 }
 
@@ -115,6 +133,7 @@ export interface QuantifierExpression {
 
 export interface UnboundedQuantifierExpression {
   kind: "UnboundedQuantifier";
+  quantifier: "Forall" | "Exists";
   names: string[];
   isTemporal?: boolean;
   body: Expression;
@@ -266,6 +285,7 @@ export interface SubexpressionExpression {
 
 export type Expression =
   | NumberExpression
+  | DecimalExpression
   | StringExpression
   | IdentifierExpression
   | ApplyExpression
@@ -302,6 +322,7 @@ export type Expression =
 export interface OperatorParam {
   name: string;
   arity: number;
+  location?: SourceLocation;
 }
 
 export interface OperatorDefinition {
@@ -309,6 +330,7 @@ export interface OperatorDefinition {
   name: string;
   params: OperatorParam[];
   body: Expression;
+  bodyRange?: SourceRange;
   isLocal: boolean;
   isRecursive: boolean;
   location: SourceLocation;
@@ -329,6 +351,7 @@ export type Definition = OperatorDefinition | FunctionDefinition;
 export interface Declaration {
   name: string;
   arity: number;
+  location: SourceLocation;
 }
 
 export interface Assumption {
@@ -351,21 +374,115 @@ export interface Instance {
   substitutions: InstanceSubstitution[];
   isLocal: boolean;
   location: SourceLocation;
+  instanceRange: SourceRange;
+  definitionRange?: SourceRange;
 }
 
-export interface OuterScope {
-  extends: string[];
-  symbols: Declaration[];
+export interface NewSymbol {
+  kind: "NewSymbol";
+  name: string;
+  arity: number;
+  level: "Constant" | "Variable" | "State" | "Action" | "Temporal";
+  set: Expression | undefined;
+  location: SourceLocation;
+}
+
+export interface AssumeProve {
+  kind: "AssumeProve";
+  assumptions: (Expression | NewSymbol | AssumeProve)[];
+  conclusion: Expression;
+  location: SourceLocation;
+}
+
+export type Fact = Expression | { kind: "ModuleFact"; name: string; location: SourceLocation };
+
+// keyword is the range of the USE or HIDE token and any ONLY after it.
+export interface UseOrHide {
+  kind: "Use" | "Hide";
+  isOnly: boolean;
+  facts: Fact[];
+  defs: Fact[];
+  keyword: SourceRange;
+  location: SourceLocation;
 }
 
+// keyword is the range of the BY, OBVIOUS, or OMITTED token.
+export type Proof =
+  | { kind: "Obvious" | "Omitted"; keyword: SourceRange; location: SourceLocation }
+  | {
+      kind: "By";
+      isOnly: boolean;
+      facts: Fact[];
+      defs: Fact[];
+      keyword: SourceRange;
+      location: SourceLocation;
+    }
+  | {
+      kind: "Steps";
+      level: number;
+      steps: ProofStep[];
+      location: SourceLocation;
+    };
+
+export interface DefineStep {
+  kind: "Define";
+  definitions: (Definition | Instance)[];
+  location: SourceLocation;
+}
+
+export type StepBody =
+  | UseOrHide
+  | Instance
+  | DefineStep
+  | { kind: "Have"; expression: Expression }
+  | { kind: "Take"; names: string[]; bounds: Bound[] }
+  | { kind: "Witness"; expressions: Expression[] }
+  | { kind: "Pick"; names: string[]; bounds: Bound[]; body: Expression }
+  | { kind: "Case"; expression: Expression }
+  | { kind: "Assert"; isSuffices: boolean; statement: Expression | AssumeProve }
+  | { kind: "Qed" };
+
+// head is the range of the step number and its statement, without the proof.
+export interface ProofStep {
+  name: string | undefined;
+  token: string;
+  body: StepBody;
+  head: SourceRange;
+  proof: Proof | undefined;
+  location: SourceLocation;
+}
+
+export interface Theorem {
+  name: string | undefined;
+  statement: Expression | AssumeProve;
+  proof: Proof | undefined;
+  location: SourceLocation;
+}
+
+// The units of a module in source order, for consumers that need the order across kinds.
+export type ModuleUnit =
+  | { kind: "Constants"; declarations: Declaration[] }
+  | { kind: "Variables"; declarations: Declaration[] }
+  | { kind: "Recursive"; declarations: Declaration[] }
+  | { kind: "Definition"; definition: Definition }
+  | { kind: "Instance"; instance: Instance }
+  | { kind: "Assumption"; assumption: Assumption }
+  | { kind: "Theorem"; theorem: Theorem }
+  | { kind: "Use"; use: UseOrHide }
+  | { kind: "Module"; module: Module };
+
 export interface Module {
   name: string;
-  outer: OuterScope | undefined;
   modules: Module[];
   extends: string[];
+  extendsRanges: SourceRange[];
   constants: Declaration[];
-  variables: string[];
+  variables: Declaration[];
   definitions: Definition[];
   instances: Instance[];
   assumptions: Assumption[];
+  location: SourceLocation;
+  theorems: Theorem[];
+  uses: UseOrHide[];
+  units: ModuleUnit[];
 }

package/src/bags.ts

@@ -1,75 +1,118 @@
 import {
+  createJavaOverrideError,
+  createOverflowError,
   defineConstant,
   defineHigherOrderOperator,
   defineOperator,
-  getElements,
+  getJavaClassName,
   getOperator,
   getValue,
+  isOutOfRange,
 } from "./builtins";
-import { TlaEvaluationError } from "./errors";
+import { TlaEvaluationError, TlaModuleError } from "./errors";
 import type { Builtin, BuiltinArgument } from "./evaluate";
 import {
-  checkInteger,
   createFunction,
+  createSet,
   createSortedFunction,
-  createSortedSet,
   formatValue,
+  getDomain,
   isEnumerable,
   isFunctionValue,
+  isSetValue,
   toFiniteFunction,
+  toFiniteSet,
   valuesEqual,
   type FunctionValue,
   type Value,
 } from "./values";
 
-const describeWrongValue = (name: string, expected: string, value: Value) =>
-  new TlaEvaluationError(
+const createWrongValueError = (name: string, expected: string, value: Value) =>
+  new TlaModuleError(
     `Applying ${name} to the following value,\nwhich is not ${expected}:\n${formatValue(value)}`,
   );
 
-const describeWrongArgument = (position: string, name: string, expected: string, value: Value) =>
-  new TlaEvaluationError(
+const createWrongArgumentError = (position: string, name: string, expected: string, value: Value) =>
+  new TlaModuleError(
     `The ${position} argument of ${name} should be a ${expected}, but instead it is:\n${formatValue(value)}`,
   );
 
-const toFunction = (value: Value): FunctionValue | undefined =>
-  isFunctionValue(value) && (value.kind === "Function" || isEnumerable(value.domain))
-    ? toFiniteFunction(value)
-    : undefined;
+const toFunction = (value: Value) => (isFunctionValue(value) ? toFiniteFunction(value) : undefined);
 
 const getFunction = (args: BuiltinArgument[], index: number, name: string) => {
   const value = getValue(args, index, name);
-  const fn = toFunction(value);
-  if (!fn) throw describeWrongValue(name, "a function with a finite domain", value);
-  return fn;
+  const functionValue = toFunction(value);
+  if (!functionValue) throw createWrongValueError(name, "a function with a finite domain", value);
+  return functionValue;
 };
 
-const isBag = (fn: FunctionValue) =>
-  fn.range.every((count) => typeof count === "number" && count > 0);
+const getBagArgument = (args: BuiltinArgument[], index: number, name: string) => {
+  const value = getValue(args, index, name);
+  const functionValue = toFunction(value);
+  if (!functionValue)
+    throw createWrongArgumentError(index === 0 ? "first" : "second", name, "bag", value);
+  return functionValue;
+};
 
-const getCount = (value: Value, name: string, bag: Value) => {
-  if (typeof value !== "number") throw describeWrongValue(name, "a bag", bag);
-  return value;
+const getFiniteElements = (set: Value, describeError: () => TlaModuleError) => {
+  if (!isSetValue(set) || !isEnumerable(set)) throw describeError();
+  return toFiniteSet(set).elements;
 };
 
-const findCount = (fn: FunctionValue, element: Value) => {
-  const position = fn.domain.findIndex((key) => valuesEqual(key, element));
-  return position === -1 ? undefined : fn.range[position];
+const isBag = (functionValue: FunctionValue) =>
+  functionValue.range.every((count) => typeof count === "number" && count > 0);
+
+const findCount = (functionValue: FunctionValue, element: Value) => {
+  const position = functionValue.domain.findIndex((key) => valuesEqual(key, element));
+  return position === -1 ? undefined : functionValue.range[position];
 };
 
-const addCounts = (left: number, right: number) => {
-  const sum = left + right;
-  if (sum > 2147483647) throw new TlaEvaluationError(`Overflow when computing ${left}+${right}`);
+const getMethod = (name: string, result: string, arity: number) =>
+  `public static ${result} tlc2.module.Bags.${name}(${Array.from({ length: arity }, () => "tlc2.value.impl.Value").join(",")})`;
+
+const BAG_DIFF = getMethod("BagDiff", "tlc2.value.impl.Value", 2);
+const SQ_SUBSETEQ = getMethod("SqSubseteq", "tlc2.value.IBoolValue", 2);
+const BAG_UNION = getMethod("BagUnion", "tlc2.value.impl.Value", 1);
+const BAG_OF_ALL = getMethod("BagOfAll", "tlc2.value.impl.Value", 2);
+const BAG_CUP = getMethod("BagCup", "tlc2.value.impl.Value", 2);
+const BAG_CARDINALITY = getMethod("BagCardinality", "tlc2.value.impl.IntValue", 1);
+
+// Bags.java casts each count to IntValue, so a count that isn't an integer fails with Java's
+// ClassCastException.
+const toCount = (value: Value, method: string) => {
+  if (typeof value === "number") return value;
+  const javaClass = `tlc2.value.impl.${getJavaClassName(value)}`;
+  throw createJavaOverrideError(
+    method,
+    `class ${javaClass} cannot be cast to class tlc2.value.impl.IntValue (${javaClass} and tlc2.value.impl.IntValue are in unnamed module of loader 'app')`,
+  );
+};
+
+const addCounts = (left: Value, right: Value, method: string) => {
+  const sum = toCount(left, method) + toCount(right, method);
+  if (isOutOfRange(sum)) throw createOverflowError(`${left}+${right}`);
   return sum;
 };
 
-const mergeBags = (bags: FunctionValue[]) =>
+// TLC subtracts counts as Java ints, which wrap on overflow.
+const subtractCounts = (
+  functionValue: FunctionValue,
+  index: number,
+  other: FunctionValue,
+  method: string,
+) => {
+  const removed = findCount(other, functionValue.domain[index]);
+  const count = toCount(functionValue.range[index], method);
+  return removed === undefined ? count : (count - toCount(removed, method)) | 0;
+};
+
+const mergeBags = (bags: FunctionValue[], method: string) =>
   createFunction(
     bags.reduce<[Value, Value][]>((pairs, bag) => {
       bag.domain.forEach((key, index) => {
         const existing = pairs.find((pair) => valuesEqual(pair[0], key));
         if (existing) {
-          existing[1] = addCounts(Number(existing[1]), Number(bag.range[index]));
+          existing[1] = addCounts(existing[1], bag.range[index], method);
           return;
         }
         pairs.push([key, bag.range[index]]);
@@ -78,107 +121,154 @@ const mergeBags = (bags: FunctionValue[]) =>
     }, []),
   );
 
+const EMPTY_BAG = createSortedFunction([], []);
+
 export const BAGS_OPERATORS: Builtin[] = [
-  defineConstant("EmptyBag", createSortedFunction([], [])),
+  defineConstant("EmptyBag", EMPTY_BAG),
   defineOperator("IsABag", 1, (args) => {
-    const fn = toFunction(getValue(args, 0, "IsABag"));
-    return fn !== undefined && isBag(fn);
+    const functionValue = toFunction(getValue(args, 0, "IsABag"));
+    return functionValue !== undefined && isBag(functionValue);
   }),
   defineOperator("BagCardinality", 1, (args) => {
     const bag = getValue(args, 0, "BagCardinality");
-    const fn = getFunction(args, 0, "BagCardinality");
-    return checkInteger(
-      fn.range.reduce<number>((total, count) => {
-        const copies = getCount(count, "BagCardinality", bag);
-        if (copies <= 0) throw describeWrongValue("BagCardinality", "a bag", bag);
-        return addCounts(total, copies);
-      }, 0),
-    );
+    const functionValue = getFunction(args, 0, "BagCardinality");
+    return functionValue.range.reduce<number>((total, count) => {
+      if (typeof count !== "number" || count <= 0) {
+        throw createWrongValueError("BagCardinality", "a bag", bag);
+      }
+      return addCounts(total, count, BAG_CARDINALITY);
+    }, 0);
   }),
   defineOperator("BagIn", 2, (args) => {
     const bag = getValue(args, 1, "BagIn");
     const count = findCount(getFunction(args, 1, "BagIn"), getValue(args, 0, "BagIn"));
     if (count === undefined) return false;
-    if (typeof count !== "number") throw describeWrongArgument("second", "BagIn", "bag", bag);
+    if (typeof count !== "number") throw createWrongArgumentError("second", "BagIn", "bag", bag);
     return count > 0;
   }),
   defineOperator("CopiesIn", 2, (args) => {
     const bag = getValue(args, 1, "CopiesIn");
     const count = findCount(getFunction(args, 1, "CopiesIn"), getValue(args, 0, "CopiesIn"));
     if (count === undefined) return 0;
-    if (typeof count !== "number") throw describeWrongArgument("second", "CopiesIn", "bag", bag);
+    if (typeof count !== "number") throw createWrongArgumentError("second", "CopiesIn", "bag", bag);
     return count;
   }),
   defineOperator("\\oplus", 2, (args) => {
     const bags = [0, 1].map((index) => {
-      const fn = getFunction(args, index, "(+)");
-      if (!isBag(fn)) {
-        throw describeWrongArgument(
+      const functionValue = getBagArgument(args, index, "(+)");
+      if (!isBag(functionValue)) {
+        throw createWrongArgumentError(
           index === 0 ? "first" : "second",
           "(+)",
           "bag",
           getValue(args, index, "(+)"),
         );
       }
-      return fn;
+      return functionValue;
     });
-    return mergeBags(bags);
+    return mergeBags(bags, BAG_CUP);
   }),
   defineOperator("\\ominus", 2, (args) => {
-    const left = getFunction(args, 0, "(-)");
-    const right = getFunction(args, 1, "(-)");
+    const left = getBagArgument(args, 0, "(-)");
+    const right = getBagArgument(args, 1, "(-)");
     return createFunction(
       left.domain.flatMap((key, index): [Value, Value][] => {
-        const removed = findCount(right, key);
-        const count = Number(left.range[index]) - (removed === undefined ? 0 : Number(removed));
+        const count = subtractCounts(left, index, right, BAG_DIFF);
         return count > 0 ? [[key, count]] : [];
       }),
     );
   }),
   defineOperator("BagUnion", 1, (args) => {
     const set = getValue(args, 0, "BagUnion");
-    const bags = getElements(args, 0, "BagUnion").map((element) => {
-      const fn = toFunction(element);
-      if (!fn) {
-        throw new TlaEvaluationError(
+    const elements = getFiniteElements(set, () =>
+      createWrongValueError("BagUnion", "a finite enumerable set", set),
+    );
+    if (elements.length < 2) return elements[0] ?? EMPTY_BAG;
+    const bags = elements.map((element) => {
+      const functionValue = toFunction(element);
+      if (!functionValue) {
+        throw new TlaModuleError(
           `Attempted to apply BagUnion to the following set, whose\nelement is not a bag:\n${formatValue(set)}`,
         );
       }
-      return fn;
+      return functionValue;
     });
-    if (bags.length === 1) return bags[0];
-    return mergeBags(bags);
+    return mergeBags(bags, BAG_UNION);
   }),
   defineOperator("\\sqsubseteq", 2, (args) => {
     const left = getFunction(args, 0, "\\sqsubseteq");
     const right = getFunction(args, 1, "\\sqsubseteq");
-    return left.domain.every((key, index) => {
-      const count = findCount(right, key);
-      return Number(left.range[index]) - (count === undefined ? 0 : Number(count)) <= 0;
-    });
+    return left.domain.every((_, index) => subtractCounts(left, index, right, SQ_SUBSETEQ) <= 0);
   }),
   defineHigherOrderOperator("BagOfAll", 2, (args) => {
     const operator = getOperator(args, 0, "BagOfAll");
+    // TLC passes an operator whose body is a number or string literal to Bags.java as that literal.
+    if (operator.literalBody !== undefined) {
+      throw new TlaModuleError(
+        `The first argument of BagOfAll should be an operator, but instead it is:\n${formatValue(operator.literalBody)}`,
+      );
+    }
     const value = getValue(args, 1, "BagOfAll");
-    const fn = toFunction(value);
-    if (!fn) {
-      throw describeWrongArgument("second", "BagOfAll", "function with a finite domain", value);
+    const functionValue = toFunction(value);
+    if (!functionValue) {
+      throw createWrongArgumentError("second", "BagOfAll", "function with a finite domain", value);
     }
     return mergeBags(
-      fn.domain.map((key, index) =>
-        createSortedFunction([operator.call([key])], [fn.range[index]]),
+      functionValue.domain.map((key, index) =>
+        createSortedFunction([operator.call([key])], [functionValue.range[index]]),
       ),
+      BAG_OF_ALL,
     );
   }),
   defineOperator("SubBag", 1, (args) => {
-    getFunction(args, 0, "SubBag");
-    throw new TlaEvaluationError("SubBag is not implemented.");
+    const value = getValue(args, 0, "SubBag");
+    if (!isFunctionValue(value)) {
+      throw new TlaEvaluationError(`DOMAIN expects a function but received ${formatValue(value)}`);
+    }
+    const functionValue = toFiniteFunction(value);
+    const range = createSet(functionValue.range).elements;
+    const invalid = range.find((count) => typeof count !== "number");
+    if (invalid !== undefined) {
+      const isFirst = typeof range[0] !== "number";
+      throw new TlaEvaluationError(
+        `The ${isFirst ? "first" : "second"} argument of >= should be an integer, but instead it is:\n${formatValue(isFirst ? range[0] : invalid)}`,
+      );
+    }
+    const counts = functionValue.range.filter((count) => typeof count === "number");
+    if (counts.some((count) => count < 1)) {
+      throw new TlaEvaluationError(
+        `Attempted to apply a function to ${formatValue(functionValue)}, which is not in its domain`,
+      );
+    }
+    return createSet(
+      functionValue.domain
+        .reduce<[Value, Value][][]>(
+          (subBags, key, index) =>
+            subBags.flatMap((entries) => [
+              entries,
+              ...Array.from({ length: counts[index] }, (_, copies): [Value, Value][] => [
+                ...entries,
+                [key, copies + 1],
+              ]),
+            ]),
+          [[]],
+        )
+        .map((entries) =>
+          createSortedFunction(
+            entries.map((entry) => entry[0]),
+            entries.map((entry) => entry[1]),
+          ),
+        ),
+    );
   }),
-  defineOperator("BagToSet", 1, (args) => createSortedSet(getFunction(args, 0, "BagToSet").domain)),
+  defineOperator("BagToSet", 1, (args) => getDomain(getFunction(args, 0, "BagToSet"))),
   defineOperator("SetToBag", 1, (args) => {
-    const elements = getElements(args, 0, "SetToBag");
+    const set = getValue(args, 0, "SetToBag");
+    const elements = getFiniteElements(set, () =>
+      createWrongValueError("BagToSet", "a function with a finite domain", set),
+    );
     return createSortedFunction(
-      elements,
+      [...elements],
       elements.map(() => 1),
     );
   }),