occam-verify-cli 0.0.921 → 0.0.923

package/src/metaLemmaMetatheorem.js

@@ -1,17 +1,17 @@
 "use strict";
 
 import Label from "./label";
-import MetaConsequent from "./metaConsequent";
-import MetaSupposition from "./metaSupposition";
-import MetastatementForMetavariableSubstitution from "./substitution/metastatementForMetavariable";
+import Consequent from "./consequent";
+import Supposition from "./supposition";
+import StatementForMetavariableSubstitution from "./substitution/statementForMetavariable";
 
 import { reverse, correlate } from "./utilities/array";
 
 export default class MetaLemmaMetatheorem {
-  constructor(labels, metaSuppositions, metaConsequent, substitutions, fileContext) {
+  constructor(labels, suppositions, consequent, substitutions, fileContext) {
     this.labels = labels;
-    this.metaSuppositions = metaSuppositions;
-    this.metaConsequent = metaConsequent;
+    this.suppositions = suppositions;
+    this.consequent = consequent;
     this.substitutions = substitutions;
     this.fileContext = fileContext;
   }
@@ -20,12 +20,12 @@ export default class MetaLemmaMetatheorem {
     return this.labels;
   }
 
-  getMetaSuppositions() {
-    return this.metaSuppositions;
+  getSuppositions() {
+    return this.suppositions;
   }
 
-  getMetaConsequent() {
-    return this.metaConsequent;
+  getConsequent() {
+    return this.consequent;
   }
 
   getSubstitutions() {
@@ -36,20 +36,20 @@ export default class MetaLemmaMetatheorem {
     return this.fileContext;
   }
 
-  matchMetastatement(metastatementNode, localContext) {
-    let metastatementNatches = false;
+  matchStatement(statementNode, localContext) {
+    let statementNatches = false;
 
     const metaproofSteps = localContext.getProofSteps(),
           substitutions = [],
-          metaSuppositionsMatch = matchMetaSuppositions(this.metaSuppositions, metaproofSteps, substitutions, this.fileContext, localContext);
+          suppositionsMatch = matchSuppositions(this.suppositions, metaproofSteps, substitutions, this.fileContext, localContext);
 
-    if (metaSuppositionsMatch) {
-      const metaConsequentMatches = matchMetaConsequent(this.metaConsequent, metastatementNode, substitutions, this.fileContext, localContext);
+    if (suppositionsMatch) {
+      const consequentMatches = matchConsequent(this.consequent, statementNode, substitutions, this.fileContext, localContext);
 
-      metastatementNatches = metaConsequentMatches;  ///
+      statementNatches = consequentMatches;  ///
     }
 
-    return metastatementNatches;
+    return statementNatches;
   }
 
   matchMetavariableNode(metavariableNode) {
@@ -70,12 +70,12 @@ export default class MetaLemmaMetatheorem {
 
             return labelJSON;
           }),
-          metaSuppositionsJSON = this.metaSuppositions.map((metaSupposition) => {
-            const metaSuppositionJSON = metaSupposition.toJSON(tokens);
+          suppositionsJSON = this.suppositions.map((supposition) => {
+            const suppositionJSON = supposition.toJSON(tokens);
 
-            return metaSuppositionJSON;
+            return suppositionJSON;
           }),
-          metaConsequentJSON = this.metaConsequent.toJSON(tokens),
+          consequentJSON = this.consequent.toJSON(tokens),
           substitutionsJSON = this.substitutions.map((substitution) => {
             const substitutionJSON = substitution.toJSON();
 
@@ -83,14 +83,14 @@ export default class MetaLemmaMetatheorem {
           }),
           localContextJSON = this.fileContext.toJSON(tokens),
           labels = labelsJSON,  ///
-          metaSuppositions = metaSuppositionsJSON,  ///
-          metaConsequent = metaConsequentJSON,  ///
+          suppositions = suppositionsJSON,  ///
+          consequent = consequentJSON,  ///
           substitutions = substitutionsJSON,  ///
           fileContext = localContextJSON,  ///
           json = {
             labels,
-            metaSuppositions,
-            metaConsequent,
+            suppositions,
+            consequent,
             substitutions,
             fileContext
           };
@@ -110,79 +110,79 @@ export default class MetaLemmaMetatheorem {
       return label;
     });
 
-    let { metaSuppositions, metaConsequent, substitutions } = json;
+    let { suppositions, consequent, substitutions } = json;
 
-    const metaSuppositionsJSON = metaSuppositions;  ///
+    const suppositionsJSON = suppositions;  ///
 
-    metaSuppositions = metaSuppositionsJSON.map((metaSuppositionJSON) => {
-      const json = metaSuppositionJSON, ///
-            metaSupposition = MetaSupposition.fromJSONAndFileContext(json, fileContext);
+    suppositions = suppositionsJSON.map((suppositionJSON) => {
+      const json = suppositionJSON, ///
+            supposition = Supposition.fromJSONAndFileContext(json, fileContext);
 
-      return metaSupposition;
+      return supposition;
     });
 
-    const metaConsequentJSON = metaConsequent;  ///
+    const consequentJSON = consequent;  ///
 
-    json = metaConsequentJSON;  ///
+    json = consequentJSON;  ///
 
-    metaConsequent = MetaConsequent.fromJSONAndFileContext(json, fileContext);
+    consequent = Consequent.fromJSONAndFileContext(json, fileContext);
 
     const substitutionsJSON = substitutions;  ///
 
     substitutions = substitutionsJSON.map((substitutionJSON) => {
       const json = substitutionJSON,  ///
-            metastatementForMetavariableSubstitution = MetastatementForMetavariableSubstitution.fromJSONAndFileContext(json, fileContext),
-            substitution = metastatementForMetavariableSubstitution;  ///
+            statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromJSONAndFileContext(json, fileContext),
+            substitution = statementForMetavariableSubstitution;  ///
 
       return substitution;
     });
 
-    return new Class(labels, metaSuppositions, metaConsequent, substitutions, fileContext);  ///
+    return new Class(labels, suppositions, consequent, substitutions, fileContext);  ///
   }
 
-  static fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(Class, labels, metaSuppositions, metaConsequent, substitutions, fileContext) { return new Class(labels, metaSuppositions, metaConsequent, substitutions, fileContext); }
+  static fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(Class, labels, suppositions, consequent, substitutions, fileContext) { return new Class(labels, suppositions, consequent, substitutions, fileContext); }
 }
 
-function matchMetaSuppositions(metaSuppositions, metaproofSteps, substitutions, fileContext, localContext) {
-  metaSuppositions = reverse(metaSuppositions); ///
+function matchSuppositions(suppositions, metaproofSteps, substitutions, fileContext, localContext) {
+  suppositions = reverse(suppositions); ///
 
   metaproofSteps = reverse(metaproofSteps); ///
 
-  const metaSuppositionsMatch = correlate(metaSuppositions, metaproofSteps, (metaSupposition, metaproofStep) => {
-    const metaSuppositionMatches = matchMetaSupposition(metaSupposition, metaproofStep, substitutions, fileContext, localContext);
+  const suppositionsMatch = correlate(suppositions, metaproofSteps, (supposition, metaproofStep) => {
+    const suppositionMatches = matchSupposition(supposition, metaproofStep, substitutions, fileContext, localContext);
 
-    if (metaSuppositionMatches) {
+    if (suppositionMatches) {
       return true;
     }
   });
 
-  return metaSuppositionsMatch;
+  return suppositionsMatch;
 }
 
-function matchMetaSupposition(metaSupposition, metaproofStep, substitutions, fileContext, localContext) {
-  let matchesMetaSupposition = false;
+function matchSupposition(supposition, metaproofStep, substitutions, fileContext, localContext) {
+  let matchesSupposition = false;
 
-  const metaSubproofNode = metaproofStep.getMetaSubproofNode(),
-        metastatementNode = metaproofStep.getMetastatementNode();
+  const metaSubproofNode = metaproofStep.getSubproofNode(),
+        statementNode = metaproofStep.getStatementNode();
 
   if (metaSubproofNode !== null) {
-    const metaSuppositionMatchesMetaSubproofNode = metaSupposition.matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localContext);
+    const suppositionMatchesSubproofNode = supposition.matchSubproofNode(metaSubproofNode, substitutions, fileContext, localContext);
 
-    matchesMetaSupposition - metaSuppositionMatchesMetaSubproofNode; ///
+    matchesSupposition - suppositionMatchesSubproofNode; ///
   }
 
-  if (metastatementNode !== null) {
-    const metaSuppositionMatchesMetastatementNode = metaSupposition.matchMetastatementNode(metastatementNode, substitutions, fileContext, localContext);
+  if (statementNode !== null) {
+    const suppositionMatchesStatementNode = supposition.matchStatementNode(statementNode, substitutions, fileContext, localContext);
 
-    matchesMetaSupposition - metaSuppositionMatchesMetastatementNode; ///
+    matchesSupposition - suppositionMatchesStatementNode; ///
   }
 
-  return matchesMetaSupposition;
+  return matchesSupposition;
 }
 
-function matchMetaConsequent(metaConsequent, metastatementNode, substitutions, fileContext, localContext) {
-  const metaConsequentMatchesMetastatementNode = metaConsequent.matchMetastatementNode(metastatementNode, substitutions, fileContext, localContext),
-        metaConsequentMatches = metaConsequentMatchesMetastatementNode; ///
+function matchConsequent(consequent, statementNode, substitutions, fileContext, localContext) {
+  const consequentMatchesStatementNode = consequent.matchStatementNode(statementNode, substitutions, fileContext, localContext),
+        consequentMatches = consequentMatchesStatementNode; ///
 
-  return metaConsequentMatches;
+  return consequentMatches;
 }

package/src/mixins/context.js

@@ -24,12 +24,6 @@ function getCombinators() { return this.context.getCombinators(); }
 
 function getConstructors() { return this.context.getConstructors(); }
 
-function findTypeByTypeName(typeName) { return this.context.findTypeByTypeName(typeName); }
-
-function findTypeByTypeNode(typeNode) { return this.context.findTypeByTypeNode(typeNode); }
-
-function findMetavariableByName(name) { return this.context.findMetavariableByName(name); }
-
 function isTypePresentByTypeName(typeName) { return this.context.isTypePresentByTypeName(typeName); }
 
 function isTypePresentByTypeNode(typeNode) { return this.context.isTypePresentByTypeNode(typeNode); }
@@ -38,8 +32,16 @@ function isMetavariablePresentByName(name) { return this.context.isMetavariableP
 
 function isLabelPresentByMetavariableNode(metavariableNode) { return this.context.isLabelPresentByMetavariableNode(metavariableNode); }
 
+function findTypeByTypeName(typeName) { return this.context.findTypeByTypeName(typeName); }
+
+function findTypeByTypeNode(typeNode) { return this.context.findTypeByTypeNode(typeNode); }
+
+function findMetavariableByName(name) { return this.context.findMetavariableByName(name); }
+
 function findLabelByMetavariableNode(metavariableNode) { return this.context.findLabelByMetavariableNode(metavariableNode); }
 
+function findMetaTypeByMetaTypeNode(metaTypeNode) { return this.context.findMetaTypeByMetaTypeNode(metaTypeNode); }
+
 function findRuleByMetavariableNode(metavariableNode) { return this.context.findRuleByMetavariableNode(metavariableNode); }
 
 function findAxiomByMetavariableNode(metavariableNode) { return this.context.findAxiomByMetavariableNode(metavariableNode); }
@@ -71,14 +73,15 @@ const contextMixins = {
   getConjectures,
   getCombinators,
   getConstructors,
-  findTypeByTypeName,
-  findTypeByTypeNode,
-  findMetavariableByName,
   isTypePresentByTypeName,
   isTypePresentByTypeNode,
   isMetavariablePresentByName,
   isLabelPresentByMetavariableNode,
+  findTypeByTypeName,
+  findTypeByTypeNode,
+  findMetavariableByName,
   findLabelByMetavariableNode,
+  findMetaTypeByMetaTypeNode,
   findRuleByMetavariableNode,
   findAxiomByMetavariableNode,
   findLemmaByMetavariableNode,

package/src/mixins/nodesVerifier/metaLevel.js

@@ -1,8 +1,8 @@
 "use strict";
 
-import MetastatementForMetavariableSubstitution from "../../substitution/metastatementForMetavariable";
+import StatementForMetavariableSubstitution from "../../substitution/statementForMetavariable";
 
-function verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions, localContextA, localMetaContextB, verifyAhead) {
+function verifyMetavariableNode(metavariableNodeA, statementNodeB, substitutions, localContextA, localMetaContextB, verifyAhead) {
   let metavariableNodeVerified;
 
   const substitution = substitutions.find((substitution) => {
@@ -14,15 +14,15 @@ function verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitut
   }) || null;
 
   if (substitution !== null) {
-    const metastatementNode = metastatementNodeB, ///
-          substitutionMetastatementNode = substitution.matchMetastatementNode(metastatementNode);
+    const statementNode = statementNodeB, ///
+          substitutionStatementNode = substitution.matchStatementNode(statementNode);
 
-    metavariableNodeVerified = substitutionMetastatementNode;  ///
+    metavariableNodeVerified = substitutionStatementNode;  ///
   } else {
     const metavariableNode = metavariableNodeA, ///
-          metastatementNode = metastatementNodeB, ///
-          metastatementForMetavariableSubstitution = MetastatementForMetavariableSubstitution.fromMetavariableNodeAndMetastatementNode(metavariableNode, metastatementNode),
-          substitution = metastatementForMetavariableSubstitution;  ///
+          statementNode = statementNodeB, ///
+          statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromMetavariableNodeAndStatementNode(metavariableNode, statementNode),
+          substitution = statementForMetavariableSubstitution;  ///
 
     substitutions.push(substitution);
 

package/src/premise.js

@@ -1,34 +1,24 @@
 "use strict";
 
-import MetaLevelLocalContext from "./context/local/metaLevel";
+import LocalContext from "./context/local";
 import metaLevelNodesVerifier from "./verifier/nodes/metaLevel";
-import IntrinsicLevelLocalContext from "./context/local/intrinsicLevel";
 import intrinsicLevelAgainstMetaLevelNodesVerifier from "./verifier/nodes/intrinsicLevelAgainstMetaLevel";
 
 import { match } from "./utilities/array";
 import { nodeAsString } from "./utilities/string";
 import { nodeQuery, nodesQuery } from "./utilities/query";
-import { statementNodeFromStatementString, metastatementNodeFromMetastatementString } from "./utilities/node";
+import { statementNodeFromStatementString } from "./utilities/node";
 
-const subproofAssertionNodeQuery = nodeQuery("/metastatement/subproofAssertion!"),
-      subproofSuppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement!/statement!"),
-      subproofLastProofStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/lastProofStep/unqualifiedStatement|qualifiedStatement/statement!"),
-      subproofAssertionMetastatementNodesQuery = nodesQuery("/subproofAssertion/metastatement"),
-      ruleSubproofPremiseMetastatementNodesQuery = nodesQuery("/ruleSubproof/premise/unqualifiedMetastatement!/metastatement!"),
-      metaSubproofMetaSuppositionMetastatementNodesQuery = nodesQuery("/metaSubproof/metaSupposition/unqualifiedMetastatement!/metastatement!"),
-      ruleSubproofLastRuleProofStepMetastatementNodeQuery = nodeQuery("/ruleSubproof/ruleSubDerivation/lastRuleProofStep/unqualifiedMetastatement|qualifiedMetastatement/metastatement!"),
-      metaSubproofLastMetaproofStepMetastatementNodeQuery = nodeQuery("/metaSubproof/metaSubDerivation/lastMetaproofStep/unqualifiedMetastatement|qualifiedMetastatement/metastatement!");
+const subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
+      subproofPremiseStatementNodesQuery = nodesQuery("/subproof/premise/unqualifiedStatement!/statement!"),
+      subproofAssertionStatementNodesQuery = nodesQuery("/subproofAssertion/statement"),
+      subproofLastProofStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/lastProofStep/unqualifiedStatement|qualifiedStatement/statement!");
 
 export default class Premise {
-  constructor(metastatementNode, statementNode) {
-    this.metastatementNode = metastatementNode;
+  constructor(statementNode) {
     this.statementnode = statementNode;
   }
 
-  getMetastatementNode() {
-    return this.metastatementNode;
-  }
-
   getStatementNode() {
     return this.statementnode;
   }
@@ -36,11 +26,11 @@ export default class Premise {
   matchStatementNode(statementNode, substitutions, fileContext, localContext) {
     let matchesStatementNode = false;
 
-    if (this.metastatementNode !== null) {
-      const intrinsicLevelLocalContext = IntrinsicLevelLocalContext.fromFileContext(fileContext),
-            nonTerminalNodeA = this.metastatementNode,  ///
+    if (this.statementNode !== null) {
+      const fileContextA = fileContext, ///
+            nonTerminalNodeA = this.statementNode,  ///
             nonTerminalNodeB = statementNode,  ///
-            localContextA = intrinsicLevelLocalContext, ///
+            localContextA = LocalContext.fromFileContext(fileContextA),
             localContextB = localContext,  ///
             nonTerminalNodeVerified = intrinsicLevelAgainstMetaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
               const verifiedAhead = true;
@@ -57,97 +47,23 @@ export default class Premise {
   matchSubproofNode(subproofNode, substitutions, fileContext, localContext) {
     let matchesSubproofNode = false;
 
-    if (this.metastatementNode !== null) {
-      const subproofAssertionNode = subproofAssertionNodeQuery(this.metastatementNode);
+    if (this.statementNode !== null) {
+      const subproofAssertionNode = subproofAssertionNodeQuery(this.statementNode);
 
       if (subproofAssertionNode !== null) {
-        const subproofSuppositionStatementNodes = subproofSuppositionStatementNodesQuery(subproofNode),
+        const subproofPremiseStatementNodes = subproofPremiseStatementNodesQuery(subproofNode),
               subproofLastProofStepStatementNode = subproofLastProofStepStatementNodeQuery(subproofNode),
               subproofStatementNodes = [
-                ...subproofSuppositionStatementNodes,
+                ...subproofPremiseStatementNodes,
                 subproofLastProofStepStatementNode
               ],
-              subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
+              subproofAssertionStatementNodes = subproofAssertionStatementNodesQuery(subproofAssertionNode);
 
-        matchesSubproofNode = match(subproofAssertionMetastatementNodes, subproofStatementNodes, (subproofAssertionMetastatementNode, subproofStatementNode) => {
-          const metaLevelLocalContext = MetaLevelLocalContext.fromFileContext(fileContext),
-                nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
+        matchesSubproofNode = match(subproofAssertionStatementNodes, subproofStatementNodes, (subproofAssertionStatementNode, subproofStatementNode) => {
+          const fileContextA = fileContext, ///
+                nonTerminalNodeA = subproofAssertionStatementNode,  ///
                 nonTerminalNodeB = subproofStatementNode, ///
-                localContextA = metaLevelLocalContext,  ///
-                localContextB = localContext,  ///
-                nonTerminalNodeVerified = intrinsicLevelAgainstMetaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
-                  const verifiedAhead = true;
-
-                  return verifiedAhead;
-                });
-
-          if (nonTerminalNodeVerified) {
-            return true;
-          }
-        });
-      }
-    }
-
-    return matchesSubproofNode;
-  }
-
-  matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, localContext) {
-    let matchesRuleSubproofNode = false;
-
-    if (this.metastatementNode !== null) {
-      const subproofAssertionNode = subproofAssertionNodeQuery(this.metastatementNode);
-
-      if (subproofAssertionNode !== null) {
-        const ruleSubproofPremiseMetastatementNodes = ruleSubproofPremiseMetastatementNodesQuery(ruleSubproofNode),
-              ruleSubproofLastRuleProofStepMetastatementNode = ruleSubproofLastRuleProofStepMetastatementNodeQuery(ruleSubproofNode),
-              ruleSubproofMetastatementNodes = [
-                ...ruleSubproofPremiseMetastatementNodes,
-                ruleSubproofLastRuleProofStepMetastatementNode
-              ],
-              subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
-
-        matchesRuleSubproofNode = match(subproofAssertionMetastatementNodes, ruleSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
-          const metaLevelLocalContext = MetaLevelLocalContext.fromFileContext(fileContext),
-                nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
-                nonTerminalNodeB = ruleSubproofMetastatementNode, ///
-                localContextA = metaLevelLocalContext,  ///
-                localContextB = localContext,  ///
-                nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
-                  const verifiedAhead = true;
-
-                  return verifiedAhead;
-                });
-
-          if (nonTerminalNodeVerified) {
-            return true;
-          }
-        });
-      }
-    }
-
-    return matchesRuleSubproofNode;
-  }
-
-  matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localContext) {
-    let matchesMetaSubproofNode = false;
-
-    if (this.metastatementNode !== null) {
-      const subproofAssertionNode = subproofAssertionNodeQuery(this.metastatementNode);
-
-      if (subproofAssertionNode !== null) {
-        const metaSubproofMetaSuppositionMetastatementNodes = metaSubproofMetaSuppositionMetastatementNodesQuery(metaSubproofNode),
-              metaSubproofLastMetaproofStepMetastatementNode = metaSubproofLastMetaproofStepMetastatementNodeQuery(metaSubproofNode),
-              metaSubproofMetastatementNodes = [
-                ...metaSubproofMetaSuppositionMetastatementNodes,
-                metaSubproofLastMetaproofStepMetastatementNode
-              ],
-              subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
-
-        matchesMetaSubproofNode = match(subproofAssertionMetastatementNodes, metaSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
-          const metaLevelLocalContext = MetaLevelLocalContext.fromFileContext(fileContext),
-                nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
-                nonTerminalNodeB = ruleSubproofMetastatementNode, ///
-                localContextA = metaLevelLocalContext,  ///
+                localContextA = LocalContext.fromFileContext(fileContextA),
                 localContextB = localContext,  ///
                 nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
                   const verifiedAhead = true;
@@ -162,37 +78,13 @@ export default class Premise {
       }
     }
 
-    return matchesMetaSubproofNode;
-  }
-
-  matchMetastatementNode(metastatementNode, substitutions, fileContext, localContext) {
-    let matchesMetastatementNode = false;
-
-    if (this.metastatementNode !== null) {
-      const metaLevelLocalContext = MetaLevelLocalContext.fromFileContext(fileContext),
-            nonTerminalNodeA = this.metastatementNode,  ///
-            nonTerminalNodeB = metastatementNode,  ///
-            localContextA = metaLevelLocalContext,  ///
-            localContextB = localContext,  ///
-            nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
-              const verifiedAhead = true;
-
-              return verifiedAhead;
-            });
-
-      matchesMetastatementNode = nonTerminalNodeVerified; ///
-    }
-
-    return matchesMetastatementNode;
+    return matchesSubproofNode;
   }
 
   toJSON(tokens) {
-    const metastatementString = nodeAsString(this.metastatementNode, tokens),
-          statementString = nodeAsString(this.statementnode, tokens),
-          metastatement = metastatementString, ///
+    const statementString = nodeAsString(this.statementnode, tokens),
           statement = statementString,  ///
           json = {
-            metastatement,
             statement
           };
 
@@ -200,28 +92,18 @@ export default class Premise {
   }
 
   static fromStatementNode(statementNode) {
-    const metastatementNode = null,
-          premise = new Premise(metastatementNode, statementNode);
-
-    return premise;
-  }
-
-  static fromMetastatementNode(metastatementNode) {
-    const statementNode = null,
-          premise = new Premise(metastatementNode, statementNode);
+    const premise = new Premise(statementNode);
 
     return premise;
   }
 
   static fromJSONAndFileContext(json, fileContext) {
-    const { metastatement, statement } = json,
-          metastatementString = metastatement,  ///
+    const { statement } = json,
           statementString = statement, ///
           lexer = fileContext.getLexer(),
           parser = fileContext.getParser(),
-          metastatementNode = metastatementNodeFromMetastatementString(metastatementString, lexer, parser),
           statementNode = statementNodeFromStatementString(statementString, lexer, parser),
-          premise = new Premise(metastatementNode, statementNode);
+          premise = new Premise(statementNode, statementNode);
 
     return premise;
   }

package/src/rule.js

@@ -46,22 +46,6 @@ export default class Rule {
     return matchesStatement;
   }
 
-  matchMetastatement(metastatementNode, localContext) {
-    let matchesMetastatement = false;
-
-    const metaproofSteps = localContext.getMetaproofSteps(),
-          substitutions = [],
-          premisesMatch = metaMatchPremises(this.premises, metaproofSteps, substitutions, this.fileContext, localContext);
-
-    if (premisesMatch) {
-      const conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, substitutions, this.fileContext, localContext);
-
-      matchesMetastatement = conclusionMatches;  ///
-    }
-
-    return matchesMetastatement;
-  }
-
   matchMetavariableNode(metavariableNode) {
     const matchesMetavariableNode = this.labels.some((label) => {
       const labelMatchesMetavariableNode = label.matchMetavariableNode(metavariableNode);
@@ -186,54 +170,3 @@ function matchConclusion(conclusion, statementNode, substitutions, fileContext,
 
   return conclusionMatches;
 }
-
-function metaMatchPremise(premise, metaproofStep, substitutions, fileContext, localContext) {
-  let premiseMatches = false;
-
-  const ruleSubproofNode = metaproofStep.getRuleSubproofNode(),
-        metaSubproofNode = metaproofStep.getMetaSubproofNode(),
-        metastatementNode = metaproofStep.getMetastatementNode()
-
-  if (ruleSubproofNode !== null) {
-    const premiseMatchesRuleSubproofNode = premise.matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, localContext);
-
-    premiseMatches = premiseMatchesRuleSubproofNode; ///
-  }
-
-  if (metaSubproofNode !== null) {
-    const premiseMatchesMetaSubproofNode = premise.matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localContext);
-
-    premiseMatches = premiseMatchesMetaSubproofNode; ///
-  }
-
-  if (metastatementNode !== null) {
-    const premiseMatchesMetastatementNode = premise.matchMetastatementNode(metastatementNode, substitutions, fileContext, localContext);
-
-    premiseMatches = premiseMatchesMetastatementNode;  ///
-  }
-
-  return premiseMatches;
-}
-
-function metaMatchPremises(premises, metaproofSteps, substitutions, fileContext, localContext) {
-  premises = reverse(premises); ///
-
-  metaproofSteps = reverse(metaproofSteps); ///
-
-  const premisesMatch = correlate(premises, metaproofSteps, (premise, metaproofStep) => {
-    const premiseMatches = metaMatchPremise(premise, metaproofStep, substitutions, fileContext, localContext);
-
-    if (premiseMatches) {
-      return true;
-    }
-  });
-
-  return premisesMatch;
-}
-
-function metaMatchConclusion(conclusion, metastatementNode, substitutions, fileContext, localContext) {
-  const conclusionMatchesMetastatementNode = conclusion.matchMetastatementNode(metastatementNode, substitutions, fileContext, localContext),
-        conclusionMatches = conclusionMatchesMetastatementNode; ///
-
-  return conclusionMatches;
-}

package/src/ruleNames.js

@@ -1,8 +1,6 @@
 "use strict";
 
 export const METAVARIABLE_RULE_NAME = "metavariable";
-export const META_ARGUMENT_RULE_NAME = "metaArgument";
 export const VARIABLE_DECLARATION_RULE_NAME = "variableDeclaration";
 export const UNQUALIFIED_STATEMENT_RULE_NAME = "unqualifiedStatement";
 export const CONSTRUCTOR_DECLARATION_RULE_NAME = "constructorDeclaration";
-export const UNQUALIFIED_METASTATEMENT_RULE_NAME = "unqualifiedMetastatement";

package/src/substitution/statementForMetavariable.js

@@ -5,6 +5,7 @@ import TermForVariableSubstitution from "./termForVariable";
 import verifyStatementAgainstStatement from "../verify/statementAtainstStatement";
 
 import { bracketedStatementChildNodeFromStatementNode } from "../utilities/match";
+import { statementNodeFromStatementString, metavariableNodeFromMetavariableString } from "../utilities/node";
 
 export default class StatementForMetavariableSubstitution extends Substitution {
   constructor(metavariableNode, statementNode, substitution) {
@@ -55,6 +56,19 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return matchesMetavariableNode;
   }
 
+  static fromJSONAndFileContext(json, fileContext) {
+    const { metavariable, statement } = json,
+            metavariableString = metavariable,  ///
+            statementString = statement,  ///
+            lexer = fileContext.getLexer(),
+            parser = fileContext.getParser(),
+            statementNode = statementNodeFromStatementString(statementString, lexer, parser),
+            metavariableNode = metavariableNodeFromMetavariableString(metavariableString, lexer, parser),
+            statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(statementNode, metavariableNode);
+
+    return statementForMetavariableSubstitution;
+  }
+
   static fromMetavariableNodeAndStatementNode(metavariableNode, statementNode) {
     let statementForMetavariableSubstitution;