occam-verify-cli 0.0.880 → 0.0.882

package/src/frame.js

@@ -0,0 +1,69 @@
+"use strict";
+
+import { push, first } from "./utilities/array";
+
+export default class Frame {
+  constructor(declarations) {
+    this.declarations = declarations;
+  }
+
+  getDeclarations() {
+    return this.declarations;
+  }
+
+  getDeclaration() {
+    let declaration = null;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      const firstDeclaration = first(this.declarations);
+
+      declaration = firstDeclaration; ///
+    }
+
+    return declaration;
+  }
+
+  isSingular() {
+    const declarationsLength = this.declarations.length,
+          singular = (declarationsLength === 1);
+
+    return singular;
+  }
+
+  addDeclarations(declarations) {
+    push(this.declarations, declarations);
+  }
+
+  matchSubstitution(substitution) {
+    const substitutionMatches = this.declarations.some((declaration) => {
+      const declarationMatchesSubstitution = declaration.matchSubstitution(substitution);
+
+      if (declarationMatchesSubstitution) {
+        return true;
+      }
+    });
+
+    return substitutionMatches;
+  }
+
+  matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem) {
+    const substitutions = metaLemmaMetatheorem.getSubstitutions(),
+          metaLemmaOrMetaTheoremMatches = substitutions.every((substitution) => {
+            const frameMatchesSubstitution = this.matchSubstitution(substitution);
+
+            if (frameMatchesSubstitution) {
+              return true;
+            }
+          });
+
+    return metaLemmaOrMetaTheoremMatches;
+  }
+
+  static fromDeclarations(declarations) {
+    const frame = new Frame(declarations);
+
+    return frame;
+  }
+}

package/src/judgement.js

@@ -0,0 +1,38 @@
+"use strict";
+
+export default class Judgement {
+  constructor(node, frame, metavariableNode) {
+    this.node = node;
+    this.frame = frame;
+    this.metavariableNode = metavariableNode;
+  }
+
+  getNode() {
+    return this.node;
+  }
+
+  getFrame() {
+    return this.frame;
+  }
+
+  getMetavariableNode() {
+    return this.metavariableNode;
+  }
+
+  getDeclarations() { return this.frame.getDeclarations(); }
+
+  matchMetavariableNode(metavariableNode) {
+    const metavariableNodeMatches = this.metavariableNode.match(metavariableNode);
+
+    return metavariableNodeMatches;
+  }
+
+  matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem) { return this.frame.matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem); }
+
+  static fromJudgementNodeFrameAndMetavariableNode(judgementNode, frame, metavariableNode) {
+    const node = judgementNode,
+          judgement = new Judgement(node, frame, metavariableNode);
+
+    return judgement;
+  }
+}

package/src/label.js

@@ -33,9 +33,9 @@ export default class Label {
 
   static fromMetavariableNode(metavariableNode) {
     const node = metavariableNode, ///
-          variable = new Label(node);
+          label = new Label(node);
 
-    return variable;
+    return label;
   }
 
   static fromJSONAndFileContext(json, fileContext) {

package/src/metaLemmaMetatheorem.js

@@ -3,10 +3,10 @@
 import Label from "./label";
 import MetaConsequent from "./metaConsequent";
 import MetaSupposition from "./metaSupposition";
+import MetastatementForMetavariableSubstitution from "./substitution/metastatementForMetavariable";
 
 import { prune } from "./utilities/array";
 import { someSubArray } from "./utilities/array";
-import MetastatementForMetavariableSubstitution from "./substitution/metastatementForMetavariable";
 
 export default class MetaLemmaMetatheorem {
   constructor(labels, metaSuppositions, metaConsequent, substitutions, fileContext) {
@@ -71,9 +71,9 @@ export default class MetaLemmaMetatheorem {
     return metastatementNatches;
   }
 
-  matchLabelMetavariableNode(labelMetavariableNode) {
+  matchLabelMetavariableNode(metavariableNode) {
     const labelMetavariableNodeMatches = this.labels.some((label) => {
-      const node = labelMetavariableNode, ///
+      const node = metavariableNode, ///
             labelMatchesNode = label.matchNode(node);
 
       if (labelMatchesNode) {

package/src/metaType/frame.js

@@ -0,0 +1,18 @@
+"use strict";
+
+import MetaType from "../metaType";
+
+import { FRAME_META_TYPE_NAME } from "../metaTypeNames";
+
+class FrameMetaType extends MetaType {
+  static fromNothing() {
+    const name = FRAME_META_TYPE_NAME,
+          frameMetaType = new FrameMetaType(name);
+
+    return frameMetaType;
+  }
+}
+
+const frameMetaType = FrameMetaType.fromNothing();
+
+export default frameMetaType;

package/src/metaType/reference.js

@@ -0,0 +1,18 @@
+"use strict";
+
+import MetaType from "../metaType";
+
+import { REFERENCE_META_TYPE_NAME } from "../metaTypeNames";
+
+class ReferenceMetaType extends MetaType {
+  static fromNothing() {
+    const name = REFERENCE_META_TYPE_NAME,
+          referenceMetaType = new ReferenceMetaType(name);
+
+    return referenceMetaType;
+  }
+}
+
+const referenceMetaType = ReferenceMetaType.fromNothing();
+
+export default referenceMetaType;

package/src/metaTypeNames.js

@@ -1,5 +1,5 @@
 "use strict";
 
+export const FRAME_META_TYPE_NAME = "Frame";
+export const REFERENCE_META_TYPE_NAME = "Reference";
 export const STATEMENT_META_TYPE_NAME = "Statement";
-export const CONTEXT_META_TYPE_NAME = "Context";
-export const LABEL_META_TYPE_NAME = "Label";

package/src/metaTypes.js

@@ -1,12 +1,12 @@
 "use strict";
 
-import labelMetaType from "./metaType/label";
-import contextMetaType from "./metaType/context";
+import frameMetaType from "./metaType/frame";
+import referenceMetaType from "./metaType/reference";
 import statementMetaType from "./metaType/statement";
 
 const metaTypes = [
-  labelMetaType,
-  contextMetaType,
+  frameMetaType,
+  referenceMetaType,
   statementMetaType
 ];
 

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

@@ -11,8 +11,6 @@ import { metastatementNodeFromMetastatementString } from "./utilities/node";
 
 const ruleSubproofAssertionNodeQuery = nodeQuery("/metastatement/ruleSubproofAssertion!"),
       ruleSubproofPremiseMetastatementQuery = nodesQuery("/ruleSubproof/premise/unqualifiedMetastatement!/metastatement!"),
-      subproofSuppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement!/statement!"),
-      subproofSubDerivationLastStatementNodeQuery = nodeQuery("/subproof/subDerivation/qualifiedStatement|unqualifiedStatement[-1]/statement!"),
       ruleSubproofAssertionMetastatementNodesQuery = nodesQuery("/ruleSubproofAssertion/metastatement"),
       ruleSubproofSubDerivationLastMetastatementQuery = nodeQuery("/ruleSubproof/ruleSubDerivation/qualifiedMetastatement|unqualifiedMetastatement[-1]/metastatement!");
 
@@ -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,  ///

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/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/utilities/name.js

@@ -7,14 +7,9 @@ const typeTerminalNodeQuery = nodeQuery("/type/@type"),
       metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type");
 
 export function typeNameFromTypeNode(typeNode) {
-  let typeName = null;
-
-  if (typeNode !== null) {
-    const typeTerminalNode = typeTerminalNodeQuery(typeNode),
-          typeTerminalNodeContent = typeTerminalNode.getContent();
-
-    typeName = typeTerminalNodeContent; ///
-  }
+  const typeTerminalNode = typeTerminalNodeQuery(typeNode),
+        typeTerminalNodeContent = typeTerminalNode.getContent(),
+        typeName = typeTerminalNodeContent; ///
 
   return typeName;
 }
@@ -28,14 +23,9 @@ export function nameFromMetavariableNode(metavariableNode) {
 }
 
 export function metaTypeNameFromMetaTypeNode(metaTypeNode) {
-  let metaTypeName = null;
-
-  if (metaTypeNode !== null) {
     const metaTypeTerminalNode = metaTypeTerminalNodeQuery(metaTypeNode),
-          metaTypeTerminalNodeContent = metaTypeTerminalNode.getContent();
-
-    metaTypeName = metaTypeTerminalNodeContent; ///
-  }
+          metaTypeTerminalNodeContent = metaTypeTerminalNode.getContent(),
+          metaTypeName = metaTypeTerminalNodeContent; ///
 
   return metaTypeName;
 }

package/src/verify/declaration.js

@@ -1,6 +1,7 @@
 "use strict";
 
-import labelMetaType from "../metaType/label";
+import Declaration from "../declaration"
+import referenceMetaType from "../metaType/reference";
 import metastatementNodeVerifier from "../verifier/node/metastatement";
 
 import { nodeQuery } from "../utilities/query";
@@ -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 === labelMetaType) {
-      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 metavariableString = localMetaContext.nodeAsString(metavariableNode),
-            labelMetaTypeName = labelMetaType.getName(),
-            metaTypeString = metaType.asString();
+      declarations.push(declaration);
 
-      localMetaContext.debug(`The '${metavariableString}' metavariable's meta-type is '${metaTypeString}' when it should be '${labelMetaTypeName}'.`, 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

@@ -0,0 +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"),
+      metavariableNodesQuery = nodesQuery("/frame/metavariable");
+
+export default function verifyFrame(frameNode, frames, derived, localMetaContext) {
+  let frameVerified;
+
+  const frameString = localMetaContext.nodeAsString(frameNode);
+
+  localMetaContext.trace(`Verifying the '${frameString}' frame...`, frameNode);
+
+  const declarations = [],
+        declarationNodes = declarationNodesQuery(frameNode),
+        declarationsVerified = declarationNodes.every((declarationNode) => {
+          const declarationVerified = verifyDeclaration(declarationNode, declarations, localMetaContext);
+
+          return declarationVerified;
+        });
+
+  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;
+}