occam-verify-cli 0.0.1075 → 0.0.1077

package/src/assertion/subproof.js

@@ -5,7 +5,6 @@ import { arrayUtilities } from "necessary";
 import shim from "../shim";
 import LocalContext from "../context/local";
 import metaLevelUnifier from "../unifier/metaLevel";
-import metaLevelVerifier from "../verifier/metaLevel";
 
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
@@ -33,6 +32,39 @@ export default class SubproofAssertion {
     return this.statements;
   }
 
+  unifySubproof(subproof, substitutions, fileContext, localContext) {
+    let subproofUnified;
+
+    const subproofString = subproof.getString(),
+          subproofAssertionString = this.string;  ///
+
+    localContext.trace(`Unifying the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion...`);
+
+    const subproofStatements = subproof.getStatements(),
+          subproofAssertionStatements = this.statements;  ///
+
+    subproofUnified = match(subproofAssertionStatements, subproofStatements, (subproofAssertionStatement, subproofStatement) => {
+      const subproofAssertionStatementNode = subproofAssertionStatement.getNode(),
+            subproofStatementNode = subproofStatement.getNode(),
+            nodeA = subproofAssertionStatementNode,  ///
+            nodeB = subproofStatementNode,  ///
+            fileContextA = fileContext,  ///
+            localContextA = LocalContext.fromFileContext(fileContextA),
+            localContextB = localContext, ///
+            unifiedAtMetaLevel = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+
+      if (unifiedAtMetaLevel) {
+        return true;
+      }
+    });
+
+    if (subproofUnified) {
+      localContext.debug(`...unified the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion.`);
+    }
+
+    return subproofUnified;
+  }
+
   verify(assignments, stated, localContext) {
     let verified;
 
@@ -40,24 +72,31 @@ export default class SubproofAssertion {
 
     localContext.trace(`Verifying the '${subproofAssertionString}' subproof assertion...`);
 
-    let verifiedWhenStated = false,
-        verifiedWhenDerived = false;
+    stated = true;  ///
 
-    if (stated) {
-      verifiedWhenStated = this.verifyWhenStated(localContext);
-    } else {
-      verifiedWhenDerived = this.verifyWhenDerived(localContext);
-    }
+    assignments = null; ///
 
-    if (verifiedWhenStated || verifiedWhenDerived) {
-      assignments = null; ///
+    const statementsVerified = this.statements.map((statement) => {
+      const statementVerified = statement.verify(assignments, stated, localContext);
 
-      stated = true;  ///
+      if (statementVerified) {
+        return true;
+      }
+    });
+
+    if (statementsVerified) {
+      let verifiedWhenStated = false,
+          verifiedWhenDerived = false;
 
-      const subproofAssertionNode = this.node,  ///
-            verifiedAtMetaLevel = metaLevelVerifier.verify(subproofAssertionNode, assignments, stated, localContext);
+      if (stated) {
+        verifiedWhenStated = this.verifyWhenStated(localContext);
+      } else {
+        verifiedWhenDerived = this.verifyWhenDerived(localContext);
+      }
 
-      verified = verifiedAtMetaLevel; ///
+      if (verifiedWhenStated || verifiedWhenDerived) {
+        verified = true; ///
+      }
     }
 
     if (verified) {
@@ -90,42 +129,22 @@ export default class SubproofAssertion {
 
     localContext.trace(`Verifying the '${subproofAssertionString}' derived subproof assertion...`);
 
-    derivedSubproofAssertionVerified = false;
+    const proofSteps = localContext.getProofSteps();
 
-    localContext.debug(`The '${subproofAssertionString}' derived subproof assertion cannot be verified.`);
-
-    return derivedSubproofAssertionVerified;
-  }
-
-  unifySubproof(subproof, substitutions, fileContext, localContext) {
-    let subproofUnified;
-
-    const subproofString = subproof.getString(),
-          subproofStatements = subproof.getStatements(),
-          subproofAssertionString = this.string;  ///
+    derivedSubproofAssertionVerified = proofSteps.some((proofStep) => {
+      const subproofAssertion = this,
+            subproofAssertionUnified = proofStep.unifySubproofAssertion(subproofAssertion, localContext);
 
-    localContext.trace(`Unifying the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion...`);
-
-    subproofUnified = match(this.statements, subproofStatements, (statement, subproofStatement) => {
-      const statementNode = statement.getNode(),
-            subproofStatementNode = subproofStatement.getNode(),
-            nodeA = statementNode,  ///
-            nodeB = subproofStatementNode,  ///
-            fileContextA = fileContext,  ///
-            localContextA = LocalContext.fromFileContext(fileContextA),
-            localContextB = localContext, ///
-            unifiedAtMetaLevel = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
-
-      if (unifiedAtMetaLevel) {
+      if (subproofAssertionUnified) {
         return true;
       }
     });
 
-    if (subproofUnified) {
-      localContext.debug(`...unified the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion.`);
+    if (derivedSubproofAssertionVerified) {
+      localContext.debug(`...verified the '${subproofAssertionString}' derived subproof assertion.`);
     }
 
-    return subproofUnified;
+    return derivedSubproofAssertionVerified;
   }
 
   static fromStatementNode(statementNode, localContext) {

package/src/declaration.js

@@ -100,17 +100,14 @@ class Declaration {
 
     localContext.trace(`Verifying the '${declarationString}' declaration...`);
 
-    stated = true;
+    stated = true;  ///
 
-    assignments = null;
+    assignments = null; ///
 
-    const referenceVerified = this.reference.verify(localContext);
+    const referenceVerified = this.reference.verify(localContext),
+          statementVerified = this.statement.verify(assignments, stated, localContext);
 
-    if (referenceVerified) {
-      const statementVerified = this.statement.verify(assignments, stated, localContext);
-
-      verified = statementVerified; ///
-    }
+    verified = (referenceVerified && statementVerified);
 
     if (verified) {
       localContext.debug(`...verified the '${declarationString}' declaration.`);

package/src/metavariable.js

@@ -6,6 +6,7 @@ import FrameForMetavariableSubstitution from "./substitution/frameForMetavariabl
 import StatementForMetavariableSubstitution from "./substitution/statementForMetavariable";
 
 import { nodeQuery } from "./utilities/query";
+import { EMPTY_STRING } from "./constants";
 import { metavariableNodeFromMetavariableString } from "./utilities/node";
 import { metaTypeFromJSON, metaTypeToMetaTypeJSON } from "./utilities/json";
 import { typeNameFromTypeNode, metavariableNameFromMetavariableNode } from "./utilities/name";
@@ -122,11 +123,9 @@ class Metavariable {
           metavariableString = this.string, ///
           substitutionString = (substitution !== null) ?
                                   substitution.getString() :
-                                    null;
+                                    EMPTY_STRING;
 
-    (substitutionString !== null) ?
-      localContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}' metavariable given the ${substitutionString} substitution...`) :
-        localContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}' metavariable...`);
+    localContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}${substitutionString}' metavariable...`);
 
     const statementNode = statement.getNode(),
           metavariableNode = this.node, ///
@@ -147,7 +146,7 @@ class Metavariable {
             metavariable = metavariableFromMetavariableNode(metavariableNode, localContext),
             statementMetavariable = statementMetavariableFromStatementNode(statementNode, localContext);
 
-      if (metavariable === statementMetavariable) {
+      if ((metavariable !== null) && (metavariable === statementMetavariable)) {
         statementUnified = true;
       } else {
         const metavariable = this,  ///
@@ -162,9 +161,7 @@ class Metavariable {
     }
 
     if (statementUnified) {
-      (substitutionString !== null) ?
-        localContext.debug(`...unified the '${statementString}' statement with the '${metavariableString}' metavariable given the ${substitutionString} substitution.`) :
-          localContext.debug(`...unified the '${statementString}' statement with the '${metavariableString}' metavariable.`);
+      localContext.debug(`...unified the '${statementString}' statement with the '${metavariableString}${substitutionString}' metavariable.`);
     }
 
     return statementUnified;

package/src/mixins/statement/unify.js

@@ -28,10 +28,10 @@ function unifyWithCombinators(statement, assignments, stated, localContext) {
 
   const combinators = localContext.getCombinators();
 
-  assignments = null; ///
-
   stated = true;  ///
 
+  assignments = null; ///
+
   unifiedWithCombinators = combinators.some((combinator) => {
     const unifiedWithCombinator = unifyStatementWithCombinator(statement, combinator, assignments, stated, localContext);
 

package/src/mixins/statement/verify.js

@@ -8,10 +8,8 @@ import ContainedAssertion from "../../assertion/contained";
 
 import { nodeQuery } from "../../utilities/query";
 
-const frameNodeQuery = nodeQuery("/statement/frame"),
-      equalityNodeQuery = nodeQuery("/statement/equality"),
+const equalityNodeQuery = nodeQuery("/statement/equality"),
       judgementNodeQuery = nodeQuery("/statement/judgement"),
-      declarationNodeQuery = nodeQuery("/statement/declaration"),
       metavariableNodeQuery = nodeQuery("/statement/metavariable!"),
       typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion"),
       definedAssertionNodeQuery = nodeQuery("/statement/definedAssertion"),
@@ -68,31 +66,6 @@ function verifyAsEquality(statement, assignments, stated, localContext) {
   return verifiedAsEquality;
 }
 
-function verifyAsFrame(statement, assignments, stated, localContext) {
-  let verifiedAsFrame = false;
-
-  const { Frame } = shim,
-        statementNode = statement.getNode(),
-        frameNode = frameNodeQuery(statementNode),
-        frame = Frame.fromFrameNode(frameNode, localContext);
-
-  if (frame !== null) {
-    const statementString = statement.getString();
-
-    localContext.trace(`Verifying the '${statementString}' statement as a frame...`);
-
-    const frameVerified = frame.verify(assignments, stated, localContext);
-
-    verifiedAsFrame = frameVerified; ///
-
-    if (verifiedAsFrame) {
-      localContext.debug(`...verified the '${statementString}' statement as a frame.`);
-    }
-  }
-
-  return verifiedAsFrame;
-}
-
 function verifyAsJudgement(statement, assignments, stated, localContext) {
   let verifiedAsJudgement = false;
 
@@ -118,31 +91,6 @@ function verifyAsJudgement(statement, assignments, stated, localContext) {
   return verifiedAsJudgement;
 }
 
-function verifyAsDeclaration(statement, assignments, stated, localContext) {
-  let verifiedAsDeclaration = false;
-
-  const { Declaration } = shim,
-        statementNode = statement.getNode(),
-        declarationNode = declarationNodeQuery(statementNode),
-        declaration = Declaration.fromDeclarationNode(declarationNode, localContext);
-
-  if (declaration !== null) {
-    const statementString = statement.getString();
-
-    localContext.trace(`Verifying the '${statementString}' statement as a declaration...`);
-
-    const declarationVerified = declaration.verify(assignments, stated, localContext);
-
-    verifiedAsDeclaration = declarationVerified; ///
-
-    if (verifiedAsDeclaration) {
-      localContext.debug(`...verified the '${statementString}' statement as a declaration.`);
-    }
-  }
-
-  return verifiedAsDeclaration;
-}
-
 function verifyAsTypeAssertion(statement, assignments, stated, localContext) {
   let verifiedAsTypeAssertion = false;
 
@@ -191,60 +139,58 @@ function verifyAsDefinedAssertion(statement, assignments, stated, localContext)
   return verifiedAsDefinedAssertion;
 }
 
-function verifyAsSubproofAssertion(statement, assignments, stated, localContext) {
-  let verifiedAsSubproofAssertion = false;
+function verifyAsContainedAssertion(statement, assignments, stated, localContext) {
+  let verifiedAsContainedAssertion = false;
 
   const statementNode = statement.getNode(),
-        subproofAssertionNode = subproofAssertionNodeQuery(statementNode),
-        subproofAssertion = SubproofAssertion.fromSubproofAssertionNode(subproofAssertionNode, localContext);
+        containedAssertionNode = containedAssertionNodeQuery(statementNode),
+        containedAssertion = ContainedAssertion.fromContainedAssertionNode(containedAssertionNode, localContext);
 
-  if (subproofAssertionNode !== null) {
+  if (containedAssertion !== null) {
     const statementString = statement.getString();
 
-    localContext.trace(`Verifying the '${statementString}' statement as a subproof assertion...`);
+    localContext.trace(`Verifying the '${statementString}' statement as a contained assertion...`);
 
-    const subproofAssertionVerified = subproofAssertion.verify(assignments, stated, localContext);
+    const containedAssertionVerified = containedAssertion.verify(assignments, stated, localContext);
 
-    verifiedAsSubproofAssertion = subproofAssertionVerified; ///
+    verifiedAsContainedAssertion = containedAssertionVerified; ///
 
-    if (verifiedAsSubproofAssertion) {
-      localContext.debug(`...verified the '${statementString}' statement as a subproof assertion.`);
+    if (verifiedAsContainedAssertion) {
+      localContext.debug(`...verified the '${statementString}' statement as a contained assertion.`);
     }
   }
 
-  return verifiedAsSubproofAssertion;
+  return verifiedAsContainedAssertion;
 }
 
-function verifyAsContainedAssertion(statement, assignments, stated, localContext) {
-  let verifiedAsContainedAssertion = false;
+function verifyAsSubproofAssertion(statement, assignments, stated, localContext) {
+  let verifiedAsSubproofAssertion = false;
 
   const statementNode = statement.getNode(),
-        containedAssertionNode = containedAssertionNodeQuery(statementNode),
-        containedAssertion = ContainedAssertion.fromContainedAssertionNode(containedAssertionNode, localContext);
+        subproofAssertionNode = subproofAssertionNodeQuery(statementNode),
+        subproofAssertion = SubproofAssertion.fromSubproofAssertionNode(subproofAssertionNode, localContext);
 
-  if (containedAssertion !== null) {
+  if (subproofAssertionNode !== null) {
     const statementString = statement.getString();
 
-    localContext.trace(`Verifying the '${statementString}' statement as a contained assertion...`);
+    localContext.trace(`Verifying the '${statementString}' statement as a subproof assertion...`);
 
-    const containedAssertionVerified = containedAssertion.verify(assignments, stated, localContext);
+    const subproofAssertionVerified = subproofAssertion.verify(assignments, stated, localContext);
 
-    verifiedAsContainedAssertion = containedAssertionVerified; ///
+    verifiedAsSubproofAssertion = subproofAssertionVerified; ///
 
-    if (verifiedAsContainedAssertion) {
-      localContext.debug(`...verified the '${statementString}' statement as a contained assertion.`);
+    if (verifiedAsSubproofAssertion) {
+      localContext.debug(`...verified the '${statementString}' statement as a subproof assertion.`);
     }
   }
 
-  return verifiedAsContainedAssertion;
+  return verifiedAsSubproofAssertion;
 }
 
 const verifyMixins = [
   verifyAsMetavariable,
   verifyAsEquality,
-  verifyAsFrame,
   verifyAsJudgement,
-  verifyAsDeclaration,
   verifyAsTypeAssertion,
   verifyAsDefinedAssertion,
   verifyAsSubproofAssertion,

package/src/premise.js

@@ -28,37 +28,6 @@ class Premise {
 
   getStatement() { return this.unqualifiedStatement.getStatement(); }
 
-  unifySubproof(subproof, substitutions, localContext) {
-    let subproofUnified = false;
-
-    const premise = this, ///
-          subproofString = subproof.getString(),
-          premiseStatement = premise.getStatement(),
-          premiseStatementString = premiseStatement.getString();
-
-    localContext.trace(`Unifying the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement...`);
-
-    const statement = this.unqualifiedStatement.getStatement(),
-          statementNode = statement.getNode(),
-          statementTokens = statement.getTokens(),
-          context = this.fileContext, ///
-          tokens = statementTokens; ///
-
-    localContext = LocalContext.fromContextAndTokens(context, tokens);  ///
-
-    const subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, localContext);
-
-    if (subproofAssertion !== null) {
-      subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, this.fileContext, localContext);
-    }
-
-    if (subproofUnified) {
-      localContext.debug(`...unified the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement.`);
-    }
-
-    return subproofUnified;
-  }
-
   unifyProofStep(proofStep, substitutions, localContext) {
     let proofStepUnified = false;
 
@@ -79,6 +48,14 @@ class Premise {
     }
 
     if (subproofUnified || statementUnified) {
+      const localContextB = localContext; ///
+
+      localContext = LocalContext.fromFileContext(this.fileContext);
+
+      const localContextA = localContext; ///
+
+      substitutions.resolve(localContextA, localContextB);
+
       proofStepUnified = true;
     }
 
@@ -112,6 +89,37 @@ class Premise {
     return statementUnified;
   }
 
+  unifySubproof(subproof, substitutions, localContext) {
+    let subproofUnified = false;
+
+    const premise = this, ///
+          subproofString = subproof.getString(),
+          premiseStatement = premise.getStatement(),
+          premiseStatementString = premiseStatement.getString();
+
+    localContext.trace(`Unifying the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement...`);
+
+    const statement = this.unqualifiedStatement.getStatement(),
+          statementNode = statement.getNode(),
+          statementTokens = statement.getTokens(),
+          context = this.fileContext, ///
+          tokens = statementTokens; ///
+
+    localContext = LocalContext.fromContextAndTokens(context, tokens);  ///
+
+    const subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, localContext);
+
+    if (subproofAssertion !== null) {
+      subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, this.fileContext, localContext);
+    }
+
+    if (subproofUnified) {
+      localContext.debug(`...unified the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement.`);
+    }
+
+    return subproofUnified;
+  }
+
   verify(localContext) {
     let verified = false;
 

package/src/proofStep.js

@@ -1,10 +1,15 @@
 "use strict";
 
+import { arrayUtilities } from "necessary";
+
 import shim from "./shim";
+import metaLevelUnifier from "./unifier/metaLevel";
 
 import { nodeQuery } from "./utilities/query";
 import { assignAssignments } from "./utilities/assignments";
 
+const { match } = arrayUtilities;
+
 const subproofNodeQuery = nodeQuery("/proofStep|lastProofStep/subproof"),
       qualifiedStatementNodeQuery = nodeQuery("/proofStep|lastProofStep/qualifiedStatement"),
       unqualifiedStatementNodeQuery = nodeQuery("/proofStep|lastProofStep/unqualifiedStatement");
@@ -45,56 +50,112 @@ class ProofStep {
   unifyStatement(statement, localContext) {
     let statementUnified = false;
 
-    const { Substitutions } = shim,
-          substitutions = Substitutions.fromNothing();
+    if ((this.qualifiedStatement !== null) || (this.unqualifiedStatement !== null !== null)) {
+      const statementString = statement.getString();
 
-    if (this.qualifiedStatement !== null) {
-      const localContextA = localContext, ///
-            localContextB = localContext; ///
+      localContext.trace(`Unifying the '${statementString}' statement...`);
 
-      statementUnified = this.qualifiedStatement.unifyStatement(statement, substitutions, localContextA, localContextB);
-    }
+      const { Substitutions } = shim,
+            localContextA = localContext, ///
+            localContextB = localContext, ///
+            substitutions = Substitutions.fromNothing();
 
-    if (this.unqualifiedStatement !== null) {
-      const localContextA = localContext, ///
-            localContextB = localContext; ///
+      if (this.qualifiedStatement !== null) {
+        statementUnified = this.qualifiedStatement.unifyStatement(statement, substitutions, localContextA, localContextB);
+      }
 
-      statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, localContextA, localContextB);
-    }
+      if (this.unqualifiedStatement !== null) {
+        statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, localContextA, localContextB);
+      }
 
-    const substitutionsLength = substitutions.getLength();
+      const substitutionsLength = substitutions.getLength();
 
-    if (substitutionsLength > 0) {
-      statementUnified = false;
+      if (substitutionsLength > 0) {
+        statementUnified = false;
+      }
+
+      if (statementUnified) {
+        localContext.debug(`...unified the '${statementString}' statement.`);
+      }
     }
 
     return statementUnified;
   }
 
+  unifySubproofAssertion(subproofAssertion, localContext) {
+    let subproofAssertionUnified = false;
+
+    if (this.subproof !== null) {
+      const subproofString = this.subproof.getString(),
+            subproofAssertionString = subproofAssertion.getString();
+
+      localContext.trace(`Unifying the '${subproofAssertionString}' subproof assertion with the '${subproofString}' subproof...`);
+
+      const { Substitutions } = shim,
+            substitutions = Substitutions.fromNothing(),
+            subproofStatements = this.subproof.getStatements(),
+            subproofAssertionStatements = subproofAssertion.getStatements();
+
+      subproofAssertionUnified = match(subproofAssertionStatements, subproofStatements, (subproofAssertionStatement, subproofStatement) => {
+        const subproofAssertionStatementNode = subproofAssertionStatement.getNode(),
+              subproofStatementNode = subproofStatement.getNode(),
+              nodeA = subproofAssertionStatementNode,  ///
+              nodeB = subproofStatementNode,  ///
+              localContextA = localContext, ///
+              localContextB = localContext, ///
+              unifiedAtMetaLevel = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+
+        if (unifiedAtMetaLevel) {
+          return true;
+        }
+      });
+
+      if (subproofAssertionUnified) {
+        const substitutionsLength = substitutions.getLength();
+
+        if (substitutionsLength > 0) {
+          subproofAssertionUnified = false;
+        }
+      }
+
+      if (subproofAssertionUnified) {
+        localContext.trace(`...unified the '${subproofAssertionString}' subproof assertion with the '${subproofString}' subproof.`);
+      }
+    }
+
+    return subproofAssertionUnified;
+  }
+
   verify(substitutions, localContext) {
     let verified = false;
 
+    let stated = false;
+
+    const assignments = [];
+
+    let subproofVerified = false,
+        qualifiedStatementVerified = false,
+        unqualifiedStatementVerified = false;
+
     if (false) {
       ///
     } else if (this.subproof !== null) {
-      const subproofVerified = this.subproof.verify(substitutions, localContext);
-
-      verified = subproofVerified;  ///
+      subproofVerified = this.subproof.verify(substitutions, localContext);
     } else if (this.qualifiedStatement !== null) {
-      const qualifiedStatementVerified = this.qualifiedStatement.verify(substitutions, localContext);
+      stated = true;
 
-      verified = qualifiedStatementVerified;  ///
+      qualifiedStatementVerified = this.qualifiedStatement.verify(substitutions, assignments, stated, localContext);
     } else if (this.unqualifiedStatement !== null) {
-      const stated = false,
-            assignments = [],
-            unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, localContext);
+      stated = false;
+
+      unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, localContext);
+    }
 
-      if (unqualifiedStatementVerified) {
-        const assignmentsAssigned = assignAssignments(assignments, localContext);
+    if (subproofVerified || qualifiedStatementVerified || unqualifiedStatementVerified) {
+      const assignmentsAssigned = assignAssignments(assignments, localContext);
 
-        if (assignmentsAssigned) {
-          verified = true;
-        }
+      if (assignmentsAssigned) {
+        verified = true;
       }
     }
 

package/src/rule.js

@@ -68,24 +68,19 @@ class Rule {
   }
 
   unifyStatement(statement, localContext) {
-    let statementUnified = false;
+    let statementUnified;
 
     const { Substitutions } = shim,
-          proofSteps = localContext.getProofSteps(),
-          substitutions = Substitutions.fromNothing(),
-          proofStepsUnified = this.unifyProofSteps(proofSteps, substitutions, localContext);
+          substitutions = Substitutions.fromNothing();
 
-    if (proofStepsUnified) {
-      const statementUnifiedWithConclusion = this.conclusion.unifyStatement(statement, substitutions, localContext);  ///
+    statementUnified = this.conclusion.unifyStatement(statement, substitutions, localContext);  ///
 
-      if (statementUnifiedWithConclusion) {
-        const localContextB = localContext; ///
+    if (statementUnified) {
+      const proofSteps = localContext.getProofSteps(),
+            proofStepsUnified = this.unifyProofSteps(proofSteps, substitutions, localContext);
 
-        localContext = LocalContext.fromFileContext(this.fileContext);
-
-        const localContextA = localContext; ///
-
-        const substitutionsResolved = substitutions.resolve(localContextA, localContextB);
+      if (proofStepsUnified) {
+        const substitutionsResolved = substitutions.areResolved();
 
         statementUnified = substitutionsResolved; ///
       }