occam-verify-cli 0.0.977 → 0.0.979

package/src/judgement.js

@@ -1,10 +1,10 @@
 "use strict";
 
 export default class Judgement {
-  constructor(node, frame, metavariableNode) {
+  constructor(node, frame, declaration) {
     this.node = node;
     this.frame = frame;
-    this.metavariableNode = metavariableNode;
+    this.declaration = declaration;
   }
 
   getNode() {
@@ -15,23 +15,17 @@ export default class Judgement {
     return this.frame;
   }
 
-  getMetavariableNode() {
-    return this.metavariableNode;
+  getDeclaration() {
+    return this.declaration;
   }
 
-  getDeclarations() { return this.frame.getDeclarations(); }
+  getMetavariable() { return this.frame.getMetavariable(); }
 
-  matchMetavariableNode(metavariableNode) {
-    const metavariableNodeMatches = this.metavariableNode.match(metavariableNode);
+  matchMetavariableName(metavariableName) { return this.frame.matchMetavariableName(metavariableName); }
 
-    return metavariableNodeMatches;
-  }
-
-  unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem) { return this.frame.unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem); }
-
-  static fromJudgementNodeFrameAndMetavariableNode(judgementNode, frame, metavariableNode) {
-    const node = judgementNode,
-          judgement = new Judgement(node, frame, metavariableNode);
+  static fromJudgementNodeFrameAndDeclaration(judgementNode, frame, declaration) {
+    const node = judgementNode, ///
+          judgement = new Judgement(node, frame, declaration);
 
     return judgement;
   }

package/src/metaTypeNames.js

@@ -1,5 +1,5 @@
 "use strict";
 
+export const FRAME_META_TYPE_NAME = "Frame";
 export const STATEMENT_META_TYPE_NAME = "Statement";
 export const REFERENCE_META_TYPE_NAME = "Reference";
-export const DECLARATION_META_TYPE_NAME = "Declaration";

package/src/reference.js

@@ -0,0 +1,31 @@
+"use strict";
+
+import { nodeAsString } from "./utilities/string";
+
+export default class Reference {
+  constructor(metavariableNode) {
+    this.metavariableNode = metavariableNode;
+  }
+
+  getMetavariableNode() {
+    return this.metavariableNode;
+  }
+
+  matchMetavariableNode(metavariableNode) {
+    const metavariableNodeMatches = this.metavariableNode.match(metavariableNode);
+
+    return metavariableNodeMatches;
+  }
+
+  asString(tokens) {
+    const string = nodeAsString(this.metavariableNode, tokens);
+
+    return string;
+  }
+
+  static fromMetavariableNode(metavariableNode) {
+    const reference = new Reference(metavariableNode);
+
+    return reference;
+  }
+}

package/src/rule.js

@@ -29,16 +29,6 @@ export default class Rule {
     return this.fileContext;
   }
 
-  getLabelMetavariableNodes() {
-    const labelMetavariableNodes = this.labels.map((label) => {
-      const labelMetavariableNode = label.getMetavariableNode();
-
-      return labelMetavariableNode;
-    });
-
-    return labelMetavariableNodes;
-  }
-
   unifyStatement(statementNode, localContext) {
     let statementUnified = false;
 

package/src/topLevelAssertion.js

@@ -34,16 +34,6 @@ export default class TopLevelAssertion {
     return this.fileContext;
   }
 
-  getLabelMetavariableNodes() {
-    const labelMetavariableNodes = this.labels.map((label) => {
-      const labelMetavariableNode = label.getMetavariableNode();
-
-      return labelMetavariableNode;
-    });
-
-    return labelMetavariableNodes;
-  }
-
   unifyStatement(statementNode, localContext) {
     let statementUnified = false;
 

package/src/unify/qualifiedStatement.js

@@ -46,18 +46,17 @@ function unifyQualifiedStatementAWithRule(qualifiedStatementNode, substitutions,
 
   if (rule !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
-          labelMetavariableNodes = rule.getLabelMetavariableNodes(),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode),
-          labelMetavariableNodesString = localContext.nodesAsString(labelMetavariableNodes);
+          metavariableString = localContext.nodeAsString(metavariableNode),
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' rule...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' rule...`, qualifiedStatementNode);
 
     const statementUnified = rule.unifyStatement(statementNode, localContext);
 
     qualifiedStatementUnifiedWithRule = statementUnified;  ///
 
     if (qualifiedStatementUnifiedWithRule) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' rule.`, qualifiedStatementNode);
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' rule.`, qualifiedStatementNode);
     }
   }
 
@@ -72,18 +71,17 @@ function unifyQualifiedStatementAWithAxiom(qualifiedStatementNode, substitutions
 
   if (axiom !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
-          labelMetavariableNodes = axiom.getLabelMetavariableNodes(),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode),
-          labelMetavariableNodesString = localContext.nodesAsString(labelMetavariableNodes);
+          metavariableString = localContext.nodeAsString(metavariableNode),
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' axiom...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' axiom...`, qualifiedStatementNode);
 
     const statementUnified = axiom.unifyStatement(statementNode, localContext);
 
     qualifiedStatementUnifiedWithAxiom = statementUnified; ///
 
     if (qualifiedStatementUnifiedWithAxiom) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' axiom.`, qualifiedStatementNode);
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' axiom.`, qualifiedStatementNode);
     }
   }
 
@@ -98,18 +96,17 @@ function unifyQualifiedStatementAWithLemma(qualifiedStatementNode, substitutions
 
   if (lemma !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
-          labelMetavariableNodes = lemma.getLabelMetavariableNodes(),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode),
-          labelMetavariableNodesString = localContext.nodesAsString(labelMetavariableNodes);
+          metavariableString = localContext.nodeAsString(metavariableNode),
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' lemma...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' lemma...`, qualifiedStatementNode);
 
     const statementUnified = lemma.unifyStatement(statementNode, localContext);
 
     qualifiedStatementUnifiedWithLemma = statementUnified; ///
 
     if (qualifiedStatementUnifiedWithLemma) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' lemma.`, qualifiedStatementNode);
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' lemma.`, qualifiedStatementNode);
     }
   }
 
@@ -124,18 +121,17 @@ function unifyQualifiedStatementAWithTheorem(qualifiedStatementNode, substitutio
 
   if (theorem !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
-          labelMetavariableNodes = theorem.getLabelMetavariableNodes(),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode),
-          labelMetavariableNodesString = localContext.nodesAsString(labelMetavariableNodes);
+          metavariableString = localContext.nodeAsString(metavariableNode),
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' theorem...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' theorem...`, qualifiedStatementNode);
 
     const statementUnified = theorem.unifyStatement(statementNode, localContext);
 
     qualifiedStatementUnifiedWithTheorem = statementUnified; ///
 
     if (qualifiedStatementUnifiedWithTheorem) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' theorem.`, qualifiedStatementNode);
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' theorem.`, qualifiedStatementNode);
     }
   }
 
@@ -150,18 +146,17 @@ function unifyQualifiedStatementAWithConjecture(qualifiedStatementNode, substitu
 
   if (conjecture !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
-          labelMetavariableNodes = conjecture.getLabelMetavariableNodes(),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode),
-          labelMetavariableNodesString = localContext.nodesAsString(labelMetavariableNodes);
+          metavariableString = localContext.nodeAsString(metavariableNode),
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' conjecture...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' conjecture...`, qualifiedStatementNode);
 
     const statementUnified = conjecture.unifyStatement(statementNode, localContext);
 
     qualifiedStatementUnifiedWithConjecture = statementUnified; ///
 
     if (qualifiedStatementUnifiedWithConjecture) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' conjecture.`, qualifiedStatementNode);
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' conjecture.`, qualifiedStatementNode);
     }
   }
 

package/src/unify/termWithType.js

@@ -10,6 +10,5 @@ export default function unifyTermWithType(termNode, typeNode, localContext) {
 
   termUnifiedWithType = termVerifiedGivenType;  ///
 
-
   return termUnifiedWithType;
 }

package/src/verify/declaration.js

@@ -1,14 +1,15 @@
 "use strict";
 
 import shim from "../shim";
+import Reference from "../reference";
 import Declaration from "../declaration"
 import referenceMetaType from "../metaType/reference";
 import verifyMetavariableGivenMetaType from "../verify/metavariableGivenMetaType";
 
 import { nodeQuery } from "../utilities/query";
 
-const statementNodeQuery = nodeQuery("/declaration/statement[1]"),
-      metavariableNodeQuery = nodeQuery("/declaration/statement[0]/metavariable!");
+const statementNodeQuery = nodeQuery("/declaration/statement"),
+      metavariableNodeQuery = nodeQuery("/declaration/reference/metavariable"); ///
 
 const verifyDeclarationFunctions = [
   verifyDerivedDeclaration,
@@ -46,8 +47,9 @@ function verifyDerivedDeclaration(declarationNode, declarations, stated, localCo
     localContext.trace(`Verifying the '${declarationString}' derived declaration...`, declarationNode);
 
     const metaType = referenceMetaType, ///
+          metavariables = [],
           metavariableNode = metavariableNodeQuery(declarationNode),
-          metavariableVerifiedGivenMetaType = verifyMetavariableGivenMetaType(metavariableNode, metaType, localContext);
+          metavariableVerifiedGivenMetaType = verifyMetavariableGivenMetaType(metavariableNode, metaType, metavariables, localContext);
 
     if (metavariableVerifiedGivenMetaType) {
       const { verifyStatement } = shim,
@@ -57,7 +59,8 @@ function verifyDerivedDeclaration(declarationNode, declarations, stated, localCo
             statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
 
       if (statementVerified) {
-        const declaration = Declaration.fromMetavariableNodeAndStatementNode(metavariableNode, statementNode);
+        const reference = Reference.fromMetavariableNode(metavariableNode),
+          declaration = Declaration.fromReferenceAndStatementNode(reference, statementNode);
 
         declarations.push(declaration);
 
@@ -82,18 +85,20 @@ function verifyStatedDeclaration(declarationNode, declarations, stated, localCon
     localContext.trace(`Verifying the '${declarationString}' stated declaration...`, declarationNode);
 
     const metaType = referenceMetaType, ///
+          metavariables = [],
           metavariableNode = metavariableNodeQuery(declarationNode),
-          metavariableVerifiedGivenMetaType = verifyMetavariableGivenMetaType(metavariableNode, metaType, localContext);
+          metavariableVerifiedGivenMetaType = verifyMetavariableGivenMetaType(metavariableNode, metaType, metavariables, localContext);
 
     if (metavariableVerifiedGivenMetaType) {
-      const { verifyStatement } = shim,
-            stated = true,
-            assignments = null,
-            statementNode = statementNodeQuery(declarationNode),
-            statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
+        const { verifyStatement } = shim,
+              stated = true,
+              assignments = null,
+              statementNode = statementNodeQuery(declarationNode),
+              statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
 
       if (statementVerified) {
-        const declaration = Declaration.fromMetavariableNodeAndStatementNode(metavariableNode, statementNode);
+        const reference = Reference.fromMetavariableNode(metavariableNode),
+              declaration = Declaration.fromReferenceAndStatementNode(reference, statementNode);
 
         declarations.push(declaration);
 

package/src/verify/frame.js

@@ -3,10 +3,10 @@
 import Frame from "../frame";
 import frameMetaType from "../metaType/frame";
 import verifyDeclaration from "../verify/declaration";
-import verifyMetavariableGivenMetaType from "../verify/metavariableGivenMetaType";
+import verifyMetavariableGivenMetaType from "./metavariableGivenMetaType";
 
+import { first } from "../utilities/array";
 import { nodesQuery } from "../utilities/query";
-import { first, push } from "../utilities/array";
 
 const declarationNodesQuery = nodesQuery("/frame/declaration"),
       metavariableNodesQuery = nodesQuery("/frame/metavariable");
@@ -46,31 +46,33 @@ function verifyDerivedFrame(frameNode, frames, stated, localContext) {
 
     localContext.trace(`Verifying the '${frameString}' derived frame...`, frameNode);
 
-    const declarationNodes = declarationNodesQuery(frameNode),
-          declarationNodesLength = declarationNodes.length;
+    const declarations = [],
+          declarationNodes = declarationNodesQuery(frameNode),
+          declarationsVerified = declarationNodes.every((declarationNode) => {
+            const declarationVerified = verifyDeclaration(declarationNode, declarations, stated, localContext);
+
+            if (declarationVerified) {
+              return true;
+            }
+          });
 
-    if (declarationNodesLength === 1) {
+    if (declarationsVerified) {
       const metavariableNodes = metavariableNodesQuery(frameNode),
-            metavariableNodesLength = metavariableNodes.length;
+            metavariablesVerified = metavariableNodes.every((metavariableNode) => {
+              const metavariableVerified = verifyMetavariable(metavariableNode, declarations, localContext);
 
-      if (metavariableNodesLength === 0) {
-        const firstDeclarationNode = first(declarationNodes),
-              declarationNode = firstDeclarationNode, ///
-              declarations = [],
-              declarationVerified = verifyDeclaration(declarationNode, declarations, stated, localContext);
+              if (metavariableVerified) {
+                return true;
+              }
+            });
 
-        if (declarationVerified) {
-          const frame = Frame.fromDeclarations(declarations);
+      if (metavariablesVerified) {
+        const frame = Frame.fromDeclarations(declarations);
 
-          frames.push(frame);
+        frames.push(frame);
 
-          derivedFrameVerified = true; ///
-        }
-      } else {
-        localContext.debug(`The '${frameString}' derived frame must no spread metavariables.`, frameNode);
+        derivedFrameVerified = true; ///
       }
-    } else {
-      localContext.debug(`The '${frameString}' derived frame must have one and only one declaration.`, frameNode);
     }
 
     if (derivedFrameVerified) {
@@ -89,30 +91,36 @@ function verifyStatedFrame(frameNode, frames, stated, localContext) {
 
     localContext.trace(`Verifying the '${frameString}' stated frame...`, frameNode);
 
-    const declarations = [],
-          declarationNodes = declarationNodesQuery(frameNode),
-          declarationsVerified = declarationNodes.every((declarationNode) => {
-            const declarationVerified = verifyDeclaration(declarationNode, declarations, stated, localContext);
+    const declarationNodes = declarationNodesQuery(frameNode),
+          declarationNodesLength = declarationNodes.length;
 
-            return declarationVerified;
-          });
+    if (declarationNodesLength === 0) {
+      const metavariableNodes = metavariableNodesQuery(frameNode),
+            metavariableNodesLength = metavariableNodes.length;
 
-          if (declarationsVerified) {
-            const metavariableNodes = metavariableNodesQuery(frameNode),
-                  metavariablesVerified = metavariableNodes.every((metavariableNode) => {
-                    const metavariableVerified = verifyMetavariable(metavariableNode, declarations, localContext);
+      if (metavariableNodesLength === 1) {
+        const firstMetavariableNode = first(metavariableNodes),
+              metavariableNode = firstMetavariableNode,
+              metaType = frameMetaType, ///
+              metavariables = [],
+              metavariableVerifiedGivenMetaType = verifyMetavariableGivenMetaType(metavariableNode, metaType, metavariables, localContext);
 
-                    return metavariableVerified;
-                  });
+        if (metavariableVerifiedGivenMetaType) {
+          const firstMetavariable = first(metavariables),
+                metavariable = firstMetavariable,
 
-            if (metavariablesVerified) {
-              const frame = Frame.fromDeclarations(declarations);
+          frame = Frame.fromMetavariable(metavariable);
 
-              frames.push(frame);
+          frames.push(frame);
 
-              statedFrameVerified = true;
-            }
-          }
+          statedFrameVerified = true;
+        }
+      } else {
+        localContext.trace(`The '${frameString}' stated frame cannot have more than one metavariable.`, frameNode);
+      }
+    } else {
+      localContext.trace(`The '${frameString}' stated frame cannot have declarations.`, frameNode);
+    }
 
     if (statedFrameVerified) {
       localContext.debug(`...verified the '${frameString}' stated frame.`, frameNode);
@@ -125,24 +133,34 @@ function verifyStatedFrame(frameNode, frames, stated, localContext) {
 function verifyMetavariable(metavariableNode, declarations, localContext) {
   let metavariableVerified = false;
 
+  const metavariableString = localContext.nodeAsString(metavariableNode);
+
+  localContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
+
   const metaType = frameMetaType, ///
-        metavariableVerifiedGivenMetaType = verifyMetavariableGivenMetaType(metavariableNode, metaType, localContext);
+        metavariables = [],
+        metavariableVerifiedGivenMetaType = verifyMetavariableGivenMetaType(metavariableNode, metaType, metavariables, localContext);
 
   if (metavariableVerifiedGivenMetaType) {
-    const judgement = localContext.findJudgementByMetavariableNode(metavariableNode);
+    const firstMetavariable = first(metavariables),
+          metavariable = firstMetavariable, ///
+          metavariableName = metavariable.getName(),
+          judgement = localContext.findJudgementByMetavariableName(metavariableName);
 
     if (judgement !== null) {
-      const judgementDeclarations = judgement.getDeclarations();
+      const declaration = judgement.getDeclaration();
 
-      push(declarations, judgementDeclarations);
+      declarations.push(declaration);
 
       metavariableVerified = true;
     } else {
-      const metavariableString = localContext.nodeAsString(metavariableNode);
-
-      localContext.debug(`There is no judgement for the '${metavariableString}' metavariable.`, metavariableNode)
+      localContext.trace(`There is no judgement for the '${metavariableString}' metavariable.`, metavariableNode);
     }
   }
 
+  if (metavariableVerified) {
+    localContext.debug(`...verified the '${metavariableString}' metavariable.`, metavariableNode);
+  }
+
   return metavariableVerified;
 }

package/src/verify/judgement.js

@@ -2,15 +2,15 @@
 
 import Judgement from "../judgement";
 import verifyFrame from "../verify/frame";
-import declarationMetaType from "../metaType/frame";
+import verifyDeclaration from "./declaration";
 import JudgementAssignment from "../assignment/judgement";
-import verifyMetavariableGivenMetaType from "../verify/metavariableGivenMetaType";
 
 import { first } from "../utilities/array";
 import { nodeQuery } from "../utilities/query";
+import { metavariableNameFromMetavariableNode } from "../utilities/name";
 
-const frameNodeQuery = nodeQuery("/judgement/frame!"),
-      metavariableNodeQuery = nodeQuery("/judgement/statement/metavariable!");
+const frameNodeQuery = nodeQuery("/judgement/frame"),
+      declarationNodeQuery = nodeQuery("/judgement/declaration");
 
 const verifyJudgementFunctions = [
   verifyDerivedJudgement,
@@ -47,40 +47,29 @@ function verifyDerivedJudgement(judgementNode, assignments, stated, localContext
 
     localContext.trace(`Verifying the '${judgementString}' derived judgement...`, judgementNode);
 
-    const metavariableNode = metavariableNodeQuery(judgementNode);
+    const declarations = [],
+          declarationNode = declarationNodeQuery(judgementNode),
+          declarationVerified = verifyDeclaration(declarationNode, declarations, stated, localContext);
 
-    if (metavariableNode !== null) {
-      const metaType = declarationMetaType, ///
-            metavariableVerifiedGivenMetaType = verifyMetavariableGivenMetaType(metavariableNode, metaType, localContext);
+    if (declarationVerified) {
+      const firstDeclaration = first(declarations),
+            declaration = firstDeclaration, ///
+            metavariableNode = declaration.getMetavariableNode(),
+            metatheorem = localContext.findMetatheoremByMetavariableNode(metavariableNode),
+            metaLemma = localContext.findMetaLemmaByMetavariableNode(metavariableNode),
+            metaLemmaMetatheorem = (metaLemma || metatheorem);  ///
 
-      if (metavariableVerifiedGivenMetaType) {
-        const judgement = localContext.findJudgementByMetavariableNode(metavariableNode);
-
-        if (judgement !== null) {
-          const frames = [],
-                frameNode = frameNodeQuery(judgementNode),
-                frameVerified = verifyFrame(frameNode, frames, stated, localContext);
-
-          if (frameVerified) {
-            const firstFrame = first(frames),
-                  frame = firstFrame, ///
-                  declaration = frame.getDeclaration(),
-                  metavariableNode = declaration.getMetavariableNode(),
-                  metatheorem = localContext.findMetatheoremByMetavariableNode(metavariableNode),
-                  metaLemma = localContext.findMetaLemmaByMetavariableNode(metavariableNode),
-                  metaLemmaMetatheorem = (metaLemma || metatheorem);  ///
-
-            if (metaLemmaMetatheorem !== null) {
-              const metaLemmaMetatheoremUnifiedWithJudgement = judgement.unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem),
-                    metaLemmaMetatheoremUnifiedWithDeclaration = declaration.unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem);
+      if (metaLemmaMetatheorem !== null) {
+        const frames = [],
+              frameNode = frameNodeQuery(judgementNode),
+              frameVerified = verifyFrame(frameNode, frames, stated, localContext);
 
-              derivedJudgementVerified = (metaLemmaMetatheoremUnifiedWithJudgement && metaLemmaMetatheoremUnifiedWithDeclaration);
-            }
-          }
-        } else {
-          const metavariableString = localContext.nodeAsString(metavariableNode);
+        if (frameVerified) {
+          const firstFrame = first(frames),
+                frame = firstFrame, ///
+                metaLemmaMetatheoremUnified = frame.unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem);
 
-          localContext.debug(`There is no judgement for the '${metavariableString}' metavariable.`, metavariableNode)
+          derivedJudgementVerified = metaLemmaMetatheoremUnified; ///
         }
       }
     }
@@ -101,22 +90,28 @@ function verifyStatedJudgement(judgementNode, assignments, stated, localContext)
 
     localContext.trace(`Verifying the '${judgementString}' stated judgement...`, judgementNode);
 
-    const metavariableNode = metavariableNodeQuery(judgementNode);
+    const frames = [],
+          frameNode = frameNodeQuery(judgementNode),
+          frameVerified = verifyFrame(frameNode, frames, stated, localContext);
 
-    if (metavariableNode !== null) {
-      const metaType = declarationMetaType, ///
-            metavariableVerifiedGivenMetaType = verifyMetavariableGivenMetaType(metavariableNode, metaType, localContext);
+    if (frameVerified) {
+      const firstFrame = first(frames),
+            frame = firstFrame, ///
+            metavariable = frame.getMetavariable(),
+            metavariableNode = metavariable.getNode(),
+            metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+            judgementPresent = localContext.isJudgementPresentByMetavariableName(metavariableName);
 
-      if (metavariableVerifiedGivenMetaType) {
-        const frames = [],
-              frameNode = frameNodeQuery(judgementNode),
-              frameVerified = verifyFrame(frameNode, frames, stated, localContext);
+      if (!judgementPresent) {
+        const declarations = [],
+              declarationNode = declarationNodeQuery(judgementNode),
+              declarationVerified = verifyDeclaration(declarationNode, declarations, stated, localContext);
 
-        if (frameVerified) {
+        if (declarationVerified) {
           if (assignments !== null) {
-            const firstFrame = first(frames),
-                  frame = firstFrame, ///
-                  judgement = Judgement.fromJudgementNodeFrameAndMetavariableNode(judgementNode, frame, metavariableNode),
+            const firstDeclaration = first(declarations),
+                  declaration = firstDeclaration, ///
+                  judgement = Judgement.fromJudgementNodeFrameAndDeclaration(judgementNode, frame, declaration),
                   judgementAssignment = JudgementAssignment.fromJudgement(judgement),
                   assignment = judgementAssignment;
 
@@ -125,6 +120,8 @@ function verifyStatedJudgement(judgementNode, assignments, stated, localContext)
 
           statedJudgementVerified = true;
         }
+      } else {
+        localContext.trace(`There is already a judgement for the '${metavariableName}' metavariable.`, judgementNode);
       }
     }
 

package/src/verify/metavariableGivenMetaType.js

@@ -4,7 +4,7 @@ import metavariableUnifier from "../unifier/metavariable";
 
 import { metavariableNameFromMetavariableNode } from "../utilities/name";
 
-export default function verifyMetavariableGivenMetaType(metavariableNode, metaType, localContext) {
+export default function verifyMetavariableGivenMetaType(metavariableNode, metaType, metavariables, localContext) {
   let metavariableVerifiedGivenMetaType = false;
 
   const metaTypeName = metaType.getName(),
@@ -27,7 +27,11 @@ export default function verifyMetavariableGivenMetaType(metavariableNode, metaTy
 
       const unified = metavariableUnifier.unify(metavariableNodeA, metavariableNodeB, localContext);
 
-      metavariableVerifiedGivenMetaType = unified; ///
+      if (unified) {
+        metavariables.push(metavariable);
+
+        metavariableVerifiedGivenMetaType = true;
+      }
     } else {
       const metavariableMetaTypeName = metavariableMetaType.getName();
 

package/src/verify/statement.js

@@ -96,7 +96,7 @@ function verifyStatementAsMetavariable(statementNode, assignments, stated, local
 
     const metavariableUnified = unifyMetavariable(metavariableNode, localContext);
 
-    statementVerifiedAsMetavariable = metavariableUnified;
+    statementVerifiedAsMetavariable = metavariableUnified;  ///
 
     if (statementVerifiedAsMetavariable) {
       localContext.debug(`...verified the '${statementString}' statement as a metavariable.`, statementNode);