occam-verify-cli 0.0.507 → 0.0.509

package/src/{metaSubstitution.js → substitution/metastatementForMetavariable.js}

@@ -1,10 +1,10 @@
 "use strict";
 
-import { matcher } from "./matcher";
-import { METASTATEMENT_RULE_NAME } from "./ruleNames";
-import { bracketedNonTerminalChildNodeFromChildNodes } from "./utilities/substitution";
+import { matcher } from "../matcher";
+import { METASTATEMENT_RULE_NAME } from "../ruleNames";
+import { bracketedNonTerminalChildNodeFromChildNodes } from "../utilities/substitution";
 
-export default class MetaSubstitution {
+export default class MetastatementForMetavariableSubstitution {
   constructor(metavariableName, metastatementNode) {
     this.metavariableName = metavariableName;
     this.metastatementNode = metastatementNode;
@@ -47,7 +47,7 @@ export default class MetaSubstitution {
   }
 
   static fromMetavariableNameAndMetastatementNode(metavariableName, metastatementNode) {
-    let metaSubstitution = new MetaSubstitution(metavariableName, metastatementNode);
+    let metastatementForMetavariableSubstitution = new MetastatementForMetavariableSubstitution(metavariableName, metastatementNode);
 
     const nonTerminalNode = metastatementNode,  ///
           childNodes = nonTerminalNode.getChildNodes(),
@@ -56,9 +56,9 @@ export default class MetaSubstitution {
     metastatementNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
 
     if (metastatementNode !== null) {
-      metaSubstitution = new MetaSubstitution(metavariableName, metastatementNode);
+      metastatementForMetavariableSubstitution = new MetastatementForMetavariableSubstitution(metavariableName, metastatementNode);
     }
 
-    return metaSubstitution;
+    return metastatementForMetavariableSubstitution;
   }
 }

package/src/{substitution.js → substitution/statementForMetavariable.js}

@@ -1,10 +1,10 @@
 "use strict";
 
-import { matcher } from "./matcher";
-import { STATEMENT_RULE_NAME } from "./ruleNames";
-import { bracketedNonTerminalChildNodeFromChildNodes } from "./utilities/substitution";
+import { matcher } from "../matcher";
+import { STATEMENT_RULE_NAME } from "../ruleNames";
+import { bracketedNonTerminalChildNodeFromChildNodes } from "../utilities/substitution";
 
-export default class Substitution {
+export default class StatementForMetavariableSubstitution {
   constructor(metavariableName, statementNode) {
     this.metavariableName = metavariableName;
     this.statementNode = statementNode;
@@ -47,7 +47,7 @@ export default class Substitution {
   }
 
   static fromMetavariableNameAndStatementNode(metavariableName, statementNode) {
-    let substitution = new Substitution(metavariableName, statementNode);
+    let statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(metavariableName, statementNode);
 
     const nonTerminalNode = statementNode,  ///
           childNodes = nonTerminalNode.getChildNodes(),
@@ -56,9 +56,9 @@ export default class Substitution {
     statementNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
 
     if (statementNode !== null) {
-      substitution = new Substitution(metavariableName, statementNode);
+      statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(metavariableName, statementNode);
     }
 
-    return substitution;
+    return statementForMetavariableSubstitution;
   }
 }

package/src/substitution/statementForVariable.js

@@ -0,0 +1,64 @@
+"use strict";
+
+import { matcher } from "../matcher";
+import { STATEMENT_RULE_NAME } from "../ruleNames";
+import { bracketedNonTerminalChildNodeFromChildNodes } from "../utilities/substitution";
+
+export default class StatementForVariableSubstitution {
+  constructor(variableName, statementNode) {
+    this.variableName = variableName;
+    this.statementNode = statementNode;
+  }
+
+  getVariableName() {
+    return this.variableName;
+  }
+
+  getStatementNode() {
+    return this.statementNode;
+  }
+
+  matchStatementNode(statementNode) {
+    let matchesStatementNode;
+
+    const nodeA = this.statementNode,  ///
+          nodeB = statementNode,
+          nodeMatches = matcher.matchNode(nodeA, nodeB);
+
+    matchesStatementNode = nodeMatches;  ///
+
+    if (!matchesStatementNode) {
+      const nonTerminalNode = statementNode,  ///
+            childNodes = nonTerminalNode.getChildNodes(), ///
+            ruleName = STATEMENT_RULE_NAME;
+
+      statementNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
+
+      if (statementNode !== null) {
+        const nodeA = this.statementNode,  ///
+              nodeB = statementNode,
+              nodeMatches = matchNode(nodeA, nodeB);
+
+        matchesStatementNode = nodeMatches;  ///
+      }
+    }
+
+    return matchesStatementNode;
+  }
+
+  static fromVariableNameAndStatementNode(variableName, statementNode) {
+    let statementForVariableSubstitution = new StatementForVariableSubstitution(variableName, statementNode);
+
+    const nonTerminalNode = statementNode,  ///
+          childNodes = nonTerminalNode.getChildNodes(),
+          ruleName = STATEMENT_RULE_NAME;
+
+    statementNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
+
+    if (statementNode !== null) {
+      statementForVariableSubstitution = new StatementForVariableSubstitution(variableName, statementNode);
+    }
+
+    return statementForVariableSubstitution;
+  }
+}

package/src/supposition.js

@@ -1,14 +1,14 @@
 "use strict";
 
 import { nodeAsString } from "./utilities/string";
-import { suppositionMatcher } from "./matcher/supposition";
 import { nodeQuery, nodesQuery } from "./utilities/query";
 import { statementNodeFromStatementString } from "./utilities/string";
+import { suppositionStatementForVariableMatcher } from "./matcher/statementForVariable/supposition";
 
-const statementNodesQuery = nodesQuery("/subproofAssertion/statement"),
-      subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
-      unqualifiedStatementStatementNodesQuery = nodesQuery("/subproof/unqualifiedStatement/statement!"),
-      qualifiedOrUnqualifiedStatementStatementNodeQuery = nodeQuery("/subproof/subDerivation/qualifiedStatement|unqualifiedStatement[-1]/statement!");
+const subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
+      subproofAssertionStatementNodesQuery = nodesQuery("/subproofAssertion/statement"),
+      subproofSuppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement/statement!"),
+      subproofSubDerivationLastStatementNodeQuery = nodeQuery("/subproof/subDerivation/qualifiedStatement|unqualifiedStatement[-1]/statement!");
 
 export default class Supposition {
   constructor(statementNode) {
@@ -25,22 +25,22 @@ export default class Supposition {
     const subproofAssertionNode = subproofAssertionNodeQuery(this.statementNode);
 
     if (subproofAssertionNode !== null) {
-      const subproofAssertionStatementNodes = statementNodesQuery(subproofAssertionNode),
-            unqualifiedStatementStatementNodes = unqualifiedStatementStatementNodesQuery(subproofNode),
-            qualifiedOrUnqualifiedStatementStatementNode = qualifiedOrUnqualifiedStatementStatementNodeQuery(subproofNode),
-            statementNodes = [
-              ...unqualifiedStatementStatementNodes,
-              qualifiedOrUnqualifiedStatementStatementNode
+      const subproofSuppositionStatementNodes = subproofSuppositionStatementNodesQuery(subproofNode),
+            subproofSubDerivationLastStatementNode = subproofSubDerivationLastStatementNodeQuery(subproofNode),
+            subproofStatementNodes = [
+              ...subproofSuppositionStatementNodes,
+              subproofSubDerivationLastStatementNode
             ],
-            statementNodesLength = statementNodes.length,
+            subproofAssertionStatementNodes = subproofAssertionStatementNodesQuery(subproofAssertionNode),
+            subproofStatementNodesLength = subproofStatementNodes.length,
             subproofAssertionStatementNodesLength = subproofAssertionStatementNodes.length;
 
-      if (statementNodesLength === subproofAssertionStatementNodesLength) {
+      if (subproofStatementNodesLength === subproofAssertionStatementNodesLength) {
         subproofNodeMatches = subproofAssertionStatementNodes.every((subproofAssertionStatementNode, index) => {
-                                const statementNode = statementNodes[index],
-                                      nonTerminalNode = statementNode, ///
-                                      suppositionNonTerminalNode = subproofAssertionStatementNode,  ///
-                                      nonTerminalNodeMatches = suppositionMatcher.matchNonTerminalNode(suppositionNonTerminalNode, nonTerminalNode, substitutions);
+                                const subproofStatementNode = subproofStatementNodes[index],
+                                      nonTerminalNodeA = subproofAssertionStatementNode,  ///
+                                      nonTerminalNodeB = subproofStatementNode, ///
+                                      nonTerminalNodeMatches = suppositionStatementForVariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
 
                                 if (nonTerminalNodeMatches) {
                                   return true;
@@ -53,9 +53,9 @@ export default class Supposition {
   }
 
   matchStatementNode(statementNode, substitutions) {
-    const nonTerminalNode = statementNode,  ///
-          suppositionNonTerminalNode = this.statementNode,  ///
-          nonTerminalNodeMatches = suppositionMatcher.matchNonTerminalNode(suppositionNonTerminalNode, nonTerminalNode, substitutions),
+    const nonTerminalNodeA = this.statementNode,  ///
+          nonTerminalNodeB = statementNode,  ///
+          nonTerminalNodeMatches = suppositionStatementForVariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
           statementNodeMatches = nonTerminalNodeMatches; ///
 
     return statementNodeMatches;

package/src/verify/assertion/type.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import Variable from "../../variable";
+import TypeAssertion from "../../assertion/type";
 
 import { first } from "../../utilities/array";
 import { nodeAsString } from "../../utilities/string";
@@ -10,14 +10,14 @@ import { verifyTermAsVariable, verifyTermAgainstConstructors } from "../../verif
 const termNodeQuery = nodeQuery("/typeAssertion/term"),
       typeNodeQuery = nodeQuery("/typeAssertion/type");
 
-export default function verifyStatementTypeAssertion(typeAssertionNode, qualified, proofContext) {
+export default function verifyTypeAssertion(typeAssertionNode, assertions, proofContext) {
   let typeAssertionVerified = false;
 
   proofContext.begin(typeAssertionNode);
 
-  const statementString = nodeAsString(typeAssertionNode);
+  const typsAssertionString = nodeAsString(typeAssertionNode);
 
-  proofContext.debug(`Verifying the '${statementString}' type assertion...`);
+  proofContext.debug(`Verifying the '${typsAssertionString}' type assertion...`);
 
   const typeNode = typeNodeQuery(typeAssertionNode),
         typeName = typeNameFromTypeNode(typeNode),
@@ -27,20 +27,20 @@ export default function verifyStatementTypeAssertion(typeAssertionNode, qualifie
     proofContext.error(`The ${typeName} type is not present.`);
   } else {
     if (!typeAssertionVerified) {
-      const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, qualified, proofContext);
+      const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, assertions, proofContext);
 
       typeAssertionVerified = variableTypeAssertionVerified;  ///
     }
 
     if (!typeAssertionVerified) {
-      const termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, qualified, proofContext);
+      const termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, assertions, proofContext);
 
       typeAssertionVerified = termTypeAssertionVerified;  ///
     }
   }
 
   if (typeAssertionVerified) {
-    proofContext.info(`Verified the '${statementString}' statement type assertion.`);
+    proofContext.info(`Verified the '${typsAssertionString}' statement type assertion.`);
   }
 
   typeAssertionVerified ?
@@ -50,7 +50,7 @@ export default function verifyStatementTypeAssertion(typeAssertionNode, qualifie
   return typeAssertionVerified;
 }
 
-function verifyVariableTypeAssertion(typeAssertionNode, qualified, proofContext) {
+function verifyVariableTypeAssertion(typeAssertionNode, assertions, proofContext) {
   let variableTypeAssertionVerified = false;
 
   const context = proofContext, ///
@@ -66,22 +66,19 @@ function verifyVariableTypeAssertion(typeAssertionNode, qualified, proofContext)
           firstVariable = first(variables),
           variable = firstVariable, ///
           variableName = variable.getName(),
-          variableType = variable.getType();
-
-    const assertedTypeEqualToOrSubTypeOfVariableType = (variableType === null) ?
+          variableType = variable.getType(),
+          assertedTypeEqualToOrSubTypeOfVariableType = (variableType === null) ?
                                                          true : ///
                                                            assertedType.isEqualToOrSubTypeOf(variableType);
 
     if (!assertedTypeEqualToOrSubTypeOfVariableType) {
       proofContext.error(`The asserted type is not equal to or a sub-type of the '${variableName}' variable type.`);
     } else {
-      if (!qualified) {
-        const type = assertedType,  ///
-              name = variableName,  ///
-              variable = Variable.fromTypeAndName(type, name);
+      const type = assertedType,  ///
+            typeAssertion = TypeAssertion.fromTypeAndVariableName(type, variableName),
+            assertion = typeAssertion;  ///
 
-        proofContext.addVariable(variable);
-      }
+      assertions.push(assertion);
 
       variableTypeAssertionVerified = true;
     }
@@ -90,7 +87,7 @@ function verifyVariableTypeAssertion(typeAssertionNode, qualified, proofContext)
   return variableTypeAssertionVerified;
 }
 
-function verifyTermTypeAssertion(typeAssertionNode, qualified, proofContext) {
+function verifyTermTypeAssertion(typeAssertionNode, assertions, proofContext) {
   let termTypeAssertionVerified = false;
 
   const types = [],
@@ -106,16 +103,18 @@ function verifyTermTypeAssertion(typeAssertionNode, qualified, proofContext) {
           firstType = first(types),
           termType = firstType,
           termString = nodeAsString(termNode),
-          assertedTypeEqualToOrSubTypeOfTermType = (termType === null) ?
+          assertedTypeEqualToTermType = (termType === null) ?
                                                      true : ///
-                                                       assertedType.isEqualToOrSubTypeOf(termType);
+                                                       assertedType.isEqualTo(termType);
 
-    if (!assertedTypeEqualToOrSubTypeOfTermType) {
-      proofContext.error(`The asserted type is not equal to or a sub-type of the '${termString}' term type.`);
+    if (!assertedTypeEqualToTermType) {
+      proofContext.error(`The asserted type is not equal to the '${termString}' term type.`);
     } else {
-      if (!qualified) {
-        debugger
-      }
+      const type = assertedType,  ///
+            typeAssertion = TypeAssertion.fromTypeAndTermNode(type, termNode),
+            assertion = typeAssertion;  ///
+
+      assertions.push(assertion);
 
       termTypeAssertionVerified = true;
     }

package/src/verify/conclusion.js

@@ -1,11 +1,13 @@
 "use strict";
 
 import Conclusion from "../conclusion";
+import verifyUnqualifiedMetastatement from "./metastatement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
-import {nodeAsString} from "../utilities/string";
+import { nodeAsString } from "../utilities/string";
 
-const metastatementNodeQuery = nodeQuery("/conclusion/unqualifiedMetastatement!/metastatement!");
+const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
+      unqualifiedMetastatementNodeQuery = nodeQuery("/conclusion/unqualifiedMetastatement!");
 
 export default function verifyConclusion(conclusionNode, conclusions, metaproofContext) {
   let conclusionVerified = false;
@@ -16,10 +18,14 @@ export default function verifyConclusion(conclusionNode, conclusions, metaproofC
 
   metaproofContext.debug(`Verifying the '${conclusionString}' conclusion...`);
 
-  const metastatementNode = metastatementNodeQuery(conclusionNode);
+  const derived = false,
+        assertions = [],
+        unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(conclusionNode),
+        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assertions, derived, metaproofContext);
 
-  if (metastatementNode !== null) {
-    const conclusion = Conclusion.fromMetastatementNode(metastatementNode);
+  if (unqualifiedMetastatementVerified) {
+    const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
+          conclusion = Conclusion.fromMetastatementNode(metastatementNode);
 
     conclusions.push(conclusion);
 

package/src/verify/consequence.js

@@ -1,11 +1,13 @@
 "use strict";
 
 import Consequence from "../consequence";
+import verifyUnqualifiedStatement from "./statement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
 import { nodeAsString } from "../utilities/string";
 
-const statementNodeQuery = nodeQuery("/consequence/unqualifiedStatement!/statement!");
+const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
+      unqualifiedStatementNodeQuery = nodeQuery("/consequence/unqualifiedStatement!");
 
 export default function verifyConsequence(consequenceNode, consequences, proofContext) {
   let consequenceVerified = false;
@@ -16,10 +18,14 @@ export default function verifyConsequence(consequenceNode, consequences, proofCo
 
   proofContext.debug(`Verifying the ${consequenceString} consequence...`);
 
-  const statementNode = statementNodeQuery(consequenceNode);
+  const derived = false,
+        assertions = [],
+        unqualifiedStatementNode = unqualifiedStatementNodeQuery(consequenceNode),
+        unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assertions, derived, proofContext);
 
-  if (statementNode !== null) {
-    const consequence = Consequence.fromStatementNode(statementNode);
+  if (unqualifiedStatementVerified) {
+    const statementNode = statementNodeQuery(unqualifiedStatementNode),
+          consequence = Consequence.fromStatementNode(statementNode);
 
     consequences.push(consequence);
 

package/src/verify/derivation.js

@@ -123,8 +123,10 @@ function verifyChild(childNode, proofContext) {
     }
 
     case UNQUALIFIED_STATEMENT_RULE_NAME: {
-      const unqualifiedStatementNode = childNode,  ///
-            unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, proofContext);
+      const derived = true,
+            assertions = [],
+            unqualifiedStatementNode = childNode,  ///
+            unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assertions, derived, proofContext);
 
       if (unqualifiedStatementVerified) {
         const statementNode = statementNodeQuery(unqualifiedStatementNode),

package/src/verify/metastatement/qualified.js

@@ -1,5 +1,7 @@
 "use strict";
 
+import verifyMetastatement from "../../verify/metastatement";
+
 import { nodeAsString } from "../../utilities/string";
 import { nodeQuery, referenceNameFromReferenceNode } from "../../utilities/query";
 
@@ -18,14 +20,26 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
 
     metaproofContext.debug(`Verifying the ${metastatementString} qualified metastatement...`);
 
-    const referenceNode = referenceNodeQuery(qualifiedMetastatementNode),
-          referenceName = referenceNameFromReferenceNode(referenceNode),
-          rule = metaproofContext.findRuleByReferenceName(referenceName);
+    let ruleMatchesStatement = true;
+
+    const referenceNode = referenceNodeQuery(qualifiedMetastatementNode);
+
+    if (referenceNode !== null) {
+      const referenceName = referenceNameFromReferenceNode(referenceNode),
+            rule = metaproofContext.findRuleByReferenceName(referenceName);
+
+      if (rule !== null) {
+        const ruleMatchesStatement = rule.matchMetastatement(metastatementNode, metaproofContext);
+
+        qualifiedMetastatementVerified = ruleMatchesStatement;  ///
+      }
+    }
 
-    if (rule !== null) {
-      const ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, metaproofContext);
+    if (ruleMatchesStatement) {
+      const assertions = [],
+            metastatementVerified = verifyMetastatement(metastatementNode, assertions, metaproofContext);
 
-      qualifiedMetastatementVerified = ruleMatchesMetastatement;  ///
+      qualifiedMetastatementVerified = metastatementVerified; ///
     }
   }
 

package/src/verify/metastatement/unqualified.js

@@ -1,11 +1,13 @@
 "use strict";
 
+import verifyMetastatement from "../metastatement";
+
 import { nodeQuery } from "../../utilities/query";
 import { nodeAsString } from "../../utilities/string";
 
 const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!");
 
-export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, metaproofContext) {
+export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assertions, derived, metaproofContext) {
   let unqualifiedMetastatementVerified = false;
 
   metaproofContext.begin(unqualifiedMetastatementNode);
@@ -17,9 +19,17 @@ export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementN
 
     metaproofContext.debug(`Verifying the ${metastatementString} unqualified metastatement...`);
 
-    const metaAssertionMatches = metaproofContext.matchMetastatement(metastatementNode);
+    let metastatementMatches = true;
+
+    if (derived) {
+      metastatementMatches = metaproofContext.matchMetastatement(metastatementNode);
+    }
+
+    if (metastatementMatches) {
+      const metastatementVerified = verifyMetastatement(metastatementNode, assertions, metaproofContext);
 
-    unqualifiedMetastatementVerified = metaAssertionMatches;  ///
+      unqualifiedMetastatementVerified = metastatementVerified; ///
+    }
   }
 
   unqualifiedMetastatementVerified ?

package/src/verify/metastatement.js

@@ -1,7 +1,7 @@
 "use strict";
 
-export default function verifyMetastatement(metastatementNode, qualified, metaproofContext) {
-  let metastatementVerified = true;
+export default function verifyMetastatement(metastatementNode, assertions, metaproofContext) {
+  let metastatementVerified = true; ///
 
   metaproofContext.begin(metastatementNode);
 

package/src/verify/premise.js

@@ -2,11 +2,13 @@
 
 import Premise from "../premise";
 import MetaproofStep from "../step/metaproof";
+import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
 import { nodeAsString } from "../utilities/string";
 
-const metastatementNodeQuery = nodeQuery("/premise/unqualifiedMetastatement!/metastatement!");
+const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
+      unqualifiedMetastatementNodeQuery = nodeQuery("/premise/unqualifiedMetastatement!");
 
 export default function verifyPremise(premiseNode, premises, metaproofContext) {
   let premiseVerified;
@@ -17,10 +19,14 @@ export default function verifyPremise(premiseNode, premises, metaproofContext) {
 
   metaproofContext.debug(`Verifying the ${premiseString} premise...`);
 
-  const metastatementNode = metastatementNodeQuery(premiseNode);
+  const derived = false,
+        assertions = [],
+        unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(premiseNode),
+        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assertions, derived, metaproofContext);
 
-  if (metastatementNode !== null) {
-    const metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode),
+  if (unqualifiedMetastatementVerified) {
+    const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
+          metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode),
           premise = Premise.fromMetastatementNode(metastatementNode);
 
     premises.push(premise);

package/src/verify/ruleDerivation.js

@@ -123,8 +123,10 @@ function verifyChild(childNode, metaproofContext) {
     }
 
     case UNQUALIFIED_METASTATEMENT_RULE_NAME: {
-      const unqualifiedMetastatementNode = childNode,  ///
-            unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, metaproofContext);
+      const derived = true,
+            assertions = [],
+            unqualifiedMetastatementNode = childNode,  ///
+            unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assertions, derived, metaproofContext);
 
       if (unqualifiedMetastatementVerified) {
         const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),

package/src/verify/statement/qualified.js

@@ -5,8 +5,8 @@ import verifyStatement from "../../verify/statement";
 import { nodeAsString } from "../../utilities/string";
 import { nodeQuery, referenceNameFromReferenceNode } from "../../utilities/query";
 
-const statementNodeQuery = nodeQuery("/qualifiedStatement/statement!"),
-      referenceNodeQuery = nodeQuery("/qualifiedStatement/qualification!/reference!");
+const referenceNodeQuery = nodeQuery("/qualifiedStatement/qualification!/reference!"),
+      statementNodeQuery = nodeQuery("/qualifiedStatement/statement!");
 
 export default function verifyQualifiedStatement(qualifiedStatementNode, proofContext) {
   let qualifiedStatementVerified = false;
@@ -20,23 +20,25 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, proofCo
 
     proofContext.debug(`Verifying the ${statementString} qualified statement...`);
 
-    const referenceNode = referenceNodeQuery(qualifiedStatementNode);
+    let ruleMatchesStatement = true;
 
-    if (referenceNode === null) {
-      const qualified = true,
-            statementVerified = verifyStatement(statementNode, qualified, proofContext);
+    const referenceNode = referenceNodeQuery(qualifiedStatementNode);
 
-      qualifiedStatementVerified = statementVerified; ///
-    } else {
+    if (referenceNode !== null) {
       const referenceName = referenceNameFromReferenceNode(referenceNode),
             rule = proofContext.findRuleByReferenceName(referenceName);
 
       if (rule !== null) {
-        const ruleMatchesStatement = rule.matchStatement(statementNode, proofContext);
-
-        qualifiedStatementVerified = ruleMatchesStatement;  ///
+        ruleMatchesStatement = rule.matchStatement(statementNode, proofContext);
       }
     }
+
+    if (ruleMatchesStatement) {
+      const assertions = [],
+            statementVerified = verifyStatement(statementNode, assertions, proofContext);
+
+      qualifiedStatementVerified = statementVerified; ///
+    }
   }
 
   qualifiedStatementVerified ?

package/src/verify/statement/unqualified.js

@@ -1,11 +1,13 @@
 "use strict";
 
+import verifyStatement from "../statement";
+
 import { nodeQuery } from "../../utilities/query";
 import { nodeAsString } from "../../utilities/string";
 
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
 
-export default function verifyUnqualifiedStatement(unqualifiedStatementNode, proofContext) {
+export default function verifyUnqualifiedStatement(unqualifiedStatementNode, assertions, derived, proofContext) {
   let unqualifiedStatementVerified = false;
 
   proofContext.begin(unqualifiedStatementNode);
@@ -17,9 +19,17 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, pro
 
     proofContext.debug(`Verifying the ${statementString} unqualified statement...`);
 
-    const assertionMatches = proofContext.matchStatement(statementNode);
+    let statementMatches = true;
+
+    if (derived) {
+      statementMatches = proofContext.matchStatement(statementNode);
+    }
+
+    if (statementMatches) {
+      const statementVerified = verifyStatement(statementNode, assertions, proofContext);
 
-    unqualifiedStatementVerified = assertionMatches;  ///
+      unqualifiedStatementVerified = statementVerified;  ///
+    }
   }
 
   unqualifiedStatementVerified ?