plan-verify 0.0.0-stage → 0.1.0

package/src/spec.ts

@@ -0,0 +1,307 @@
+/**
+ * Declared vocabulary of an EARS spec.
+ * Events and states are booleans. Inputs and outputs are Bool, Int, or enum.
+ * Every Int has an inclusive range so the solver's domain is finite.
+ */
+
+import { formatInt, replaceWord } from "./text.ts";
+
+export type Role = "event" | "state" | "input" | "output";
+
+export type Sort =
+  | { kind: "bool" }
+  | { kind: "int"; min: number; max: number }
+  | { kind: "enum"; enumName: string };
+
+export interface EnumDecl {
+  name: string;
+  variants: string[];
+  line: number;
+}
+
+export interface SymbolDecl {
+  role: Role;
+  name: string;
+  sort: Sort;
+  description: string;
+  /** Plain words that stand for this symbol in a requirement. Empty means the name is used. */
+  phrase: string;
+  /** How a report states this Bool when it is true. Empty means the phrase is used. */
+  outcomeYes: string;
+  /** How a report states this Bool when it is false. Empty means it is derived. */
+  outcomeNo: string;
+  /** Verb words that also name this Bool, such as "start the subscription". */
+  action: string;
+  /** Report template for an Int or enum. `{value}` stands for the number or variant. */
+  says: string;
+  /** Requirement pattern for an Int or enum. `{value}` and `{op}` are holes. */
+  asText: string;
+  unwanted: boolean;
+  line: number;
+  source: string;
+}
+
+export interface Requirement {
+  id: string;
+  line: number;
+  sentence: string;
+  system: string;
+  antecedent: Term | null;
+  consequent: Term;
+  hasWhen: boolean;
+  hasIf: boolean;
+  whenTerm: Term | null;
+}
+
+export interface Spec {
+  enums: EnumDecl[];
+  symbols: SymbolDecl[];
+  requirements: Requirement[];
+}
+
+/**
+ * Predicate terms. Sorts are checked when the spec is parsed, so a term
+ * that reaches the solver is boolean, integer, or an enum value of one type.
+ */
+export type Term =
+  | { kind: "bool"; value: boolean }
+  | { kind: "int"; value: number }
+  | { kind: "enum"; enumName: string; variant: string; index: number }
+  | { kind: "sym"; name: string; index: number; phrase: string }
+  | { kind: "not"; term: Term }
+  | { kind: "and"; left: Term; right: Term }
+  | { kind: "or"; left: Term; right: Term }
+  | { kind: "eq"; left: Term; right: Term }
+  | { kind: "neq"; left: Term; right: Term }
+  | { kind: "lt"; left: Term; right: Term }
+  | { kind: "le"; left: Term; right: Term }
+  | { kind: "gt"; left: Term; right: Term }
+  | { kind: "ge"; left: Term; right: Term }
+  | { kind: "add"; left: Term; right: Term }
+  | { kind: "sub"; left: Term; right: Term };
+
+export function findSymbol(spec: Spec, name: string): number {
+  for (let i = 0; i < spec.symbols.length; i++) {
+    if (spec.symbols[i].name === name) return i;
+  }
+  return -1;
+}
+
+export function findEnum(spec: Spec, name: string): EnumDecl | null {
+  for (let i = 0; i < spec.enums.length; i++) {
+    if (spec.enums[i].name === name) return spec.enums[i];
+  }
+  return null;
+}
+
+export function findVariant(spec: Spec, variant: string): { enumName: string; index: number } | null {
+  for (let i = 0; i < spec.enums.length; i++) {
+    const decl = spec.enums[i];
+    for (let v = 0; v < decl.variants.length; v++) {
+      if (decl.variants[v] === variant) return { enumName: decl.name, index: v };
+    }
+  }
+  return null;
+}
+
+export function isDriver(sym: SymbolDecl): boolean {
+  return sym.role !== "output";
+}
+
+export function domainSize(spec: Spec, sym: SymbolDecl): number {
+  if (sym.sort.kind === "bool") return 2;
+  if (sym.sort.kind === "int") return sym.sort.max - sym.sort.min + 1;
+  const decl = findEnum(spec, sym.sort.enumName);
+  if (decl === null) return 0;
+  return decl.variants.length;
+}
+
+export function codeAt(sym: SymbolDecl, domainIndex: number): number {
+  if (sym.sort.kind === "int") return sym.sort.min + domainIndex;
+  return domainIndex;
+}
+
+export function displayCode(spec: Spec, sym: SymbolDecl, code: number): string {
+  if (sym.sort.kind === "bool") return code === 1 ? "true" : "false";
+  if (sym.sort.kind === "int") return String(Math.trunc(code));
+  const decl = findEnum(spec, sym.sort.enumName);
+  if (decl === null) return "?";
+  if (code < 0 || code >= decl.variants.length) return "?";
+  return decl.variants[code];
+}
+
+/**
+ * How a report names one assigned symbol.
+ * A Bool uses its outcome when one is declared. Otherwise a phrase that
+ * contains "is" is stated with "was" or "was not", and any other phrase
+ * stays as written, with "not" in front when the Bool is false.
+ * An integer or enum uses `says` when that template is declared.
+ * Otherwise a singular integer reads "the quantity was 12", and a plural
+ * or an enum reads "were set to" or "was set to".
+ */
+export function describeAssignment(sym: SymbolDecl, shown: string, isTrue: boolean): string {
+  if (sym.sort.kind === "bool") return reportBool(sym, isTrue);
+  return speakBound(sym, shown, "eq", false);
+}
+
+/**
+ * How a report states an integer or enum comparison.
+ * `linked` means the right side is another phrase, so a numeric `says`
+ * template is left unused. `rel` is eq, neq, lt, le, gt, or ge.
+ */
+export function speakBound(sym: SymbolDecl, shown: string, rel: string, linked: boolean): string {
+  if (!linked && sym.says.length > 0) return speakSays(sym, shown, rel);
+  const name = sym.phrase.length > 0 ? sym.phrase : sym.name;
+  const be = copulaOf(name);
+  if (linked) return name + " " + be + " " + linkedTail(rel, shown);
+  if (rel === "eq") {
+    if (sym.sort.kind === "enum" || pluralNoun(name)) return name + " " + be + " set to " + shown;
+    return name + " " + be + " " + shown;
+  }
+  if (rel === "neq") {
+    if (sym.sort.kind === "enum" || pluralNoun(name)) return name + " " + be + " not set to " + shown;
+    return name + " " + be + " not " + shown;
+  }
+  return name + " " + be + " " + relationTail(rel, shown);
+}
+
+/** The number or variant on the right of a comparison, or empty when it is not a literal. */
+export function literalShown(term: Term): string {
+  if (term.kind === "int") return formatInt(term.value);
+  if (term.kind === "enum") return term.variant;
+  return "";
+}
+
+/** How a report states a Bool. */
+export function reportBool(sym: SymbolDecl, isTrue: boolean): string {
+  if (isTrue && sym.outcomeYes.length > 0) return sym.outcomeYes;
+  if (!isTrue && sym.outcomeNo.length > 0) return sym.outcomeNo;
+  if (!isTrue && sym.outcomeYes.length > 0) return negateReport(sym.outcomeYes);
+  if (sym.phrase.length === 0) return sym.name + " is " + (isTrue ? "true" : "false");
+  if (hasWord(sym.phrase, "is")) {
+    if (isTrue) return replaceWord(sym.phrase, "is", "was");
+    return replaceWord(sym.phrase, "is", "was not");
+  }
+  if (isTrue) return sym.phrase;
+  return "not " + sym.phrase;
+}
+
+/** Insert "not" after the first "was", "were", or "is", or prefix "not" when none is there. */
+export function negateReport(text: string): string {
+  const afterWas = insertNotAfter(text, "was");
+  if (afterWas.length > 0) return afterWas;
+  const afterWere = insertNotAfter(text, "were");
+  if (afterWere.length > 0) return afterWere;
+  const afterIs = insertNotAfter(text, "is");
+  if (afterIs.length > 0) return afterIs;
+  return "not " + text;
+}
+
+function speakSays(sym: SymbolDecl, shown: string, rel: string): string {
+  const filled = fillTemplate(sym.says, shown, sym.name);
+  if (rel === "eq") return filled;
+  if (rel === "neq") return negateReport(filled);
+  if (rel === "le") return "at most " + filled;
+  if (rel === "ge") return "at least " + filled;
+  if (rel === "lt") return "less than " + filled;
+  if (rel === "gt") return "greater than " + filled;
+  return filled;
+}
+
+function fillTemplate(template: string, shown: string, symbolName: string): string {
+  let text = replaceToken(template, "{value}", shown);
+  text = replaceToken(text, "{name}", shown);
+  text = replaceToken(text, "{" + symbolName + "}", shown);
+  return text;
+}
+
+function replaceToken(text: string, token: string, shown: string): string {
+  let out = "";
+  let i = 0;
+  while (i < text.length) {
+    if (text.slice(i, i + token.length) === token) {
+      out += shown;
+      i += token.length;
+      continue;
+    }
+    out += text.slice(i, i + 1);
+    i++;
+  }
+  return out;
+}
+
+function linkedTail(rel: string, shown: string): string {
+  if (rel === "neq") return "not " + shown;
+  return relationTail(rel, shown);
+}
+
+function relationTail(rel: string, shown: string): string {
+  if (rel === "le") return "at most " + shown;
+  if (rel === "ge") return "at least " + shown;
+  if (rel === "lt") return "less than " + shown;
+  if (rel === "gt") return "greater than " + shown;
+  return shown;
+}
+
+function copulaOf(phrase: string): string {
+  if (pluralNoun(phrase)) return "were";
+  return "was";
+}
+
+function pluralNoun(phrase: string): boolean {
+  const last = lowerLast(phrase);
+  if (last.length === 0) return false;
+  if (last === "status" || last === "is" || last === "bus") return false;
+  if (last.length >= 2 && last.slice(last.length - 2) === "ss") return false;
+  if (last.length >= 4 && last.slice(last.length - 4) === "ness") return false;
+  return last.slice(last.length - 1) === "s";
+}
+
+function lowerLast(phrase: string): string {
+  let start = 0;
+  for (let i = 0; i < phrase.length; i++) {
+    if (phrase.charCodeAt(i) === 32) start = i + 1;
+  }
+  let out = "";
+  for (let i = start; i < phrase.length; i++) {
+    const code = phrase.charCodeAt(i);
+    if (code >= 65 && code <= 90) out += String.fromCharCode(code + 32);
+    else out += phrase.slice(i, i + 1);
+  }
+  return out;
+}
+
+function insertNotAfter(text: string, word: string): string {
+  const changed = replaceWord(text, word, word + " not");
+  if (changed === text) return "";
+  return changed;
+}
+
+function hasWord(text: string, word: string): boolean {
+  return replaceWord(text, word, word + "\u0001") !== text;
+}
+
+export function termMentions(term: Term, index: number): boolean {
+  if (term.kind === "sym") return term.index === index;
+  if (term.kind === "not") return termMentions(term.term, index);
+  if (
+    term.kind === "and" ||
+    term.kind === "or" ||
+    term.kind === "eq" ||
+    term.kind === "neq" ||
+    term.kind === "lt" ||
+    term.kind === "le" ||
+    term.kind === "gt" ||
+    term.kind === "ge" ||
+    term.kind === "add" ||
+    term.kind === "sub"
+  ) {
+    return termMentions(term.left, index) || termMentions(term.right, index);
+  }
+  return false;
+}
+
+export function requirementMentions(req: Requirement, index: number): boolean {
+  if (req.antecedent !== null && termMentions(req.antecedent, index)) return true;
+  return termMentions(req.consequent, index);
+}

package/src/term.ts

@@ -0,0 +1,331 @@
+/**
+ * Evaluation and printing for predicate terms.
+ * Partial assignments use three-valued logic: an assertion is pruned only
+ * when it is forced false, which keeps the search sound.
+ */
+
+import { findEnum, type Spec, type SymbolDecl, type Term } from "./spec.ts";
+import { formatInt, formatSmtInt } from "./text.ts";
+
+export const T_FALSE = 0;
+export const T_TRUE = 1;
+export const T_UNKNOWN = 2;
+
+export class Binding {
+  known: boolean[];
+  code: number[];
+
+  constructor(n: number) {
+    this.known = [];
+    this.code = [];
+    for (let i = 0; i < n; i++) {
+      this.known.push(false);
+      this.code.push(0);
+    }
+  }
+
+  copy(): Binding {
+    const next = new Binding(this.code.length);
+    for (let i = 0; i < this.code.length; i++) {
+      next.known[i] = this.known[i];
+      next.code[i] = this.code[i];
+    }
+    return next;
+  }
+}
+
+interface Value {
+  known: boolean;
+  kind: string;
+  code: number;
+}
+
+function unknownValue(): Value {
+  return { known: false, kind: "", code: 0 };
+}
+
+function knownValue(kind: string, code: number): Value {
+  return { known: true, kind: kind, code: code };
+}
+
+export function evalBool(term: Term, spec: Spec, env: Binding): number {
+  if (term.kind === "bool") return term.value ? T_TRUE : T_FALSE;
+  if (term.kind === "sym") {
+    if (!env.known[term.index]) return T_UNKNOWN;
+    const sym = spec.symbols[term.index];
+    if (sym.sort.kind !== "bool") return T_UNKNOWN;
+    return env.code[term.index] === 1 ? T_TRUE : T_FALSE;
+  }
+  if (term.kind === "not") {
+    const inner = evalBool(term.term, spec, env);
+    if (inner === T_UNKNOWN) return T_UNKNOWN;
+    return inner === T_TRUE ? T_FALSE : T_TRUE;
+  }
+  if (term.kind === "and") {
+    const left = evalBool(term.left, spec, env);
+    const right = evalBool(term.right, spec, env);
+    if (left === T_FALSE || right === T_FALSE) return T_FALSE;
+    if (left === T_TRUE && right === T_TRUE) return T_TRUE;
+    return T_UNKNOWN;
+  }
+  if (term.kind === "or") {
+    const left = evalBool(term.left, spec, env);
+    const right = evalBool(term.right, spec, env);
+    if (left === T_TRUE || right === T_TRUE) return T_TRUE;
+    if (left === T_FALSE && right === T_FALSE) return T_FALSE;
+    return T_UNKNOWN;
+  }
+  if (
+    term.kind === "eq" ||
+    term.kind === "neq" ||
+    term.kind === "lt" ||
+    term.kind === "le" ||
+    term.kind === "gt" ||
+    term.kind === "ge"
+  ) {
+    return evalCmp(term, spec, env);
+  }
+  return T_UNKNOWN;
+}
+
+function evalCmp(term: Term, spec: Spec, env: Binding): number {
+  if (
+    term.kind !== "eq" &&
+    term.kind !== "neq" &&
+    term.kind !== "lt" &&
+    term.kind !== "le" &&
+    term.kind !== "gt" &&
+    term.kind !== "ge"
+  ) {
+    return T_UNKNOWN;
+  }
+  const left = evalValue(term.left, spec, env);
+  const right = evalValue(term.right, spec, env);
+  if (!left.known || !right.known) return T_UNKNOWN;
+  if (left.kind !== right.kind) return T_UNKNOWN;
+  const eq = left.code === right.code;
+  if (term.kind === "eq") return eq ? T_TRUE : T_FALSE;
+  if (term.kind === "neq") return eq ? T_FALSE : T_TRUE;
+  if (left.kind !== "int") return T_UNKNOWN;
+  if (term.kind === "lt") return left.code < right.code ? T_TRUE : T_FALSE;
+  if (term.kind === "le") return left.code <= right.code ? T_TRUE : T_FALSE;
+  if (term.kind === "gt") return left.code > right.code ? T_TRUE : T_FALSE;
+  return left.code >= right.code ? T_TRUE : T_FALSE;
+}
+
+function evalValue(term: Term, spec: Spec, env: Binding): Value {
+  if (term.kind === "bool") return knownValue("bool", term.value ? 1 : 0);
+  if (term.kind === "int") return knownValue("int", term.value);
+  if (term.kind === "enum") return knownValue("enum:" + term.enumName, term.index);
+  if (term.kind === "sym") {
+    if (!env.known[term.index]) return unknownValue();
+    const sym = spec.symbols[term.index];
+    if (sym.sort.kind === "bool") return knownValue("bool", env.code[term.index] === 1 ? 1 : 0);
+    if (sym.sort.kind === "int") return knownValue("int", env.code[term.index]);
+    return knownValue("enum:" + sym.sort.enumName, env.code[term.index]);
+  }
+  if (term.kind === "add" || term.kind === "sub") {
+    const left = evalValue(term.left, spec, env);
+    const right = evalValue(term.right, spec, env);
+    if (!left.known || !right.known) return unknownValue();
+    if (left.kind !== "int" || right.kind !== "int") return unknownValue();
+    const code = term.kind === "add" ? left.code + right.code : left.code - right.code;
+    return knownValue("int", code);
+  }
+  return unknownValue();
+}
+
+export function evalAssertion(antecedent: Term | null, consequent: Term, spec: Spec, env: Binding): number {
+  const guard = antecedent === null ? T_TRUE : evalBool(antecedent, spec, env);
+  if (guard === T_FALSE) return T_TRUE;
+  const body = evalBool(consequent, spec, env);
+  if (body === T_TRUE) return T_TRUE;
+  if (guard === T_TRUE && body === T_FALSE) return T_FALSE;
+  return T_UNKNOWN;
+}
+
+function isSimple(term: Term): boolean {
+  return term.kind === "bool" || term.kind === "int" || term.kind === "enum" || term.kind === "sym";
+}
+
+export function formatTerm(term: Term): string {
+  if (term.kind === "bool") return term.value ? "true" : "false";
+  if (term.kind === "int") return formatInt(term.value);
+  if (term.kind === "enum") return term.variant;
+  if (term.kind === "sym") {
+    if (term.phrase.length > 0) return term.phrase;
+    return term.name;
+  }
+  if (term.kind === "not") {
+    if (isSimple(term.term)) return "not " + formatTerm(term.term);
+    return "not (" + formatTerm(term.term) + ")";
+  }
+  if (term.kind === "and") return formatSide(term.left, "and", true) + " and " + formatSide(term.right, "and", false);
+  if (term.kind === "or") return formatSide(term.left, "or", true) + " or " + formatSide(term.right, "or", false);
+  if (term.kind === "add") return formatSide(term.left, "add", true) + " + " + formatSide(term.right, "add", false);
+  if (term.kind === "sub") return formatSide(term.left, "add", true) + " - " + formatSide(term.right, "add", false);
+  return formatSide(term.left, "add", true) + " " + comparisonWord(term) + " " + formatSide(term.right, "add", true);
+}
+
+function comparisonWord(term: Term): string {
+  if (
+    term.kind !== "eq" &&
+    term.kind !== "neq" &&
+    term.kind !== "lt" &&
+    term.kind !== "le" &&
+    term.kind !== "gt" &&
+    term.kind !== "ge"
+  ) {
+    return "?";
+  }
+  if (term.left.kind === "sym" && term.left.phrase.length > 0) {
+    if (term.kind === "eq") return "is";
+    if (term.kind === "neq") return "is not";
+    if (term.kind === "lt") return "is less than";
+    if (term.kind === "le") return "is at most";
+    if (term.kind === "gt") return "is greater than";
+    return "is at least";
+  }
+  return cmpOp(term);
+}
+
+function formatSide(term: Term, parent: string, isLeft: boolean): string {
+  if (needsParen(term, parent, isLeft)) return "(" + formatTerm(term) + ")";
+  return formatTerm(term);
+}
+
+function needsParen(term: Term, parent: string, isLeft: boolean): boolean {
+  if (parent === "or") return term.kind === "or" && !isLeft;
+  if (parent === "and") return term.kind === "or" || (term.kind === "and" && !isLeft);
+  if (parent === "add") {
+    if (term.kind === "or" || term.kind === "and" || term.kind === "not") return true;
+    if (term.kind === "eq" || term.kind === "neq" || term.kind === "lt" || term.kind === "le" || term.kind === "gt" || term.kind === "ge") {
+      return true;
+    }
+    if ((term.kind === "add" || term.kind === "sub") && !isLeft) return true;
+  }
+  return false;
+}
+
+function cmpOp(term: Term): string {
+  if (term.kind === "eq") return "=";
+  if (term.kind === "neq") return "!=";
+  if (term.kind === "lt") return "<";
+  if (term.kind === "le") return "<=";
+  if (term.kind === "gt") return ">";
+  if (term.kind === "ge") return ">=";
+  return "?";
+}
+
+export function formatSmtTerm(term: Term): string {
+  if (term.kind === "bool") return term.value ? "true" : "false";
+  if (term.kind === "int") return formatSmtInt(term.value);
+  if (term.kind === "enum") return term.variant;
+  if (term.kind === "sym") return term.name;
+  if (term.kind === "not") return "(not " + formatSmtTerm(term.term) + ")";
+  if (term.kind === "and") return "(and " + formatSmtTerm(term.left) + " " + formatSmtTerm(term.right) + ")";
+  if (term.kind === "or") return "(or " + formatSmtTerm(term.left) + " " + formatSmtTerm(term.right) + ")";
+  if (term.kind === "eq") return "(= " + formatSmtTerm(term.left) + " " + formatSmtTerm(term.right) + ")";
+  if (term.kind === "neq") return "(not (= " + formatSmtTerm(term.left) + " " + formatSmtTerm(term.right) + "))";
+  if (term.kind === "lt") return "(< " + formatSmtTerm(term.left) + " " + formatSmtTerm(term.right) + ")";
+  if (term.kind === "le") return "(<= " + formatSmtTerm(term.left) + " " + formatSmtTerm(term.right) + ")";
+  if (term.kind === "gt") return "(> " + formatSmtTerm(term.left) + " " + formatSmtTerm(term.right) + ")";
+  if (term.kind === "ge") return "(>= " + formatSmtTerm(term.left) + " " + formatSmtTerm(term.right) + ")";
+  if (term.kind === "add") return "(+ " + formatSmtTerm(term.left) + " " + formatSmtTerm(term.right) + ")";
+  return "(- " + formatSmtTerm(term.left) + " " + formatSmtTerm(term.right) + ")";
+}
+
+export function formatScenario(spec: Spec, env: Binding): string {
+  const lines: string[] = [];
+  lines.push("{");
+  for (let i = 0; i < spec.symbols.length; i++) {
+    const sym = spec.symbols[i];
+    const comma = i + 1 < spec.symbols.length ? "," : "";
+    lines.push("  \"" + sym.name + "\": " + jsonLiteral(spec, sym, env.code[i]) + comma);
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+
+function jsonLiteral(spec: Spec, sym: SymbolDecl, code: number): string {
+  if (sym.sort.kind === "bool") return code === 1 ? "true" : "false";
+  if (sym.sort.kind === "int") return formatInt(code);
+  const decl = findEnum(spec, sym.sort.enumName);
+  const variant = decl === null || code < 0 || code >= decl.variants.length ? "?" : decl.variants[code];
+  return "\"" + variant + "\"";
+}
+
+export function mentionedIndexes(antecedent: Term | null, consequent: Term): number[] {
+  const found: number[] = [];
+  if (antecedent !== null) collectIndexes(antecedent, found);
+  collectIndexes(consequent, found);
+  const ordered: number[] = [];
+  for (let i = 0; i < found.length; i++) {
+    let seen = false;
+    for (let j = 0; j < ordered.length; j++) {
+      if (ordered[j] === found[i]) seen = true;
+    }
+    if (!seen) ordered.push(found[i]);
+  }
+  const sorted: number[] = [];
+  for (let i = 0; i < ordered.length; i++) sorted.push(ordered[i]);
+  for (let i = 0; i < sorted.length; i++) {
+    for (let j = i + 1; j < sorted.length; j++) {
+      if (sorted[j] < sorted[i]) {
+        const tmp = sorted[i];
+        sorted[i] = sorted[j];
+        sorted[j] = tmp;
+      }
+    }
+  }
+  return sorted;
+}
+
+export function termsEqual(left: Term, right: Term): boolean {
+  if (left.kind === "bool" && right.kind === "bool") return left.value === right.value;
+  if (left.kind === "int" && right.kind === "int") return left.value === right.value;
+  if (left.kind === "enum" && right.kind === "enum") return left.enumName === right.enumName && left.index === right.index;
+  if (left.kind === "sym" && right.kind === "sym") return left.index === right.index;
+  if (left.kind === "not" && right.kind === "not") return termsEqual(left.term, right.term);
+  if (left.kind === "and" && right.kind === "and") return termsSamePair(left.left, left.right, right.left, right.right);
+  if (left.kind === "or" && right.kind === "or") return termsSamePair(left.left, left.right, right.left, right.right);
+  if (left.kind === "eq" && right.kind === "eq") return termsSamePair(left.left, left.right, right.left, right.right);
+  if (left.kind === "neq" && right.kind === "neq") return termsSamePair(left.left, left.right, right.left, right.right);
+  if (left.kind === "lt" && right.kind === "lt") return termsSamePair(left.left, left.right, right.left, right.right);
+  if (left.kind === "le" && right.kind === "le") return termsSamePair(left.left, left.right, right.left, right.right);
+  if (left.kind === "gt" && right.kind === "gt") return termsSamePair(left.left, left.right, right.left, right.right);
+  if (left.kind === "ge" && right.kind === "ge") return termsSamePair(left.left, left.right, right.left, right.right);
+  if (left.kind === "add" && right.kind === "add") return termsSamePair(left.left, left.right, right.left, right.right);
+  if (left.kind === "sub" && right.kind === "sub") return termsSamePair(left.left, left.right, right.left, right.right);
+  return false;
+}
+
+function termsSamePair(a: Term, b: Term, c: Term, d: Term): boolean {
+  return termsEqual(a, c) && termsEqual(b, d);
+}
+
+function collectIndexes(term: Term, found: number[]): void {
+  if (term.kind === "sym") {
+    found.push(term.index);
+    return;
+  }
+  if (term.kind === "not") {
+    collectIndexes(term.term, found);
+    return;
+  }
+  if (
+    term.kind === "and" ||
+    term.kind === "or" ||
+    term.kind === "eq" ||
+    term.kind === "neq" ||
+    term.kind === "lt" ||
+    term.kind === "le" ||
+    term.kind === "gt" ||
+    term.kind === "ge" ||
+    term.kind === "add" ||
+    term.kind === "sub"
+  ) {
+    collectIndexes(term.left, found);
+    collectIndexes(term.right, found);
+  }
+}