occam-verify-cli 0.0.879 → 0.0.881

package/src/verify/frame.js

@@ -0,0 +1,30 @@
+"use strict";
+
+import verifyDeclaration from "../verify/declaration";
+
+import { nodesQuery } from "../utilities/query";
+
+const declarationNodesQuery = nodesQuery("/frame/declaration");
+
+export default function verifyFrame(frameNode, derived, localMetaContext) {
+  let frameVerified;
+
+  const frameString = localMetaContext.nodeAsString(frameNode);
+
+  localMetaContext.trace(`Verifying the '${frameString}' frame...`, frameNode);
+
+  const declarationNodes = declarationNodesQuery(frameNode),
+        declarationsVerified = declarationNodes.every((declarationNode) => {
+          const declarationVerified = verifyDeclaration(declarationNode, derived, localMetaContext);
+
+          return declarationVerified;
+        });
+
+  frameVerified = declarationsVerified; ///
+
+  if (frameVerified) {
+    localMetaContext.debug(`...verified the '${frameString}' frame.`, frameNode);
+  }
+
+  return frameVerified;
+}

package/src/verify/judgement.js

@@ -1,44 +1,32 @@
 "use strict";
 
-import verifyContext from "../verify/context";
-import contextMetaType from "../metaType/context";
+import verifyFrame from "../verify/frame";
+import frameMetaType from "../metaType/frame";
 
 import { nodeQuery } from "../utilities/query";
 
-const contextNodeQuery = nodeQuery("/judgement/metastatement/context!"),
+const frameNodeQuery = nodeQuery("/judgement/frame!"),
       metavariableNodeQuery = nodeQuery("/judgement/metavariable!");
 
-export default function verifyJudgement(judgementNode, derived, localMetaContext) {
-  let judgementVerified = false;
+export default function verifyJudgement(judgementNode, assignments, derived, localMetaContext) {
+  let judgementVerified;
 
   const judgementString = localMetaContext.nodeAsString(judgementNode);
 
   localMetaContext.trace(`Verifying the '${judgementString}' judgement...`, judgementNode);
 
-  const metavariableNode = metavariableNodeQuery(judgementNode),
-        metavariable = localMetaContext.findMetavariableByMetavariableNode(metavariableNode, localMetaContext);
+  const verifyJudgementFunctions = [
+    verifyDerivedJudgement,
+    verifyStatedJudgement
+  ];
 
-  if (metavariable !== null) {
-    const metaType = metavariable.getMetaType();
+  judgementVerified = verifyJudgementFunctions.some((verifyJudgementFunction) => {
+    const judgementVerified = verifyJudgementFunction(judgementNode, assignments, derived, localMetaContext);
 
-    if (metaType === contextMetaType) {
-      const contextNode = contextNodeQuery(judgementNode);
-
-      if (contextNode !== null) {
-        const contextVerified = verifyContext(contextNode, derived, localMetaContext);
-
-        judgementVerified = contextVerified;  ///
-      } else {
-        localMetaContext.debug(`The right hand side of the '${judgementString}' judgement must be a context.`, judgementNode);
-      }
-    } else {
-      const contextMetaTypeName = contextMetaType.getName(),
-            metavariableString = localMetaContext.nodeAsString(metavariableNode),
-            metaTypeString = metaType.asString();
-
-      localMetaContext.debug(`The '${metavariableString}' metavariable's meta-type is '${metaTypeString}' when it should be '${contextMetaTypeName}'.`, judgementNode);
+    if (judgementVerified) {
+      return true;
     }
-  }
+  });
 
   if (judgementVerified) {
     localMetaContext.debug(`...verified the '${judgementString}' judgement.`, judgementNode);
@@ -46,3 +34,85 @@ export default function verifyJudgement(judgementNode, derived, localMetaContext
 
   return judgementVerified;
 }
+
+function verifyDerivedJudgement(judgementNode, assignments, derived, localMetaContext) {
+  let derivedJudgementVerified = false;
+
+  if (derived) {
+    // const judgementString = localMetaContext.nodeAsString(judgementNode);
+    //
+    // localMetaContext.trace(`Verifying the '${judgementString}' derived judgement...`, judgementNode);
+    //
+    // const metavariableNode = metavariableNodeQuery(judgementNode),
+    //       metavariable = localMetaContext.findMetavariableByMetavariableNode(metavariableNode, localMetaContext);
+    //
+    // if (metavariable !== null) {
+    //   const metaType = metavariable.getMetaType();
+    //
+    //   if (metaType === frameMetaType) {
+    //     const frameNode = frameNodeQuery(judgementNode);
+    //
+    //     if (frameNode !== null) {
+    //       const frameVerified = verifyFrame(frameNode, derived, localMetaContext);
+    //
+    //       derivedJudgementVerified = frameVerified;  ///
+    //     } else {
+    //       localMetaContext.debug(`The right hand side of the '${judgementString}' judgement must be a frame.`, judgementNode);
+    //     }
+    //   } else {
+    //     const frameMetaTypeName = frameMetaType.getName(),
+    //       metavariableString = localMetaContext.nodeAsString(metavariableNode),
+    //       metaTypeString = metaType.asString();
+    //
+    //     localMetaContext.debug(`The '${metavariableString}' metavariable's meta-type is '${metaTypeString}' when it should be '${frameMetaTypeName}'.`, judgementNode);
+    //   }
+    // }
+    //
+    // if (derivedJudgementVerified) {
+    //   localMetaContext.debug(`...verified the '${judgementString}' derived judgement.`, judgementNode);
+    // }
+  }
+
+  return derivedJudgementVerified;
+}
+
+function verifyStatedJudgement(judgementNode, assignments, derived, localMetaContext) {
+  let statedJudgementVerified = false;
+
+  if (!derived) {
+    const judgementString = localMetaContext.nodeAsString(judgementNode);
+
+    localMetaContext.trace(`Verifying the '${judgementString}' stated judgement...`, judgementNode);
+
+    const metavariableNode = metavariableNodeQuery(judgementNode),
+          metavariable = localMetaContext.findMetavariableByMetavariableNode(metavariableNode, localMetaContext);
+
+    if (metavariable !== null) {
+      const metaType = metavariable.getMetaType();
+
+      if (metaType === frameMetaType) {
+        const frameNode = frameNodeQuery(judgementNode);
+
+        if (frameNode !== null) {
+          const frameVerified = verifyFrame(frameNode, derived, localMetaContext);
+
+          statedJudgementVerified = frameVerified;  ///
+        } else {
+          localMetaContext.debug(`The right hand side of the '${judgementString}' judgement must be a frame.`, judgementNode);
+        }
+      } else {
+        const frameMetaTypeName = frameMetaType.getName(),
+              metavariableString = localMetaContext.nodeAsString(metavariableNode),
+              metaTypeString = metaType.asString();
+
+        localMetaContext.debug(`The '${metavariableString}' metavariable's meta-type is '${metaTypeString}' when it should be '${frameMetaTypeName}'.`, judgementNode);
+      }
+    }
+
+    if (statedJudgementVerified) {
+      localMetaContext.debug(`...verified the '${judgementString}' stated judgement.`, judgementNode);
+    }
+  }
+
+  return statedJudgementVerified;
+}

package/src/verify/metaConsequent.js

@@ -8,7 +8,7 @@ import { nodeQuery } from "../utilities/query";
 const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/metaConsequent/unqualifiedMetastatement!");
 
-export default function verifyMetaConsequent(metaConsequentNode, metaConsequents, localMetaContext) {
+export default function verifyMetaConsequent(metaConsequentNode, metaConsequents, substitutions, localMetaContext) {
   let metaConsequentVerified = false;
 
   const metaConsequentString = localMetaContext.nodeAsString(metaConsequentNode);

package/src/verify/metaDerivation.js

@@ -15,13 +15,13 @@ const childNodesQuery = nodesQuery("/metaDerivation|metaSubDerivation/*"),
       metaSuppositionNodesQuery = nodesQuery("/metaSubproof/metaSupposition"),
       metaSubDerivationNodeQuery = nodeQuery("/metaSubproof/metaSubDerivation");
 
-export default function verifyMetaDerivation(metaDerivationNode, localMetaContext) {
+export default function verifyMetaDerivation(metaDerivationNode, substitutions, localMetaContext) {
   let metaDerivationVerified;
 
   const childNodes = childNodesQuery(metaDerivationNode);
 
   metaDerivationVerified = childNodes.every((childNode) => {
-    const childVerified = verifyChild(childNode, localMetaContext);
+    const childVerified = verifyChild(childNode, substitutions, localMetaContext);
 
     if (childVerified) {
       return true;
@@ -31,13 +31,13 @@ export default function verifyMetaDerivation(metaDerivationNode, localMetaContex
   return metaDerivationVerified;
 }
 
-function verifyMetaSubDerivation(metaSubDerivationNode, localMetaContext) {
+function verifyMetaSubDerivation(metaSubDerivationNode, substitutions, localMetaContext) {
   let metaSubDerivationVerified;
 
   const childNodes = childNodesQuery(metaSubDerivationNode);
 
   metaSubDerivationVerified = childNodes.every((childNode) => {
-    const childVerified = verifyChild(childNode, localMetaContext);
+    const childVerified = verifyChild(childNode, substitutions, localMetaContext);
 
     if (childVerified) {
       return true;
@@ -47,18 +47,18 @@ function verifyMetaSubDerivation(metaSubDerivationNode, localMetaContext) {
   return metaSubDerivationVerified;
 }
 
-function verifyMetaSubproof(metaSubproofNode, localMetaContext) {
+function verifyMetaSubproof(metaSubproofNode, substitutions, localMetaContext) {
   let metaSubproofVerified = false;
 
   localMetaContext = LocalMetaContext.fromLocalMetaContext(localMetaContext); ///
 
   const metaSuppositions = [],
         metaSuppositionNodes = metaSuppositionNodesQuery(metaSubproofNode),
-        metaSuppositionsVerified = verifyMetaSuppositions(metaSuppositionNodes, metaSuppositions, localMetaContext);
+        metaSuppositionsVerified = verifyMetaSuppositions(metaSuppositionNodes, metaSuppositions, substitutions, localMetaContext);
 
   if (metaSuppositionsVerified) {
     const metaSubDerivationNode = metaSubDerivationNodeQuery(metaSubproofNode),
-          metaSubDerivationVerified = verifyMetaSubDerivation(metaSubDerivationNode, localMetaContext);
+          metaSubDerivationVerified = verifyMetaSubDerivation(metaSubDerivationNode, substitutions, localMetaContext);
 
     if (metaSubDerivationVerified) {
       metaSubproofVerified = true;
@@ -68,7 +68,7 @@ function verifyMetaSubproof(metaSubproofNode, localMetaContext) {
   return metaSubproofVerified;
 }
 
-function verifyChild(childNode, localMetaContext) {
+function verifyChild(childNode, substitutions, localMetaContext) {
   let childVerified = false;
 
   const childNodeRuleName = childNode.getRuleName();
@@ -79,7 +79,7 @@ function verifyChild(childNode, localMetaContext) {
 
       const metaSubproofNode = childNode;  ///
 
-      metaSubproofVerified = verifyMetaSubproof(metaSubproofNode, localMetaContext);
+      metaSubproofVerified = verifyMetaSubproof(metaSubproofNode, substitutions, localMetaContext);
 
       if (metaSubproofVerified) {
         const metaproofStep = MetaproofStep.fromMetaSubproofNode(metaSubproofNode);
@@ -97,10 +97,9 @@ function verifyChild(childNode, localMetaContext) {
 
       const derived = true,
             assignments = [],
-            metavariableReferences = true,
             qualifiedMetastatementNode = childNode;  ///
 
-      qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, metavariableReferences, assignments, derived, localMetaContext);
+      qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, substitutions, assignments, derived, localMetaContext);
 
       if (qualifiedMetastatementVerified) {
         const assignmentAssigned = assignAssignment(assignments, localMetaContext);

package/src/verify/metaLemma.js

@@ -31,23 +31,24 @@ export default function verifyMetaLemma(metaLemmaNode, fileContext) {
         labelsVerified = verifyLabels(labelsNode, labels, fileContext);
 
   if (labelsVerified) {
-    const metaSuppositions = [],
+    const substitutions = [],
+          metaSuppositions = [],
           metaSuppositionNodes = metaSuppositionsNodeQuery(metaLemmaNode),
-          metaSuppositionsVerified = verifyMetaSuppositions(metaSuppositionNodes, metaSuppositions, localMetaContext);
+          metaSuppositionsVerified = verifyMetaSuppositions(metaSuppositionNodes, metaSuppositions, substitutions, localMetaContext);
 
     if (metaSuppositionsVerified) {
       const metaConsequents = [],
             metaConsequentNode = metaConsequentNodeQuery(metaLemmaNode),
-            metaConsequentVerified = verifyMetaConsequent(metaConsequentNode, metaConsequents, localMetaContext);
+            metaConsequentVerified = verifyMetaConsequent(metaConsequentNode, metaConsequents, substitutions, localMetaContext);
 
       if (metaConsequentVerified) {
         const metaproofNode = metaproofNodeQuery(metaLemmaNode),
               firstMetaConsequent = first(metaConsequents),
               metaConsequent = firstMetaConsequent, ///
-              metaproofVerified = verifyMetaproof(metaproofNode, metaConsequent, localMetaContext);
+              metaproofVerified = verifyMetaproof(metaproofNode, metaConsequent, substitutions, localMetaContext);
 
         if (metaproofVerified) {
-          const metaLemma = MetaLemma.fromLabelsMetaSuppositionsMetaConsequentAndFileContext(labels, metaSuppositions, metaConsequent, fileContext);
+          const metaLemma = MetaLemma.fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(labels, metaSuppositions, metaConsequent, substitutions, fileContext);
 
           fileContext.addMetaLemma(metaLemma);
 

package/src/verify/metaSuppositions.js

@@ -2,7 +2,7 @@
 
 import verifyMetaSupposition from "../verify/metaSupposition";
 
-export default function verifyMetaSuppositions(metaSuppositionNodes, metaSuppositions, localMetaContext) {
+export default function verifyMetaSuppositions(metaSuppositionNodes, metaSuppositions, substitutions, localMetaContext) {
   let metaSuppositionsVerified;
 
   metaSuppositionsVerified = metaSuppositionNodes.every((metaSuppositionNode) => {

package/src/verify/metaproof.js

@@ -6,11 +6,11 @@ import { nodeQuery } from "../utilities/query";
 
 const metaDerivationNodeQuery = nodeQuery("/metaproof/metaDerivation!");
 
-export default function verifyMetaproof(metaproofNode, conclusion, localMetaproof) {
+export default function verifyMetaproof(metaproofNode, conclusion, substitutions, localMetaproof) {
   let metaproofVerified = false;
 
   const metaDerivationNode = metaDerivationNodeQuery(metaproofNode),
-        metaDerivationVerified = verifyMetaDerivation(metaDerivationNode, localMetaproof);
+        metaDerivationVerified = verifyMetaDerivation(metaDerivationNode, substitutions, localMetaproof);
 
   if (metaDerivationVerified) {
     const lastMetaproofStep = localMetaproof.getLastMetaproofStep();

package/src/verify/metastatement/qualified.js

@@ -1,13 +1,14 @@
 "use strict";
 
 import verifyMetastatement from "../metastatement";
+import verifyMetavariableAgainstMetastatement from "../../verify/metavariableAgainstMetastatement";
 
 import { nodeQuery } from "../../utilities/query";
 
 const metastatementNodeQuery = nodeQuery("/qualifiedMetastatement/metastatement!"),
       referenceMetavariableNodeQuery = nodeQuery("/qualifiedMetastatement/reference!/metavariable!");
 
-export default function verifyQualifiedMetastatement(qualifiedMetastatementNode, metavariableReferences, assignments, derived, localMetaContext) {
+export default function verifyQualifiedMetastatement(qualifiedMetastatementNode, substitutions, assignments, derived, localMetaContext) {
   let qualifiedMetastatementVerified = false;
 
   const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode);
@@ -27,18 +28,26 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
 
       qualifiedMetastatementVerified = ruleMatchesMetastatement;  ///
     } else {
-      if (metavariableReferences) {
+      if (substitutions !== null) {
         const metavariableNode = referenceMetavariableNode, ///
               metavariablePresent = localMetaContext.isMetavariablePresentByMetavariableNode(metavariableNode, localMetaContext);
 
         if (metavariablePresent) {
           const metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localMetaContext, () => {
-                  const verifiedAhead = true;
+            const verifiedAhead = true;
 
-                  return verifiedAhead;
-                });
+            return verifiedAhead;
+          });
 
-          qualifiedMetastatementVerified = metastatementVerified; ///
+          if (metastatementVerified) {
+            const metavariableVerifiedAgainstMetastatement = verifyMetavariableAgainstMetastatement(metavariableNode, metastatementNode, substitutions, () => {
+              const verifiedAhead = true;
+
+              return verifiedAhead;
+            });
+
+            qualifiedMetastatementVerified = metavariableVerifiedAgainstMetastatement; ///
+          }
         }
       }
     }

package/src/verify/metastatement.js

@@ -1,13 +1,11 @@
 "use strict";
 
 import verifyJudgement from "../verify/judgement";
-import verifyMetaEquality from "../verify/metaEquality";
 import metastatementNodeVerifier from "../verifier/node/metastatement";
 
 import { nodeQuery } from "../utilities/query";
 
-const judgementNodeQuery = nodeQuery("/metastatement/judgement!"),
-      metaEqualityNodeQuery = nodeQuery("/metastatement/metaEquality!");
+const judgementNodeQuery = nodeQuery("/metastatement/judgement!");
 
 function verifyMetastatement(metastatementNode, assignments, derived, localMetaContext) {
   let metastatementVerified;
@@ -17,7 +15,6 @@ function verifyMetastatement(metastatementNode, assignments, derived, localMetaC
   localMetaContext.trace(`Verifying the '${metastatementString}' metastatement...`, metastatementNode);
 
   const verifyMetaStatementFunctions = [
-    verifyMetastatementAsMetaEquality,
     verifyMetastatementAsJudgement,
     verifyMetastatementAsIs
   ];
@@ -43,28 +40,6 @@ Object.assign(metastatementNodeVerifier, {
 
 export default verifyMetastatement;
 
-function verifyMetastatementAsMetaEquality(metastatementNode, assignments, derived, localMetaContext) {
-  let metastatementVerifiedAsMetaEquality = false;
-
-  const metaEqualityNode = metaEqualityNodeQuery(metastatementNode);
-
-  if (metaEqualityNode !== null) {
-    const metastatementString = localMetaContext.nodeAsString(metastatementNode);
-
-    localMetaContext.trace(`Verifying the '${metastatementString}' metastatement as a meta-equality...`, metastatementNode);
-
-    const metaEqualityVerified = verifyMetaEquality(metaEqualityNode, assignments, derived, localMetaContext);
-
-    metastatementVerifiedAsMetaEquality = metaEqualityVerified;  ///
-
-    if (metastatementVerifiedAsMetaEquality) {
-      localMetaContext.debug(`...verified the '${metastatementString}' metastatement as a meta-equality.`, metastatementNode);
-    }
-  }
-
-  return metastatementVerifiedAsMetaEquality;
-}
-
 function verifyMetastatementAsJudgement(metastatementNode, assignments, derived, localMetaContext) {
   let metastatementVerifiedAsJudgement = false;
 
@@ -75,7 +50,7 @@ function verifyMetastatementAsJudgement(metastatementNode, assignments, derived,
 
     localMetaContext.trace(`Verifying the '${metastatementString}' metastatement as a judgement...`, metastatementNode);
 
-    const judgementVerified = verifyJudgement(judgementNode, derived, localMetaContext);
+    const judgementVerified = verifyJudgement(judgementNode, assignments, derived, localMetaContext);
 
     metastatementVerifiedAsJudgement = judgementVerified;  ///
 
@@ -90,10 +65,9 @@ function verifyMetastatementAsJudgement(metastatementNode, assignments, derived,
 function verifyMetastatementAsIs(metastatementNode, assignments, derived, localMetaContext) {
   let metastatementVerifiedAsIs = false;
 
-  const judgementNode = judgementNodeQuery(metastatementNode),
-        metaEqualityNode = metaEqualityNodeQuery(metastatementNode);
+  const judgementNode = judgementNodeQuery(metastatementNode);
 
-  if ((judgementNode === null) && (metaEqualityNode === null)) {
+  if (judgementNode === null) {
     const metastatementString = localMetaContext.nodeAsString(metastatementNode);
 
     localMetaContext.trace(`Verifying the '${metastatementString}' metastatement as is...`, metastatementNode);

package/src/verify/metatheorem.js

@@ -28,23 +28,24 @@ export default function verifyMetatheorem(metatheoremNode, fileContext) {
         labelsVerified = verifyLabels(labelsNode, labels, fileContext);
 
   if (labelsVerified) {
-    const metaSuppositions = [],
+    const substitutions = [],
+          metaSuppositions = [],
           metaSuppositionNodes = metaSuppositionsNodeQuery(metatheoremNode),
-          metaSuppositionsVerified = verifyMetaSuppositions(metaSuppositionNodes, metaSuppositions, localMetaContext);
+          metaSuppositionsVerified = verifyMetaSuppositions(metaSuppositionNodes, metaSuppositions, substitutions, localMetaContext);
 
     if (metaSuppositionsVerified) {
       const metaConsequents = [],
             metaConsequentNode = metaConsequentNodeQuery(metatheoremNode),
-            metaConsequentVerified = verifyMetaConsequent(metaConsequentNode, metaConsequents, localMetaContext);
+            metaConsequentVerified = verifyMetaConsequent(metaConsequentNode, metaConsequents, substitutions, localMetaContext);
 
       if (metaConsequentVerified) {
         const metaproofNode = metaproofNodeQuery(metatheoremNode),
               firstMetaConsequent = first(metaConsequents),
               metaConsequent = firstMetaConsequent, ///
-              metaproofVerified = verifyMetaproof(metaproofNode, metaConsequent, localMetaContext);
+              metaproofVerified = verifyMetaproof(metaproofNode, metaConsequent, substitutions, localMetaContext);
 
         if (metaproofVerified) {
-          const metatheorem = Metatheorem.fromLabelsMetaSuppositionsMetaConsequentAndFileContext(labels, metaSuppositions, metaConsequent, fileContext);
+          const metatheorem = Metatheorem.fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(labels, metaSuppositions, metaConsequent, substitutions, fileContext);
 
           fileContext.addMetatheorem(metatheorem);
 

package/src/verify/metavariable.js

@@ -18,8 +18,7 @@ export default function verifyMetavariable(metavariableNode, metaTypeNode, fileC
 
   fileContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
 
-  const name = nameFromMetavariableNode(metavariableNode),
-        metavariablePresent = fileContext.isMetavariablePresentByName(name);
+  const metavariablePresent = fileContext.isMetavariablePresentByMetavariableNode(metavariableNode);
 
   if (metavariablePresent) {
     fileContext.debug(`The metavariable '${metavariableString}' is already present.`, metavariableNode);
@@ -49,6 +48,7 @@ export default function verifyMetavariable(metavariableNode, metaTypeNode, fileC
       }
 
       const node = metavariableNode,  ///
+            name = nameFromMetavariableNode(metavariableNode),
             metavariable = Metavariable.fromNodeNameTermTypeAndMetaType(node, name, termType, metaType),
             metavariableAssignment = MetavariableAssignment.fromMetavariable(metavariable),
             metavariableAssigned = metavariableAssignment.assign(fileContext);

package/src/verify/metavariableAgainstMetastatement.js

@@ -2,7 +2,7 @@
 
 import MetastatementForMetavariableSubstitution from "../substitution/metastatementForMetavariable";
 
-export default function verifyMetavariableAgainstMetastatement(metavariableNode, metastatementNode, substitutions, localContextA, localMetaContextB, verifyAhead) {
+export default function verifyMetavariableAgainstMetastatement(metavariableNode, metastatementNode, substitutions, verifyAhead) {
   let metavariableVerifiedAgainstMetastatement = false;
 
   const substitution = substitutions.find((substitution) => {

package/src/verify/ruleDerivation.js

@@ -94,10 +94,10 @@ function verifyChild(childNode, localMetaContext) {
 
       const derived = true,
             assignments = [],
-            metavariableReferences = true,
+            substitutions = null,
             qualifiedMetastatementNode = childNode;  ///
 
-      qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, metavariableReferences, assignments, derived, localMetaContext);
+      qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, substitutions, assignments, derived, localMetaContext);
 
       if (qualifiedMetastatementVerified) {
         const assignmentAssigned = assignAssignment(assignments, localMetaContext);

package/lib/assignment/metaEquality.js

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return MetaEqualityAssignment;
-    }
-});
-function _class_call_check(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-    }
-}
-function _defineProperties(target, props) {
-    for(var i = 0; i < props.length; i++){
-        var descriptor = props[i];
-        descriptor.enumerable = descriptor.enumerable || false;
-        descriptor.configurable = true;
-        if ("value" in descriptor) descriptor.writable = true;
-        Object.defineProperty(target, descriptor.key, descriptor);
-    }
-}
-function _create_class(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties(Constructor, staticProps);
-    return Constructor;
-}
-var MetaEqualityAssignment = /*#__PURE__*/ function() {
-    function MetaEqualityAssignment(metaEquality) {
-        _class_call_check(this, MetaEqualityAssignment);
-        this.metaEquality = metaEquality;
-    }
-    _create_class(MetaEqualityAssignment, [
-        {
-            key: "getMetaEquality",
-            value: function getMetaEquality() {
-                return this.metaEquality;
-            }
-        },
-        {
-            key: "assign",
-            value: function assign(localMetaContext) {
-                var metaEqualityAdded = localMetaContext.addMetaEquality(this.metaEquality), metaEqualityNode = this.metaEquality.getNode(), metaEqualityString = localMetaContext.nodeAsString(metaEqualityNode), metaEqualityAssigned = metaEqualityAdded; ///
-                metaEqualityAssigned ? localMetaContext.trace("Assigned the '".concat(metaEqualityString, "' meta-equality."), metaEqualityNode) : localMetaContext.debug("Unable to assign the '".concat(metaEqualityString, "' meta-equality."), metaEqualityNode);
-                return metaEqualityAssigned;
-            }
-        }
-    ], [
-        {
-            key: "fromMetaEquality",
-            value: function fromMetaEquality(metaEquality) {
-                var metaEqualityAssignment = new MetaEqualityAssignment(metaEquality);
-                return metaEqualityAssignment;
-            }
-        }
-    ]);
-    return MetaEqualityAssignment;
-}();
-
-//# sourceMappingURL=data:application/json;base64,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