occam-verify-cli 0.0.881 → 0.0.882

package/src/axiomLemmaTheoremConjecture.js

@@ -66,9 +66,9 @@ export default class AxiomLemmaTheoremConjecture {
     return statementNatches;
   }
 
-  matchLabelMetavariableNode(labelMetavariableNode) {
+  matchLabelMetavariableNode(metavariableNode) {
     const labelMetavariableNodeMatches = this.labels.some((label) => {
-      const node = labelMetavariableNode, ///
+      const node = metavariableNode, ///
             labelMatchesNode = label.matchNode(node);
 
       if (labelMatchesNode) {
@@ -149,16 +149,7 @@ export default class AxiomLemmaTheoremConjecture {
 
 function matchSupposition(supposition, proofSteps, substitutions, localContext, statementLocalContext) {
   const proofStep = prune(proofSteps, (proofStep) => {
-    const subproofNode = proofStep.getSubproofNode(),
-          statementNode = proofStep.getStatementNode();
-
-    if (subproofNode !== null) {
-      const subProofMatches = supposition.matchSubproofNode(subproofNode, substitutions, localContext, statementLocalContext);
-
-      if (!subProofMatches) {  ///
-        return true;
-      }
-    }
+    const statementNode = proofStep.getStatementNode();
 
     if (statementNode !== null) {
       const statementMatches = supposition.matchStatementNode(statementNode, substitutions, localContext, statementLocalContext);

package/src/context/file.js

@@ -17,7 +17,6 @@ import { push } from "../utilities/array";
 import { objectType } from "../type";
 import { typeFromJSONAndFileContext } from "../type";
 import { nodeAsString, nodesAsString } from "../utilities/string";
-import localMeta from "./localMeta";
 
 export default class FileContext {
   constructor(releaseContext, filePath, tokens, node, types, rules, axioms, lemmas, theorems, variables, metaLemmas, conjectures, combinators, constructors, metatheorems, metavariables) {
@@ -361,22 +360,8 @@ export default class FileContext {
     return metaType;
   }
 
-  findMetavariableByMetavariableNode(metavariableNode) {
-    const node = metavariableNode,  ///
-          metavariables = this.getMetavariables(),
-          metavariable = metavariables.find((metavariable) => {
-            const matches = metavariable.matchNode(node);
-
-            if (matches) {
-              return true;
-            }
-          }) || null;
-
-    return metavariable;
-  }
-
-  findLabelByLabelMetavariableNode(labelMetavariableNode) {
-    const name = labelMetavariableNode,  ///
+  findLabelByMetavariableNode(metavariableNode) {
+    const name = metavariableNode,  ///
           labels = this.getLabels(),
           label = labels.find((label) => {
             const matches = label.matchNode(name);
@@ -389,10 +374,10 @@ export default class FileContext {
     return label;
   }
 
-  findRuleByLabelMetavariableNode(labelMetavariableNode) {
+  findRuleByMetavariableNode(metavariableNode) {
     const rules = this.getRules(),
           rule = rules.find((rule) => {
-            const ruleMatchesLabelMetavariableNode = rule.matchLabelMetavariableNode(labelMetavariableNode);
+            const ruleMatchesLabelMetavariableNode = rule.matchLabelMetavariableNode(metavariableNode);
 
             if (ruleMatchesLabelMetavariableNode) {
               return true;
@@ -402,10 +387,10 @@ export default class FileContext {
     return rule;
   }
 
-  findAxiomByLabelMetavariableNode(labelMetavariableNode) {
+  findAxiomByMetavariableNode(metavariableNode) {
     const axioms = this.getAxioms(),
           axiom = axioms.find((axiom) => {
-            const axiomMatchesLabelMetavariableNode = axiom.matchLabelMetavariableNode(labelMetavariableNode);
+            const axiomMatchesLabelMetavariableNode = axiom.matchLabelMetavariableNode(metavariableNode);
 
             if (axiomMatchesLabelMetavariableNode) {
               return true;
@@ -415,10 +400,10 @@ export default class FileContext {
     return axiom;
   }
 
-  findLemmaByLabelMetavariableNode(labelMetavariableNode) {
+  findLemmaByMetavariableNode(metavariableNode) {
     const lemmas = this.getLemmas(),
           lemma = lemmas.find((lemma) => {
-            const lemmaMatchesLabelMetavariableNode = lemma.matchLabelMetavariableNode(labelMetavariableNode);
+            const lemmaMatchesLabelMetavariableNode = lemma.matchLabelMetavariableNode(metavariableNode);
 
             if (lemmaMatchesLabelMetavariableNode) {
               return true;
@@ -428,10 +413,10 @@ export default class FileContext {
     return lemma;
   }
 
-  findTheoremByLabelMetavariableNode(labelMetavariableNode) {
+  findTheoremByMetavariableNode(metavariableNode) {
     const theorems = this.getTheorems(),
           theorem = theorems.find((theorem) => {
-            const theoremMatchesLabelMetavariableNode = theorem.matchLabelMetavariableNode(labelMetavariableNode);
+            const theoremMatchesLabelMetavariableNode = theorem.matchLabelMetavariableNode(metavariableNode);
 
             if (theoremMatchesLabelMetavariableNode) {
               return true;
@@ -441,10 +426,10 @@ export default class FileContext {
     return theorem;
   }
 
-  findMetaLemmaByLabelMetavariableNode(labelMetavariableNode) {
+  findMetaLemmaByMetavariableNode(metavariableNode) {
     const metaLemmas = this.getMetaLemmas(),
           metaLemma = metaLemmas.find((metaLemma) => {
-            const metaLemmaMatchesLabelMetavariableNode = metaLemma.matchLabelMetavariableNode(labelMetavariableNode);
+            const metaLemmaMatchesLabelMetavariableNode = metaLemma.matchLabelMetavariableNode(metavariableNode);
 
             if (metaLemmaMatchesLabelMetavariableNode) {
               return true;
@@ -454,10 +439,10 @@ export default class FileContext {
     return metaLemma;
   }
 
-  findConjectureByLabelMetavariableNode(labelMetavariableNode) {
+  findConjectureByMetavariableNode(metavariableNode) {
     const conjectures = this.getConjectures(),
           conjecture = conjectures.find((conjecture) => {
-            const conjectureMatchesLabelMetavariableNode = conjecture.matchLabelMetavariableNode(labelMetavariableNode);
+            const conjectureMatchesLabelMetavariableNode = conjecture.matchLabelMetavariableNode(metavariableNode);
 
             if (conjectureMatchesLabelMetavariableNode) {
               return true;
@@ -467,10 +452,10 @@ export default class FileContext {
     return conjecture;
   }
 
-  findMetatheoremByLabelMetavariableNode(labelMetavariableNode) {
+  findMetatheoremByMetavariableNode(metavariableNode) {
     const metatheorems = this.getMetatheorems(),
           metatheorem = metatheorems.find((metatheorem) => {
-            const metatheoremMatchesLabelMetavariableNode = metatheorem.matchLabelMetavariableNode(labelMetavariableNode);
+            const metatheoremMatchesLabelMetavariableNode = metatheorem.matchLabelMetavariableNode(metavariableNode);
 
             if (metatheoremMatchesLabelMetavariableNode) {
               return true;
@@ -480,6 +465,20 @@ export default class FileContext {
     return metatheorem;
   }
 
+  findMetavariableByMetavariableNode(metavariableNode) {
+    const node = metavariableNode,  ///
+          metavariables = this.getMetavariables(),
+          metavariable = metavariables.find((metavariable) => {
+            const matches = metavariable.matchNode(node);
+
+            if (matches) {
+              return true;
+            }
+          }) || null;
+
+    return metavariable;
+  }
+
   isTypePresentByTypeName(typeName) {
     const type = this.findTypeByTypeName(typeName),
           typePresent = (type !== null);
@@ -508,8 +507,8 @@ export default class FileContext {
     return variablePresent;
   }
 
-  isLabelPresentByLabelMetavariableNode(labelMetavariableNode) {
-    const label = this.findLabelByLabelMetavariableNode(labelMetavariableNode),
+  isLabelPresentByMetavariableNode(metavariableNode) {
+    const label = this.findLabelByMetavariableNode(metavariableNode),
           labelPresent = (label !== null);
 
     return labelPresent;

package/src/context/localMeta.js

@@ -74,7 +74,18 @@ class LocalMetaContext {
   }
 
   addJudgement(judgement) {
-    this.judgements.push(judgement);
+    let judgementAdded = false;
+
+    const metavariableNode = judgement.getMetavariableNode(),
+          judgementPresent = this.isJudgementPresentByMetavariableNode(metavariableNode);
+
+    if (!judgementPresent) {
+      this.judgements.push(judgement);
+
+      judgementAdded = true;
+    }
+
+    return judgementAdded;
   }
 
   addMetavariable(metavariable) {
@@ -138,6 +149,19 @@ class LocalMetaContext {
     return variable;
   }
 
+  findJudgementByMetavariableNode(metavariableNode) {
+    const judgements = this.getJudgements(),
+          judgement = judgements.find((judgement) => {
+            const metavariableMatches = judgement.matchMetavariableNode(metavariableNode);
+
+            if (metavariableMatches) {
+              return true;
+            }
+          }) || null;
+
+    return judgement;
+  }
+
   isVariablePresentByVariableNode(variableNode) {
     const variable = this.findVariableByVariableNode(variableNode),
           variablePresent = (variable !== null);
@@ -145,6 +169,13 @@ class LocalMetaContext {
     return variablePresent;
   }
 
+  isJudgementPresentByMetavariableNode(metavariableNode) {
+    const judgement = this.findJudgementByMetavariableNode(metavariableNode),
+          judgementPresent = (judgement !== null);
+
+    return judgementPresent;
+  }
+
   findMetavariableByMetavariableNode(metavariableNode, localMetaContext) {
     const node = metavariableNode,  ///
           metavariables = this.getMetavariables(),

package/src/declaration.js

@@ -0,0 +1,58 @@
+"use strict";
+
+import { matchMetastatement } from "./utilities/metaproof";
+
+export default class Declaration {
+  constructor(metavariableNode, metastatementNode) {
+    this.metavariableNode = metavariableNode;
+    this.metastatementNode = metastatementNode;
+  }
+
+  getMetavariableNode() {
+    return this.metavariableNode;
+  }
+
+  getMetastatementNode() {
+    return this.metastatementNode;
+  }
+
+  matchSubstitution(substitution) {
+    const metavariableNode = substitution.getMetavariableNode(),
+          metastatementNode = substitution.getMetastatementNode(),
+          metavariableNodeMatches = this.matchMetavariableNode(metavariableNode),
+          metastatementNodeMatches = this.matchMetastatementNode(metastatementNode),
+          substitutionMatches = (metavariableNodeMatches && metastatementNodeMatches);
+
+    return substitutionMatches;
+  }
+
+  matchMetavariableNode(metavariableNode) {
+    const metavariableNodeMatches = this.metavariableNode.match(metavariableNode);
+
+    return metavariableNodeMatches;
+  }
+
+  matchMetastatementNode(metastatementNode) {
+    const metastatementNodeA = metastatementNode, ///
+          metastatementNodeB = this.metastatementNode,  ///
+          metastatementMatches = matchMetastatement(metastatementNodeA, metastatementNodeB),
+          metastatementNodeMatches = metastatementMatches;  ///
+
+    return metastatementNodeMatches;
+  }
+
+  matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem) {
+    const metaConsequent = metaLemmaMetatheorem.getMetaConsequent(),
+          metastatementNode = metaConsequent.getMetastatementNode(),
+          matches = this.metastatementNode.match(metastatementNode),
+          metaLemmaOrMetaTheoremMatches = matches;  ///
+
+    return metaLemmaOrMetaTheoremMatches;
+  }
+
+  static fromMetavariableNodeAndMetastatementNode(metavariableNode, metastatementNode) {
+    const declaration = new Declaration(metavariableNode, metastatementNode);
+
+    return declaration;
+  }
+}

package/src/frame.js

@@ -1,27 +1,69 @@
 "use strict";
 
+import { push, first } from "./utilities/array";
+
 export default class Frame {
-  constructor(node, declarations) {
-    this.node = node;
+  constructor(declarations) {
     this.declarations = declarations;
   }
 
-  getNode() {
-    return this.node;
-  }
-
   getDeclarations() {
     return this.declarations;
   }
 
+  getDeclaration() {
+    let declaration = null;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      const firstDeclaration = first(this.declarations);
+
+      declaration = firstDeclaration; ///
+    }
+
+    return declaration;
+  }
+
+  isSingular() {
+    const declarationsLength = this.declarations.length,
+          singular = (declarationsLength === 1);
+
+    return singular;
+  }
+
   addDeclarations(declarations) {
     push(this.declarations, declarations);
   }
 
-  fromFrameNodeAndDeclarations(frameNode, declarations) {
-    const node = frameNode, ///
-          frame = new Frame(node, declarations);
+  matchSubstitution(substitution) {
+    const substitutionMatches = this.declarations.some((declaration) => {
+      const declarationMatchesSubstitution = declaration.matchSubstitution(substitution);
+
+      if (declarationMatchesSubstitution) {
+        return true;
+      }
+    });
+
+    return substitutionMatches;
+  }
+
+  matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem) {
+    const substitutions = metaLemmaMetatheorem.getSubstitutions(),
+          metaLemmaOrMetaTheoremMatches = substitutions.every((substitution) => {
+            const frameMatchesSubstitution = this.matchSubstitution(substitution);
+
+            if (frameMatchesSubstitution) {
+              return true;
+            }
+          });
+
+    return metaLemmaOrMetaTheoremMatches;
+  }
+
+  static fromDeclarations(declarations) {
+    const frame = new Frame(declarations);
 
     return frame;
   }
-}
+}

package/src/judgement.js

@@ -1,10 +1,10 @@
 "use strict";
 
 export default class Judgement {
-  constructor(node, frame, metavariable) {
+  constructor(node, frame, metavariableNode) {
     this.node = node;
     this.frame = frame;
-    this.metavariable = metavariable;
+    this.metavariableNode = metavariableNode;
   }
 
   getNode() {
@@ -15,13 +15,23 @@ export default class Judgement {
     return this.frame;
   }
 
-  getMetavariable() {
-    return this.metavariable;
+  getMetavariableNode() {
+    return this.metavariableNode;
   }
 
-  static fromJudgementNodeFrameAndMetavariable(judgementNode, frame, metavariable) {
+  getDeclarations() { return this.frame.getDeclarations(); }
+
+  matchMetavariableNode(metavariableNode) {
+    const metavariableNodeMatches = this.metavariableNode.match(metavariableNode);
+
+    return metavariableNodeMatches;
+  }
+
+  matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem) { return this.frame.matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem); }
+
+  static fromJudgementNodeFrameAndMetavariableNode(judgementNode, frame, metavariableNode) {
     const node = judgementNode,
-          judgement = new Judgement(node, frame, metavariable);
+          judgement = new Judgement(node, frame, metavariableNode);
 
     return judgement;
   }

package/src/label.js

@@ -33,9 +33,9 @@ export default class Label {
 
   static fromMetavariableNode(metavariableNode) {
     const node = metavariableNode, ///
-          variable = new Label(node);
+          label = new Label(node);
 
-    return variable;
+    return label;
   }
 
   static fromJSONAndFileContext(json, fileContext) {

package/src/metaLemmaMetatheorem.js

@@ -3,10 +3,10 @@
 import Label from "./label";
 import MetaConsequent from "./metaConsequent";
 import MetaSupposition from "./metaSupposition";
+import MetastatementForMetavariableSubstitution from "./substitution/metastatementForMetavariable";
 
 import { prune } from "./utilities/array";
 import { someSubArray } from "./utilities/array";
-import MetastatementForMetavariableSubstitution from "./substitution/metastatementForMetavariable";
 
 export default class MetaLemmaMetatheorem {
   constructor(labels, metaSuppositions, metaConsequent, substitutions, fileContext) {
@@ -71,9 +71,9 @@ export default class MetaLemmaMetatheorem {
     return metastatementNatches;
   }
 
-  matchLabelMetavariableNode(labelMetavariableNode) {
+  matchLabelMetavariableNode(metavariableNode) {
     const labelMetavariableNodeMatches = this.labels.some((label) => {
-      const node = labelMetavariableNode, ///
+      const node = metavariableNode, ///
             labelMatchesNode = label.matchNode(node);
 
       if (labelMatchesNode) {

package/src/mixins/context.js

@@ -26,7 +26,7 @@ function getConstructors() { return this.context.getConstructors(); }
 
 function findTypeByTypeName(typeName) { return this.context.findTypeByTypeName(typeName); }
 
-function findTypeByTypeNode(labelMetavariableNode) { return this.context.findTypeByTypeNode(labelMetavariableNode); }
+function findTypeByTypeNode(typeNode) { return this.context.findTypeByTypeNode(typeNode); }
 
 function findMetavariableByName(name) { return this.context.findMetavariableByName(name); }
 
@@ -36,19 +36,23 @@ function isTypePresentByTypeNode(typeNode) { return this.context.isTypePresentBy
 
 function isMetavariablePresentByName(name) { return this.context.isMetavariablePresentByName(name); }
 
-function findLabelByLabelMetavariableNode(labelMetavariableNode) { return this.context.findLabelByLabelMetavariableNode(labelMetavariableNode); }
+function isLabelPresentByMetavariableNode(metavariableNode) { return this.context.isLabelPresentByMetavariableNode(metavariableNode); }
 
-function findRuleByLabelMetavariableNode(labelMetavariableNode) { return this.context.findRuleByLabelMetavariableNode(labelMetavariableNode); }
+function findLabelByMetavariableNode(metavariableNode) { return this.context.findLabelByMetavariableNode(metavariableNode); }
 
-function findAxiomByLabelMetavariableNode(labelMetavariableNode) { return this.context.findAxiomByLabelMetavariableNode(labelMetavariableNode); }
+function findRuleByMetavariableNode(metavariableNode) { return this.context.findRuleByMetavariableNode(metavariableNode); }
 
-function findLemmaByLabelMetavariableNode(labelMetavariableNode) { return this.context.findLemmaByLabelMetavariableNode(labelMetavariableNode); }
+function findAxiomByMetavariableNode(metavariableNode) { return this.context.findAxiomByMetavariableNode(metavariableNode); }
 
-function findTheoremByLabelMetavariableNode(labelMetavariableNode) { return this.context.findTheoremByLabelMetavariableNode(labelMetavariableNode); }
+function findLemmaByMetavariableNode(metavariableNode) { return this.context.findLemmaByMetavariableNode(metavariableNode); }
 
-function findConjectureByLabelMetavariableNode(labelMetavariableNode) { return this.context.findConjectureByLabelMetavariableNode(labelMetavariableNode); }
+function findTheoremByMetavariableNode(metavariableNode) { return this.context.findTheoremByMetavariableNode(metavariableNode); }
 
-function isLabelPresentByLabelMetavariableNode(labelMetavariableNode) { return this.context.isLabelPresentByLabelMetavariableNode(labelMetavariableNode); }
+function findMetaLemmaByMetavariableNode(metavariableNode) { return this.context.findMetaLemmaByMetavariableNode(metavariableNode); }
+
+function findConjectureByMetavariableNode(metavariableNode) { return this.context.findConjectureByMetavariableNode(metavariableNode); }
+
+function findMetatheoremByMetavariableNode(metavariableNode) { return this.context.findMetatheoremByMetavariableNode(metavariableNode); }
 
 function nodeAsString(node) { return this.context.nodeAsString(node); }
 
@@ -73,13 +77,15 @@ const contextMixins = {
   isTypePresentByTypeName,
   isTypePresentByTypeNode,
   isMetavariablePresentByName,
-  findLabelByLabelMetavariableNode,
-  findRuleByLabelMetavariableNode,
-  findAxiomByLabelMetavariableNode,
-  findLemmaByLabelMetavariableNode,
-  findTheoremByLabelMetavariableNode,
-  findConjectureByLabelMetavariableNode,
-  isLabelPresentByLabelMetavariableNode,
+  isLabelPresentByMetavariableNode,
+  findLabelByMetavariableNode,
+  findRuleByMetavariableNode,
+  findAxiomByMetavariableNode,
+  findLemmaByMetavariableNode,
+  findTheoremByMetavariableNode,
+  findMetaLemmaByMetavariableNode,
+  findConjectureByMetavariableNode,
+  findMetatheoremByMetavariableNode,
   nodeAsString,
   nodesAsString
 };

package/src/premise.js

@@ -11,8 +11,6 @@ import { metastatementNodeFromMetastatementString } from "./utilities/node";
 
 const ruleSubproofAssertionNodeQuery = nodeQuery("/metastatement/ruleSubproofAssertion!"),
       ruleSubproofPremiseMetastatementQuery = nodesQuery("/ruleSubproof/premise/unqualifiedMetastatement!/metastatement!"),
-      subproofSuppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement!/statement!"),
-      subproofSubDerivationLastStatementNodeQuery = nodeQuery("/subproof/subDerivation/qualifiedStatement|unqualifiedStatement[-1]/statement!"),
       ruleSubproofAssertionMetastatementNodesQuery = nodesQuery("/ruleSubproofAssertion/metastatement"),
       ruleSubproofSubDerivationLastMetastatementQuery = nodeQuery("/ruleSubproof/ruleSubDerivation/qualifiedMetastatement|unqualifiedMetastatement[-1]/metastatement!");
 
@@ -25,45 +23,6 @@ export default class Premise {
     return this.metastatementNode;
   }
 
-  matchSubproofNode(subproofNode, substitutions, fileContext, statementLocalContext) {
-    let subproofNodeMatches = false;
-
-    const subproofAssertionNode = ruleSubproofAssertionNodeQuery(this.metastatementNode);
-
-    if (subproofAssertionNode !== null) {
-      const subproofSuppositionStatementNodes = subproofSuppositionStatementNodesQuery(subproofNode),
-            subproofSubDerivationLastStatementNode = subproofSubDerivationLastStatementNodeQuery(subproofNode),
-            subproofStatementNodes = [
-              ...subproofSuppositionStatementNodes,
-              subproofSubDerivationLastStatementNode
-            ],
-            ruleSubproofAssertionMetastatementNodes = ruleSubproofAssertionMetastatementNodesQuery(subproofAssertionNode),
-            subproofStatementNodesLength = subproofStatementNodes.length,
-            ruleSubproofAssertionMetastatementNodesLength = ruleSubproofAssertionMetastatementNodes.length;
-
-      if (subproofStatementNodesLength === ruleSubproofAssertionMetastatementNodesLength) {
-        subproofNodeMatches = match(ruleSubproofAssertionMetastatementNodes, subproofStatementNodes, (ruleSubproofAssertionMetastatementNode, subproofStatementNode) => {
-          const nonTerminalNodeA = ruleSubproofAssertionMetastatementNode,  ///
-                nonTerminalNodeB = subproofStatementNode, ///
-                fileContextA = fileContext, ///
-                localContextA = LocalContext.fromFileContext(fileContextA),
-                localContextB = statementLocalContext,  ///
-                nonTerminalNodeVerified = intrinsicLevelAgainstMetaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
-                  const verifiedAhead = true;
-
-                  return verifiedAhead;
-                });
-
-          if (nonTerminalNodeVerified) {
-            return true;
-          }
-        });
-      }
-    }
-
-    return subproofNodeMatches;
-  }
-
   matchStatementNode(statementNode, substitutions, fileContext, statementLocalContext) {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = statementNode,  ///

package/src/rule.js

@@ -99,9 +99,9 @@ export default class Rule {
     return metastatementNatches;
   }
 
-  matchLabelMetavariableNode(labelMetavariableNode) {
+  matchLabelMetavariableNode(metavariableNode) {
     const labelMetavariableNodeMatches = this.labels.some((label) => {
-      const node = labelMetavariableNode, ///
+      const node = metavariableNode, ///
             labelMatchesNode = label.matchNode(node);
 
       if (labelMatchesNode) {
@@ -183,16 +183,7 @@ export default class Rule {
 
 function matchPremise(premise, proofSteps, substitutions, fileContext, statementLocalContext) {
   const proofStep = prune(proofSteps, (proofStep) => {
-    const subproofNode = proofStep.getSubproofNode(),
-          statementNode = proofStep.getStatementNode()
-
-    if (subproofNode !== null) {
-      const subProofNodeMatches = premise.matchSubproofNode(subproofNode, substitutions, fileContext, statementLocalContext);
-
-      if (!subProofNodeMatches) {  ///
-        return true;
-      }
-    }
+    const statementNode = proofStep.getStatementNode()
 
     if (statementNode !== null) {
       const statementNodeMatches = premise.matchStatementNode(statementNode, substitutions, fileContext, statementLocalContext);

package/src/supposition.js

@@ -2,16 +2,9 @@
 
 import intrinsicLevelNodesVerifier from "./verifier/nodes/intrinsicLevel";
 
-import { match } from "./utilities/array";
 import { nodeAsString } from "./utilities/string";
-import { nodeQuery, nodesQuery } from "./utilities/query";
 import { statementNodeFromStatementString } from "./utilities/node";
 
-const subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
-      subproofAssertionStatementNodesQuery = nodesQuery("/subproofAssertion/statement"),
-      subproofSuppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement/statement!"),
-      subproofSubDerivationLastStatementNodeQuery = nodeQuery("/subproof/subDerivation/qualifiedStatement|unqualifiedStatement[-1]/statement!");
-
 export default class Supposition {
   constructor(statementNode) {
     this.statementNode = statementNode;
@@ -21,44 +14,6 @@ export default class Supposition {
     return this.statementNode;
   }
 
-  matchSubproofNode(subproofNode, substitutions, localContext, statementLocalContext) {
-    let subproofNodeMatches = false;
-
-    const subproofAssertionNode = subproofAssertionNodeQuery(this.statementNode);
-
-    if (subproofAssertionNode !== null) {
-      const subproofSuppositionStatementNodes = subproofSuppositionStatementNodesQuery(subproofNode),
-            subproofSubDerivationLastStatementNode = subproofSubDerivationLastStatementNodeQuery(subproofNode),
-            subproofStatementNodes = [
-              ...subproofSuppositionStatementNodes,
-              subproofSubDerivationLastStatementNode
-            ],
-            subproofAssertionStatementNodes = subproofAssertionStatementNodesQuery(subproofAssertionNode),
-            subproofStatementNodesLength = subproofStatementNodes.length,
-            subproofAssertionStatementNodesLength = subproofAssertionStatementNodes.length;
-
-      if (subproofStatementNodesLength === subproofAssertionStatementNodesLength) {
-        subproofNodeMatches = match(subproofAssertionStatementNodes, subproofStatementNodes, (subproofAssertionStatementNode, subproofStatementNode) => {
-          const nonTerminalNodeA = subproofAssertionStatementNode,  ///
-                nonTerminalNodeB = subproofStatementNode, ///
-                localContextA = localContext, ///
-                localContextB = statementLocalContext,  ///
-                nonTerminalNodeVerified = intrinsicLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
-                  const verifiedAhead = true;
-
-                  return verifiedAhead;
-                });
-
-          if (nonTerminalNodeVerified) {
-            return true;
-          }
-        });
-      }
-    }
-
-    return subproofNodeMatches;
-  }
-
   matchStatementNode(statementNode, substitutions, localContext, statementLocalContext) {
     const nonTerminalNodeA = this.statementNode,  ///
           nonTerminalNodeB = statementNode,  ///