occam-verify-cli 0.0.893 → 0.0.894

package/src/premise.js

@@ -11,9 +11,13 @@ import { nodeQuery, nodesQuery } from "./utilities/query";
 import { metastatementNodeFromMetastatementString } from "./utilities/node";
 
 const subproofAssertionNodeQuery = nodeQuery("/metastatement/subproofAssertion!"),
+      subproofSuppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement!/statement!"),
+      subproofLastProofStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/lastProofStep/unqualifiedStatement|qualifiedStatement/statement!"),
       subproofAssertionMetastatementNodesQuery = nodesQuery("/subproofAssertion/metastatement"),
       ruleSubproofPremiseMetastatementNodesQuery = nodesQuery("/ruleSubproof/premise/unqualifiedMetastatement!/metastatement!"),
-      ruleSubproofLastRuleProofStepMetastatementNodeQuery = nodeQuery("/ruleSubproof/ruleSubDerivation/lastRuleProofStep/unqualifiedMetastatement|qualifiedMetastatement/metastatement!");
+      metaSubproofMetaSuppositionMetastatementNodesQuery = nodesQuery("/metaSubproof/metaSupposition/unqualifiedMetastatement!/metastatement!"),
+      ruleSubproofLastRuleProofStepMetastatementNodeQuery = nodeQuery("/ruleSubproof/ruleSubDerivation/lastRuleProofStep/unqualifiedMetastatement|qualifiedMetastatement/metastatement!"),
+      metaSubproofLastMetaProofStepMetastatementNodeQuery = nodeQuery("/metaSubproof/metaSubDerivation/lastMetaProofStep/unqualifiedMetastatement|qualifiedMetastatement/metastatement!");
 
 export default class Premise {
   constructor(metastatementNode) {
@@ -24,12 +28,12 @@ export default class Premise {
     return this.metastatementNode;
   }
 
-  matchStatementNode(statementNode, substitutions, fileContext, statementLocalContext) {
+  matchStatementNode(statementNode, substitutions, fileContext, localContext) {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = statementNode,  ///
           fileContextA = fileContext, ///
           localContextA = LocalContext.fromFileContext(fileContextA),
-          localContextB = statementLocalContext,  ///
+          localContextB = localContext,  ///
           nonTerminalNodeVerified = intrinsicLevelAgainstMetaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
             const verifiedAhead = true;
 
@@ -40,6 +44,41 @@ export default class Premise {
     return statementNodeMatches;
   }
 
+  matchSubproofNode(subproofNode, substitutions, fileContext, localContext) {
+    let subproofNodeMatches = false;
+
+    const subproofAssertionNode = subproofAssertionNodeQuery(this.metastatementNode);
+
+    if (subproofAssertionNode !== null) {
+      const subproofSuppositionStatementNodes = subproofSuppositionStatementNodesQuery(subproofNode),
+            subproofLastProofStepStatementNode = subproofLastProofStepStatementNodeQuery(subproofNode),
+            subproofStatementNodes = [
+              ...subproofSuppositionStatementNodes,
+              subproofLastProofStepStatementNode
+            ],
+            subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
+
+      subproofNodeMatches = match(subproofAssertionMetastatementNodes, subproofStatementNodes, (subproofAssertionMetastatementNode, subproofStatementNode) => {
+        const nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
+              nonTerminalNodeB = subproofStatementNode, ///
+              fileContextA = fileContext, ///
+              localContextA = LocalMetaContext.fromFileContext(fileContextA),
+              localContextB = localContext,  ///
+              nonTerminalNodeVerified = intrinsicLevelAgainstMetaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+                const verifiedAhead = true;
+
+                return verifiedAhead;
+              });
+
+        if (nonTerminalNodeVerified) {
+          return true;
+        }
+      });
+    }
+
+    return subproofNodeMatches;
+  }
+
   matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, localMetaContext) {
     let ruleSubproofNodeMatches = false;
 
@@ -52,33 +91,64 @@ export default class Premise {
               ...ruleSubproofPremiseMetastatementNodes,
               ruleSubproofLastRuleProofStepMetastatementNode
             ],
-            ruleSubproofMetastatementNodesLength = ruleSubproofMetastatementNodes.length,
-            subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode),
-            subproofAssertionMetastatementNodesLength = subproofAssertionMetastatementNodes.length;
-
-      if (ruleSubproofMetastatementNodesLength === subproofAssertionMetastatementNodesLength) {
-        ruleSubproofNodeMatches = match(subproofAssertionMetastatementNodes, ruleSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
-          const nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
-                nonTerminalNodeB = ruleSubproofMetastatementNode, ///
-                fileContextA = fileContext, ///
-                localMetaContextA = LocalMetaContext.fromFileContext(fileContextA),
-                localMetaContextB = localMetaContext,  ///
-                nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, () => {
-                  const verifiedAhead = true;
-
-                  return verifiedAhead;
-                });
-
-          if (nonTerminalNodeVerified) {
-            return true;
-          }
-        });
-      }
+            subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
+
+      ruleSubproofNodeMatches = match(subproofAssertionMetastatementNodes, ruleSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
+        const nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
+          nonTerminalNodeB = ruleSubproofMetastatementNode, ///
+          fileContextA = fileContext, ///
+          localMetaContextA = LocalMetaContext.fromFileContext(fileContextA),
+          localMetaContextB = localMetaContext,  ///
+          nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, () => {
+            const verifiedAhead = true;
+
+            return verifiedAhead;
+          });
+
+        if (nonTerminalNodeVerified) {
+          return true;
+        }
+      });
     }
 
     return ruleSubproofNodeMatches;
   }
 
+  matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localMetaContext) {
+    let metaSubproofNodeMatches = false;
+
+    const subproofAssertionNode = subproofAssertionNodeQuery(this.metastatementNode);
+
+    if (subproofAssertionNode !== null) {
+      const metaSubproofMetaSuppositionMetastatementNodes = metaSubproofMetaSuppositionMetastatementNodesQuery(metaSubproofNode),
+            metaSubproofLastMetaProofStepMetastatementNode = metaSubproofLastMetaProofStepMetastatementNodeQuery(metaSubproofNode),
+            metaSubproofMetastatementNodes = [
+              ...metaSubproofMetaSuppositionMetastatementNodes,
+              metaSubproofLastMetaProofStepMetastatementNode
+            ],
+            subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
+
+      metaSubproofNodeMatches = match(subproofAssertionMetastatementNodes, metaSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
+        const nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
+              nonTerminalNodeB = ruleSubproofMetastatementNode, ///
+              fileContextA = fileContext, ///
+              localMetaContextA = LocalMetaContext.fromFileContext(fileContextA),
+              localMetaContextB = localMetaContext,  ///
+              nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, () => {
+                const verifiedAhead = true;
+
+                return verifiedAhead;
+              });
+
+        if (nonTerminalNodeVerified) {
+          return true;
+        }
+      });
+    }
+
+    return metaSubproofNodeMatches;
+  }
+
   matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext) {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = metastatementNode,  ///

package/src/rule.js

@@ -4,9 +4,8 @@ import Label from "./label";
 import Premise from "./premise";
 import Conclusion from "./conclusion";
 
-import { prune } from "./utilities/array";
+import { extract } from "./utilities/array";
 import { someSubArray } from "./utilities/array";
-import local from "./context/local";
 
 export default class Rule {
   constructor(labels, premises, conclusion, fileContext) {
@@ -35,25 +34,24 @@ export default class Rule {
   matchStatement(statementNode, localContext) {
     let statementNatches;
 
-    const premisesLength = this.premises.length,
-          statementLocalContext = localContext; ///
+    const premisesLength = this.premises.length;
 
     if (premisesLength === 0) {
       const substitutions = [],
-            conclusionMatches = matchConclusion(this.conclusion, statementNode, substitutions, this.fileContext, statementLocalContext);
+            conclusionMatches = matchConclusion(this.conclusion, statementNode, substitutions, this.fileContext, localContext);
 
       statementNatches = conclusionMatches; ///
     } else {
-      const proofSteps = statementLocalContext.getProofSteps();
+      const proofSteps = localContext.getProofSteps();
 
       statementNatches = someSubArray(proofSteps, premisesLength, (proofSteps) => {
         let premisesMatchConclusion = false;
 
         const substitutions = [],
-              premisesMatch = matchPremises(this.premises, proofSteps, substitutions, this.fileContext, statementLocalContext);
+              premisesMatch = matchPremises(this.premises, proofSteps, substitutions, this.fileContext, localContext);
 
         if (premisesMatch) {
-          const conclusionMatches = matchConclusion(this.conclusion, statementNode, substitutions, this.fileContext, statementLocalContext);
+          const conclusionMatches = matchConclusion(this.conclusion, statementNode, substitutions, this.fileContext, localContext);
 
           premisesMatchConclusion = conclusionMatches;  ///
         }
@@ -182,14 +180,23 @@ export default class Rule {
   }
 }
 
-function matchPremise(premise, proofSteps, substitutions, fileContext, statementLocalContext) {
-  const proofStep = prune(proofSteps, (proofStep) => {
-    const statementNode = proofStep.getStatementNode()
+function matchPremise(premise, proofSteps, substitutions, fileContext, localContext) {
+  const proofStep = extract(proofSteps, (proofStep) => {
+    const subproofNode = proofStep.getSubproofNode(),
+          statementNode = proofStep.getStatementNode();
+
+    if (subproofNode !== null) {
+      const subproofNodeMatches = premise.matchSubproofNode(subproofNode, substitutions, fileContext, localContext);
+
+      if (subproofNodeMatches) {
+        return true;
+      }
+    }
 
     if (statementNode !== null) {
-      const statementNodeMatches = premise.matchStatementNode(statementNode, substitutions, fileContext, statementLocalContext);
+      const statementNodeMatches = premise.matchStatementNode(statementNode, substitutions, fileContext, localContext);
 
-      if (!statementNodeMatches) {  ///
+      if (statementNodeMatches) {
         return true;
       }
     }
@@ -200,9 +207,9 @@ function matchPremise(premise, proofSteps, substitutions, fileContext, statement
   return premiseMatches;
 }
 
-function matchPremises(premise, proofSteps, substitutions, fileContext, statementLocalContext) {
+function matchPremises(premise, proofSteps, substitutions, fileContext, localContext) {
   const premisesMatch = premise.every((premise) => {
-    const premiseMatches = matchPremise(premise, proofSteps, substitutions, fileContext, statementLocalContext);
+    const premiseMatches = matchPremise(premise, proofSteps, substitutions, fileContext, localContext);
 
     if (premiseMatches) {
       return true;
@@ -212,22 +219,31 @@ function matchPremises(premise, proofSteps, substitutions, fileContext, statemen
   return premisesMatch;
 }
 
-function matchConclusion(conclusion, statementNode, substitutions, fileContext, statementLocalContext) {
-  const statementNodeMatches = conclusion.matchStatementNode(statementNode, substitutions, fileContext, statementLocalContext),
+function matchConclusion(conclusion, statementNode, substitutions, fileContext, localContext) {
+  const statementNodeMatches = conclusion.matchStatementNode(statementNode, substitutions, fileContext, localContext),
         conclusionMatches = statementNodeMatches; ///
 
   return conclusionMatches;
 }
 
 function metaMatchPremise(premise, metaproofSteps, substitutions, fileContext, localMetaContext) {
-  const metaproofStep = prune(metaproofSteps, (metaproofStep) => {
+  const metaproofStep = extract(metaproofSteps, (metaproofStep) => {
     const ruleSubproofNode = metaproofStep.getRuleSubproofNode(),
+          metaSubproofNode = metaproofStep.getMetaSubproofNode(),
           metastatementNode = metaproofStep.getMetastatementNode()
 
     if (ruleSubproofNode !== null) {
       const ruleSubProofNodeMatches = premise.matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, localMetaContext);
 
-      if (!ruleSubProofNodeMatches) {  ///
+      if (ruleSubProofNodeMatches) {
+        return true;
+      }
+    }
+
+    if (metaSubproofNode !== null) {
+      const metaSubProofNodeMatches = premise.matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localMetaContext);
+
+      if (metaSubProofNodeMatches) {
         return true;
       }
     }
@@ -235,7 +251,7 @@ function metaMatchPremise(premise, metaproofSteps, substitutions, fileContext, l
     if (metastatementNode !== null) {
       const metastatementNodeMatches = premise.matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext);
 
-      if (!metastatementNodeMatches) {  ///
+      if (metastatementNodeMatches) {
         return true;
       }
     }

package/src/step/metaproof.js

@@ -9,12 +9,17 @@ const metastatementNodesQuery = nodesQuery("/subproofAssertion/metastatement"),
       qualifiedOrUnqualifiedMetastatementMetastatementNodesQuery = nodesQuery("/ruleSubproof/qualifiedMetastatement|unqualifiedMetastatement/metastatement!");
 
 export default class MetaproofStep {
-  constructor(ruleSubproofNode, metaSubproofNode, metastatementNode) {
+  constructor(statementNode, ruleSubproofNode, metaSubproofNode, metastatementNode) {
+    this.statementNode = statementNode;
     this.ruleSubproofNode = ruleSubproofNode;
     this.metaSubproofNode = metaSubproofNode;
     this.metastatementNode = metastatementNode;
   }
 
+  getStatementNode() {
+    return this.statementNode;
+  }
+
   getRuleSubproofNode() {
     return this.ruleSubproofNode;
   }
@@ -90,27 +95,39 @@ export default class MetaproofStep {
     return ruleSubproofAssertionMatches;
   }
 
+  static fromStatementNode(statementNode) {
+    const ruleSubproofNode = null,
+          metaSubproofNode = null,
+          metastatementNode = null,
+          metaProofStep = new MetaproofStep(statementNode, ruleSubproofNode, metaSubproofNode, metastatementNode);
+
+    return metaProofStep;
+  }
+
   static fromRuleSubproofNode(ruleSubproofNode) {
-    const metaSubproofNode = null,
+    const statementNode = null,
+          metaSubproofNode = null,
           metastatementNode = null,
-          metaProofStep = new MetaproofStep(ruleSubproofNode, metaSubproofNode, metastatementNode);
+          metaProofStep = new MetaproofStep(statementNode, ruleSubproofNode, metaSubproofNode, metastatementNode);
 
     return metaProofStep;
   }
 
   static fromMetaSubproofNode(metaSubproofNode) {
-    const ruleSubproofNode = null,
+    const statementNode = null,
+          ruleSubproofNode = null,
           metastatementNode = null,
-          metaProofStep = new MetaproofStep(ruleSubproofNode, metaSubproofNode, metastatementNode);
+          metaProofStep = new MetaproofStep(statementNode, ruleSubproofNode, metaSubproofNode, metastatementNode);
 
     return metaProofStep;
 
   }
 
   static fromMetastatementNode(metastatementNode) {
-    const ruleSubproofNode = null,
+    const statementNode = null,
+          ruleSubproofNode = null,
           metaSubproofNode = null,
-          metaProofStep = new MetaproofStep(ruleSubproofNode, metaSubproofNode, metastatementNode);
+          metaProofStep = new MetaproofStep(statementNode, ruleSubproofNode, metaSubproofNode, metastatementNode);
 
     return metaProofStep;
   }

package/src/utilities/array.js

@@ -6,7 +6,7 @@ import permutationsMatrix from "../permutationsMatrix";
 
 import { MAXIMUM_INDEXES_LENGTH, MAXIMUM_PERMUTATION_LENGTH } from "../constants";
 
-export const { first, second, last, push, prune, match, filter, compress, separate } = arrayUtilities;
+export const { first, second, last, push, prune, extract, match, filter, compress, separate } = arrayUtilities;
 
 export function someSubArray(array, subArrayLength, callback) {
   let found = false;

package/src/verify/metaProofStep.js

@@ -32,7 +32,7 @@ export default function verifyMetaProofStep(metaProofStepNode, substitutions, lo
   } else if (metaSubproofNode !== null) {
     let metaSubproofVerified;
 
-    metaSubproofVerified = verifyMetaSubproof(metaSubproofNode, localMetaContext);
+    metaSubproofVerified = verifyMetaSubproof(metaSubproofNode, substitutions, localMetaContext);
 
     if (metaSubproofVerified) {
       const metaproofStep = MetaproofStep.fromMetaSubproofNode(metaSubproofNode);

package/src/verify/metaSubDerivation.js

@@ -4,14 +4,14 @@ import { nodesQuery } from "../utilities/query";
 
 const metaProofStepNodesQuery = nodesQuery("/metaSubDerivation/metaProofStep|lastMetaProofStep");
 
-export default function verifyMetaSubDerivation(metaSubDerivationNode, localMetaContext) {
+export default function verifyMetaSubDerivation(metaSubDerivationNode, substitutions, localMetaContext) {
   let metaSubDerivationVerified;
 
   const metaProofStepNodes = metaProofStepNodesQuery(metaSubDerivationNode);
 
   metaSubDerivationVerified = metaProofStepNodes.every((metaProofStepNode) => {
     const { verifyMetaProofStep } = verifyMetaSubDerivation,
-          metaProofStepVerified = verifyMetaProofStep(metaProofStepNode, localMetaContext);
+          metaProofStepVerified = verifyMetaProofStep(metaProofStepNode, substitutions, localMetaContext);
 
     if (metaProofStepVerified) {
       return true;

package/src/verify/metaSubproof.js

@@ -9,7 +9,7 @@ import { nodeQuery, nodesQuery } from "../utilities/query";
 const suppositionNodesQuery = nodesQuery("/metaSubproof/supposition"),
       metaSubDerivationNodeQuery = nodeQuery("/metaSubproof/metaSubDerivation");
 
-export default function verifyMetaSubproof(metaSubproofNode, localMetaContext) {
+export default function verifyMetaSubproof(metaSubproofNode, substitutions, localMetaContext) {
   let metaSubproofVerified = false;
 
   localMetaContext = LocalMetaContext.fromLocalMetaContext(localMetaContext); ///
@@ -20,7 +20,7 @@ export default function verifyMetaSubproof(metaSubproofNode, localMetaContext) {
 
   if (metaSuppositionsVerified) {
     const metaSubDerivationNode = metaSubDerivationNodeQuery(metaSubproofNode),
-          metaSubDerivationVerified = verifyMetaSubDerivation(metaSubDerivationNode, localMetaContext);
+          metaSubDerivationVerified = verifyMetaSubDerivation(metaSubDerivationNode, substitutions, localMetaContext);
 
     if (metaSubDerivationVerified) {
       metaSubproofVerified = true;

package/src/verify/metastatement/qualified.js

@@ -1,6 +1,5 @@
 "use strict";
 
-import verifyMetastatement from "../../verify/metastatement";
 import verifyMetavariableAgainstMetastatement from "../../verify/metavariableAgainstMetastatement";
 
 import { nodeQuery } from "../../utilities/query";
@@ -15,28 +14,30 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
 
   localMetaContext.trace(`Verifying the '${qualifiedMetastatementString}' qualified metastatement...`, qualifiedMetastatementNode);
 
-  const derived = false,
-        metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
-        metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localMetaContext, () => {
-          const verifiedAhead = true;
+  const metavariableNode = metavariableNodeQuery(qualifiedMetastatementNode),
+        verifyQualifiedMetastatementFunctions = [
+          verifyQualifiedMetastatementAAgainstRule,
+          verifyQualifiedMetastatementAAgainstReference
+        ];
 
-          return verifiedAhead;
-        });
+  qualifiedMetastatementVerified = verifyQualifiedMetastatementFunctions.some((verifyQualifiedMetastatementFunction) => {  ///
+    const qualifiedMetastatementVerified = verifyQualifiedMetastatementFunction(qualifiedMetastatementNode, metavariableNode, substitutions, localMetaContext);
 
-  if (metastatementVerified) {
-    const metavariableNode = metavariableNodeQuery(qualifiedMetastatementNode),
-          verifyQualifiedMetastatementFunctions = [
-            verifyQualifiedMetastatementAAgainstRule,
-            verifyQualifiedMetastatementAAgainstReference
-          ];
-
-    qualifiedMetastatementVerified = verifyQualifiedMetastatementFunctions.some((verifyQualifiedMetastatementFunction) => {  ///
-      const qualifiedMetastatementVerified = verifyQualifiedMetastatementFunction(qualifiedMetastatementNode, metavariableNode, substitutions, localMetaContext);
-
-      if (qualifiedMetastatementVerified) {
-        return true;
-      }
-    });
+    if (qualifiedMetastatementVerified) {
+      return true;
+    }
+  });
+
+  if (qualifiedMetastatementVerified) {
+    const derived = false,
+          metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
+          metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localMetaContext, () => {
+            const verifiedAhead = true;
+
+            return verifiedAhead;
+          });
+
+    qualifiedMetastatementVerified = metastatementVerified; ///
   }
 
   if (qualifiedMetastatementVerified) {
@@ -98,3 +99,32 @@ function verifyQualifiedMetastatementAAgainstReference(qualifiedMetastatementNod
 
   return qualifiedMetastatementVerifiedAgainstReference;
 }
+
+function verifyMetastatement(metastatementNode, assignments, derived, localMetaContext) {
+  let metastatementVerified;
+
+  const metastatementString = localMetaContext.nodeAsString(metastatementNode);
+
+  localMetaContext.trace(`Verifying the '${metastatementString}' metastatement...`, metastatementNode);
+
+  const verifyMetaStatementFunctions = [
+    ///
+  ];
+
+  verifyMetaStatementFunctions.some((verifyStatementFunction) => {
+    const metastatementVerified = verifyStatementFunction(metastatementNode, assignments, derived, localMetaContext);
+
+    if (metastatementVerified) {
+      return true;
+    }
+  });
+
+  metastatementVerified = true; ///
+
+  if (metastatementVerified) {
+    localMetaContext.debug(`...verified the '${metastatementString}' metastatement.`, metastatementNode);
+  }
+
+  return metastatementVerified;
+}
+

package/src/verify/ruleProofStep.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import LocalContext from "../context/local";
 import MetaproofStep from "../step/metaproof";
 import verifyRuleSubproof from "../verify/ruleSubproof";
 import verifyRuleSubDerivation from "../verify/ruleSubDerivation";
@@ -11,7 +12,8 @@ import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified"
 import { nodeQuery } from "../utilities/query";
 import { assignAssignment } from "../utilities/assignments";
 
-const ruleSubproofNodeQuery = nodeQuery("/ruleProofStep|lastRuleProofStep/ruleSubproof!"),
+const statementNodeQuery = nodeQuery("/qualifiedStatement|unqualifiedStatement/statement!"),
+      ruleSubproofNodeQuery = nodeQuery("/ruleProofStep|lastRuleProofStep/ruleSubproof!"),
       metastatementNodeQuery = nodeQuery("/qualifiedMetastatement|unqualifiedMetastatement/metastatement!"),
       qualifiedStatementNodeQuery = nodeQuery("/ruleProofStep|lastRuleProofStep/qualifiedStatement!"),
       unqualifiedStatementNodeQuery = nodeQuery("/ruleProofStep|lastRuleProofStep/unqualifiedStatement!"),
@@ -42,7 +44,27 @@ export default function verifyRuleProofStep(ruleProofStepNode, localMetaContext)
       ruleProofStepVerified = true;
     }
   } else if (qualifiedStatementNode !== null) {
-    debugger
+    let qualifiedStatementVerified;
+
+    const assignments = [],
+          localContext = LocalContext.fromLocalMetaContext(localMetaContext);
+
+    qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, assignments, localContext);
+
+    if (qualifiedStatementVerified) {
+      const assignmentAssigned = assignAssignment(assignments, localContext);
+
+      qualifiedStatementVerified = assignmentAssigned; ///
+    }
+
+    if (qualifiedStatementVerified) {
+      const statementNode = statementNodeQuery(qualifiedStatementNode),
+            metaproofStep = MetaproofStep.fromStatementNode(statementNode);
+
+      localMetaContext.addMetaproofStep(metaproofStep);
+
+      ruleProofStepVerified = true;
+    }
   } else if (unqualifiedStatementNode !== null) {
     debugger
   } else if (qualifiedMetastatementNode !== null) {

package/src/verify/statement/qualified.js

@@ -1,8 +1,7 @@
 "use strict";
 
-import verifyStatement from "../../verify/statement";
-
 import { nodeQuery } from "../../utilities/query";
+import { verifyStatementAsEquality, verifyStatementAsTypeAssertion } from "../../verify/statement";
 
 const statementNodeQuery = nodeQuery("/qualifiedStatement/statement!"),
       metavariableNodeQuery = nodeQuery("/qualifiedStatement/reference!/metavariable!");
@@ -14,31 +13,33 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
 
   localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement...`, qualifiedStatementNode);
 
-  const derived = false,
-        statementNode = statementNodeQuery(qualifiedStatementNode),
-        statementVerified = verifyStatement(statementNode, assignments, derived, localContext, () => {
-          const verifiedAhead = true;
+  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
+        verifyQualifiedStatementFunctions = [
+          verifyQualifiedStatementAAgainstRule,
+          verifyQualifiedStatementAAgainstAxiom,
+          verifyQualifiedStatementAAgainstLemma,
+          verifyQualifiedStatementAAgainstTheorem,
+          verifyQualifiedStatementAAgainstConjecture
+        ];
 
-          return verifiedAhead;
-        });
+  qualifiedStatementVerified = verifyQualifiedStatementFunctions.some((verifyQualifiedStatementFunction) => {  ///
+    const qualifiedStatementVerified = verifyQualifiedStatementFunction(qualifiedStatementNode, metavariableNode, localContext);
 
-  if (statementVerified) {
-    const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
-          verifyQualifiedStatementFunctions = [
-            verifyQualifiedStatementAAgainstRule,
-            verifyQualifiedStatementAAgainstAxiom,
-            verifyQualifiedStatementAAgainstLemma,
-            verifyQualifiedStatementAAgainstTheorem,
-            verifyQualifiedStatementAAgainstConjecture
-          ];
-
-    qualifiedStatementVerified = verifyQualifiedStatementFunctions.some((verifyQualifiedStatementFunction) => {  ///
-      const qualifiedStatementVerified = verifyQualifiedStatementFunction(qualifiedStatementNode, metavariableNode, localContext);
-
-      if (qualifiedStatementVerified) {
-        return true;
-      }
-    });
+    if (qualifiedStatementVerified) {
+      return true;
+    }
+  });
+
+  if (qualifiedStatementVerified) {
+    const derived = false,
+          statementNode = statementNodeQuery(qualifiedStatementNode),
+          statementVerified = verifyStatement(statementNode, assignments, derived, localContext, () => {
+            const verifiedAhead = true;
+
+            return verifiedAhead;
+          });
+
+    qualifiedStatementVerified = statementVerified;  ///
   }
 
   if (qualifiedStatementVerified) {
@@ -167,3 +168,32 @@ function verifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, meta
 
   return qualifiedStatementVerifiedAgainstConjecture;
 }
+
+function verifyStatement(statementNode, assignments, derived, localContext, verifyAhead) {
+  let statementVerified;
+
+  const statementString = localContext.nodeAsString(statementNode);
+
+  localContext.trace(`Verifying the '${statementString}' statement...`, statementNode);
+
+  const verifyStatementFunctions = [
+    verifyStatementAsEquality,
+    verifyStatementAsTypeAssertion
+  ];
+
+  verifyStatementFunctions.some((verifyStatementFunction) => {
+    const statementVerified = verifyStatementFunction(statementNode, assignments, derived, localContext, verifyAhead);
+
+    if (statementVerified) {
+      return true;
+    }
+  });
+
+  statementVerified = true; ///
+
+  if (statementVerified) {
+    localContext.debug(`...verified the '${statementString}' statement.`, statementNode);
+  }
+
+  return statementVerified;
+}