occam-verify-cli 1.0.444 → 1.0.448

package/src/element/subproof.js

@@ -22,28 +22,28 @@ export default define(class Subproof extends Element {
     return this.subDerivation;
   }
 
-  getLastStep() { return this.subDerivation.getLastStep(); }
+  getLastProofAssertion() { return this.subDerivation.getLastProofAssertion(); }
 
   getStatements() {
-    const lastStep = this.getLastStep(),
+    const lastProofAssertion = this.getLastProofAssertion(),
           suppositionStatements = this.suppositions.map((supposition) => {
             const suppositionStatement = supposition.getStatement();
 
             return suppositionStatement;
           }),
-          lastStepStatement = lastStep.getStatement(),
+          lastProofAssertionStatement = lastProofAssertion.getStatement(),
           statements = [
             ...suppositionStatements,
-            lastStepStatement
+            lastProofAssertionStatement
           ];
 
     return statements;
   }
 
-  isStep() {
-    const sStep = false;
+  isProofAssertion() {
+    const proofAssertion = false;
 
-    return sStep;
+    return proofAssertion;
   }
 
   verify(substitutions, assignments, context) {

package/src/element/supposition.js

@@ -1,25 +1,19 @@
 "use strict";
 
-import Element from "../element";
-import elements from "../elements";
+import ProofAssertion from "./proofAssertion";
 import TemporaryContext from "../context/temporary";
 import assignAssignments from "../process/assign";
 
 import { define } from "../elements";
 import { termsFromJSON, framesFromJSON, statementFromJSON, procedureCallFromJSON, termsToTermsJSON, framesToFramesJSON, statementToStatementJSON, procedureCallToProcedureCallJSON } from "../utilities/json";
 
-export default define(class Supposition extends Element {
+export default define(class Supposition extends ProofAssertion {
   constructor(context, string, node, statement, procedureCall) {
     super(context, string, node);
 
-    this.statement = statement;
     this.procedureCall = procedureCall;
   }
 
-  getStatement() {
-    return this.statement;
-  }
-
   getProcedureCall() {
     return this.procedureCall;
   }
@@ -36,23 +30,23 @@ export default define(class Supposition extends Element {
 
     context.trace(`Verifying the '${suppositionString}' supposition...`, node);
 
-    if ((this.statement === null) && (this.procedureCall === null)) {
+    const statement = this.getStatement();
+
+    if ((statement === null) && (this.procedureCall === null)) {
       context.debug(`Unable to verify the '${suppositionString}' supposition because it is nonsense.`, node);
     } else {
-      if (this.statement !== null) {
+      if (statement !== null) {
         const stated = true,
               assignments = [],
-              statementValidates = this.statement.validate(assignments, stated, context);
+              statementValidates = statement.validate(assignments, stated, context);
 
         if (statementValidates) {
           const assignmentsAssigned = assignAssignments(assignments, context);
 
           if (assignmentsAssigned) {
-            const { Step } = elements,
-                  step = Step.fromStatement(this.statement, context),
-                  stepOrSubproof = step;  ///
+            const subproofOrProofAssertion = this;  ///
 
-            context.addStepOrSubproof(stepOrSubproof);
+            context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
             verifies = true;
           }
@@ -95,8 +89,10 @@ export default define(class Supposition extends Element {
 
     context = specificContext;  ///
 
-    if (this.statement !== null) {
-      const statementUnifiesIndependently = this.statement.unifyIndependently(substitutions, generalContext, specificContext);
+    const statement = this.getStatement();
+
+    if (statement !== null) {
+      const statementUnifiesIndependently = statement.unifyIndependently(substitutions, generalContext, specificContext);
 
       if (statementUnifiesIndependently) {
         unifiesIndependently = true;
@@ -118,113 +114,118 @@ export default define(class Supposition extends Element {
     return unifiesIndependently;
   }
 
-  unifyStepOrSubproof(stepOrSubproof, substitutions, context) {
-    let stepOrSubproofUnifies = false;
+  unifySubproofOrProosAssertion(subproofOrProofAssertion, substitutions, context) {
+    let subproofOrProofAssertionUnifies = false;
 
-    const stepOrSubProofStep = stepOrSubproof.isStep(),
-          subproof = stepOrSubProofStep ?
+    const subproofOrProofAssertionProofAssertion = subproofOrProofAssertion.isProofAssertion(),
+          subproof = subproofOrProofAssertionProofAssertion ?
                         null :
-                          stepOrSubproof,
-          step = stepOrSubProofStep ?
-                   stepOrSubproof :
-                     null;
+                          subproofOrProofAssertion,
+          proofAssertion = subproofOrProofAssertionProofAssertion ?
+                             subproofOrProofAssertion :
+                               null;
 
     substitutions.snapshot();
 
     if (subproof !== null) {
       const subproofUnifies = this.unifySubproof(subproof, substitutions, context);
 
-      stepOrSubproofUnifies = subproofUnifies; ///
+      if (subproofUnifies) {
+        subproofOrProofAssertionUnifies = true;
+      }
     }
 
-    if (step !== null) {
-      const statementUnifies = this.unifyStep(step, substitutions, context);
+    if (proofAssertion !== null) {
+      const proofAssertionUnifies = this.unifyProofAssertion(proofAssertion, substitutions, context);
 
-      stepOrSubproofUnifies = statementUnifies;  ///
+      if (proofAssertionUnifies) {
+        subproofOrProofAssertionUnifies = true;
+      }
     }
 
-    if (stepOrSubproofUnifies) {
+    if (subproofOrProofAssertionUnifies) {
       substitutions.resolve(context);
     }
 
-    stepOrSubproofUnifies ?
+    subproofOrProofAssertionUnifies ?
       substitutions.continue() :
         substitutions.rollback(context);
 
-    return stepOrSubproofUnifies;
+    return subproofOrProofAssertionUnifies;
   }
 
-  unifySubproof(subproof, substitutions, context) {
-    let subproofUnifies = false;
+  unifyProofAssertion(proofAssertion, substitutions, context) {
+    let stepUnifies = false;
 
-    const supposition = this, ///
-          subproofString = subproof.getString(),
-          suppositionStatement = supposition.getStatement(),
-          suppositionStatementString = suppositionStatement.getString();
+    const node = this.getNode(),
+          suppositionString = this.getString(),
+          proofAssertionString = proofAssertion.getString();
 
-    context.trace(`Unifying the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement...`);
+    context.trace(`Unifying the '${proofAssertionString}' proof assertion with the '${suppositionString}' supposition...`, node);
 
     const specificContext = context;  ///
 
     context = this.getContext();
 
-    const generalContext = context;  ///
+    const generalContext = context; ///
 
     context = specificContext;  ///
 
-    if (this.statement !== null) {
-      const node = this.getNode(),
-            assertionNode = node, /// 
-            assertion = context.findAssertionByAssertionNode(assertionNode);
-
-      if (assertion !== null) {}
+    const statement = proofAssertion.getStatement(),
+          statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
 
-      if (subproofAssertion !== null) {
-        subproofUnifies = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);
-      }
+    if (statementUnifies) {
+      stepUnifies = true;
     }
 
-    if (subproofUnifies) {
-      context.debug(`...unified the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement.`);
+    if (stepUnifies) {
+      context.debug(`...unified the '${proofAssertionString}' proof assertion with the '${suppositionString}' supposition.`, node);
     }
 
-    return subproofUnifies;
+    return stepUnifies;
   }
 
-  unifyStep(step, substitutions, context) {
-    let stepUnifies;
+  unifySubproof(subproof, substitutions, context) {
+    let subproofUnifies = false;
 
-    context = step.getContext();
+    const node = this.getNode(),
+          subproofString = subproof.getString(),
+          suppositionString = this.getString();
 
-    const statement = step.getStatement(),
-          statementUnifies = this.unifyStatement(statement, substitutions, context);
+    context.trace(`Unifying the '${subproofString}' subproof with the '${suppositionString}' supposition...`, node);
 
-    stepUnifies = statementUnifies;  ///
+    const specificContext = context;  ///
 
-    return stepUnifies;
-  }
+    context = this.getContext();
 
-  unifyStatement(statement, substitutions, context) {
-    let statementUnifies;
+    const generalContext = context; ///
 
-    const supposition = this, ///
-          statementString = statement.getString(),
-          suppositionString = supposition.getString();
+    context = specificContext;  ///
+
+    const statement = this.getStatement();
 
-    context.trace(`Unifying the '${statementString}' statement with the '${suppositionString}' supposition...`);
+    if (statement !== null) {
+      const statementNode = statement.getNode(),
+            subproofAssertionNode = statementNode.getSubproofAssertionNode();
 
-    if (this.statement !== null) {
-      const generalContext = this.context,  ///
-            specificContext = context;  ///
+      if (subproofAssertionNode !== null) {
+        const context = generalContext, ///
+              assertionNode = subproofAssertionNode,  ///
+              assertion = context.findAssertionByAssertionNode(assertionNode)
 
-      statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
+        if (assertion !== null) {
+          const subproofAssertion = assertion;  ///
+
+          subproofUnifies = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);
+        }
+      }
     }
 
-    if (statementUnifies) {
-      context.debug(`...unified the '${statementString}' statement with the '${suppositionString}' supposition.`);
+    if (subproofUnifies) {
+      context.debug(`...unified the '${subproofString}' subproof with the '${suppositionString}' supposition.`, node);
     }
 
-    return statementUnifies;
+    return subproofUnifies;
   }
 
   unifySupposition(supposition, substitutions, generalContext, specificContext) {

package/src/metaTypes.js

@@ -8,6 +8,19 @@ let frameMetaType = null,
     referenceMetaType = null,
     statementMetaType = null;
 
+export function getMetaTypes() {
+  const frameMetaType = frameMetaTypeFromNothing(),
+        referenceMetaType = referenceMetaTypeFromNothing(),
+        statementMetaType = statementMetaTypeFromNothing(),
+        metaTypes = [
+          frameMetaType,
+          referenceMetaType,
+          statementMetaType
+        ];
+
+  return metaTypes;
+}
+
 export function frameMetaTypeFromNothing() {
   if (frameMetaType === null) {
     const { MetaType } = elements,
@@ -19,24 +32,24 @@ export function frameMetaTypeFromNothing() {
   return frameMetaType;
 }
 
-export function referenceMetaTypeFromNothing() {
-  if (referenceMetaType === null) {
+export function statementMetaTypeFromNothing() {
+  if (statementMetaType === null) {
     const { MetaType } = elements,
-          name = REFERENCE_META_TYPE_NAME;  ///
+          name = STATEMENT_META_TYPE_NAME;  ///
 
-    referenceMetaType = MetaType.fromName(name);
+    statementMetaType = MetaType.fromName(name);
   }
 
-  return referenceMetaType;
+  return statementMetaType;
 }
 
-export function statementMetaTypeFromNothing() {
-  if (statementMetaType === null) {
+export function referenceMetaTypeFromNothing() {
+  if (referenceMetaType === null) {
     const { MetaType } = elements,
-          name = STATEMENT_META_TYPE_NAME;  ///
+          name = REFERENCE_META_TYPE_NAME;  ///
 
-    statementMetaType = MetaType.fromName(name);
+    referenceMetaType = MetaType.fromName(name);
   }
 
-  return statementMetaType;
+  return referenceMetaType;
 }

package/src/node/subDerivation.js

@@ -5,13 +5,6 @@ import NonTerminalNode from "../nonTerminalNode";
 import { STEP_RULE_NAME, SUBPROOF_RULE_NAME } from "../ruleNames";
 
 export default class SubDerivationNode extends NonTerminalNode {
-  getLastStepNode() {
-    const ruleName = STEP_RULE_NAME,
-          lastStepNode = this.getLastNodeByRuleName(ruleName);
-
-    return lastStepNode;
-  }
-
   getStepOrSubproofNodes() {
     const ruleNames = [
             STEP_RULE_NAME,

package/src/node/subproof.js

@@ -17,13 +17,6 @@ export default class SubproofNode extends NonTerminalNode {
     return subproofNode;
   }
 
-  getLastStepNode() {
-    const subDerivationNode = this.getSubDerivationNode(),
-          lastStepNode = subDerivationNode.getLastStepNode();
-
-    return lastStepNode;
-  }
-
   getSuppositionNodes() {
     const ruleName = SUPPOSITION_RULE_NAME,
           suppositionNodes = this.getNodesByRuleName(ruleName);

package/src/utilities/brackets.js

@@ -1,7 +1,6 @@
 "use strict";
 
-import elements from "../elements";
-
+import { termFromTermNode, statementFromStatementNode } from "../utilities/element";
 import { BRACKETED_TERM_DEPTH, BRACKETED_STATEMENT_DEPTH } from "../constants";
 import { bracketedConstructorFromNothing, bracketedCombinatorFromNothing } from "../utilities/instance";
 
@@ -10,10 +9,9 @@ export function stripBracketsFromTerm(term, context) {
         bracketedTermChildNode = bracketedTermChildNodeFromTermNode(termNode);
 
   if (bracketedTermChildNode !== null) {
-    const { Term } = elements,
-          termNode = bracketedTermChildNode;  ///
+    const termNode = bracketedTermChildNode;  ///
 
-    term = Term.fromTermNode(termNode, context);
+    term = termFromTermNode(termNode, context);
   }
 
   return term;
@@ -34,10 +32,9 @@ export function stripBracketsFromStatement(statement, context) {
         bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);
 
   if (bracketedStatementChildNode !== null) {
-    const { Statement } = elements,
-          statementNode = bracketedStatementChildNode;  ///
+    const statementNode = bracketedStatementChildNode;  ///
 
-    statement = Statement.fromStatementNode(statementNode, context);
+    statement = statementFromStatementNode(statementNode, context);
   }
 
   return statement;

package/src/utilities/instance.js

@@ -2,6 +2,7 @@
 
 import nominalContext from "../context/nominal";
 
+import { getMetaTypes } from "../metaTypes";
 import { BASE_TYPE_SYMBOL } from "../constants";
 import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 import { instantiateCombinator, instantiateConstructor } from "../process/instantiate";
@@ -21,9 +22,7 @@ export function bracketedCombinatorFromNothing() {
     const combinatorNode = instantiateCombinator(string, context),
           bracketedCombinatorNode = combinatorNode;  ///
 
-    context = {
-      nodeAsString: () => string
-    };
+    context = contextFromString(string);
 
     bracketedCombinator = combinatorFromCombinatorNode(bracketedCombinatorNode, context);
   }
@@ -42,12 +41,31 @@ export function bracketedConstructorFromNothing() {
     const constructorNode = instantiateConstructor(string, context),
           bracketedConstructorNode = constructorNode;  ///
 
-    context = {
-      nodeAsString: () => string
-    };
+    context = contextFromString(string);
 
     bracketedConstructor = constructorFromConstructorNode(bracketedConstructorNode, context);
   }
 
   return bracketedConstructor;
 }
+
+function contextFromString(string) {
+  const context = {
+    nodeAsString: () => string,
+    getMetaTypes: () => getMetaTypes(),
+    findMetaTypeByMetaTypeName(metaTypeName) {
+      const metaTypes = this.getMetaTypes(),
+            metaType = metaTypes.find((metaType) => {
+              const metaTypeComparesToMetaTypeName = metaType.compareMetaTypeName(metaTypeName);
+
+              if (metaTypeComparesToMetaTypeName) {
+                return true;
+              }
+            }) || null;
+
+      return metaType;
+    }
+  };
+
+  return context;
+}

package/src/utilities/string.js

@@ -150,17 +150,17 @@ export function rulsStringFromLabelsPremisesAndConclusion(labels, premises, conc
         conclusionString = conclusion.getString(),
         labelsString = labelsStringFromLabels(labels),
         ruleString = (premisesString !== null) ?
-                       `${labelsString} :: [${premisesString}] ... ${conclusionString}` :
+                       `${labelsString} :: [${premisesString}]...${conclusionString}` :
                          `${labelsString} :: ${conclusionString}`;
 
   return ruleString;
 }
 
 export function subproofStringFromSuppositionsAndSubDerivation(suppositions, subDerivation) {
-  const lastStep = subDerivation.getLastStep(),
-        lastStepString = lastStep.getString(),
+  const lastProofAssertion = subDerivation.getLastProofAssertion(),
         suppositionsString = suppositionsStringFromSuppositions(suppositions),
-        subproofString = `[${suppositionsString}] ... ${lastStepString}`;
+        lastProofAssertionString = lastProofAssertion.getString(),
+        subproofString = `[${suppositionsString}]...${lastProofAssertionString}`;
 
   return subproofString;
 }
@@ -205,7 +205,7 @@ export function metaLemmaMetatheoremStringFromLabelSuppositionsAndDeduction(labe
         deductionString = deduction.getString(),
         labelString = label.getString(),
         metaLemmaMetatheoremString = (suppositionsString !== null) ?
-                                       `${labelString} :: [${suppositionsString}] ... ${deductionString}` :
+                                       `${labelString} :: [${suppositionsString}]...${deductionString}` :
                                          `${labelString} :: ${deductionString}`;
 
   return metaLemmaMetatheoremString;
@@ -220,11 +220,11 @@ export function axiomLemmaTheoremConjectureStringFromLabelsSuppositionsAndDeduct
 
   if (labelsString !== null) {
     axiomLemmaTheoremConjectureString = (suppositionsString !== null) ?
-                                          `${labelsString} :: [${suppositionsString}] ... ${deductionString}` :
+                                          `${labelsString} :: [${suppositionsString}]...${deductionString}` :
                                             `${labelsString} :: ${deductionString}`;
   } else {
     axiomLemmaTheoremConjectureString = (suppositionsString !== null) ?
-                                         `[${suppositionsString}] ... ${deductionString}` :
+                                         `[${suppositionsString}]...${deductionString}` :
                                             deductionString;
   }
 

package/src/utilities/unification.js

@@ -24,10 +24,10 @@ function unifyStatementWithRule(statement, reference, satisfiesAssertion, substi
 
       context.trace(`Unifying the '${statementString}' statement with the '${ruleString}' rule...`);
 
-      const stepsOrSubproofs = context.getStepsOrSubproofs(),
-            statementAndStepsUnify = rule.unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, context);
+      const subproofOrProofAssertions = context.getSubproofOrProofAssertions(),
+            statementAndSubproofOrProofAssertionsUnify = rule.unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, context);
 
-      if (statementAndStepsUnify) {
+      if (statementAndSubproofOrProofAssertionsUnify) {
         statementUnifiesWithRule = true;
       }
 
@@ -44,14 +44,14 @@ function unifyStatementWithReference(statement, reference, satisfiesAssertion, s
   let statementUnifiesWithReference = false;
 
   if (reference !== null) {
-    const metavariableVerifies = reference.verifyMetavariable(context);
+    const statementString = statement.getString(),
+          referenceString = reference.getString();
 
-    if (metavariableVerifies) {
-      const statementString = statement.getString(),
-            referenceString = reference.getString();
+    context.trace(`Unifying the '${statementString}' statement with the '${referenceString}' reference...`);
 
-      context.trace(`Unifying the '${statementString}' statement with the '${referenceString}' reference...`);
+    const metavariableValidates = reference.validateMetavariable(context);
 
+    if (metavariableValidates) {
       const { StatementSubstitution } = elements,
             metavariable = reference.getMetavariable(),
             statementSubstitution = StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context),
@@ -60,10 +60,10 @@ function unifyStatementWithReference(statement, reference, satisfiesAssertion, s
       substitutions.addSubstitution(substitution, context);
 
       statementUnifiesWithReference = true;
+    }
 
-      if (statementUnifiesWithReference) {
-        context.debug(`...unified the '${statementString}' statement with the '${referenceString}' reference.`);
-      }
+    if (statementUnifiesWithReference) {
+      context.debug(`...unified the '${statementString}' statement with the '${referenceString}' reference.`);
     }
   }
 
@@ -86,9 +86,9 @@ function unifyStatementAsSatisfiesAssertion(statement, reference, satisfiesAsser
     satisfiesAssertion.verifySignature(assignments, stated, context);
 
     if (reference === null) {
-      const stepsOrSubproofs = context.getStepsOrSubproofs();
+      const subproofOrProofAssertions = context.getSubproofOrProofAssertions();
 
-      statementUnifiesAsSatisfiesAssertion = backwardsSome(stepsOrSubproofs, (stepsOrSubproof) => {
+      statementUnifiesAsSatisfiesAssertion = backwardsSome(subproofOrProofAssertions, (stepsOrSubproof) => {
         const stepOrSubProofUnifiesWIthSatisfiesAssertion = stepsOrSubproof.unifyWithSatisfiesAssertion(satisfiesAssertion, context);
 
         if (stepOrSubProofUnifiesWIthSatisfiesAssertion) {
@@ -149,13 +149,13 @@ function unifyStatementWithAxiomLemmaTheoremOrConjecture(statement, reference, s
 
       context.trace(`Unifying the '${statementString}' statement with the '${axiomLemmaTheoremOrConjectureString}' axiom, lemma, theorem or conjecture...`);
 
-      const stepsOrSubproofs = context.getStepsOrSubproofs();
+      const subproofOrProofAssertions = context.getSubproofOrProofAssertions();
 
       substitutions = Substitutions.fromNothing();
 
-      const statementAndStepsUnify = axiomLemmaTheoremOrConjecture.unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, substitutions, context);
+      const statementAndSubproofOrProofAssertionsUnify = axiomLemmaTheoremOrConjecture.unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, substitutions, context);
 
-      if (statementAndStepsUnify) {
+      if (statementAndSubproofOrProofAssertionsUnify) {
         const { StatementSubstitution } = elements,
               metavariable = reference.getMetavariable(),
               statementSubstitution = StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context),
@@ -292,8 +292,8 @@ function unifyStatementWithSatisfiesAssertion(statement, reference, satisfiesAss
 
     context.trace(`Unifying the '${statementString}' statememnt with the '${satisfiesAssertionString}' satisfies assertion...`);
 
-    const stepsOrSubproofs = context.getStepsOrSubproofs(),
-          statementUnifies = satisfiesAssertion.unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, context);
+    const subproofOrProofAssertions = context.getSubproofOrProofAssertions(),
+          statementUnifies = satisfiesAssertion.unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, context);
 
     if (statementUnifies) {
       statementUnifiesWithSatisfiesAssertion = true;
@@ -307,23 +307,23 @@ function unifyStatementWithSatisfiesAssertion(statement, reference, satisfiesAss
   return statementUnifiesWithSatisfiesAssertion;
 }
 
-function compareStatementWithStepsOrSubproofs(statement, reference, satisfiesAssertion, substitutions, context) {
+function compareStatementWithSubproofOrProofAssertions(statement, reference, satisfiesAssertion, substitutions, context) {
   let statementEquatesWithStepOrSubproofs = false;
 
   if (reference === null) {
     const statementString = statement.getString();
 
-    context.trace(`Comparing the '${statementString}' statement with the steps or subproofs...`);
+    context.trace(`Comparing the '${statementString}' statement with the subproofs or proof asssertions...`);
 
-    const stepsOrSubproofs = context.getStepsOrSubproofs(),
-          statementUnifiesWithSteps = statement.compareStepsOrSubproofs(stepsOrSubproofs, context);
+    const subproofOrProofAssertions = context.getSubproofOrProofAssertions(),
+          statementUnifiesWithSteps = statement.compareSubproofOrProofAssertions(subproofOrProofAssertions, context);
 
     if (statementUnifiesWithSteps) {
       statementEquatesWithStepOrSubproofs = true;
     }
 
     if (statementEquatesWithStepOrSubproofs) {
-      context.debug(`...compared the '${statementString}' statement with the steps or subproofs.`);
+      context.debug(`...compared the '${statementString}' statement with the subproofs or proof asssertions.`);
     }
   }
 
@@ -340,5 +340,5 @@ export const unifyStatements = [
   unifyStatementAsTypeAssertion,
   unifyStatementAsPropertyAssertion,
   unifyStatementWithSatisfiesAssertion,
-  compareStatementWithStepsOrSubproofs
+  compareStatementWithSubproofOrProofAssertions
 ];