occam-verify-cli 0.0.972 → 0.0.975

package/src/unify/termWithConstructors.js

@@ -1,7 +1,6 @@
 "use strict";
 
-import Term from "../term";
-import termWithConstructorUnifier from "../unifier/termWithConstructor";
+import unifyTermWithConstructor from "../unify/termWithConstructor";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -26,38 +25,3 @@ export default function unifyTermWithConstructors(termNode, terms, localContext,
 
   return termUnifiedWithConstructors;
 }
-
-export function unifyTermWithConstructor(termNode, terms, constructor, localContext, verifyAhead) {
-  let termUnifiedWithConstructor = false;
-
-  const termString = localContext.nodeAsString(termNode),
-        constructorString = constructor.getString(),
-        constructorTermNode = constructor.getTermNode();
-
-  localContext.trace(`Unifying the '${termString}' term with the '${constructorString}' constructor...`, termNode);
-
-  const termNodeA = termNode,  ///
-        constructorTermNodeB = constructorTermNode,  ///
-        unified = termWithConstructorUnifier.unify(termNodeA, constructorTermNodeB, localContext);
-
-  if (unified) {
-    let verifiedAhead;
-
-    const type = constructor.getType(),
-          term = Term.fromTermNodeAndType(termNode, type);
-
-    terms.push(term);
-
-    verifiedAhead = verifyAhead();
-
-    terms.pop();
-
-    termUnifiedWithConstructor = verifiedAhead;  ///
-  }
-
-  if (termUnifiedWithConstructor) {
-    localContext.debug(`...unified the '${termString}' term with the '${constructorString}' constructor.`, termNode);
-  }
-
-  return termUnifiedWithConstructor;
-}

package/src/unify/{statement/unqualified.js → unqualifiedStatement.js}

@@ -1,6 +1,6 @@
 "use strict";
 
-import { nodeQuery } from "../../utilities/query";
+import { nodeQuery } from "../utilities/query";
 
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
 

package/src/verifier/statementAsCombinator.js

@@ -29,8 +29,8 @@ class StatementAsCombinatorVerifier extends Verifier {
       nodeQuery: statementNodeQuery,
       verify: (statementNode, fileContext) => {
         const { verifyStatement } = shim,
-              stated = false, ///
-              assignments = [],
+              stated = false,
+              assignments = null,
               localContext = LocalContext.fromFileContext(fileContext),
               statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
 

package/src/verify/assertion/contained.js

@@ -23,7 +23,7 @@ export default function verifyContainedAssertion(containedAssertionNode, assignm
 
   localContext.trace(`Verifying the '${containedAssertionString}' contained assertion...`, containedAssertionNode);
 
-  assignments = []; ///
+  assignments = null; ///
 
   stated = true;  ///
 

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!");
@@ -18,14 +19,19 @@ const verifyDefinedAssertionFunctions = [
 export default function verifyDefinedAssertion(definedAssertionNode, assignments, stated, localContext) {
   let definedAssertionVerified;
 
-  const definedAssertionString = localContext.nodeAsString(definedAssertionNode);
+  const definedAssertionString = localContext.nodeAsString(definedAssertionNode),
+        savedStated = stated; ///;
 
   localContext.trace(`Verifying the '${definedAssertionString}' defined assertion...`, definedAssertionNode);
 
-  assignments = []; ///
+  assignments = null; ///
+
+  stated = true;  ///
 
   const verified = metaLevelVerifier.verify(definedAssertionNode, assignments, stated, localContext);
 
+  stated = savedStated; ///
+
   if (verified) {
     definedAssertionVerified = verifyDefinedAssertionFunctions.some((verifyDefinedAssertionFunction) => {
       const definedAssertionVerified = verifyDefinedAssertionFunction(definedAssertionNode, assignments, stated, localContext);
@@ -58,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/assertion/type.js

@@ -112,11 +112,13 @@ function verifyStatedTypeAssertion(typeAssertionNode, assignments, stated, local
                 const variableNode = variableNodeQuery(termNode);
 
                 if (variableNode !== null) {
-                  const variable = Variable.fromVariableNodeAndType(variableNode, type),
-                        variableAssignment = VariableAssignment.fromVariable(variable),
-                        assignment = variableAssignment;  ///
+                  if (assignments !== null) {
+                    const variable = Variable.fromVariableNodeAndType(variableNode, type),
+                          variableAssignment = VariableAssignment.fromVariable(variable),
+                          assignment = variableAssignment;  ///
 
-                  assignments.push(assignment);
+                    assignments.push(assignment);
+                  }
                 }
 
                 verifiedAhead = true;

package/src/verify/conclusion.js

@@ -19,7 +19,7 @@ export default function verifyConclusion(conclusionNode, conclusions, localConte
 
   if (unqualifiedStatementNode !== null) {
     const stated = true,
-          assignments = [],
+          assignments = null,
           statementNode = statementNodeQuery(unqualifiedStatementNode),
           statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
 

package/src/verify/consequent.js

@@ -19,7 +19,7 @@ export default function verifyConsequent(consequentNode, consequents, localConte
 
   if (unqualifiedStatementNode !== null) {
     const stated = true,
-          assignments = [],
+          assignments = null,
           statementNode = statementNodeQuery(unqualifiedStatementNode),
           statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
 

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);
 
-    debugger
+    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,13 +81,14 @@ 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 = [],
+            assignments = null,
             statementNode = statementNodeQuery(declarationNode),
             statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
 
@@ -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/equality.js

@@ -41,7 +41,7 @@ function verifyDerivedEquality(equalityNode, assignments, stated, localContext)
   if (!stated) {
     const equalityString = localContext.nodeAsString(equalityNode);
 
-    localContext.trace(`Verifying the '${equalityString}' stated equality...`, equalityNode);
+    localContext.trace(`Verifying the '${equalityString}' derived equality...`, equalityNode);
 
     const terms = [],
           termNodes = termNodesQuery(equalityNode),
@@ -54,10 +54,12 @@ function verifyDerivedEquality(equalityNode, assignments, stated, localContext)
               const equalityEqual = equality.isEqual(localContext);
 
               if (equalityEqual) {
-                const equalityAssignment = EqualityAssignment.fromEquality(equality),
-                      assignment = equalityAssignment; ///
+                if (assignments !== null) {
+                  const equalityAssignment = EqualityAssignment.fromEquality(equality),
+                        assignment = equalityAssignment; ///
 
-                assignments.push(assignment);
+                  assignments.push(assignment);
+                }
 
                 verifiedAhead = true;
               }
@@ -69,7 +71,7 @@ function verifyDerivedEquality(equalityNode, assignments, stated, localContext)
     derivedEqualityVerified = termsVerified; ///
 
     if (derivedEqualityVerified) {
-      localContext.debug(`...verified the '${equalityString}' stated equality.`, equalityNode);
+      localContext.debug(`...verified the '${equalityString}' derived equality.`, equalityNode);
     }
   }
 
@@ -92,10 +94,12 @@ function verifyStatedEquality(equalityNode, assignments, stated, localContext) {
             const equality = Equality.fromTermsAndEqualityNode(terms, equalityNode);
 
             if (equality !== null) {
-              const equalityAssignment = EqualityAssignment.fromEquality(equality),
-                    assignment = equalityAssignment; ///
+              if (assignments !== null) {
+                const equalityAssignment = EqualityAssignment.fromEquality(equality),
+                      assignment = equalityAssignment; ///
 
-              assignments.push(assignment);
+                assignments.push(assignment);
+              }
 
               verifiedAhead = true;
             }

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);
 
-    debugger
+    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";
@@ -46,49 +47,41 @@ function verifyDerivedJudgement(judgementNode, assignments, stated, localContext
 
     localContext.trace(`Verifying the '${judgementString}' derived judgement...`, judgementNode);
 
-    const metavariableNode = metavariableNodeQuery(judgementNode),
-          metavariableVerified = verifyMetavariable(metavariableNode, localContext);
+    const metavariableNode = metavariableNodeQuery(judgementNode);
 
-    if (metavariableVerified) {
-      const judgement = localContext.findJudgementByMetavariableNode(metavariableNode);
+    if (metavariableNode !== null) {
+      const metaType = frameMetaType, ///
+            metavariableVerifiedGivenMetaType = verifyMetavariableGivenMetaType(metavariableNode, metaType, localContext);
 
-      if (judgement !== null) {
-        const frames = [],
-              frameNode = frameNodeQuery(judgementNode),
-              frameVerified = verifyFrame(frameNode, frames, assignments, stated, localContext);
+      if (metavariableVerifiedGivenMetaType) {
+        const judgement = localContext.findJudgementByMetavariableNode(metavariableNode);
 
-        if (frameVerified) {
-          const firstFrame = first(frames),
-                frame = firstFrame, ///
-                frameSingular = frame.isSingular();
+        if (judgement !== null) {
+          const frames = [],
+                frameNode = frameNodeQuery(judgementNode),
+                frameVerified = verifyFrame(frameNode, frames, stated, localContext);
 
-          if (frameSingular) {
-            const declaration = frame.getDeclaration(),
+          if (frameVerified) {
+            const firstFrame = first(frames),
+                  frame = firstFrame, ///
+                  declaration = frame.getDeclaration(),
                   metavariableNode = declaration.getMetavariableNode(),
-                  metaLemma = localContext.findMetaLemmaByMetavariableNode(metavariableNode),
                   metatheorem = localContext.findMetatheoremByMetavariableNode(metavariableNode),
+                  metaLemma = localContext.findMetaLemmaByMetavariableNode(metavariableNode),
                   metaLemmaMetatheorem = (metaLemma || metatheorem);  ///
 
             if (metaLemmaMetatheorem !== null) {
-              const metaLemmaMetatheoremUnifiedWithDeclaration = declaration.unifyMetaLemmaOrMetaTheorem(metaLemmaMetatheorem),
-                    metaLemmaMetatheoremUnifiedWithJudgement = judgement.unifyMetaLemmaOrMetaTheorem(metaLemmaMetatheorem);
-
-              derivedJudgementVerified = (metaLemmaMetatheoremUnifiedWithDeclaration && metaLemmaMetatheoremUnifiedWithJudgement);
-            } else {
-              const metavariableString = localContext.nodeAsString(metavariableNode);
+              const metaLemmaMetatheoremUnifiedWithJudgement = judgement.unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem),
+                    metaLemmaMetatheoremUnifiedWithDeclaration = declaration.unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem);
 
-              localContext.debug(`There are no meta-lemmas or metatheorems corresponding to the '${metavariableString}' metavariable.`, judgementNode);
+              derivedJudgementVerified = (metaLemmaMetatheoremUnifiedWithJudgement && metaLemmaMetatheoremUnifiedWithDeclaration);
             }
-          } else {
-            const frameString = localContext.nodeAsString(frameNode);
-
-            localContext.debug(`The '${frameString}' is not singular.`, judgementNode);
           }
-        }
-      } else {
-        const metavariableString = localContext.nodeAsString(metavariableNode);
+        } 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)
+        }
       }
     }
 
@@ -108,24 +101,30 @@ function verifyStatedJudgement(judgementNode, assignments, stated, localContext)
 
     localContext.trace(`Verifying the '${judgementString}' stated judgement...`, judgementNode);
 
-    const metavariableNode = metavariableNodeQuery(judgementNode),
-          metavariableVerified = verifyMetavariable(metavariableNode, localContext);
+    const metavariableNode = metavariableNodeQuery(judgementNode);
 
-    if (metavariableVerified) {
-      const frames = [],
-            frameNode = frameNodeQuery(judgementNode),
-            frameVerified = verifyFrame(frameNode, frames, stated, localContext);
+    if (metavariableNode !== null) {
+      const metaType = frameMetaType, ///
+            metavariableVerifiedGivenMetaType = verifyMetavariableGivenMetaType(metavariableNode, metaType, localContext);
 
-      if (frameVerified) {
-        const firstFrame = first(frames),
-              frame = firstFrame, ///
-              judgement = Judgement.fromJudgementNodeFrameAndMetavariableNode(judgementNode, frame, metavariableNode),
-              judgementAssignment = JudgementAssignment.fromJudgement(judgement),
-              assignment = judgementAssignment;
+      if (metavariableVerifiedGivenMetaType) {
+        const frames = [],
+              frameNode = frameNodeQuery(judgementNode),
+              frameVerified = verifyFrame(frameNode, frames, stated, localContext);
 
-        assignments.push(assignment);
+        if (frameVerified) {
+          if (assignments !== null) {
+            const firstFrame = first(frames),
+                  frame = firstFrame, ///
+                  judgement = Judgement.fromJudgementNodeFrameAndMetavariableNode(judgementNode, frame, metavariableNode),
+                  judgementAssignment = JudgementAssignment.fromJudgement(judgement),
+                  assignment = judgementAssignment;
+
+            assignments.push(assignment);
+          }
 
-        statedJudgementVerified = true;
+          statedJudgementVerified = true;
+        }
       }
     }
 
@@ -136,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/premise.js

@@ -29,12 +29,12 @@ export default function verifyPremise(premiseNode, premises, localContext) {
       const assignmentsAssigned = assignAssignments(assignments, localContext);
 
       if (assignmentsAssigned) {
-        const metaproofStep = ProofStep.fromStatementNode(statementNode),
-              premise = Premise.fromStatementNode(statementNode);
+        const premise = Premise.fromStatementNode(statementNode),
+              proofStep = ProofStep.fromStatementNode(statementNode);
 
         premises.push(premise);
 
-        localContext.addProofStep(metaproofStep);
+        localContext.addProofStep(proofStep);
 
         premiseVerified = true;
       }