occam-verify-cli 0.0.974 → 0.0.975

package/src/unify/qualifiedStatement.js

@@ -1,6 +1,10 @@
 "use strict";
 
+import metavariableUnifier from "../unifier/metavariable";
+import StatementForMetavariableSubstitution from "../substitution/statementForMetavariable";
+
 import { nodeQuery } from "../utilities/query";
+import { metavariableNameFromMetavariableNode } from "../utilities/name";
 
 const statementNodeQuery = nodeQuery("/qualifiedStatement/statement!"),
       metavariableNodeQuery = nodeQuery("/qualifiedStatement/reference/metavariable!");
@@ -42,17 +46,18 @@ function unifyQualifiedStatementAWithRule(qualifiedStatementNode, substitutions,
 
   if (rule !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
-          metavariableString = localContext.nodeAsString(metavariableNode),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+          labelMetavariableNodes = rule.getLabelMetavariableNodes(),
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode),
+          labelMetavariableNodesString = localContext.nodesAsString(labelMetavariableNodes);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' rule...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' rule...`, qualifiedStatementNode);
 
     const statementUnified = rule.unifyStatement(statementNode, localContext);
 
     qualifiedStatementUnifiedWithRule = statementUnified;  ///
 
     if (qualifiedStatementUnifiedWithRule) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' rule.`, qualifiedStatementNode);
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' rule.`, qualifiedStatementNode);
     }
   }
 
@@ -67,17 +72,18 @@ function unifyQualifiedStatementAWithAxiom(qualifiedStatementNode, substitutions
 
   if (axiom !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
-          metavariableString = localContext.nodeAsString(metavariableNode),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+          labelMetavariableNodes = axiom.getLabelMetavariableNodes(),
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode),
+          labelMetavariableNodesString = localContext.nodesAsString(labelMetavariableNodes);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' axiom...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' axiom...`, qualifiedStatementNode);
 
     const statementUnified = axiom.unifyStatement(statementNode, localContext);
 
     qualifiedStatementUnifiedWithAxiom = statementUnified; ///
 
     if (qualifiedStatementUnifiedWithAxiom) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' axiom.`, qualifiedStatementNode);
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' axiom.`, qualifiedStatementNode);
     }
   }
 
@@ -92,17 +98,18 @@ function unifyQualifiedStatementAWithLemma(qualifiedStatementNode, substitutions
 
   if (lemma !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
-          metavariableString = localContext.nodeAsString(metavariableNode),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+          labelMetavariableNodes = lemma.getLabelMetavariableNodes(),
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode),
+          labelMetavariableNodesString = localContext.nodesAsString(labelMetavariableNodes);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' lemma...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' lemma...`, qualifiedStatementNode);
 
     const statementUnified = lemma.unifyStatement(statementNode, localContext);
 
     qualifiedStatementUnifiedWithLemma = statementUnified; ///
 
     if (qualifiedStatementUnifiedWithLemma) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' lemma.`, qualifiedStatementNode);
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' lemma.`, qualifiedStatementNode);
     }
   }
 
@@ -117,17 +124,18 @@ function unifyQualifiedStatementAWithTheorem(qualifiedStatementNode, substitutio
 
   if (theorem !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
-          metavariableString = localContext.nodeAsString(metavariableNode),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+          labelMetavariableNodes = theorem.getLabelMetavariableNodes(),
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode),
+          labelMetavariableNodesString = localContext.nodesAsString(labelMetavariableNodes);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' theorem...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' theorem...`, qualifiedStatementNode);
 
     const statementUnified = theorem.unifyStatement(statementNode, localContext);
 
     qualifiedStatementUnifiedWithTheorem = statementUnified; ///
 
     if (qualifiedStatementUnifiedWithTheorem) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' theorem.`, qualifiedStatementNode);
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' theorem.`, qualifiedStatementNode);
     }
   }
 
@@ -142,17 +150,18 @@ function unifyQualifiedStatementAWithConjecture(qualifiedStatementNode, substitu
 
   if (conjecture !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
-          metavariableString = localContext.nodeAsString(metavariableNode),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+          labelMetavariableNodes = conjecture.getLabelMetavariableNodes(),
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode),
+          labelMetavariableNodesString = localContext.nodesAsString(labelMetavariableNodes);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' conjecture...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' conjecture...`, qualifiedStatementNode);
 
     const statementUnified = conjecture.unifyStatement(statementNode, localContext);
 
     qualifiedStatementUnifiedWithConjecture = statementUnified; ///
 
     if (qualifiedStatementUnifiedWithConjecture) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' conjecture.`, qualifiedStatementNode);
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' conjecture.`, qualifiedStatementNode);
     }
   }
 
@@ -162,21 +171,42 @@ function unifyQualifiedStatementAWithConjecture(qualifiedStatementNode, substitu
 function unifyQualifiedStatementAWithReference(qualifiedStatementNode, substitutions, localContext) {
   let qualifiedStatementUnifiedWithReference = false;
 
-  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
-        metavariableString = localContext.nodeAsString(metavariableNode),
-        metavariablePresent = localContext.isMetavariablePresentByMetavariableNode(metavariableNode),
-        qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+  let metavariableNode = metavariableNodeQuery(qualifiedStatementNode);
 
-  localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' reference...`, qualifiedStatementNode);
+  const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+        metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
 
-  if (metavariablePresent) {
+  if (metavariable !== null) {
+    const statementNode = statementNodeQuery(qualifiedStatementNode),
+          statementString = localContext.nodeAsString(statementNode),
+          metavariableString = localContext.nodeAsString(metavariableNode);
 
-    debugger
+    localContext.trace(`Unifying the '${statementString}' qualified statement with the '${metavariableString}' reference...`, qualifiedStatementNode);
 
-  }
+    const metavariableNodeA = metavariableNode; ///
+
+    metavariableNode = metavariable.getNode();
+
+    const metavariableNodeB = metavariableNode; ///
+
+    const unified = metavariableUnifier.unify(metavariableNodeA, metavariableNodeB, localContext);
 
-  if (qualifiedStatementUnifiedWithReference) {
-    localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' reference.`, qualifiedStatementNode);
+    if (unified) {
+      metavariableNode = metavariableNodeA; ///
+
+      const statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementNodeAndMetavariableNode(statementNode, metavariableNode),
+            substitution = statementForMetavariableSubstitution, ///
+            localContextA = localContext, ///
+            localContextB = localContext; ///
+
+      substitutions.addSubstitution(substitution, localContextA, localContextB);
+
+      qualifiedStatementUnifiedWithReference = true;
+    }
+
+    if (qualifiedStatementUnifiedWithReference) {
+      localContext.debug(`...unified the '${statementString}' qualified statement with the '${metavariableString}' reference.`, qualifiedStatementNode);
+    }
   }
 
   return qualifiedStatementUnifiedWithReference;

package/src/unify/statementWithCombinators.js

@@ -9,6 +9,8 @@ export default function unifyStatementWithCombinators(statementNode, assignments
 
   assignments = null; ///
 
+  stated = true;  ///
+
   statementUnifiedWithCombinators = combinators.some((combinator) => {
     const statementUnifiedWithCombinator = unifyStatementWithCombinator(statementNode, combinator, assignments, stated, localContext);
 

package/src/verify/assertion/defined.js

@@ -6,6 +6,7 @@ import metaLevelVerifier from "../../verifier/metaLevel";
 import { first } from "../../utilities/array";
 import { nodeQuery } from "../../utilities/query";
 import { isAssertionNegated } from "../../utilities/assertion";
+import { metavariableNameFromMetavariableNode } from "../../utilities/name";
 
 const variableNodeQuery = nodeQuery("/definedAssertion/term/variable!"),
       metavariableNodeQuery = nodeQuery("/definedAssertion/statement[-1]/metavariable!");
@@ -63,7 +64,8 @@ function verifyDerivedDefinedAssertion(definedAssertionNode, assignments, stated
     if (false) {
       ///
     } else if (metavariableNode !== null) {
-      const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode),
+      const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+            metavariable = localContext.findMetavariableByMetavariableName(metavariableName),
             metavariableDefined = localContext.isMetavariableDefined(metavariable);
 
       if (!assertionNegated) {

package/src/verify/declaration.js

@@ -3,6 +3,7 @@
 import shim from "../shim";
 import Declaration from "../declaration"
 import referenceMetaType from "../metaType/reference";
+import verifyMetavariableGivenMetaType from "../verify/metavariableGivenMetaType";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -44,7 +45,25 @@ function verifyDerivedDeclaration(declarationNode, declarations, stated, localCo
 
     localContext.trace(`Verifying the '${declarationString}' derived declaration...`, declarationNode);
 
-    derivedDeclarationVerified = false; ///
+    const metaType = referenceMetaType, ///
+          metavariableNode = metavariableNodeQuery(declarationNode),
+          metavariableVerifiedGivenMetaType = verifyMetavariableGivenMetaType(metavariableNode, metaType, localContext);
+
+    if (metavariableVerifiedGivenMetaType) {
+      const { verifyStatement } = shim,
+            stated = true,
+            assignments = null,
+            statementNode = statementNodeQuery(declarationNode),
+            statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
+
+      if (statementVerified) {
+        const declaration = Declaration.fromMetavariableNodeAndStatementNode(metavariableNode, statementNode);
+
+        declarations.push(declaration);
+
+        derivedDeclarationVerified = true;
+      }
+    }
 
     if (derivedDeclarationVerified) {
       localContext.debug(`...verified the '${declarationString}' derived declaration.`, declarationNode);
@@ -62,10 +81,11 @@ function verifyStatedDeclaration(declarationNode, declarations, stated, localCon
 
     localContext.trace(`Verifying the '${declarationString}' stated declaration...`, declarationNode);
 
-    const metavariableNode = metavariableNodeQuery(declarationNode),
-          metavariableVerified = verifyMetavariable(metavariableNode, localContext);
+    const metaType = referenceMetaType, ///
+          metavariableNode = metavariableNodeQuery(declarationNode),
+          metavariableVerifiedGivenMetaType = verifyMetavariableGivenMetaType(metavariableNode, metaType, localContext);
 
-    if (metavariableVerified) {
+    if (metavariableVerifiedGivenMetaType) {
       const { verifyStatement } = shim,
             stated = true,
             assignments = null,
@@ -88,34 +108,3 @@ function verifyStatedDeclaration(declarationNode, declarations, stated, localCon
 
   return statedDeclarationVerified;
 }
-
-function verifyMetavariable(metavariableNode, localContext) {
-  let metavariableVerified = false;
-
-  const metavariableString = localContext.nodeAsString(metavariableNode);
-
-  localContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
-
-  const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode);
-
-  if (metavariable !== null) {
-    const metaType = metavariable.getMetaType();
-
-    if (metaType === referenceMetaType) {
-      metavariableVerified = true;
-    } else {
-      const referenceMetaTypeName = referenceMetaType.getName(),
-            metaTypeString = metaType.asString();
-
-      localContext.debug(`The '${metavariableString}' metavariable's meta-type is '${metaTypeString}' when it should be '${referenceMetaTypeName}'.`, metavariableNode);
-    }
-  } else {
-    localContext.debug(`The '${metavariableString}' metavariable is not present'.`, metavariableNode);
-  }
-
-  if (metavariableVerified) {
-    localContext.debug(`...verified the '${metavariableString}' metavariable.`, metavariableNode);
-  }
-
-  return metavariableVerified;
-}

package/src/verify/frame.js

@@ -3,9 +3,10 @@
 import Frame from "../frame";
 import frameMetaType from "../metaType/frame";
 import verifyDeclaration from "../verify/declaration";
+import verifyMetavariableGivenMetaType from "../verify/metavariableGivenMetaType";
 
-import { push } from "../utilities/array";
 import { nodesQuery } from "../utilities/query";
+import { first, push } from "../utilities/array";
 
 const declarationNodesQuery = nodesQuery("/frame/declaration"),
       metavariableNodesQuery = nodesQuery("/frame/metavariable");
@@ -45,7 +46,32 @@ function verifyDerivedFrame(frameNode, frames, stated, localContext) {
 
     localContext.trace(`Verifying the '${frameString}' derived frame...`, frameNode);
 
-    derivedFrameVerified = false; ///
+    const declarationNodes = declarationNodesQuery(frameNode),
+          declarationNodesLength = declarationNodes.length;
+
+    if (declarationNodesLength === 1) {
+      const metavariableNodes = metavariableNodesQuery(frameNode),
+            metavariableNodesLength = metavariableNodes.length;
+
+      if (metavariableNodesLength === 0) {
+        const firstDeclarationNode = first(declarationNodes),
+              declarationNode = firstDeclarationNode, ///
+              declarations = [],
+              declarationVerified = verifyDeclaration(declarationNode, declarations, stated, localContext);
+
+        if (declarationVerified) {
+          const frame = Frame.fromDeclarations(declarations);
+
+          frames.push(frame);
+
+          derivedFrameVerified = true; ///
+        }
+      } else {
+        localContext.debug(`The '${frameString}' derived frame must no spread metavariables.`, frameNode);
+      }
+    } else {
+      localContext.debug(`The '${frameString}' derived frame must have one and only one declaration.`, frameNode);
+    }
 
     if (derivedFrameVerified) {
       localContext.debug(`...verified the '${frameString}' derived frame.`, frameNode);
@@ -65,25 +91,28 @@ function verifyStatedFrame(frameNode, frames, stated, 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 metavariableVerified;
           });
 
-    if (declarationsVerified && metavariablesVerified) {
-      const frame = Frame.fromDeclarations(declarations);
+          if (declarationsVerified) {
+            const metavariableNodes = metavariableNodesQuery(frameNode),
+                  metavariablesVerified = metavariableNodes.every((metavariableNode) => {
+                    const metavariableVerified = verifyMetavariable(metavariableNode, declarations, localContext);
 
-      frames.push(frame);
+                    return metavariableVerified;
+                  });
 
-      statedFrameVerified = true;
-    }
+            if (metavariablesVerified) {
+              const frame = Frame.fromDeclarations(declarations);
+
+              frames.push(frame);
+
+              statedFrameVerified = true;
+            }
+          }
 
     if (statedFrameVerified) {
       localContext.debug(`...verified the '${frameString}' stated frame.`, frameNode);
@@ -96,39 +125,23 @@ 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 metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode);
+  const metaType = frameMetaType, ///
+        metavariableVerifiedGivenMetaType = verifyMetavariableGivenMetaType(metavariableNode, metaType, localContext);
 
-  if (metavariable !== null) {
-    const metaType = metavariable.getMetaType();
+  if (metavariableVerifiedGivenMetaType) {
+    const judgement = localContext.findJudgementByMetavariableNode(metavariableNode);
 
-    if (metaType === frameMetaType) {
-      const judgement = localContext.findJudgementByMetavariableNode(metavariableNode);
+    if (judgement !== null) {
+      const judgementDeclarations = judgement.getDeclarations();
 
-      if (judgement !== null) {
-        const judgementDeclarations = judgement.getDeclarations();
+      push(declarations, judgementDeclarations);
 
-        push(declarations, judgementDeclarations);
-
-        metavariableVerified = true;
-      } else {
-        localContext.debug(`There is no judgement for the '${metavariableString}' metavariable.`, metavariableNode);
-      }
+      metavariableVerified = true;
     } else {
-      const frameMetaTypeName = frameMetaType.getName(),
-            metaTypeString = metaType.asString();
+      const metavariableString = localContext.nodeAsString(metavariableNode);
 
-      localContext.debug(`The '${metavariableString}' metavariable's meta-type is '${metaTypeString}' when it should be '${frameMetaTypeName}'.`, metavariableNode);
+      localContext.debug(`There is no judgement for the '${metavariableString}' metavariable.`, metavariableNode)
     }
-  } else {
-    localContext.debug(`The '${metavariableString}' metavariable is not present'.`, metavariableNode);
-  }
-
-  if (metavariableVerified) {
-    localContext.debug(`...verified the '${metavariableString}' metavariable.`, metavariableNode);
   }
 
   return metavariableVerified;

package/src/verify/judgement.js

@@ -4,6 +4,7 @@ import Judgement from "../judgement";
 import verifyFrame from "../verify/frame";
 import frameMetaType from "../metaType/frame";
 import JudgementAssignment from "../assignment/judgement";
+import verifyMetavariableGivenMetaType from "../verify/metavariableGivenMetaType";
 
 import { first } from "../utilities/array";
 import { nodeQuery } from "../utilities/query";
@@ -49,9 +50,10 @@ function verifyDerivedJudgement(judgementNode, assignments, stated, localContext
     const metavariableNode = metavariableNodeQuery(judgementNode);
 
     if (metavariableNode !== null) {
-      const metavariableVerified = verifyMetavariable(metavariableNode, localContext);
+      const metaType = frameMetaType, ///
+            metavariableVerifiedGivenMetaType = verifyMetavariableGivenMetaType(metavariableNode, metaType, localContext);
 
-      if (metavariableVerified) {
+      if (metavariableVerifiedGivenMetaType) {
         const judgement = localContext.findJudgementByMetavariableNode(metavariableNode);
 
         if (judgement !== null) {
@@ -62,35 +64,23 @@ function verifyDerivedJudgement(judgementNode, assignments, stated, localContext
           if (frameVerified) {
             const firstFrame = first(frames),
                   frame = firstFrame, ///
-                  frameSingular = frame.isSingular();
+                  declaration = frame.getDeclaration(),
+                  metavariableNode = declaration.getMetavariableNode(),
+                  metatheorem = localContext.findMetatheoremByMetavariableNode(metavariableNode),
+                  metaLemma = localContext.findMetaLemmaByMetavariableNode(metavariableNode),
+                  metaLemmaMetatheorem = (metaLemma || metatheorem);  ///
 
-            if (frameSingular) {
-              const declaration = frame.getDeclaration(),
-                    metavariableNode = declaration.getMetavariableNode(),
-                    metaLemma = localContext.findMetaLemmaByMetavariableNode(metavariableNode),
-                    metatheorem = localContext.findMetatheoremByMetavariableNode(metavariableNode),
-                    metaLemmaMetatheorem = (metaLemma || metatheorem);  ///
+            if (metaLemmaMetatheorem !== null) {
+              const metaLemmaMetatheoremUnifiedWithJudgement = judgement.unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem),
+                    metaLemmaMetatheoremUnifiedWithDeclaration = declaration.unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem);
 
-              if (metaLemmaMetatheorem !== null) {
-                const metaLemmaMetatheoremUnifiedWithDeclaration = declaration.unifyMetaLemmaOrMetaTheorem(metaLemmaMetatheorem),
-                      metaLemmaMetatheoremUnifiedWithJudgement = judgement.unifyMetaLemmaOrMetaTheorem(metaLemmaMetatheorem);
-
-                derivedJudgementVerified = (metaLemmaMetatheoremUnifiedWithDeclaration && metaLemmaMetatheoremUnifiedWithJudgement);
-              } else {
-                const metavariableString = localContext.nodeAsString(metavariableNode);
-
-                localContext.debug(`There are no meta-lemmas or metatheorems corresponding to the '${metavariableString}' metavariable.`, judgementNode);
-              }
-            } else {
-              const frameString = localContext.nodeAsString(frameNode);
-
-              localContext.debug(`The '${frameString}' is not singular.`, judgementNode);
+              derivedJudgementVerified = (metaLemmaMetatheoremUnifiedWithJudgement && metaLemmaMetatheoremUnifiedWithDeclaration);
             }
           }
         } else {
           const metavariableString = localContext.nodeAsString(metavariableNode);
 
-          localContext.debug(`There is no judgement present for the '${metavariableString}' metavariable.`, judgementNode);
+          localContext.debug(`There is no judgement for the '${metavariableString}' metavariable.`, metavariableNode)
         }
       }
     }
@@ -114,9 +104,10 @@ function verifyStatedJudgement(judgementNode, assignments, stated, localContext)
     const metavariableNode = metavariableNodeQuery(judgementNode);
 
     if (metavariableNode !== null) {
-      const metavariableVerified = verifyMetavariable(metavariableNode, localContext);
+      const metaType = frameMetaType, ///
+            metavariableVerifiedGivenMetaType = verifyMetavariableGivenMetaType(metavariableNode, metaType, localContext);
 
-      if (metavariableVerified) {
+      if (metavariableVerifiedGivenMetaType) {
         const frames = [],
               frameNode = frameNodeQuery(judgementNode),
               frameVerified = verifyFrame(frameNode, frames, stated, localContext);
@@ -144,34 +135,3 @@ function verifyStatedJudgement(judgementNode, assignments, stated, localContext)
 
   return statedJudgementVerified;
 }
-
-function verifyMetavariable(metavariableNode, localContext) {
-  let metavariableVerified = false;
-
-  const metavariableString = localContext.nodeAsString(metavariableNode);
-
-  localContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
-
-  const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode);
-
-  if (metavariable !== null) {
-    const metaType = metavariable.getMetaType();
-
-    if (metaType === frameMetaType) {
-      metavariableVerified = true;
-    } else {
-      const frameMetaTypeName = frameMetaType.getName(),
-            metaTypeString = metaType.asString();
-
-      localContext.debug(`The '${metavariableString}' metavariable's meta-type is '${metaTypeString}' when it should be '${frameMetaTypeName}'.`, metavariableNode);
-    }
-  } else {
-    localContext.debug(`The '${metavariableString}' metavariable is not present'.`, metavariableNode);
-  }
-
-  if (metavariableVerified) {
-    localContext.debug(`...verified the '${metavariableString}' metavariable.`, metavariableNode);
-  }
-
-  return metavariableVerified;
-}

package/src/verify/metavariableGivenMetaType.js

@@ -0,0 +1,45 @@
+"use strict";
+
+import metavariableUnifier from "../unifier/metavariable";
+
+import { metavariableNameFromMetavariableNode } from "../utilities/name";
+
+export default function verifyMetavariableGivenMetaType(metavariableNode, metaType, localContext) {
+  let metavariableVerifiedGivenMetaType = false;
+
+  const metaTypeName = metaType.getName(),
+        metavariableString = localContext.nodeAsString(metavariableNode);
+
+  localContext.trace(`Verifying the '${metavariableString}' metavariable given the '${metaTypeName}' meta-type...`, metavariableNode);
+
+  const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+        metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
+
+  if (metavariable !== null) {
+    const metavariableMetaType = metavariable.getMetaType();
+
+    if (metavariableMetaType === metaType) {
+      const metavariableNodeA = metavariableNode; ///
+
+      metavariableNode = metavariable.getNode();
+
+      const metavariableNodeB = metavariableNode; ///
+
+      const unified = metavariableUnifier.unify(metavariableNodeA, metavariableNodeB, localContext);
+
+      metavariableVerifiedGivenMetaType = unified; ///
+    } else {
+      const metavariableMetaTypeName = metavariableMetaType.getName();
+
+      localContext.debug(`The '${metavariableString}' metavariable's meta-type is '${metavariableMetaTypeName}' when it should be '${metaTypeName}'.`, metavariableNode);
+    }
+  } else {
+    localContext.debug(`The '${metavariableString}' metavariable is not present'.`, metavariableNode);
+  }
+
+  if (metavariableVerifiedGivenMetaType) {
+    localContext.debug(`...verified the '${metavariableString}' metavariable given the '${metaTypeName}' meta-type.`, metavariableNode);
+  }
+
+  return metavariableVerifiedGivenMetaType;
+}

package/src/verify/statement.js

@@ -6,6 +6,7 @@ import verifyEquality from "../verify/equality";
 import verifyJudgement from "../verify/judgement";
 import verifyDeclaration from "../verify/declaration";
 import verifyTypeAssertion from "../verify/assertion/type";
+import metavariableUnifier from "../unifier/metavariable";
 import verifyDefinedAssertion from "../verify/assertion/defined";
 import verifySubproofAssertion from "../verify/assertion/subproof";
 import verifyContainedAssertion from "../verify/assertion/contained";
@@ -13,6 +14,7 @@ import unifyStatementWithCombinators from "../unify/statementWithCombinators";
 import unifyStatementWithBracketedCombinator from "../unify/statementWithBracketedCombinator";
 
 import { nodeQuery } from "../utilities/query";
+import { metavariableNameFromMetavariableNode } from "../utilities/name";
 
 const frameNodeQuery = nodeQuery("/statement/frame!"),
       equalityNodeQuery = nodeQuery("/statement/equality!"),
@@ -92,9 +94,9 @@ function verifyStatementAsMetavariable(statementNode, assignments, stated, local
 
     localContext.trace(`Verifying the '${statementString}' statement as a metavariable...`, statementNode);
 
-    const metavariableVerified = verifyMetavariable(metavariableNode, localContext);
+    const metavariableUnified = unifyMetavariable(metavariableNode, localContext);
 
-    statementVerifiedAsMetavariable = metavariableVerified;
+    statementVerifiedAsMetavariable = metavariableUnified;
 
     if (statementVerifiedAsMetavariable) {
       localContext.debug(`...verified the '${statementString}' statement as a metavariable.`, statementNode);
@@ -280,24 +282,31 @@ function verifyStatementAsContainedAssertion(statementNode, assignments, stated,
   return statementVerifiedAsContainedAssertion;
 }
 
-function verifyMetavariable(metavariableNode, localContext) {
-  let metavariableVerified = false;
+function unifyMetavariable(metavariableNode, localContext) {
+  let metavariableUnified;
 
   const metavariableString = localContext.nodeAsString(metavariableNode);
 
-  localContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
+  localContext.trace(`Unifying the '${metavariableString}' metavariable...`, metavariableNode);
 
-  const metavariablePresent = localContext.isMetavariablePresentByMetavariableNode(metavariableNode);
+  const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+        metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
 
-  if (!metavariablePresent) {
-    localContext.trace(`The '${metavariableString}' metavariable is not present.`, metavariableNode);
-  } else {
-    metavariableVerified = true;
+  if (metavariable !== null) {
+    const metavariableNodeA = metavariableNode; ///
+
+    metavariableNode = metavariable.getNode();
+
+    const metavariableNodeB = metavariableNode; ///
+
+    const unified = metavariableUnifier.unify(metavariableNodeA, metavariableNodeB, localContext);
+
+    metavariableUnified = unified;  ///
   }
 
-  if (metavariableVerified) {
-    localContext.debug(`...verified the '${metavariableString}' metavariable.`, metavariableNode);
+  if (metavariableUnified) {
+    localContext.debug(`...unified the '${metavariableString}' metavariable.`, metavariableNode);
   }
 
-  return metavariableVerified;
+  return metavariableUnified;
 }