occam-verify-cli 0.0.909 → 0.0.911

package/src/supposition.js

@@ -24,9 +24,9 @@ export default class Supposition {
 
             return verifiedAhead;
           }),
-          statementNodeMatches = nonTerminalNodeVerified; ///
+          matchesStatementNode = nonTerminalNodeVerified; ///
 
-    return statementNodeMatches;
+    return matchesStatementNode;
   }
 
   toJSON(tokens) {

package/src/type.js

@@ -92,23 +92,23 @@ export default class Type {
   }
 
   matchName(name) {
-    const nameMatches = (this.name === name);
+    const matchesName = (this.name === name);
 
-    return nameMatches;
+    return matchesName;
   }
 
   matchTypeName(typeName) {
-    const typeNameMatches = (this.name === typeName);
+    const matchesTypeName = (this.name === typeName);
 
-    return typeNameMatches;
+    return matchesTypeName;
   }
 
   matchTypeNode(typeNode) {
     const typeName = typeNameFromTypeNode(typeNode),
-          typeNameMatches = this.matchTypeName(typeName),
-          typeNodeMatches = typeNameMatches;  ///
+          matchesTypeName = this.matchTypeName(typeName),
+          matchesTypeNode = matchesTypeName;  ///
 
-    return typeNodeMatches;
+    return matchesTypeNode;
   }
 
   asString(tokens, noSuperType = false) {

package/src/utilities/match.js

@@ -0,0 +1,100 @@
+"use strict";
+
+import bracketedStatementNode from "../node/statement/bracketed";
+import bracketedMetastatementNode from "../node/metastatement/bracketed";
+
+import { nodeQuery } from "../utilities/query";
+import { BRACKETED_STATEMENT_DEPTH, BRACKETED_METASTATEMENT_DEPTH } from "../constants";
+
+const bracketedStatementChildNodeQuery = nodeQuery("/statement/metaArgument!/statement!"),
+      bracketedMetastatementChildNodeQuery = nodeQuery("/metastatement/metastatement!");
+
+export function matchStatementModuloBrackets(statementNodeA, statementNodeB) {
+  let statementMatchesModuloBrackets = false;
+
+  if (!statementMatchesModuloBrackets) {
+    const statementNodeAMatchesStatementNodeB = statementNodeA.match(statementNodeB);
+
+    statementMatchesModuloBrackets = statementNodeAMatchesStatementNodeB;  ///
+  }
+
+  if (!statementMatchesModuloBrackets) {
+    const bracketedStatementChildNodeA = bracketedStatementChildNodeFromStatementNode(statementNodeA);
+
+    if (bracketedStatementChildNodeA !== null) {
+      const bracketedStatementChildNodeAMatchStatementNodeB = bracketedStatementChildNodeA.match(statementNodeB);
+
+      statementMatchesModuloBrackets = bracketedStatementChildNodeAMatchStatementNodeB; ///
+    }
+  }
+
+  if (!statementMatchesModuloBrackets) {
+    const bracketedStatementChildNodeB = bracketedStatementChildNodeFromStatementNode(statementNodeB);
+
+    if (bracketedStatementChildNodeB !== null) {
+      const statementNodeAMatchBracketedStatementChildNodeB = statementNodeA.match(bracketedStatementChildNodeB);
+
+      statementMatchesModuloBrackets = statementNodeAMatchBracketedStatementChildNodeB; ///
+    }
+  }
+
+  return statementMatchesModuloBrackets;
+}
+
+export function matchMetastatementModuloBrackets(metastatementNodeA, metastatementNodeB) {
+  let metastatementMatches = false;
+
+  if (!metastatementMatches) {
+    const metastatementNodeMatches = metastatementNodeA.match(metastatementNodeB);
+
+    metastatementMatches = metastatementNodeMatches;  ///
+  }
+
+  if (!metastatementMatches) {
+    const bracketedMetastatementChildNodeA = bracketedMetastatementChildNodeFromMetastatementNode(metastatementNodeA);
+
+    if (bracketedMetastatementChildNodeA !== null) {
+      const bracketedMetastatementChildNodeAMatchesMetastatementNodeB = bracketedMetastatementChildNodeA.match(metastatementNodeB);
+
+      metastatementMatches = bracketedMetastatementChildNodeAMatchesMetastatementNodeB; ///
+    }
+  }
+
+  if (!metastatementMatches) {
+    const bracketedMetastatementChildNodeB = bracketedMetastatementChildNodeFromMetastatementNode(metastatementNodeB);
+
+    if (bracketedMetastatementChildNodeB !== null) {
+      const metastatementNodeAMatchesBracketedMetastatementChildNodeB = metastatementNodeA.match(bracketedMetastatementChildNodeB);
+
+      metastatementMatches = metastatementNodeAMatchesBracketedMetastatementChildNodeB; ///
+    }
+  }
+
+  return metastatementMatches;
+}
+
+export function bracketedStatementChildNodeFromStatementNode(statementNode) {
+  let bracketedStatementChildNode = null;
+
+  const depth = BRACKETED_STATEMENT_DEPTH,
+        statementNodeMatchBracketedStatementNode = statementNode.match(bracketedStatementNode, depth);
+
+  if (statementNodeMatchBracketedStatementNode) {
+    bracketedStatementChildNode = bracketedStatementChildNodeQuery(statementNode);
+  }
+
+  return bracketedStatementChildNode;
+}
+
+export function bracketedMetastatementChildNodeFromMetastatementNode(metastatementNode) {
+  let bracketedMetastatementChildNode = null;
+
+  const depth = BRACKETED_METASTATEMENT_DEPTH,
+        metastatementNodeMatchesBracketedMetastatementNode = metastatementNode.match(bracketedMetastatementNode, depth);
+
+  if (metastatementNodeMatchesBracketedMetastatementNode) {
+    bracketedMetastatementChildNode = bracketedMetastatementChildNodeQuery(metastatementNode);
+  }
+
+  return bracketedMetastatementChildNode;
+}

package/src/variable.js

@@ -21,31 +21,31 @@ export default class Variable {
   match(variable) {
     const type = variable.getType(),
           node = variable.getNode(),
-          typeMatches = this.matchType(type),
-          nodeMatches = this.matchNode(node),
-          matches = nodeMatches && typeMatches;
+          matchesType = this.matchType(type),
+          matchesNode = this.matchNode(node),
+          matches = matchesNode && matchesType;
 
     return matches;
   }
 
   matchNode(node) {
-    const nodeMatches = this.node.match(node);
+    const matchesNode = this.node.match(node);
 
-    return nodeMatches;
+    return matchesNode;
   }
 
   matchType(type) {
-    const typeMatches = this.type.match(type);
+    const matchesType = this.type.match(type);
 
-    return typeMatches;
+    return matchesType;
   }
 
   matchNodeAndType(node, type) {
-    const nodeMatches = this.matchNode(node),
-          typeMatches = this.matchType(type),
-          nodeAndTypeMatch = nodeMatches && typeMatches;
+    const matchesNode = this.matchNode(node),
+          matchesType = this.matchType(type),
+          matchesNodeAndType = matchesNode && matchesType;
 
-    return nodeAndTypeMatch;
+    return matchesNodeAndType;
   }
 
   asString(tokens) {

package/src/verify/containedAssertion.js

@@ -6,37 +6,86 @@ import { nodeQuery, nodesQuery } from "../utilities/query";
 const variableNodeQuery = nodeQuery("/containedAssertion/term/variable!"),
       metastatementVariableNodesQuery = nodesQuery("/containedAssertion/statement//variable");
 
-export default function verifyContainedAssertion(containedAssertionNode) {
-  let containedAssertionVerified = false;
-
-  const containedAssertionNegated = isAssertionNegated(containedAssertionNode),
-        variableNode = variableNodeQuery(containedAssertionNode),
-        negated = containedAssertionNegated;  ///
-
-  if (false) {
-    ///
-  } else if (variableNode !== null) {
-    const metastatementVariableNodes = metastatementVariableNodesQuery(containedAssertionNode),
-          variableNodeMatchesMetaArgumentVariableNode = metastatementVariableNodes.some((metastatementVariableNode) => {
-            const variableNodeMatchesMetaArgumentVariableNode = variableNode.match(metastatementVariableNode);
-
-            if (variableNodeMatchesMetaArgumentVariableNode) {
-              return true;
-            }
-          });
-
-    if (!negated) {
-      if (variableNodeMatchesMetaArgumentVariableNode) {
-        containedAssertionVerified = true;
-      }
+export default function verifyContainedAssertion(containedAssertionNode, assignments, derived, localContext) {
+  let containedAssertionVerified;
+
+  const containedAssertionString = localContext.nodeAsString(containedAssertionNode);
+
+  localContext.trace(`Verifying the '${containedAssertionString}' contained assertion...`, containedAssertionNode);
+
+  const containedAssertionFunctions = [
+    verifyDerivedContainedAssertion,
+    verifyStatedContainedAssertion
+  ];
+
+  containedAssertionVerified = containedAssertionFunctions.some((containedAssertionFunction) => {
+    const containedAssertionVerified = containedAssertionFunction(containedAssertionNode, assignments, derived, localContext);
+
+    if (containedAssertionVerified) {
+      return true;
     }
+  });
+
+  if (containedAssertionVerified) {
+    localContext.debug(`...verified the '${containedAssertionString}' contained assertion.`, containedAssertionNode);
+  }
+
+  return containedAssertionVerified;
+}
+
+function verifyDerivedContainedAssertion(containedAssertionNode, assignments, derived, localContext) {
+  let derivedContainedAssertionVerified = false;
+
+  if (derived) {
+    const containedAssertionString = localContext.nodeAsString(containedAssertionNode);
+
+    localContext.trace(`Verifying the derived '${containedAssertionString}' contained assertion...`, containedAssertionNode);
 
-    if (negated) {
-      if (!variableNodeMatchesMetaArgumentVariableNode) {
-        containedAssertionVerified = true;
+    const containedAssertionNegated = isAssertionNegated(containedAssertionNode),
+          variableNode = variableNodeQuery(containedAssertionNode),
+          negated = containedAssertionNegated;  ///
+
+    if (false) {
+      ///
+    } else if (variableNode !== null) {
+      const metastatementVariableNodes = metastatementVariableNodesQuery(containedAssertionNode),
+            variableNodeMatchesMetaArgumentVariableNode = metastatementVariableNodes.some((metastatementVariableNode) => {
+              const variableNodeMatchesMetaArgumentVariableNode = variableNode.match(metastatementVariableNode);
+
+              if (variableNodeMatchesMetaArgumentVariableNode) {
+                return true;
+              }
+            });
+
+      if (!negated) {
+        if (variableNodeMatchesMetaArgumentVariableNode) {
+          derivedContainedAssertionVerified = true;
+        }
       }
+
+      if (negated) {
+        if (!variableNodeMatchesMetaArgumentVariableNode) {
+          derivedContainedAssertionVerified = true;
+        }
+      }
+    }
+
+    if (derivedContainedAssertionVerified) {
+      localContext.debug(`...verified the derived '${containedAssertionString}' contained assertion.`, containedAssertionNode);
     }
   }
 
-  return containedAssertionVerified;
+  return derivedContainedAssertionVerified;
+}
+
+function verifyStatedContainedAssertion(containedAssertionNode, assignments, derived, localContext) {
+  let derivedStatedAssertionVerified = false;
+
+  if (!derived) {
+    const containedAssertionString = localContext.nodeAsString(containedAssertionNode);
+
+    localContext.debug(`The stated '${containedAssertionString}' contained assertion cannot be verified.`, containedAssertionNode);
+  }
+
+  return derivedStatedAssertionVerified;
 }

package/src/verify/definedAssertion.js

@@ -9,60 +9,109 @@ import { isAssertionNegated } from "../utilities/verify";
 const termNodeQuery = nodeQuery("/definedAssertion/term!"),
       variableNodeQuery = nodeQuery("/definedAssertion/term/variable!");
 
-export default function verifyDefinedAssertion(definedAssertionNode, localContext) {
-  let definedAssertionVerified = false;
+export default function verifyDefinedAssertion(definedAssertionNode, assignments, derived, localContext) {
+  let definedAssertionVerified;
 
-  const definedAssertionNegated = isAssertionNegated(definedAssertionNode),
-        variableNode = variableNodeQuery(definedAssertionNode),
-        termNode = termNodeQuery(definedAssertionNode),
-        negated = definedAssertionNegated;  ///
+  const definedAssertionString = localContext.nodeAsString(definedAssertionNode);
 
-  if (false) {
-    ///
-  } else if (variableNode !== null) {
-    const variable = localContext.findVariableByVariableNode(variableNode);
+  localContext.trace(`Verifying the '${definedAssertionString}' defined assertion...`, definedAssertionNode);
 
-    if (variable !== null) {
-      const variableDefined = localContext.isVariableDefined(variable);
+  const definedAssertionFunctions = [
+    verifyDerivedDefinedAssertion,
+    verifyStatedDefinedAssertion
+  ];
 
-      if (!negated) {
-        if (variableDefined) {
-          definedAssertionVerified = true;
+  definedAssertionVerified = definedAssertionFunctions.some((definedAssertionFunction) => {
+    const definedAssertionVerified = definedAssertionFunction(definedAssertionNode, assignments, derived, localContext);
+
+    if (definedAssertionVerified) {
+      return true;
+    }
+  });
+
+  if (definedAssertionVerified) {
+    localContext.debug(`...verified the '${definedAssertionString}' defined assertion.`, definedAssertionNode);
+  }
+
+  return definedAssertionVerified;
+}
+
+function verifyDerivedDefinedAssertion(definedAssertionNode, assignments, derived, localContext) {
+  let derivedDefinedAssertionVerified = false;
+
+  if (derived) {
+    const definedAssertionString = localContext.nodeAsString(definedAssertionNode);
+
+    localContext.trace(`Verifying the derived '${definedAssertionString}' defined assertion...`, definedAssertionNode);
+
+    const definedAssertionNegated = isAssertionNegated(definedAssertionNode),
+          variableNode = variableNodeQuery(definedAssertionNode),
+          termNode = termNodeQuery(definedAssertionNode),
+          negated = definedAssertionNegated;  ///
+
+    if (false) {
+      ///
+    } else if (variableNode !== null) {
+      const variable = localContext.findVariableByVariableNode(variableNode);
+
+      if (variable !== null) {
+        const variableDefined = localContext.isVariableDefined(variable);
+
+        if (!negated) {
+          if (variableDefined) {
+            derivedDefinedAssertionVerified = true;
+          }
         }
-      }
 
-      if (negated) {
-        if (!variableDefined) {
-          definedAssertionVerified = true;
+        if (negated) {
+          if (!variableDefined) {
+            derivedDefinedAssertionVerified = true;
+          }
         }
       }
-    }
-  } else if (termNode !== null) {
-    const terms = [],
-          termVerified = verifyTerm(termNode, terms, localContext, () => {
-            const verifiedAhead = true;
-
-            return verifiedAhead;
-          });
-
-    if (termVerified) {
-      const firstTerm = first(terms),
-            term = firstTerm, ///
-            termGrounded = localContext.isTermGrounded(term);
-
-      if (!negated) {
-        if (termGrounded) {
-          definedAssertionVerified = true;
+    } else if (termNode !== null) {
+      const terms = [],
+            termVerified = verifyTerm(termNode, terms, localContext, () => {
+              const verifiedAhead = true;
+
+              return verifiedAhead;
+            });
+
+      if (termVerified) {
+        const firstTerm = first(terms),
+              term = firstTerm, ///
+              termGrounded = localContext.isTermGrounded(term);
+
+        if (!negated) {
+          if (termGrounded) {
+            derivedDefinedAssertionVerified = true;
+          }
         }
-      }
 
-      if (negated) {
-        if (!termGrounded) {
-          definedAssertionVerified = true;
+        if (negated) {
+          if (!termGrounded) {
+            derivedDefinedAssertionVerified = true;
+          }
         }
       }
     }
+
+    if (derivedDefinedAssertionVerified) {
+      localContext.debug(`...verified the derived '${definedAssertionString}' defined assertion.`, definedAssertionNode);
+    }
   }
 
-  return definedAssertionVerified;
+  return derivedDefinedAssertionVerified;
+}
+
+function verifyStatedDefinedAssertion(definedAssertionNode, assignments, derived, localContext) {
+  let derivedStatedAssertionVerified = false;
+
+  if (!derived) {
+    const definedAssertionString = localContext.nodeAsString(definedAssertionNode);
+
+    localContext.debug(`The stated '${definedAssertionString}' defined assertion cannot be verified.`, definedAssertionNode);
+  }
+
+  return derivedStatedAssertionVerified;
 }

package/src/verify/frame.js

@@ -10,7 +10,7 @@ import { nodesQuery } from "../utilities/query";
 const declarationNodesQuery = nodesQuery("/frame/declaration"),
       metavariableNodesQuery = nodesQuery("/frame/metavariable");
 
-export default function verifyFrame(frameNode, frames, derived, localMetaContext) {
+export default function verifyFrame(frameNode, frames, assignments, derived, localMetaContext) {
   let frameVerified;
 
   const frameString = localMetaContext.nodeAsString(frameNode);

package/src/verify/frameAssertion.js

@@ -55,7 +55,7 @@ function verifyDerivedFrameAssertion(frameAssertionNode, assignments, derived, l
       if (frameAssertion !== null) {
         const frames = [],
               frameNode = frameNodeQuery(frameAssertionNode),
-              frameVerified = verifyFrame(frameNode, frames, derived, localMetaContext);
+              frameVerified = verifyFrame(frameNode, frames, assignments, derived, localMetaContext);
 
         if (frameVerified) {
           const firstFrame = first(frames),
@@ -114,7 +114,7 @@ function verifyStatedFrameAssertion(frameAssertionNode, assignments, derived, lo
     if (metavariableVerified) {
       const frames = [],
             frameNode = frameNodeQuery(frameAssertionNode),
-            frameVerified = verifyFrame(frameNode, frames, derived, localMetaContext);
+            frameVerified = verifyFrame(frameNode, frames, assignments, derived, localMetaContext);
 
       if (frameVerified) {
         const firstFrame = first(frames),

package/src/verify/metaDerivation.js

@@ -1,20 +1,20 @@
 "use strict";
 
-import verifyMetaProofStep from "../verify/metaProofStep";
+import verifyMetaproofStep from "../verify/metaproofStep";
 
 import { nodesQuery } from "../utilities/query";
 
-const metaProofStepNodesQuery = nodesQuery("/metaDerivation/metaProofStep|lastMetaProofStep");
+const metaproofStepNodesQuery = nodesQuery("/metaDerivation/metaproofStep|lastMetaproofStep");
 
 export default function verifyMetaDerivation(metaDerivationNode, substitutions, localMetaContext) {
   let metaDerivationVerified;
 
-  const metaProofStepNodes = metaProofStepNodesQuery(metaDerivationNode);
+  const metaproofStepNodes = metaproofStepNodesQuery(metaDerivationNode);
 
-  metaDerivationVerified = metaProofStepNodes.every((metaProofStepNode) => {
-    const metaProofStepVerified = verifyMetaProofStep(metaProofStepNode, substitutions, localMetaContext);
+  metaDerivationVerified = metaproofStepNodes.every((metaproofStepNode) => {
+    const metaproofStepVerified = verifyMetaproofStep(metaproofStepNode, substitutions, localMetaContext);
 
-    if (metaProofStepVerified) {
+    if (metaproofStepVerified) {
       return true;
     }
   });

package/src/verify/metaSubDerivation.js

@@ -2,18 +2,18 @@
 
 import { nodesQuery } from "../utilities/query";
 
-const metaProofStepNodesQuery = nodesQuery("/metaSubDerivation/metaProofStep|lastMetaProofStep");
+const metaproofStepNodesQuery = nodesQuery("/metaSubDerivation/metaproofStep|lastMetaproofStep");
 
 export default function verifyMetaSubDerivation(metaSubDerivationNode, substitutions, localMetaContext) {
   let metaSubDerivationVerified;
 
-  const metaProofStepNodes = metaProofStepNodesQuery(metaSubDerivationNode);
+  const metaproofStepNodes = metaproofStepNodesQuery(metaSubDerivationNode);
 
-  metaSubDerivationVerified = metaProofStepNodes.every((metaProofStepNode) => {
-    const { verifyMetaProofStep } = verifyMetaSubDerivation,
-          metaProofStepVerified = verifyMetaProofStep(metaProofStepNode, substitutions, localMetaContext);
+  metaSubDerivationVerified = metaproofStepNodes.every((metaproofStepNode) => {
+    const { verifyMetaproofStep } = verifyMetaSubDerivation,
+          metaproofStepVerified = verifyMetaproofStep(metaproofStepNode, substitutions, localMetaContext);
 
-    if (metaProofStepVerified) {
+    if (metaproofStepVerified) {
       return true;
     }
   });

package/src/verify/{metaProofStep.js → metaproofStep.js}

@@ -11,21 +11,21 @@ import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified"
 import { nodeQuery } from "../utilities/query";
 import { assignAssignment } from "../utilities/assignments";
 
-const metaSubproofNodeQuery = nodeQuery("/metaProofStep|lastMetaProofStep/metaSubproof!"),
+const metaSubproofNodeQuery = nodeQuery("/metaproofStep|lastMetaproofStep/metaSubproof!"),
       metastatementNodeQuery = nodeQuery("/qualifiedMetastatement|unqualifiedMetastatement/metastatement!"),
-      qualifiedStatementNodeQuery = nodeQuery("/metaProofStep|lastMetaProofStep/qualifiedStatement!"),
-      unqualifiedStatementNodeQuery = nodeQuery("/metaProofStep|lastMetaProofStep/unqualifiedStatement!"),
-      qualifiedMetastatementNodeQuery = nodeQuery("/metaProofStep|lastMetaProofStep/qualifiedMetastatement!"),
-      unqualifiedMetastatementNodeQuery = nodeQuery("/metaProofStep|lastMetaProofStep/unqualifiedMetastatement!");
+      qualifiedStatementNodeQuery = nodeQuery("/metaproofStep|lastMetaproofStep/qualifiedStatement!"),
+      unqualifiedStatementNodeQuery = nodeQuery("/metaproofStep|lastMetaproofStep/unqualifiedStatement!"),
+      qualifiedMetastatementNodeQuery = nodeQuery("/metaproofStep|lastMetaproofStep/qualifiedMetastatement!"),
+      unqualifiedMetastatementNodeQuery = nodeQuery("/metaproofStep|lastMetaproofStep/unqualifiedMetastatement!");
 
-export default function verifyMetaProofStep(metaProofStepNode, substitutions, localMetaContext) {
-  let metaProofStepVerified = false;
+export default function verifyMetaproofStep(metaproofStepNode, substitutions, localMetaContext) {
+  let metaproofStepVerified = false;
 
-  const metaSubproofNode = metaSubproofNodeQuery(metaProofStepNode),
-        qualifiedStatementNode = qualifiedStatementNodeQuery(metaProofStepNode),
-        unqualifiedStatementNode = unqualifiedStatementNodeQuery(metaProofStepNode),
-        qualifiedMetastatementNode = qualifiedMetastatementNodeQuery(metaProofStepNode),
-        unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(metaProofStepNode);
+  const metaSubproofNode = metaSubproofNodeQuery(metaproofStepNode),
+        qualifiedStatementNode = qualifiedStatementNodeQuery(metaproofStepNode),
+        unqualifiedStatementNode = unqualifiedStatementNodeQuery(metaproofStepNode),
+        qualifiedMetastatementNode = qualifiedMetastatementNodeQuery(metaproofStepNode),
+        unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(metaproofStepNode);
 
   if (false) {
     ///
@@ -39,12 +39,53 @@ export default function verifyMetaProofStep(metaProofStepNode, substitutions, lo
 
       localMetaContext.addMetaproofStep(metaproofStep);
 
-      metaProofStepVerified = true;
+      metaproofStepVerified = true;
     }
   } else if (qualifiedStatementNode !== null) {
-    debugger
+    let qualifiedStatementVerified;
+
+    const assignments = [],
+          localContext = 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);
+
+      metaproofStepVerified = true;
+    }
   } else if (unqualifiedStatementNode !== null) {
-    debugger
+    let qualifiedStatementVerified;
+
+    const assignments = [],
+          localContext = localMetaContext,  ///
+          substitutions = null;
+
+    qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, substitutions, assignments, localContext);
+
+    if (qualifiedStatementVerified) {
+      const assignmentAssigned = assignAssignment(assignments, localContext);
+
+      qualifiedStatementVerified = assignmentAssigned; ///
+    }
+
+    if (qualifiedStatementVerified) {
+      const statementNode = statementNodeQuery(qualifiedStatementNode),
+            metaproofStep = MetaproofStep.fromStatementNode(statementNode);
+
+      localMetaContext.addMetaproofStep(metaproofStep);
+
+      metaproofStepVerified = qualifiedStatementVerified; ///
+    }
   } else if (qualifiedMetastatementNode !== null) {
     let qualifiedMetastatementVerified;
 
@@ -65,7 +106,7 @@ export default function verifyMetaProofStep(metaProofStepNode, substitutions, lo
 
       localMetaContext.addMetaproofStep(metaproofStep);
 
-      metaProofStepVerified = qualifiedMetastatementVerified; ///
+      metaproofStepVerified = qualifiedMetastatementVerified; ///
     }
   } else if (unqualifiedMetastatementNode !== null) {
     let unqualifiedMetastatementVerified;
@@ -88,13 +129,13 @@ export default function verifyMetaProofStep(metaProofStepNode, substitutions, lo
 
       localMetaContext.addMetaproofStep(metaproofStep);
 
-      metaProofStepVerified = true;
+      metaproofStepVerified = true;
     }
   }
 
-  return metaProofStepVerified;
+  return metaproofStepVerified;
 }
 
 Object.assign(verifyMetaSubDerivation, {
-  verifyMetaProofStep
+  verifyMetaproofStep
 });