occam-verify-cli 0.0.968 → 0.0.971

package/src/verify/assertion/subproof.js

@@ -7,18 +7,18 @@ const verifySubproofAssertionFunctions = [
   verifyStatedSubproofAssertion
 ];
 
-export default function verifySubproofAssertion(subproofAssertionNode, assignments, derived, localContext) {
-  let subproofAssertionVerified;
+export default function verifySubproofAssertion(subproofAssertionNode, assignments, stated, localContext) {
+  let subproofAssertionVerified = false;
 
   const subproofAssertionString = localContext.nodeAsString(subproofAssertionNode);
 
   localContext.trace(`Verifying the '${subproofAssertionString}' subproof assertion...`, subproofAssertionNode);
 
-  const verified = metaLevelVerifier.verify(subproofAssertionNode, assignments, derived, localContext);
+  const verified = metaLevelVerifier.verify(subproofAssertionNode, assignments, stated, localContext);
 
   if (verified) {
     subproofAssertionVerified = verifySubproofAssertionFunctions.some((verifySubproofAssertionFunction) => {
-      const subproofAssertionVerified = verifySubproofAssertionFunction(subproofAssertionNode, assignments, derived, localContext);
+      const subproofAssertionVerified = verifySubproofAssertionFunction(subproofAssertionNode, assignments, stated, localContext);
 
       if (subproofAssertionVerified) {
         return true;
@@ -33,10 +33,10 @@ export default function verifySubproofAssertion(subproofAssertionNode, assignmen
   return subproofAssertionVerified;
 }
 
-function verifyDerivedSubproofAssertion(subproofAssertionNode, assignments, derived, localContext) {
+function verifyDerivedSubproofAssertion(subproofAssertionNode, assignments, stated, localContext) {
   let derivedSubproofAssertionVerified;
 
-  if (derived) {
+  if (!stated) {
     const subproofAssertionString = localContext.nodeAsString(subproofAssertionNode);
 
     localContext.trace(`Verifying the '${subproofAssertionString}' derived subproof assertion...`, subproofAssertionNode);
@@ -49,10 +49,10 @@ function verifyDerivedSubproofAssertion(subproofAssertionNode, assignments, deri
   return derivedSubproofAssertionVerified;
 }
 
-function verifyStatedSubproofAssertion(subproofAssertionNode, assignments, derived, localContext) {
+function verifyStatedSubproofAssertion(subproofAssertionNode, assignments, stated, localContext) {
   let statedSubproofAssertionVerified;
 
-  if (!derived) {
+  if (stated) {
     const subproofAssertionString = localContext.nodeAsString(subproofAssertionNode);
 
     localContext.trace(`Verifying the '${subproofAssertionString}' stated subproof assertion...`, subproofAssertionNode);

package/src/verify/assertion/type.js

@@ -11,20 +11,20 @@ const termNodeQuery = nodeQuery("/typeAssertion/term!"),
       typeNodeQuery = nodeQuery("/typeAssertion/type!"),
       variableNodeQuery = nodeQuery("/term/variable!");
 
-export default function verifyTypeAssertion(typeAssertionNode, assignments, derived, localContext) {
+const verifyTypeAssertionFunctions = [
+  verifyDerivedTypeAssertion,
+  verifyStatedTypeAssertion
+];
+
+export default function verifyTypeAssertion(typeAssertionNode, assignments, stated, localContext) {
   let typeAssertionVerified;
 
   const typeAssertionString = localContext.nodeAsString(typeAssertionNode);
 
   localContext.trace(`Verifying the '${typeAssertionString}' type assertion...`, typeAssertionNode);
 
-  const verifyTypeAssertionFunctions = [
-    verifyDerivedTypeAssertion,
-    verifyStatedTypeAssertion
-  ];
-
   typeAssertionVerified = verifyTypeAssertionFunctions.some((verifyTypeAssertionFunction) => {
-    const typeAssertionVerified = verifyTypeAssertionFunction(typeAssertionNode, assignments, derived, localContext);
+    const typeAssertionVerified = verifyTypeAssertionFunction(typeAssertionNode, assignments, stated, localContext);
 
     if (typeAssertionVerified) {
       return true;
@@ -38,10 +38,10 @@ export default function verifyTypeAssertion(typeAssertionNode, assignments, deri
   return typeAssertionVerified;
 }
 
-function verifyDerivedTypeAssertion(typeAssertionNode, assignments, derived, localContext) {
+function verifyDerivedTypeAssertion(typeAssertionNode, assignments, stated, localContext) {
   let derivedTypeAssertionVerified = false;
 
-  if (derived) {
+  if (!stated) {
     const typeAssertionString = localContext.nodeAsString(typeAssertionNode);
 
     localContext.trace(`Verifying the '${typeAssertionString}' derived type assertion...`, typeAssertionNode);
@@ -82,10 +82,10 @@ function verifyDerivedTypeAssertion(typeAssertionNode, assignments, derived, loc
   return derivedTypeAssertionVerified;
 }
 
-function verifyStatedTypeAssertion(typeAssertionNode, assignments, derived, localContext) {
+function verifyStatedTypeAssertion(typeAssertionNode, assignments, stated, localContext) {
   let statedTypeAssertionVerified = false;
 
-  if (!derived) {
+  if (stated) {
     const typeAssertionString = localContext.nodeAsString(typeAssertionNode);
 
     localContext.trace(`Verifying the '${typeAssertionString}' stated type assertion...`, typeAssertionNode);

package/src/verify/conclusion.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import Conclusion from "../conclusion";
-import verifyUnqualifiedStatement from "../verify/statement/unqualified";
+import verifyStatement from "../verify/statement";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -15,16 +15,16 @@ export default function verifyConclusion(conclusionNode, conclusions, localConte
 
   localContext.trace(`Verifying the '${conclusionString}' conclusion...`, conclusionNode);
 
-  const derived = false,
-        assignments = [],
-        unqualifiedStatementNode = unqualifiedStatementNodeQuery(conclusionNode);
+  const unqualifiedStatementNode = unqualifiedStatementNodeQuery(conclusionNode);
 
   if (unqualifiedStatementNode !== null) {
-    const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
+    const stated = true,
+          assignments = [],
+          statementNode = statementNodeQuery(unqualifiedStatementNode),
+          statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
 
-    if (unqualifiedStatementVerified) {
-      const statementNode = statementNodeQuery(unqualifiedStatementNode),
-            conclusion = Conclusion.fromStatementNode(statementNode);
+    if (statementVerified) {
+      const conclusion = Conclusion.fromStatementNode(statementNode);
 
       conclusions.push(conclusion);
 

package/src/verify/consequent.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import Consequent from "../consequent";
-import verifyUnqualifiedStatement from "../verify/statement/unqualified";
+import verifyStatement from "../verify/statement";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -15,16 +15,16 @@ export default function verifyConsequent(consequentNode, consequents, localConte
 
   localContext.trace(`Verifying the '${consequentString}' consequent...`, consequentNode);
 
-  const derived = false,
-        assignments = [],
-        unqualifiedStatementNode = unqualifiedStatementNodeQuery(consequentNode);
+  const unqualifiedStatementNode = unqualifiedStatementNodeQuery(consequentNode);
 
   if (unqualifiedStatementNode !== null) {
-    const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
+    const stated = true,
+          assignments = [],
+          statementNode = statementNodeQuery(unqualifiedStatementNode),
+          statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
 
-    if (unqualifiedStatementVerified) {
-      const statementNode = statementNodeQuery(unqualifiedStatementNode),
-            consequent = Consequent.fromStatementNode(statementNode);
+    if (statementVerified) {
+      const consequent = Consequent.fromStatementNode(statementNode);
 
       consequents.push(consequent);
 

package/src/verify/declaration/metavariable.js

@@ -5,7 +5,7 @@ import MetavariableAssignment from "../../assignment/metavariable";
 
 import { first } from "../../utilities/array";
 import { nodeQuery } from "../../utilities/query";
-import { nameFromMetavariableNode } from "../../utilities/name";
+import { metavariableNameFromMetavariableNode } from "../../utilities/name";
 
 const termNodeQuery = nodeQuery("/argument/term"),
       typeNodeQuery = nodeQuery("/argument/type"),
@@ -70,8 +70,9 @@ function verifyMetavariable(metavariableNode, metaTypeNode, fileContext) {
         termType = firstTermType; ///
       }
 
-      const node = metavariableNode,  ///
-            name = nameFromMetavariableNode(metavariableNode),
+      const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+            node = metavariableNode,  ///
+            name = metavariableName,  ///
             metavariable = Metavariable.fromNodeNameTermTypeAndMetaType(node, name, termType, metaType),
             metavariableAssignment = MetavariableAssignment.fromMetavariable(metavariable),
             metavariableAssigned = metavariableAssignment.assign(fileContext);

package/src/verify/declaration.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import shim from "../shim";
 import Declaration from "../declaration"
 import referenceMetaType from "../metaType/reference";
 
@@ -8,20 +9,20 @@ import { nodeQuery } from "../utilities/query";
 const statementNodeQuery = nodeQuery("/declaration/statement!"),
       metavariableNodeQuery = nodeQuery("/declaration/metavariable!");
 
-export default function verifyDeclaration(declarationNode, assignments, derived, localContext) {
+const verifyDeclarationFunctions = [
+  verifyDerivedDeclaration,
+  verifyStatedDeclaration
+];
+
+export default function verifyDeclaration(declarationNode, declarations, stated, localContext) {
   let declarationVerified;
 
   const declarationString = localContext.nodeAsString(declarationNode);
 
   localContext.trace(`Verifying the '${declarationString}' declaration...`, declarationNode);
 
-  const verifyDeclarationFunctions = [
-    verifyDerivedDeclaration,
-    verifyStatedDeclaration
-  ];
-
   declarationVerified = verifyDeclarationFunctions.some((verifyDeclarationFunction) => {
-    const declarationVerified = verifyDeclarationFunction(declarationNode, assignments, derived, localContext);
+    const declarationVerified = verifyDeclarationFunction(declarationNode, declarations, stated, localContext);
 
     if (declarationVerified) {
       return true;
@@ -35,32 +36,54 @@ export default function verifyDeclaration(declarationNode, assignments, derived,
   return declarationVerified;
 }
 
-function verifyStatedDeclaration(declarationNode, declarations, localContext) {
-  let statedDeclarationVerified = false;
+function verifyDerivedDeclaration(declarationNode, declarations, stated, localContext) {
+  let derivedDeclarationVerified;
 
-  const declarationString = localContext.nodeAsString(declarationNode);
+  if (!stated) {
+    const declarationString = localContext.nodeAsString(declarationNode);
 
-  localContext.trace(`Verifying the '${declarationString}' stated declaration...`, declarationNode);
+    localContext.trace(`Verifying the '${declarationString}' derived declaration...`, declarationNode);
 
-  const metavariableNode = metavariableNodeQuery(declarationNode),
-        metavariableVerified = verifyMetavariable(metavariableNode, localContext);
+    debugger
 
-  if (metavariableVerified) {
-    const statementNode = statementNodeQuery(declarationNode);
+    if (derivedDeclarationVerified) {
+      localContext.debug(`...verified the '${declarationString}' derived declaration.`, declarationNode);
+    }
+  }
 
-    debugger
+  return derivedDeclarationVerified;
+}
+
+function verifyStatedDeclaration(declarationNode, declarations, stated, localContext) {
+  let statedDeclarationVerified = false;
+
+  if (stated) {
+    const declarationString = localContext.nodeAsString(declarationNode);
+
+    localContext.trace(`Verifying the '${declarationString}' stated declaration...`, declarationNode);
 
-    if (statementVerified) {
-      const declaration = Declaration.fromMetavariableNodeAndStatementNode(metavariableNode, statementNode);
+    const metavariableNode = metavariableNodeQuery(declarationNode),
+          metavariableVerified = verifyMetavariable(metavariableNode, localContext);
 
-      declarations.push(declaration);
+    if (metavariableVerified) {
+      const { verifyStatement } = shim,
+            stated = true,
+            assignments = [],
+            statementNode = statementNodeQuery(declarationNode),
+            statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
 
-      statedDeclarationVerified = true;
+      if (statementVerified) {
+        const declaration = Declaration.fromMetavariableNodeAndStatementNode(metavariableNode, statementNode);
+
+        declarations.push(declaration);
+
+        statedDeclarationVerified = true;
+      }
     }
-  }
 
-  if (statedDeclarationVerified) {
-    localContext.debug(`...verified the '${declarationString}' stated declaration.`, declarationNode);
+    if (statedDeclarationVerified) {
+      localContext.debug(`...verified the '${declarationString}' stated declaration.`, declarationNode);
+    }
   }
 
   return statedDeclarationVerified;

package/src/verify/equality.js

@@ -8,20 +8,20 @@ import { nodesQuery } from "../utilities/query";
 
 const termNodesQuery = nodesQuery("/equality/term");
 
-export default function verifyEquality(equalityNode, assignments, derived, localContext) {
+const verifyEqualityFunctions = [
+  verifyDerivedEquality,
+  verifyStatedEquality
+];
+
+export default function verifyEquality(equalityNode, assignments, stated, localContext) {
   let equalityVerified;
 
   const equalityString = localContext.nodeAsString(equalityNode);
 
   localContext.trace(`Verifying the '${equalityString}' equality...`, equalityNode);
 
-  const verifyEqualityFunctions = [
-    verifyDerivedEquality,
-    verifyStatedEquality
-  ];
-
   equalityVerified = verifyEqualityFunctions.some((verifyEqualityFunction) => {
-    const equalityVerified = verifyEqualityFunction(equalityNode, assignments, derived, localContext);
+    const equalityVerified = verifyEqualityFunction(equalityNode, assignments, stated, localContext);
 
     if (equalityVerified) {
       return true;
@@ -35,13 +35,13 @@ export default function verifyEquality(equalityNode, assignments, derived, local
   return equalityVerified;
 }
 
-function verifyDerivedEquality(equalityNode, assignments, derived, localContext) {
+function verifyDerivedEquality(equalityNode, assignments, stated, localContext) {
   let derivedEqualityVerified = false;
 
-  if (derived) {
+  if (!stated) {
     const equalityString = localContext.nodeAsString(equalityNode);
 
-    localContext.trace(`Verifying the '${equalityString}' derived equality...`, equalityNode);
+    localContext.trace(`Verifying the '${equalityString}' stated equality...`, equalityNode);
 
     const terms = [],
           termNodes = termNodesQuery(equalityNode),
@@ -69,17 +69,17 @@ function verifyDerivedEquality(equalityNode, assignments, derived, localContext)
     derivedEqualityVerified = termsVerified; ///
 
     if (derivedEqualityVerified) {
-      localContext.debug(`...verified the '${equalityString}' derived equality.`, equalityNode);
+      localContext.debug(`...verified the '${equalityString}' stated equality.`, equalityNode);
     }
   }
 
   return derivedEqualityVerified;
 }
 
-function verifyStatedEquality(equalityNode, assignments, derived, localContext) {
+function verifyStatedEquality(equalityNode, assignments, stated, localContext) {
   let statedEqualityVerified = false;
 
-  if (!derived) {
+  if (stated) {
     const equalityString = localContext.nodeAsString(equalityNode);
 
     localContext.trace(`Verifying the '${equalityString}' stated equality...`, equalityNode);

package/src/verify/frame.js

@@ -10,20 +10,20 @@ import { nodesQuery } from "../utilities/query";
 const declarationNodesQuery = nodesQuery("/frame/declaration"),
       metavariableNodesQuery = nodesQuery("/frame/metavariable");
 
-export default function verifyFrame(frameNode, assignments, derived, localContext) {
+const verifyFrameFunctions = [
+  verifyDerivedFrame,
+  verifyStatedFrame
+];
+
+export default function verifyFrame(frameNode, frames, stated, localContext) {
   let frameVerified;
 
   const frameString = localContext.nodeAsString(frameNode);
 
   localContext.trace(`Verifying the '${frameString}' frame...`, frameNode);
 
-  const verifyFrameFunctions = [
-    verifyDerivedFrame,
-    verifyStatedFrame
-  ];
-
   frameVerified = verifyFrameFunctions.some((verifyFrameFunction) => {
-    const frameVerified = verifyFrameFunction(frameNode, assignments, derived, localContext);
+    const frameVerified = verifyFrameFunction(frameNode, frames, stated, localContext);
 
     if (frameVerified) {
       return true;
@@ -37,37 +37,57 @@ export default function verifyFrame(frameNode, assignments, derived, localContex
   return frameVerified;
 }
 
-function verifyStatedFrame(frameNode, frames, assignments, derived, localContext) {
+function verifyDerivedFrame(frameNode, frames, stated, localContext) {
+  let derivedFrameVerified;
+
+  if (!stated) {
+    const frameString = localContext.nodeAsString(frameNode);
+
+    localContext.trace(`Verifying the '${frameString}' derived frame...`, frameNode);
+
+    debugger
+
+    if (derivedFrameVerified) {
+      localContext.debug(`...verified the '${frameString}' derived frame.`, frameNode);
+    }
+  }
+
+  return derivedFrameVerified;
+}
+
+function verifyStatedFrame(frameNode, frames, stated, localContext) {
   let statedFrameVerified;
 
-  const frameString = localContext.nodeAsString(frameNode);
+  if (stated) {
+    const frameString = localContext.nodeAsString(frameNode);
 
-  localContext.trace(`Verifying the '${frameString}' stated frame...`, frameNode);
+    localContext.trace(`Verifying the '${frameString}' stated frame...`, frameNode);
 
-  const declarations = [],
-        declarationNodes = declarationNodesQuery(frameNode),
-        metavariableNodes = metavariableNodesQuery(frameNode),
-        declarationsVerified = declarationNodes.every((declarationNode) => {
-          const declarationVerified = verifyDeclaration(declarationNode, declarations, localContext);
+    const declarations = [],
+          declarationNodes = declarationNodesQuery(frameNode),
+          metavariableNodes = metavariableNodesQuery(frameNode),
+          declarationsVerified = declarationNodes.every((declarationNode) => {
+            const declarationVerified = verifyDeclaration(declarationNode, declarations, stated, localContext);
 
-          return declarationVerified;
-        }),
-        metavariablesVerified = metavariableNodes.every((metavariableNode) => {
-          const metavariableVerified = verifyMetavariable(metavariableNode, declarations, localContext);
+            return declarationVerified;
+          }),
+          metavariablesVerified = metavariableNodes.every((metavariableNode) => {
+            const metavariableVerified = verifyMetavariable(metavariableNode, declarations, localContext);
 
-          return metavariableVerified;
-        });
+            return metavariableVerified;
+          });
 
-  if (declarationsVerified && metavariablesVerified) {
-    const frame = Frame.fromDeclarations(declarations);
+    if (declarationsVerified && metavariablesVerified) {
+      const frame = Frame.fromDeclarations(declarations);
 
-    frames.push(frame);
+      frames.push(frame);
 
-    statedFrameVerified = true;
-  }
+      statedFrameVerified = true;
+    }
 
-  if (statedFrameVerified) {
-    localContext.debug(`...verified the '${frameString}' stated frame.`, frameNode);
+    if (statedFrameVerified) {
+      localContext.debug(`...verified the '${frameString}' stated frame.`, frameNode);
+    }
   }
 
   return statedFrameVerified;

package/src/verify/judgement.js

@@ -11,20 +11,20 @@ import { nodeQuery } from "../utilities/query";
 const frameNodeQuery = nodeQuery("/judgement/frame!"),
       metavariableNodeQuery = nodeQuery("/judgement/metavariable!");
 
-export default function verifyJudgement(judgementNode, assignments, derived, localContext) {
+const verifyJudgementFunctions = [
+  verifyDerivedJudgement,
+  verifyStatedJudgement
+];
+
+export default function verifyJudgement(judgementNode, assignments, stated, localContext) {
   let judgementVerified;
 
   const judgementString = localContext.nodeAsString(judgementNode);
 
   localContext.trace(`Verifying the '${judgementString}' judgement...`, judgementNode);
 
-  const verifyJudgementFunctions = [
-    verifyDerivedJudgement,
-    verifyStatedJudgement
-  ];
-
   judgementVerified = verifyJudgementFunctions.some((verifyJudgementFunction) => {
-    const judgementVerified = verifyJudgementFunction(judgementNode, assignments, derived, localContext);
+    const judgementVerified = verifyJudgementFunction(judgementNode, assignments, stated, localContext);
 
     if (judgementVerified) {
       return true;
@@ -38,10 +38,10 @@ export default function verifyJudgement(judgementNode, assignments, derived, loc
   return judgementVerified;
 }
 
-function verifyDerivedJudgement(judgementNode, assignments, derived, localContext) {
+function verifyDerivedJudgement(judgementNode, assignments, stated, localContext) {
   let derivedJudgementVerified = false;
 
-  if (derived) {
+  if (!stated) {
     const judgementString = localContext.nodeAsString(judgementNode);
 
     localContext.trace(`Verifying the '${judgementString}' derived judgement...`, judgementNode);
@@ -55,7 +55,7 @@ function verifyDerivedJudgement(judgementNode, assignments, derived, localContex
       if (judgement !== null) {
         const frames = [],
               frameNode = frameNodeQuery(judgementNode),
-              frameVerified = verifyFrame(frameNode, frames, assignments, derived, localContext);
+              frameVerified = verifyFrame(frameNode, frames, assignments, stated, localContext);
 
         if (frameVerified) {
           const firstFrame = first(frames),
@@ -100,10 +100,10 @@ function verifyDerivedJudgement(judgementNode, assignments, derived, localContex
   return derivedJudgementVerified;
 }
 
-function verifyStatedJudgement(judgementNode, assignments, derived, localContext) {
+function verifyStatedJudgement(judgementNode, assignments, stated, localContext) {
   let statedJudgementVerified = false;
 
-  if (!derived) {
+  if (stated) {
     const judgementString = localContext.nodeAsString(judgementNode);
 
     localContext.trace(`Verifying the '${judgementString}' stated judgement...`, judgementNode);
@@ -114,7 +114,7 @@ function verifyStatedJudgement(judgementNode, assignments, derived, localContext
     if (metavariableVerified) {
       const frames = [],
             frameNode = frameNodeQuery(judgementNode),
-            frameVerified = verifyFrame(frameNode, frames, assignments, derived, localContext);
+            frameVerified = verifyFrame(frameNode, frames, stated, localContext);
 
       if (frameVerified) {
         const firstFrame = first(frames),

package/src/verify/metavariable.js

@@ -2,7 +2,7 @@
 
 import { nodeQuery } from "../utilities/query";
 import { unifyTermWithTermType } from "../metavariable";
-import { nameFromMetavariableNode } from "../utilities/name";
+import { metavariableNameFromMetavariableNode } from "../utilities/name";
 
 const termNodeQuery = nodeQuery("/metavariable/argument/term"),
       typeNodeQuery = nodeQuery("/metavariable/argument/type");
@@ -14,8 +14,8 @@ export default function verifyMetavariable(metavariableNode, localContext) {
 
   localContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
 
-  const name = nameFromMetavariableNode(metavariableNode),
-        metavariable = localContext.findMetavariableByName(name);
+  const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+        metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
 
   if (metavariable === null) {
     localContext.debug(`The metavariable '${metavariableString}' is not present.`, metavariableNode);

package/src/verify/premise.js

@@ -2,7 +2,7 @@
 
 import Premise from "../premise";
 import ProofStep from "../proofStep";
-import verifyUnqualifiedStatement from "../verify/statement/unqualified";
+import verifyStatement from "../verify/statement";
 
 import { nodeQuery } from "../utilities/query";
 import { assignAssignments } from "../utilities/assignments";
@@ -20,16 +20,16 @@ export default function verifyPremise(premiseNode, premises, localContext) {
   const unqualifiedStatementNode = unqualifiedStatementNodeQuery(premiseNode);
 
   if (unqualifiedStatementNode !== null) {
-    const derived = false,
+    const stated = true,
           assignments = [],
-          unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
+          statementNode = statementNodeQuery(unqualifiedStatementNode),
+          statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
 
-    if (unqualifiedStatementVerified) {
+    if (statementVerified) {
       const assignmentsAssigned = assignAssignments(assignments, localContext);
 
       if (assignmentsAssigned) {
-        const statementNode = statementNodeQuery(unqualifiedStatementNode),
-              metaproofStep = ProofStep.fromStatementNode(statementNode),
+        const metaproofStep = ProofStep.fromStatementNode(statementNode),
               premise = Premise.fromStatementNode(statementNode);
 
         premises.push(premise);

package/src/verify/proofStep.js

@@ -7,7 +7,6 @@ import verifyQualifiedStatement from "../verify/statement/qualified";
 import verifyUnqualifiedStatement from "../verify/statement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
-import { assignAssignments } from "../utilities/assignments";
 
 const subproofNodeQuery = nodeQuery("/proofStep|lastProofStep/subproof!"),
       statementNodeQuery = nodeQuery("/qualifiedStatement|unqualifiedStatement/statement!"),
@@ -23,45 +22,29 @@ export default function verifyProofStep(proofStepNode, substitutions, localConte
 
   let proofStep = null;
 
-  if (subproofNode !== null) {
-    let subproofVerified;
-
-    subproofVerified = verifySubproof(subproofNode, substitutions, localContext);
+  if (false) {
+    ///
+  } else if (subproofNode !== null) {
+    const subproofVerified = verifySubproof(subproofNode, substitutions, localContext);
 
     if (subproofVerified) {
       proofStep = ProofStep.fromSubproofNode(subproofNode);
     }
-  } else {
-    if (qualifiedStatementNode !== null) {
-      const derived = false,  ///
-            assignments = [],
-            qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, substitutions, assignments, derived, localContext);
-
-      if (qualifiedStatementVerified) {
-        const assignmentsAssigned = assignAssignments(assignments, localContext);
+  } else if (qualifiedStatementNode !== null) {
+    const qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, substitutions, localContext);
 
-        if (assignmentsAssigned) {
-          const statementNode = statementNodeQuery(qualifiedStatementNode);
+    if (qualifiedStatementVerified) {
+      const statementNode = statementNodeQuery(qualifiedStatementNode);
 
-          proofStep = ProofStep.fromStatementNode(statementNode);
-        }
-      }
+      proofStep = ProofStep.fromStatementNode(statementNode);
     }
+  } else if (unqualifiedStatementNode !== null) {
+    const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, localContext);
 
-    if (unqualifiedStatementNode !== null) {
-      const derived = true,
-            assignments = [],
-            unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
-
-      if (unqualifiedStatementVerified) {
-        const assignmentsAssigned = assignAssignments(assignments, localContext);
-
-        if (assignmentsAssigned) {
-          const statementNode = statementNodeQuery(unqualifiedStatementNode);
+    if (unqualifiedStatementVerified) {
+      const statementNode = statementNodeQuery(unqualifiedStatementNode);
 
-          proofStep = ProofStep.fromStatementNode(statementNode);
-        }
-      }
+      proofStep = ProofStep.fromStatementNode(statementNode);
     }
   }