occam-verify-cli 0.0.881 → 0.0.883

package/src/mixins/context.js

@@ -26,7 +26,7 @@ function getConstructors() { return this.context.getConstructors(); }
 
 function findTypeByTypeName(typeName) { return this.context.findTypeByTypeName(typeName); }
 
-function findTypeByTypeNode(labelMetavariableNode) { return this.context.findTypeByTypeNode(labelMetavariableNode); }
+function findTypeByTypeNode(typeNode) { return this.context.findTypeByTypeNode(typeNode); }
 
 function findMetavariableByName(name) { return this.context.findMetavariableByName(name); }
 
@@ -36,19 +36,23 @@ function isTypePresentByTypeNode(typeNode) { return this.context.isTypePresentBy
 
 function isMetavariablePresentByName(name) { return this.context.isMetavariablePresentByName(name); }
 
-function findLabelByLabelMetavariableNode(labelMetavariableNode) { return this.context.findLabelByLabelMetavariableNode(labelMetavariableNode); }
+function isLabelPresentByMetavariableNode(metavariableNode) { return this.context.isLabelPresentByMetavariableNode(metavariableNode); }
 
-function findRuleByLabelMetavariableNode(labelMetavariableNode) { return this.context.findRuleByLabelMetavariableNode(labelMetavariableNode); }
+function findLabelByMetavariableNode(metavariableNode) { return this.context.findLabelByMetavariableNode(metavariableNode); }
 
-function findAxiomByLabelMetavariableNode(labelMetavariableNode) { return this.context.findAxiomByLabelMetavariableNode(labelMetavariableNode); }
+function findRuleByMetavariableNode(metavariableNode) { return this.context.findRuleByMetavariableNode(metavariableNode); }
 
-function findLemmaByLabelMetavariableNode(labelMetavariableNode) { return this.context.findLemmaByLabelMetavariableNode(labelMetavariableNode); }
+function findAxiomByMetavariableNode(metavariableNode) { return this.context.findAxiomByMetavariableNode(metavariableNode); }
 
-function findTheoremByLabelMetavariableNode(labelMetavariableNode) { return this.context.findTheoremByLabelMetavariableNode(labelMetavariableNode); }
+function findLemmaByMetavariableNode(metavariableNode) { return this.context.findLemmaByMetavariableNode(metavariableNode); }
 
-function findConjectureByLabelMetavariableNode(labelMetavariableNode) { return this.context.findConjectureByLabelMetavariableNode(labelMetavariableNode); }
+function findTheoremByMetavariableNode(metavariableNode) { return this.context.findTheoremByMetavariableNode(metavariableNode); }
 
-function isLabelPresentByLabelMetavariableNode(labelMetavariableNode) { return this.context.isLabelPresentByLabelMetavariableNode(labelMetavariableNode); }
+function findMetaLemmaByMetavariableNode(metavariableNode) { return this.context.findMetaLemmaByMetavariableNode(metavariableNode); }
+
+function findConjectureByMetavariableNode(metavariableNode) { return this.context.findConjectureByMetavariableNode(metavariableNode); }
+
+function findMetatheoremByMetavariableNode(metavariableNode) { return this.context.findMetatheoremByMetavariableNode(metavariableNode); }
 
 function nodeAsString(node) { return this.context.nodeAsString(node); }
 
@@ -73,13 +77,15 @@ const contextMixins = {
   isTypePresentByTypeName,
   isTypePresentByTypeNode,
   isMetavariablePresentByName,
-  findLabelByLabelMetavariableNode,
-  findRuleByLabelMetavariableNode,
-  findAxiomByLabelMetavariableNode,
-  findLemmaByLabelMetavariableNode,
-  findTheoremByLabelMetavariableNode,
-  findConjectureByLabelMetavariableNode,
-  isLabelPresentByLabelMetavariableNode,
+  isLabelPresentByMetavariableNode,
+  findLabelByMetavariableNode,
+  findRuleByMetavariableNode,
+  findAxiomByMetavariableNode,
+  findLemmaByMetavariableNode,
+  findTheoremByMetavariableNode,
+  findMetaLemmaByMetavariableNode,
+  findConjectureByMetavariableNode,
+  findMetatheoremByMetavariableNode,
   nodeAsString,
   nodesAsString
 };

package/src/premise.js

@@ -9,11 +9,9 @@ import { nodeAsString } from "./utilities/string";
 import { nodeQuery, nodesQuery } from "./utilities/query";
 import { metastatementNodeFromMetastatementString } from "./utilities/node";
 
-const ruleSubproofAssertionNodeQuery = nodeQuery("/metastatement/ruleSubproofAssertion!"),
+const subproofAssertionNodeQuery = nodeQuery("/metastatement/subproofAssertion!"),
       ruleSubproofPremiseMetastatementQuery = nodesQuery("/ruleSubproof/premise/unqualifiedMetastatement!/metastatement!"),
-      subproofSuppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement!/statement!"),
-      subproofSubDerivationLastStatementNodeQuery = nodeQuery("/subproof/subDerivation/qualifiedStatement|unqualifiedStatement[-1]/statement!"),
-      ruleSubproofAssertionMetastatementNodesQuery = nodesQuery("/ruleSubproofAssertion/metastatement"),
+      subproofAssertionMetastatementNodesQuery = nodesQuery("/subproofAssertion/metastatement"),
       ruleSubproofSubDerivationLastMetastatementQuery = nodeQuery("/ruleSubproof/ruleSubDerivation/qualifiedMetastatement|unqualifiedMetastatement[-1]/metastatement!");
 
 export default class Premise {
@@ -25,45 +23,6 @@ export default class Premise {
     return this.metastatementNode;
   }
 
-  matchSubproofNode(subproofNode, substitutions, fileContext, statementLocalContext) {
-    let subproofNodeMatches = false;
-
-    const subproofAssertionNode = ruleSubproofAssertionNodeQuery(this.metastatementNode);
-
-    if (subproofAssertionNode !== null) {
-      const subproofSuppositionStatementNodes = subproofSuppositionStatementNodesQuery(subproofNode),
-            subproofSubDerivationLastStatementNode = subproofSubDerivationLastStatementNodeQuery(subproofNode),
-            subproofStatementNodes = [
-              ...subproofSuppositionStatementNodes,
-              subproofSubDerivationLastStatementNode
-            ],
-            ruleSubproofAssertionMetastatementNodes = ruleSubproofAssertionMetastatementNodesQuery(subproofAssertionNode),
-            subproofStatementNodesLength = subproofStatementNodes.length,
-            ruleSubproofAssertionMetastatementNodesLength = ruleSubproofAssertionMetastatementNodes.length;
-
-      if (subproofStatementNodesLength === ruleSubproofAssertionMetastatementNodesLength) {
-        subproofNodeMatches = match(ruleSubproofAssertionMetastatementNodes, subproofStatementNodes, (ruleSubproofAssertionMetastatementNode, subproofStatementNode) => {
-          const nonTerminalNodeA = ruleSubproofAssertionMetastatementNode,  ///
-                nonTerminalNodeB = subproofStatementNode, ///
-                fileContextA = fileContext, ///
-                localContextA = LocalContext.fromFileContext(fileContextA),
-                localContextB = statementLocalContext,  ///
-                nonTerminalNodeVerified = intrinsicLevelAgainstMetaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
-                  const verifiedAhead = true;
-
-                  return verifiedAhead;
-                });
-
-          if (nonTerminalNodeVerified) {
-            return true;
-          }
-        });
-      }
-    }
-
-    return subproofNodeMatches;
-  }
-
   matchStatementNode(statementNode, substitutions, fileContext, statementLocalContext) {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = statementNode,  ///
@@ -83,9 +42,9 @@ export default class Premise {
   matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, metastatementLocalMetaContext) {
     let ruleSubproofNodeMatches = false;
 
-    const ruleSubproofAssertionNode = ruleSubproofAssertionNodeQuery(this.metastatementNode);
+    const subproofAssertionNode = subproofAssertionNodeQuery(this.metastatementNode);
 
-    if (ruleSubproofAssertionNode !== null) {
+    if (subproofAssertionNode !== null) {
       const ruleSubproofPremiseMetastatement = ruleSubproofPremiseMetastatementQuery(ruleSubproofNode),
             ruleSubproofSubDerivationLastMetastatement = ruleSubproofSubDerivationLastMetastatementQuery(ruleSubproofNode),
             ruleSubproofMetastatementNodes = [
@@ -93,12 +52,12 @@ export default class Premise {
               ruleSubproofSubDerivationLastMetastatement
             ],
             ruleSubproofMetastatementNodesLength = ruleSubproofMetastatementNodes.length,
-            ruleSubproofAssertionMetastatementNodes = ruleSubproofAssertionMetastatementNodesQuery(ruleSubproofAssertionNode),
-            ruleSubproofAssertionMetastatementNodesLength = ruleSubproofAssertionMetastatementNodes.length;
+            subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode),
+            subproofAssertionMetastatementNodesLength = subproofAssertionMetastatementNodes.length;
 
-      if (ruleSubproofMetastatementNodesLength === ruleSubproofAssertionMetastatementNodesLength) {
-        ruleSubproofNodeMatches = match(ruleSubproofAssertionMetastatementNodes, ruleSubproofMetastatementNodes, (ruleSubproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
-          const nonTerminalNodeA = ruleSubproofAssertionMetastatementNode,  ///
+      if (ruleSubproofMetastatementNodesLength === subproofAssertionMetastatementNodesLength) {
+        ruleSubproofNodeMatches = match(subproofAssertionMetastatementNodes, ruleSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
+          const nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = ruleSubproofMetastatementNode, ///
                 fileContextA = fileContext, ///
                 localContextA = LocalContext.fromFileContext(fileContextA),

package/src/rule.js

@@ -99,9 +99,9 @@ export default class Rule {
     return metastatementNatches;
   }
 
-  matchLabelMetavariableNode(labelMetavariableNode) {
+  matchLabelMetavariableNode(metavariableNode) {
     const labelMetavariableNodeMatches = this.labels.some((label) => {
-      const node = labelMetavariableNode, ///
+      const node = metavariableNode, ///
             labelMatchesNode = label.matchNode(node);
 
       if (labelMatchesNode) {
@@ -183,16 +183,7 @@ export default class Rule {
 
 function matchPremise(premise, proofSteps, substitutions, fileContext, statementLocalContext) {
   const proofStep = prune(proofSteps, (proofStep) => {
-    const subproofNode = proofStep.getSubproofNode(),
-          statementNode = proofStep.getStatementNode()
-
-    if (subproofNode !== null) {
-      const subProofNodeMatches = premise.matchSubproofNode(subproofNode, substitutions, fileContext, statementLocalContext);
-
-      if (!subProofNodeMatches) {  ///
-        return true;
-      }
-    }
+    const statementNode = proofStep.getStatementNode()
 
     if (statementNode !== null) {
       const statementNodeMatches = premise.matchStatementNode(statementNode, substitutions, fileContext, statementLocalContext);

package/src/step/metaproof.js

@@ -4,8 +4,8 @@ import { first, second } from "../utilities/array";
 import { matchMetastatement } from "../utilities/metaproof";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const metastatementNodesQuery = nodesQuery("/ruleSubproofAssertion/metastatement"),
-      ruleSubproofAssertionNodeQuery = nodeQuery("/metastatement/ruleSubproofAssertion"),
+const metastatementNodesQuery = nodesQuery("/subproofAssertion/metastatement"),
+      ruleSubproofAssertionNodeQuery = nodeQuery("/metastatement/subproofAssertion"),
       qualifiedOrUnqualifiedMetastatementMetastatementNodesQuery = nodesQuery("/ruleSubproof/qualifiedMetastatement|unqualifiedMetastatement/metastatement!");
 
 export default class MetaproofStep {

package/src/supposition.js

@@ -2,16 +2,9 @@
 
 import intrinsicLevelNodesVerifier from "./verifier/nodes/intrinsicLevel";
 
-import { match } from "./utilities/array";
 import { nodeAsString } from "./utilities/string";
-import { nodeQuery, nodesQuery } from "./utilities/query";
 import { statementNodeFromStatementString } from "./utilities/node";
 
-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) {
     this.statementNode = statementNode;
@@ -21,44 +14,6 @@ export default class Supposition {
     return this.statementNode;
   }
 
-  matchSubproofNode(subproofNode, substitutions, localContext, statementLocalContext) {
-    let subproofNodeMatches = false;
-
-    const subproofAssertionNode = subproofAssertionNodeQuery(this.statementNode);
-
-    if (subproofAssertionNode !== null) {
-      const subproofSuppositionStatementNodes = subproofSuppositionStatementNodesQuery(subproofNode),
-            subproofSubDerivationLastStatementNode = subproofSubDerivationLastStatementNodeQuery(subproofNode),
-            subproofStatementNodes = [
-              ...subproofSuppositionStatementNodes,
-              subproofSubDerivationLastStatementNode
-            ],
-            subproofAssertionStatementNodes = subproofAssertionStatementNodesQuery(subproofAssertionNode),
-            subproofStatementNodesLength = subproofStatementNodes.length,
-            subproofAssertionStatementNodesLength = subproofAssertionStatementNodes.length;
-
-      if (subproofStatementNodesLength === subproofAssertionStatementNodesLength) {
-        subproofNodeMatches = match(subproofAssertionStatementNodes, subproofStatementNodes, (subproofAssertionStatementNode, subproofStatementNode) => {
-          const nonTerminalNodeA = subproofAssertionStatementNode,  ///
-                nonTerminalNodeB = subproofStatementNode, ///
-                localContextA = localContext, ///
-                localContextB = statementLocalContext,  ///
-                nonTerminalNodeVerified = intrinsicLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
-                  const verifiedAhead = true;
-
-                  return verifiedAhead;
-                });
-
-          if (nonTerminalNodeVerified) {
-            return true;
-          }
-        });
-      }
-    }
-
-    return subproofNodeMatches;
-  }
-
   matchStatementNode(statementNode, substitutions, localContext, statementLocalContext) {
     const nonTerminalNodeA = this.statementNode,  ///
           nonTerminalNodeB = statementNode,  ///

package/src/verify/declaration.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import Declaration from "../declaration"
 import referenceMetaType from "../metaType/reference";
 import metastatementNodeVerifier from "../verifier/node/metastatement";
 
@@ -8,7 +9,7 @@ import { nodeQuery } from "../utilities/query";
 const metavariableNodeQuery = nodeQuery("/declaration/metavariable!"),
       metastatementNodeQuery = nodeQuery("/declaration/metastatement!");
 
-export default function verifyDeclaration(declarationNode, derived, localMetaContext) {
+export default function verifyDeclaration(declarationNode, declarations, localMetaContext) {
   let declarationVerified = false;
 
   const declarationString = localMetaContext.nodeAsString(declarationNode);
@@ -16,31 +17,26 @@ export default function verifyDeclaration(declarationNode, derived, localMetaCon
   localMetaContext.trace(`Verifying the '${declarationString}' declaration...`, declarationNode);
 
   const metavariableNode = metavariableNodeQuery(declarationNode),
-        metavariable = localMetaContext.findMetavariableByMetavariableNode(metavariableNode, localMetaContext);
+        metavariableVerified = verifyMetavariable(metavariableNode, localMetaContext);
 
-  if (metavariable !== null) {
-    const metaType = metavariable.getMetaType();
+  if (metavariableVerified) {
+    const metastatementNode = metastatementNodeQuery(declarationNode);
 
-    if (metaType === referenceMetaType) {
-      const metastatementNode = metastatementNodeQuery(declarationNode);
+    const { verifyMetastatement } = metastatementNodeVerifier,
+          derived = false,
+          assignments = [],
+          metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localMetaContext, () => {
+            const verifiedAhead = true;
 
-      if (metastatementNode !== null) {
-        const { verifyMetastatement } = metastatementNodeVerifier,
-              assignments = [],
-              metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localMetaContext, () => {
-                const verifiedAhead = true;
+            return verifiedAhead;
+          });
 
-                return verifiedAhead;
-              });
+    if (metastatementVerified) {
+      const declaration = Declaration.fromMetavariableNodeAndMetastatementNode(metavariableNode, metastatementNode);
 
-        declarationVerified = metastatementVerified;  ///
-      }
-    } else {
-      const referenceMetaTypeName = referenceMetaType.getName(),
-            metavariableString = localMetaContext.nodeAsString(metavariableNode),
-            metaTypeString = metaType.asString();
+      declarations.push(declaration);
 
-      localMetaContext.debug(`The '${metavariableString}' metavariable's meta-type is '${metaTypeString}' when it should be '${referenceMetaTypeName}'.`, declarationNode);
+      declarationVerified = true;
     }
   }
 
@@ -49,4 +45,35 @@ export default function verifyDeclaration(declarationNode, derived, localMetaCon
   }
 
   return declarationVerified;
+}
+
+function verifyMetavariable(metavariableNode, localMetaContext) {
+  let metavariableVerified = false;
+
+  const metavariableString = localMetaContext.nodeAsString(metavariableNode);
+
+  localMetaContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
+
+  const metavariable = localMetaContext.findMetavariableByMetavariableNode(metavariableNode, localMetaContext);
+
+  if (metavariable !== null) {
+    const metaType = metavariable.getMetaType();
+
+    if (metaType === referenceMetaType) {
+      metavariableVerified = true;
+    } else {
+      const referenceMetaTypeName = referenceMetaType.getName(),
+            metaTypeString = metaType.asString();
+
+      localMetaContext.debug(`The '${metavariableString}' metavariable's meta-type is '${metaTypeString}' when it should be '${referenceMetaTypeName}'.`, metavariableNode);
+    }
+  } else {
+    localMetaContext.debug(`The '${metavariableString}' metavariable is not present'.`, metavariableNode);
+  }
+
+  if (metavariableVerified) {
+    localMetaContext.debug(`...verified the '${metavariableString}' metavariable.`, metavariableNode);
+  }
+
+  return metavariableVerified;
 }

package/src/verify/frame.js

@@ -1,30 +1,91 @@
 "use strict";
 
+import Frame from "../frame";
+import frameMetaType from "../metaType/frame";
 import verifyDeclaration from "../verify/declaration";
 
+import { push } from "../utilities/array";
 import { nodesQuery } from "../utilities/query";
 
-const declarationNodesQuery = nodesQuery("/frame/declaration");
+const declarationNodesQuery = nodesQuery("/frame/declaration"),
+      metavariableNodesQuery = nodesQuery("/frame/metavariable");
 
-export default function verifyFrame(frameNode, derived, localMetaContext) {
+export default function verifyFrame(frameNode, frames, derived, localMetaContext) {
   let frameVerified;
 
   const frameString = localMetaContext.nodeAsString(frameNode);
 
   localMetaContext.trace(`Verifying the '${frameString}' frame...`, frameNode);
 
-  const declarationNodes = declarationNodesQuery(frameNode),
+  const declarations = [],
+        declarationNodes = declarationNodesQuery(frameNode),
         declarationsVerified = declarationNodes.every((declarationNode) => {
-          const declarationVerified = verifyDeclaration(declarationNode, derived, localMetaContext);
+          const declarationVerified = verifyDeclaration(declarationNode, declarations, localMetaContext);
 
           return declarationVerified;
         });
 
-  frameVerified = declarationsVerified; ///
+  if (declarationsVerified) {
+    const metavariableNodes = metavariableNodesQuery(frameNode),
+          metavariablesVerified = metavariableNodes.every((metavariableNode) => {
+            const metavariableVerified = verifyMetavariable(metavariableNode, declarations, localMetaContext);
+
+            return metavariableVerified;
+          });
+
+    if (metavariablesVerified) {
+      const frame = Frame.fromDeclarations(declarations);
+
+      frames.push(frame);
+
+      frameVerified = true;
+    }
+  }
 
   if (frameVerified) {
     localMetaContext.debug(`...verified the '${frameString}' frame.`, frameNode);
   }
 
   return frameVerified;
+}
+
+function verifyMetavariable(metavariableNode, declarations, localMetaContext) {
+  let metavariableVerified = false;
+
+  const metavariableString = localMetaContext.nodeAsString(metavariableNode);
+
+  localMetaContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
+
+  const metavariable = localMetaContext.findMetavariableByMetavariableNode(metavariableNode, localMetaContext);
+
+  if (metavariable !== null) {
+    const metaType = metavariable.getMetaType();
+
+    if (metaType === frameMetaType) {
+      const judgement = localMetaContext.findJudgementByMetavariableNode(metavariableNode);
+
+      if (judgement !== null) {
+        const judgementDeclarations = judgement.getDeclarations();
+
+        push(declarations, judgementDeclarations);
+
+        metavariableVerified = true;
+      } else {
+        localMetaContext.debug(`There is no judgement for the '${metavariableString}' metavariable.`, metavariableNode);
+      }
+    } else {
+      const frameMetaTypeName = frameMetaType.getName(),
+            metaTypeString = metaType.asString();
+
+      localMetaContext.debug(`The '${metavariableString}' metavariable's meta-type is '${metaTypeString}' when it should be '${frameMetaTypeName}'.`, metavariableNode);
+    }
+  } else {
+    localMetaContext.debug(`The '${metavariableString}' metavariable is not present'.`, metavariableNode);
+  }
+
+  if (metavariableVerified) {
+    localMetaContext.debug(`...verified the '${metavariableString}' metavariable.`, metavariableNode);
+  }
+
+  return metavariableVerified;
 }

package/src/verify/judgement.js

@@ -1,8 +1,11 @@
 "use strict";
 
+import Judgement from "../judgement";
 import verifyFrame from "../verify/frame";
 import frameMetaType from "../metaType/frame";
+import JudgementAssignment from "../assignment/judgement";
 
+import { first } from "../utilities/array";
 import { nodeQuery } from "../utilities/query";
 
 const frameNodeQuery = nodeQuery("/judgement/frame!"),
@@ -39,38 +42,59 @@ function verifyDerivedJudgement(judgementNode, assignments, derived, localMetaCo
   let derivedJudgementVerified = false;
 
   if (derived) {
-    // const judgementString = localMetaContext.nodeAsString(judgementNode);
-    //
-    // localMetaContext.trace(`Verifying the '${judgementString}' derived judgement...`, judgementNode);
-    //
-    // const metavariableNode = metavariableNodeQuery(judgementNode),
-    //       metavariable = localMetaContext.findMetavariableByMetavariableNode(metavariableNode, localMetaContext);
-    //
-    // if (metavariable !== null) {
-    //   const metaType = metavariable.getMetaType();
-    //
-    //   if (metaType === frameMetaType) {
-    //     const frameNode = frameNodeQuery(judgementNode);
-    //
-    //     if (frameNode !== null) {
-    //       const frameVerified = verifyFrame(frameNode, derived, localMetaContext);
-    //
-    //       derivedJudgementVerified = frameVerified;  ///
-    //     } else {
-    //       localMetaContext.debug(`The right hand side of the '${judgementString}' judgement must be a frame.`, judgementNode);
-    //     }
-    //   } else {
-    //     const frameMetaTypeName = frameMetaType.getName(),
-    //       metavariableString = localMetaContext.nodeAsString(metavariableNode),
-    //       metaTypeString = metaType.asString();
-    //
-    //     localMetaContext.debug(`The '${metavariableString}' metavariable's meta-type is '${metaTypeString}' when it should be '${frameMetaTypeName}'.`, judgementNode);
-    //   }
-    // }
-    //
-    // if (derivedJudgementVerified) {
-    //   localMetaContext.debug(`...verified the '${judgementString}' derived judgement.`, judgementNode);
-    // }
+    const judgementString = localMetaContext.nodeAsString(judgementNode);
+
+    localMetaContext.trace(`Verifying the '${judgementString}' derived judgement...`, judgementNode);
+
+    const metavariableNode = metavariableNodeQuery(judgementNode),
+          metavariableVerified = verifyMetavariable(metavariableNode, localMetaContext);
+
+    if (metavariableVerified) {
+      const judgement = localMetaContext.findJudgementByMetavariableNode(metavariableNode);
+
+      if (judgement !== null) {
+        const frames = [],
+              frameNode = frameNodeQuery(judgementNode),
+              frameVerified = verifyFrame(frameNode, frames, derived, localMetaContext);
+
+        if (frameVerified) {
+          const firstFrame = first(frames),
+                frame = firstFrame, ///
+                frameSingular = frame.isSingular();
+
+          if (frameSingular) {
+            const declaration = frame.getDeclaration(),
+                  metavariableNode = declaration.getMetavariableNode(),
+                  metaLemma = localMetaContext.findMetaLemmaByMetavariableNode(metavariableNode),
+                  metatheorem = localMetaContext.findMetatheoremByMetavariableNode(metavariableNode),
+                  metaLemmaMetatheorem = (metaLemma || metatheorem);  ///
+
+            if (metaLemmaMetatheorem !== null) {
+              const judgementMatchesMetaLemmaMetatheorem = judgement.matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem),
+                    declarationMatchesMetaLemmaMetatheorem = declaration.matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem);
+
+              derivedJudgementVerified = (judgementMatchesMetaLemmaMetatheorem && declarationMatchesMetaLemmaMetatheorem);
+            } else {
+              const metavariableString = localMetaContext.nodeAsString(metavariableNode);
+
+              localMetaContext.debug(`There are no meta-lemmas or metatheorems corresponding to the '${metavariableString}' metavariable.`, judgementNode);
+            }
+          } else {
+            const frameString = localMetaContext.nodeAsString(frameNode);
+
+            localMetaContext.debug(`The '${frameString}' is not singular.`, judgementNode);
+          }
+        }
+      } else {
+        const metavariableString = localMetaContext.nodeAsString(metavariableNode);
+
+        localMetaContext.debug(`There is no judgement present for the '${metavariableString}' metavariable.`, judgementNode);
+      }
+    }
+
+    if (derivedJudgementVerified) {
+      localMetaContext.debug(`...verified the '${judgementString}' derived judgement.`, judgementNode);
+    }
   }
 
   return derivedJudgementVerified;
@@ -85,27 +109,23 @@ function verifyStatedJudgement(judgementNode, assignments, derived, localMetaCon
     localMetaContext.trace(`Verifying the '${judgementString}' stated judgement...`, judgementNode);
 
     const metavariableNode = metavariableNodeQuery(judgementNode),
-          metavariable = localMetaContext.findMetavariableByMetavariableNode(metavariableNode, localMetaContext);
+          metavariableVerified = verifyMetavariable(metavariableNode, localMetaContext);
 
-    if (metavariable !== null) {
-      const metaType = metavariable.getMetaType();
+    if (metavariableVerified) {
+      const frames = [],
+            frameNode = frameNodeQuery(judgementNode),
+            frameVerified = verifyFrame(frameNode, frames, derived, localMetaContext);
 
-      if (metaType === frameMetaType) {
-        const frameNode = frameNodeQuery(judgementNode);
+      if (frameVerified) {
+        const firstFrame = first(frames),
+              frame = firstFrame, ///
+              judgement = Judgement.fromJudgementNodeFrameAndMetavariableNode(judgementNode, frame, metavariableNode),
+              judgementAssignment = JudgementAssignment.fromJudgement(judgement),
+              assignment = judgementAssignment;
 
-        if (frameNode !== null) {
-          const frameVerified = verifyFrame(frameNode, derived, localMetaContext);
-
-          statedJudgementVerified = frameVerified;  ///
-        } else {
-          localMetaContext.debug(`The right hand side of the '${judgementString}' judgement must be a frame.`, judgementNode);
-        }
-      } else {
-        const frameMetaTypeName = frameMetaType.getName(),
-              metavariableString = localMetaContext.nodeAsString(metavariableNode),
-              metaTypeString = metaType.asString();
+        assignments.push(assignment);
 
-        localMetaContext.debug(`The '${metavariableString}' metavariable's meta-type is '${metaTypeString}' when it should be '${frameMetaTypeName}'.`, judgementNode);
+        statedJudgementVerified = true;
       }
     }
 
@@ -115,4 +135,35 @@ function verifyStatedJudgement(judgementNode, assignments, derived, localMetaCon
   }
 
   return statedJudgementVerified;
-}
+}
+
+function verifyMetavariable(metavariableNode, localMetaContext) {
+  let metavariableVerified = false;
+
+  const metavariableString = localMetaContext.nodeAsString(metavariableNode);
+
+  localMetaContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
+
+  const metavariable = localMetaContext.findMetavariableByMetavariableNode(metavariableNode, localMetaContext);
+
+  if (metavariable !== null) {
+    const metaType = metavariable.getMetaType();
+
+    if (metaType === frameMetaType) {
+      metavariableVerified = true;
+    } else {
+      const frameMetaTypeName = frameMetaType.getName(),
+            metaTypeString = metaType.asString();
+
+      localMetaContext.debug(`The '${metavariableString}' metavariable's meta-type is '${metaTypeString}' when it should be '${frameMetaTypeName}'.`, metavariableNode);
+    }
+  } else {
+    localMetaContext.debug(`The '${metavariableString}' metavariable is not present'.`, metavariableNode);
+  }
+
+  if (metavariableVerified) {
+    localMetaContext.debug(`...verified the '${metavariableString}' metavariable.`, metavariableNode);
+  }
+
+  return metavariableVerified;
+}