occam-verify-cli 0.0.262 → 0.0.263

package/bin/conclusion.js

@@ -1,5 +1,8 @@
 "use strict";
 
+const { METAVARIABLE_RULE_NAME } = require("./ruleNames"),
+      { metavariableNameFromMetavariableNode } = require("./utilities/query");
+
 class Conclusion {
   constructor(metastatementNode) {
     this.metastatementNode = metastatementNode;
@@ -9,6 +12,15 @@ class Conclusion {
     return this.metastatementNode;
   }
 
+  matchNonTerminalNode(metastatementNode, metaSubstitutions) {
+    const nonTerminalNode = metastatementNode,  ///
+          conclusionNonTerminalNode = this.metastatementNode,  ///
+          conclusionNonTerminalNodeMatches = matchConclusionNonTerminalNode(conclusionNonTerminalNode, nonTerminalNode, metaSubstitutions),
+          nonTerminalNodeMatches = conclusionNonTerminalNodeMatches; ///
+
+    return nonTerminalNodeMatches;
+  }
+
   static fromMetastatementNode(metastatementNode) {
     const conclusion = new Conclusion(metastatementNode);
 
@@ -17,3 +29,114 @@ class Conclusion {
 }
 
 module.exports = Conclusion;
+
+function matchConclusionNode(conclusionNode, node, metaSubstitutions) {
+  let conclusionNodeMatches = false;
+
+  const nodeTerminalNode = node.isTerminalNode(),
+        ruleNodeTerminalNode = conclusionNode.isTerminalNode();
+
+  if (nodeTerminalNode === ruleNodeTerminalNode) {
+    if (nodeTerminalNode) {
+      const terminalNode = node,  ///
+            conclusionTerminalNode = conclusionNode,  ///
+            conclusionTerminalNodeMatches = matchConclusionTerminalNode(conclusionTerminalNode, terminalNode, metaSubstitutions);
+
+      conclusionNodeMatches = conclusionTerminalNodeMatches;  ///
+    } else {
+      const nonTerminalNode = node, ///
+            conclusionNonTerminalNode = conclusionNode,  ///
+            conclusionNonTerminalNodeMatches = matchConclusionNonTerminalNode(conclusionNonTerminalNode, nonTerminalNode, metaSubstitutions);
+
+      conclusionNodeMatches = conclusionNonTerminalNodeMatches; ///
+    }
+  }
+
+  return conclusionNodeMatches;
+}
+
+function matchConclusionChildNodes(conclusionChildNodes, childNodes, metaSubstitutions) {
+  let conclusionChildNodesMatches = false;
+
+  const childNodesLength = childNodes.length,
+        conclusionChildNodesLength = conclusionChildNodes.length;
+
+  if (childNodesLength === conclusionChildNodesLength) {
+    conclusionChildNodesMatches = childNodes.every((childNode, index) => {
+      const conclusionChildNode = conclusionChildNodes[index],
+            conclusionNode = conclusionChildNode, ///
+            node = childNode, ///
+            conclusionNodeMatches = matchConclusionNode(conclusionNode, node, metaSubstitutions);
+
+      if (conclusionNodeMatches) {
+        return true;
+      }
+    })
+  }
+
+  return conclusionChildNodesMatches;
+}
+
+function matchConclusionMetavariable(conclusionMetavariableNode, nonTerminalNode, metaSubstitutions) {
+  let conclusionMetavariableMatches = true;
+
+  const conclusionMetavariableName = metavariableNameFromMetavariableNode(conclusionMetavariableNode),
+        metaSubstitution = metaSubstitutions.find((metaSubstitution) => {
+          const metavariableName = metaSubstitution.getMetavariableName();
+
+          if (metavariableName === conclusionMetavariableName) {
+            return true;
+          }
+        }) || null;
+
+  if (metaSubstitution !== null) {
+    const metaSubstitutionNonTerminalNodeMatches = metaSubstitution.matchNonTerminalNode(nonTerminalNode);
+
+    conclusionMetavariableMatches = metaSubstitutionNonTerminalNodeMatches;  ///
+  }
+
+  return conclusionMetavariableMatches;
+}
+
+function matchConclusionTerminalNode(conclusionTerminalNode, terminalNode, metaSubstitutions) {
+  let conclusionTerminalNodeMatches = false;
+
+  const matches = conclusionTerminalNode.match(terminalNode);
+
+  if (matches) {
+    conclusionTerminalNodeMatches = true;
+  }
+
+  return conclusionTerminalNodeMatches;
+}
+
+function matchConclusionNonTerminalNode(conclusionNonTerminalNode, nonTerminalNode, metaSubstitutions) {
+  let conclusionNonTerminalNodeMatches = false;
+
+  const conclusionRuleName = conclusionNonTerminalNode.getRuleName(); ///
+
+  switch (conclusionRuleName) {
+    case METAVARIABLE_RULE_NAME: {
+      const conclusionMetavariableNode = conclusionNonTerminalNode, ///
+            conclusionMetavariableMatches = matchConclusionMetavariable(conclusionMetavariableNode, nonTerminalNode, metaSubstitutions);
+
+      conclusionNonTerminalNodeMatches = conclusionMetavariableMatches;
+
+      break;
+    }
+
+    default: {
+      const ruleName = nonTerminalNode.getRuleName();
+
+      if (ruleName === conclusionRuleName) {
+        const childNodes = nonTerminalNode.getChildNodes(),
+              conclusionChildNodes = conclusionNonTerminalNode.getChildNodes(),
+              conclusionChildNodesMatches = matchConclusionChildNodes(conclusionChildNodes, childNodes, metaSubstitutions);
+
+        conclusionNonTerminalNodeMatches = conclusionChildNodesMatches; ///
+      }
+    }
+  }
+
+  return conclusionNonTerminalNodeMatches;
+}

package/bin/metaSubstitution.js

@@ -14,6 +14,14 @@ class MetaSubstitution {
     return this.nonTerminalNode;
   }
 
+  matchNonTerminalNode(nonTerminalNode) {
+    const metaSubstitutionNonTerminalNode = this.nonTerminalNode,
+          metaSubstitutionNonTerminalNodeMatches = matchMetaSubstitutionNonTerminalNode(metaSubstitutionNonTerminalNode, nonTerminalNode),
+          nonTerminalNodeMatches = metaSubstitutionNonTerminalNodeMatches;  ///
+
+    return nonTerminalNodeMatches;
+  }
+
   static fromMetavariableNameAndNonTerminalNode(metavariableName, nonTerminalNode) {
     const metaSubstitution = new MetaSubstitution(metavariableName, nonTerminalNode);
 
@@ -22,3 +30,79 @@ class MetaSubstitution {
 }
 
 module.exports = MetaSubstitution;
+
+function matchMetaSubstitutionNode(metaSubstitutionNode, node) {
+  let metaSubstitutionNodeMatches = false;
+
+  const nodeTerminalNode = node.isTerminalNode(),
+        ruleNodeTerminalNode = metaSubstitutionNode.isTerminalNode();
+
+  if (nodeTerminalNode === ruleNodeTerminalNode) {
+    if (nodeTerminalNode) {
+      const terminalNode = node,  ///
+            metaSubstitutionTerminalNode = metaSubstitutionNode,  ///
+            metaSubstitutionTerminalNodeMatches = matchMetaSubstitutionTerminalNode(metaSubstitutionTerminalNode, terminalNode);
+
+      metaSubstitutionNodeMatches = metaSubstitutionTerminalNodeMatches;  ///
+    } else {
+      const nonTerminalNode = node, ///
+            metaSubstitutionNonTerminalNode = metaSubstitutionNode,  ///
+            metaSubstitutionNonTerminalNodeMatches = matchMetaSubstitutionNonTerminalNode(metaSubstitutionNonTerminalNode, nonTerminalNode);
+
+      metaSubstitutionNodeMatches = metaSubstitutionNonTerminalNodeMatches; ///
+    }
+  }
+
+  return metaSubstitutionNodeMatches;
+}
+
+function matchMetaSubstitutionChildNodes(metaSubstitutionChildNodes, childNodes) {
+  let metaSubstitutionChildNodesMatches = false;
+
+  const childNodesLength = childNodes.length,
+        metaSubstitutionChildNodesLength = metaSubstitutionChildNodes.length;
+
+  if (childNodesLength === metaSubstitutionChildNodesLength) {
+    metaSubstitutionChildNodesMatches = childNodes.every((childNode, index) => {
+      const metaSubstitutionChildNode = metaSubstitutionChildNodes[index],
+            metaSubstitutionNode = metaSubstitutionChildNode, ///
+            node = childNode, ///
+            metaSubstitutionNodeMatches = matchMetaSubstitutionNode(metaSubstitutionNode, node);
+
+      if (metaSubstitutionNodeMatches) {
+        return true;
+      }
+    })
+  }
+
+  return metaSubstitutionChildNodesMatches;
+}
+
+function matchMetaSubstitutionTerminalNode(metaSubstitutionTerminalNode, terminalNode) {
+  let metaSubstitutionTerminalNodeMatches = false;
+
+  const matches = metaSubstitutionTerminalNode.match(terminalNode);
+
+  if (matches) {
+    metaSubstitutionTerminalNodeMatches = true;
+  }
+
+  return metaSubstitutionTerminalNodeMatches;
+}
+
+function matchMetaSubstitutionNonTerminalNode(metaSubstitutionNonTerminalNode, nonTerminalNode) {
+  let metaSubstitutionNonTerminalNodeMatches = false;
+
+  const ruleName = nonTerminalNode.getRuleName(),
+        metaSubstitutionRuleName = metaSubstitutionNonTerminalNode.getRuleName(); ///
+
+  if (ruleName === metaSubstitutionRuleName) {
+    const childNodes = nonTerminalNode.getChildNodes(),
+          metaSubstitutionChildNodes = metaSubstitutionNonTerminalNode.getChildNodes(),
+          metaSubstitutionChildNodesMatches = matchMetaSubstitutionChildNodes(metaSubstitutionChildNodes, childNodes);
+
+    metaSubstitutionNonTerminalNodeMatches = metaSubstitutionChildNodesMatches; ///
+  }
+
+  return metaSubstitutionNonTerminalNodeMatches;
+}

package/bin/premise.js

@@ -1,19 +1,150 @@
 "use strict";
 
+const MetaSubstitution = require("./metaSubstitution");
+
+const { METAVARIABLE_RULE_NAME } = require("./ruleNames"),
+      { metavariableNameFromMetavariableNode } = require("./utilities/query");
+
 class Premise {
-  constructor(metastatementNodes) {
-    this.metastatementNodes = metastatementNodes;
+  constructor(metastatementNode) {
+    this.metastatementNode = metastatementNode;
+  }
+
+  getMetastatementNode() {
+    return this.metastatementNode;
   }
 
-  getMetastatementNodes() {
-    return this.metastatementNodes;
+  matchNonTerminalNode(nonTerminalNode, metaSubstitutions) {
+    const premiseNonTerminalNode = this.metastatementNode,  ///
+          premiseNonTerminalNodeMatches = matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions),
+          nonTerminalNodeMatches = premiseNonTerminalNodeMatches; ///
+
+    return nonTerminalNodeMatches;
   }
 
-  static fromMetastatementNodes(metastatementNodes) {
-    const premise = new Premise(metastatementNodes);
+  static fromMetastatementNode(metastatementNode) {
+    const premise = new Premise(metastatementNode);
 
     return premise;
   }
 }
 
 module.exports = Premise;
+
+function matchPremiseNode(premiseNode, node, metaSubstitutions) {
+  let premiseNodeMatches = false;
+
+  const nodeTerminalNode = node.isTerminalNode(),
+        ruleNodeTerminalNode = premiseNode.isTerminalNode();
+
+  if (nodeTerminalNode === ruleNodeTerminalNode) {
+    if (nodeTerminalNode) {
+      const terminalNode = node,  ///
+            premiseTerminalNode = premiseNode,  ///
+            premiseTerminalNodeMatches = matchPremiseTerminalNode(premiseTerminalNode, terminalNode, metaSubstitutions);
+
+      premiseNodeMatches = premiseTerminalNodeMatches;  ///
+    } else {
+      const nonTerminalNode = node, ///
+            premiseNonTerminalNode = premiseNode,  ///
+            premiseNonTerminalNodeMatches = matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions);
+
+      premiseNodeMatches = premiseNonTerminalNodeMatches; ///
+    }
+  }
+
+  return premiseNodeMatches;
+}
+
+function matchPremiseChildNodes(premiseChildNodes, childNodes, metaSubstitutions) {
+  let premiseChildNodesMatches = false;
+
+  const childNodesLength = childNodes.length,
+      premiseChildNodesLength = premiseChildNodes.length;
+
+  if (childNodesLength === premiseChildNodesLength) {
+    premiseChildNodesMatches = childNodes.every((childNode, index) => {
+      const premiseChildNode = premiseChildNodes[index],
+            premiseNode = premiseChildNode, ///
+            node = childNode, ///
+            premiseNodeMatches = matchPremiseNode(premiseNode, node, metaSubstitutions);
+
+      if (premiseNodeMatches) {
+        return true;
+      }
+    })
+  }
+
+  return premiseChildNodesMatches;
+}
+
+function matchPremiseMetavariable(premiseMetavariableNode, nonTerminalNode, metaSubstitutions) {
+  let premiseMetavariableMatches;
+
+  const premiseMetavariableName = metavariableNameFromMetavariableNode(premiseMetavariableNode),
+        metaSubstitution = metaSubstitutions.find((metaSubstitution) => {
+        const metavariableName = metaSubstitution.getMetavariableName();
+
+        if (metavariableName === premiseMetavariableName) {
+          return true;
+        }
+      }) || null;
+
+  if (metaSubstitution !== null) {
+    const nonTerminalNodeMatches = metaSubstitution.matchNonTerminalNode(nonTerminalNode);
+
+    premiseMetavariableMatches = nonTerminalNodeMatches;  ///
+  } else {
+    const metavariableName = premiseMetavariableName, ///
+          metaSubstitution = MetaSubstitution.fromMetavariableNameAndNonTerminalNode(metavariableName, nonTerminalNode);
+
+    metaSubstitutions.push(metaSubstitution);
+
+    premiseMetavariableMatches = true;
+  }
+
+  return premiseMetavariableMatches;
+}
+
+function matchPremiseTerminalNode(premiseTerminalNode, terminalNode, metaSubstitutions) {
+  let premiseTerminalNodeMatches = false;
+
+  const matches = premiseTerminalNode.match(terminalNode);
+
+  if (matches) {
+    premiseTerminalNodeMatches = true;
+  }
+
+  return premiseTerminalNodeMatches;
+}
+
+function matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions) {
+  let premiseNonTerminalNodeMatches = false;
+
+  const premiseRuleName = premiseNonTerminalNode.getRuleName(); ///
+
+  switch (premiseRuleName) {
+    case METAVARIABLE_RULE_NAME: {
+      const premiseMetavariableNode = premiseNonTerminalNode, ///
+            premiseMetavariableMatches = matchPremiseMetavariable(premiseMetavariableNode, nonTerminalNode, metaSubstitutions);
+
+      premiseNonTerminalNodeMatches = premiseMetavariableMatches;
+
+      break;
+    }
+
+    default: {
+      const ruleName = nonTerminalNode.getRuleName();
+
+      if (ruleName === premiseRuleName) {
+        const childNodes = nonTerminalNode.getChildNodes(),
+              premiseChildNodes = premiseNonTerminalNode.getChildNodes(),
+              premiseChildNodesMatches = matchPremiseChildNodes(premiseChildNodes, childNodes, metaSubstitutions);
+
+        premiseNonTerminalNodeMatches = premiseChildNodesMatches; ///
+      }
+    }
+  }
+
+  return premiseNonTerminalNodeMatches;
+}

package/bin/rule.js

@@ -1,41 +1,44 @@
 "use strict";
 
-const { labelsAsString } = require("./utilities/string");
+const { labelsAsString } = require("./utilities/string"),
+      { prune, someCombination } = require("./utilities/array");
 
 class Rule {
-  constructor(labels, premise, conclusion, metastatementNode) {
+  constructor(labels, premises, conclusion) {
     this.labels = labels;
-    this.premise = premise;
+    this.premises = premises;
     this.conclusion = conclusion;
-    this.metastatementNode = metastatementNode;
   }
 
   getLabels() {
     return this.labels;
   }
 
-  getPremise() {
-    return this.premise;
+  getPremises() {
+    return this.premises;
   }
 
   getConclusion() {
     return this.conclusion;
   }
 
-  getPremiseMetastatementNodes() {
-    const metastatementNodes = (this.premise !== null) ?
-                                  this.premise.getMetastatementNodes() :
-                                    [];
+  matchMetastatement(metastatementNode, context) {
+    let metastatementNodes = context.getMetastatementNodes();
 
-    return metastatementNodes;
-  }
+    const premisesLength = this.premises.length,
+          start = -premisesLength;
+
+    metastatementNodes = metastatementNodes.slice(start); ///
+
+    const matchesMetastatement = someCombination(metastatementNodes, (metastatementNodes) => {
+      const premisesMatchConclusion = matchPremisesAndConclusion(this.premises, this.conclusion, metastatementNodes, metastatementNode);
 
-  getConclusionMetastatementNode() {
-    const metastatementNode = (this.conclusion !== null) ?
-                                 this.conclusion.getMetastatementNode() :
-                                   this.metastatementNode;
+      if (premisesMatchConclusion) {
+        return true;
+      }
+    });
 
-    return metastatementNode;
+    return matchesMetastatement;
   }
 
   asString() {
@@ -44,21 +47,61 @@ class Rule {
     return string;
   }
 
-  static fromMetastatementNodeAndLabels(metastatementNode, labels) {
-    const premise = null,
-          conclusion = null,
-          rule = new Rule(labels, premise, conclusion, metastatementNode);
+  static fromPremisesConclusionAndLabels(premises, conclusion, labels) {
+    const rule = new Rule(labels, premises, conclusion);
 
     return rule;
   }
+}
 
-  static fromPremiseConclusionAndLabels(premise, conclusion, labels) {
-    const metastatementNode = null,
-          rule = new Rule(labels, premise, conclusion, metastatementNode);
+module.exports = Rule;
 
-    return rule;
-  }
+function matchPremise(premise, metastatementNodes, metaSubstitutions) {
+  const metastatementNode = prune(metastatementNodes, (metastatementNode) => {
+    const nonTerminalNode = metastatementNode,  ///
+          nonTerminalNodeMatches = premise.matchNonTerminalNode(nonTerminalNode, metaSubstitutions);
+
+    if (!nonTerminalNodeMatches) {  ///
+      return true;
+    }
+  }) || null;
+
+  const premiseMatches = (metastatementNode !== null);
+
+  return premiseMatches;
 }
 
-module.exports = Rule;
+function matchPremises(premise, metastatementNodes, metaSubstitutions) {
+  const premisesMatches = premise.every((premise) => {
+    const premiseMatches = matchPremise(premise, metastatementNodes, metaSubstitutions);
+
+    if (premiseMatches) {
+      return true;
+    }
+  });
 
+  return premisesMatches;
+}
+
+function matchConclusion(conclusion, metastatementNode, metaSubstitutions) {
+  const nonTerminalNode = metastatementNode,  ///
+        nonTerminalNodeMatches = conclusion.matchNonTerminalNode(nonTerminalNode, metaSubstitutions),
+        conclusionMatches = nonTerminalNodeMatches; ///
+
+  return conclusionMatches;
+}
+
+function matchPremisesAndConclusion(premises, conclusion, metastatementNodes, metastatementNode) {
+  let premisesMatchConclusion = false;
+
+  const metaSubstitutions = [],
+        premisesMatches = matchPremises(premises, metastatementNodes, metaSubstitutions);
+
+  if (premisesMatches) {
+    const conclusionMatches = matchConclusion(conclusion, metastatementNode, metaSubstitutions);
+
+    premisesMatchConclusion = conclusionMatches;  ///
+  }
+
+  return premisesMatchConclusion;
+}

package/bin/verify/metaAntecedent.js

@@ -1,14 +1,12 @@
 "use strict";
 
-const MetaAntecedent = require("../metaAntecedent"),
-      verifyUnqualifiedMetastatement = require("../verify/metastatement/unqualified");
+const verifyUnqualifiedMetastatement = require("../verify/metastatement/unqualified");
 
-const { nodeQuery, nodesQuery } = require("../utilities/query");
+const { nodesQuery } = require("../utilities/query");
 
-const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement"),
-      unqualifiedMetastatementNodesQuery = nodesQuery("/metaAntecedent/unqualifiedMetastatement");
+const unqualifiedMetastatementNodesQuery = nodesQuery("/metaAntecedent/unqualifiedMetastatement");
 
-function verifyMetaAntecedent(metaAntecedentNode, metaAntecedents, context) {
+function verifyMetaAntecedent(metaAntecedentNode, context) {
   const unqualifiedMetastatementNodes = unqualifiedMetastatementNodesQuery(metaAntecedentNode),
         metaAntecedentVerified = unqualifiedMetastatementNodes.every((unqualifiedMetastatementNode) => {
           const unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
@@ -18,17 +16,6 @@ function verifyMetaAntecedent(metaAntecedentNode, metaAntecedents, context) {
           }
         });
 
-  if (metaAntecedentVerified) {
-    const metastatementNodes = unqualifiedMetastatementNodes.map((unqualifiedMetastatementNode) => {
-            const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
-
-            return metastatementNode;
-          }),
-          metaAntecedent = MetaAntecedent.fromMetastatementNodes(metastatementNodes);
-
-    metaAntecedents.push(metaAntecedent);
-  }
-
   return metaAntecedentVerified;
 }
 

package/bin/verify/metaConsequent.js

@@ -1,12 +1,10 @@
 "use strict";
 
-const MetaConsequent = require("../metaConsequent"),
-      verifyUnqualifiedMetaStatement = require("../verify/metastatement/unqualified");
+const verifyUnqualifiedMetaStatement = require("../verify/metastatement/unqualified");
 
 const { nodeQuery } = require("../utilities/query");
 
-const metastatementNodeQuery = nodeQuery("/unqualifiedMetaStatement/metastatement!"),
-      unqualifiedMetaStatementNodeQuery = nodeQuery("/metaConsequent/unqualifiedMetaStatement!");
+const unqualifiedMetaStatementNodeQuery = nodeQuery("/metaConsequent/unqualifiedMetaStatement!");
 
 function verifyMetaConsequent(metaConsequentNode, metaConsequents, context) {
   let metaConsequentVerified = false;
@@ -16,14 +14,7 @@ function verifyMetaConsequent(metaConsequentNode, metaConsequents, context) {
   if (unqualifiedMetaStatementNode !== null) {
     const unqualifiedMetaStatementVerified = verifyUnqualifiedMetaStatement(unqualifiedMetaStatementNode, context);
 
-    if (unqualifiedMetaStatementVerified) {
-      const metastatementNode = metastatementNodeQuery(unqualifiedMetaStatementNode),
-            metaConsequent = MetaConsequent.fromMetaStatementNode(metastatementNode);
-
-      metaConsequents.push(metaConsequent);
-
-      metaConsequentVerified = true;
-    }
+    metaConsequentVerified = unqualifiedMetaStatementVerified;
   }
 
   return metaConsequentVerified;

package/bin/verify/metaDerivation.js

@@ -10,16 +10,16 @@ const { nodeQuery, nodesQuery } = require("../utilities/query"),
 
 const metaAntecedentNodeQuery = nodeQuery("/metaSublemma/metaAntecedent!"),
       metaDerivationNodeQuery = nodeQuery("/metaSublemma/metaDerivation!"),
-      metaSublemmaChildNodesQuery = nodesQuery("/metaDerivation/*"),
+      metaDerivationChildNodesQuery = nodesQuery("/metaDerivation/*"),
       qualifiedMetastatementNodeQuery = nodeQuery("/metaSublemma/qualifiedMetastatement!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/metaSublemma/unqualifiedMetastatement!");
 
-function verifyMetaDerivation(metaNode, context) {
+function verifyMetaDerivation(metaDerivationNode, context) {
   const derived = true;
 
   context.setDerived(derived);
 
-  const metaSublemmaChildNodes = metaSublemmaChildNodesQuery(metaNode),
+  const metaSublemmaChildNodes = metaDerivationChildNodesQuery(metaDerivationNode),
         metaSublemmaChildNodesVerified = metaSublemmaChildNodes.every((metaSublemmaChildNode) => {
           let metaSublemmaChildNodeVerified;
 
@@ -70,9 +70,8 @@ function verifyMetaSublemma(metaSublemmaNode, context) {
 
   context = metaproofContext; ///
 
-  const metaAntecedents = [],
-        metaAntecedentNode = metaAntecedentNodeQuery(metaSublemmaNode),
-        metaAntecedentVerified = verifyMetaAntecedent(metaAntecedentNode, metaAntecedents, context);
+  const metaAntecedentNode = metaAntecedentNodeQuery(metaSublemmaNode),
+        metaAntecedentVerified = verifyMetaAntecedent(metaAntecedentNode, context);
 
   if (metaAntecedentVerified) {
     let metaDerivationVerified = true;

package/bin/verify/metaproof.js

@@ -27,16 +27,18 @@ function verifyMetaproof(metaproofNode, rules, context) {
           qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, context);
 
     if (qualifiedMetastatementVerified) {
-      const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
-            firstRule = first(rules),
-            rule = firstRule, ///
-            metastatementString = nodeAsString(metastatementNode),
-            conclusionMetastatementNode = rule.getConclusionMetastatementNode(),
-            conclusionMetastatementString = nodeAsString(conclusionMetastatementNode);
-
-      if (metastatementString === conclusionMetastatementString) {
-        metaproofVerified = true;
-      }
+      debugger
+
+      // const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
+      //       firstRule = first(rules),
+      //       rule = firstRule, ///
+      //       metastatementString = nodeAsString(metastatementNode),
+      //       conclusionMetastatementNode = rule.getConclusionMetastatementNode(),
+      //       conclusionMetastatementString = nodeAsString(conclusionMetastatementNode);
+      //
+      // if (metastatementString === conclusionMetastatementString) {
+      //   metaproofVerified = true;
+      // }
     }
   }
 

package/bin/verify/metastatement/qualified.js

@@ -2,8 +2,7 @@
 
 const { loggingUtilities } = require("necessary");
 
-const { matchRule } = require("../../utilities/rule"),
-      { nodeAsString } = require("../../utilities/string"),
+const { nodeAsString } = require("../../utilities/string"),
       { nodeQuery, referenceNameFromReferenceNode } = require("../../utilities/query");
 
 const { log } = loggingUtilities;
@@ -22,9 +21,9 @@ function verifyQualifiedMetastatement(qualifiedMetastatementNode, context) {
           rule = context.findRuleByReferenceName(referenceName);
 
     if (rule !== null) {
-      const ruleMatches = matchRule(rule, metastatementNode, context);
+      const ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, context);
 
-      if (ruleMatches) {
+      if (ruleMatchesMetastatement) {
         context.addMetastatementNode(metastatementNode);
 
         const metastatementString = nodeAsString(metastatementNode);
@@ -40,4 +39,3 @@ function verifyQualifiedMetastatement(qualifiedMetastatementNode, context) {
 }
 
 module.exports = verifyQualifiedMetastatement;
-

package/bin/verify/{premise.js → premiseOrPremises.js}

@@ -8,9 +8,9 @@ const { nodeQuery, nodesQuery } = require("../utilities/query");
 const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement"),
       unqualifiedMetastatementNodesQuery = nodesQuery("/premise|premises/unqualifiedMetastatement");
 
-function verifyPremise(premiseNode, premises, context) {
-  const unqualifiedMetastatementNodes = unqualifiedMetastatementNodesQuery(premiseNode),
-        premiseVerified = unqualifiedMetastatementNodes.every((unqualifiedMetastatementNode) => {
+function verifyPremiseOrPremises(premiseOrPremisesNode, premises, context) {
+  const unqualifiedMetastatementNodes = unqualifiedMetastatementNodesQuery(premiseOrPremisesNode),
+        premiseOrPremisesVerified = unqualifiedMetastatementNodes.every((unqualifiedMetastatementNode) => {
           const unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
 
           if (unqualifiedMetastatementVerified) {
@@ -18,18 +18,16 @@ function verifyPremise(premiseNode, premises, context) {
           }
         });
 
-  if (premiseVerified) {
-    const metastatementNodes = unqualifiedMetastatementNodes.map((unqualifiedMetastatementNode) => {
-            const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
+  if (premiseOrPremisesVerified) {
+    unqualifiedMetastatementNodes.forEach((unqualifiedMetastatementNode) => {
+      const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
+            premise = Premise.fromMetastatementNode(metastatementNode);
 
-            return metastatementNode;
-          }),
-          premise = Premise.fromMetastatementNodes(metastatementNodes);
-
-    premises.push(premise);
+      premises.push(premise);
+    });
   }
 
-  return premiseVerified;
+  return premiseOrPremisesVerified;
 }
 
-module.exports = verifyPremise;
+module.exports = verifyPremiseOrPremises;

package/bin/verify/rule/inferenceConditional.js

@@ -2,15 +2,15 @@
 
 const Rule = require("../../rule"),
       verifyLabels = require("../../verify/labels"),
-      verifyPremise = require("../../verify/premise"),
-      verifyConclusion = require("../../verify/conclusion");
+      verifyConclusion = require("../../verify/conclusion"),
+      verifyPremiseOrPremises = require("../../verify/premiseOrPremises");
 
 const { first } = require("../../utilities/array"),
       { nodeQuery, nodesQuery } = require("../../utilities/query");
 
 const labelNodesQuery = nodesQuery("/rule/label"),
-      premiseNodeQuery = nodeQuery("/inferenceConditional/premise|premises!"),
       conclusionNodeQuery = nodeQuery("/inferenceConditional/conclusion!"),
+      premiseOrPremisesNodeQuery = nodeQuery("/inferenceConditional/premise|premises!"),
       inferenceConditionalNodeQuery = nodeQuery("/rule/inferenceConditional!");
 
 function verifyInferenceConditionalRule(ruleNode, rules, context) {
@@ -25,20 +25,18 @@ function verifyInferenceConditionalRule(ruleNode, rules, context) {
 
     if (labelsVerified) {
       const premises = [],
-            premiseNode = premiseNodeQuery(inferenceConditionalNode),
-            premiseVerified = verifyPremise(premiseNode, premises, context);
+            premiseOrPremisesNode = premiseOrPremisesNodeQuery(inferenceConditionalNode),
+            premiseOrPremisesVerified = verifyPremiseOrPremises(premiseOrPremisesNode, premises, context);
 
-      if (premiseVerified) {
+      if (premiseOrPremisesVerified) {
         const conclusions = [],
               conclusionNode = conclusionNodeQuery(inferenceConditionalNode),
               conclusionVerified = verifyConclusion(conclusionNode, conclusions, context);
 
         if (conclusionVerified) {
-          const firstPremise = first(premises),
-                firstConclusion = first(conclusions),
-                premise = firstPremise, ///
+          const firstConclusion = first(conclusions),
                 conclusion = firstConclusion, ///
-                rule = Rule.fromPremiseConclusionAndLabels(premise, conclusion, labels);
+                rule = Rule.fromPremisesConclusionAndLabels(premises, conclusion, labels);
 
           rules.push(rule);
 

package/bin/verify/rule/unqualifiedMetastatement.js

@@ -1,6 +1,7 @@
 "use strict";
 
 const Rule = require("../../rule"),
+      Conclusion = require("../../conclusion"),
       verifyLabels = require("../../verify/labels"),
       verifyUnqualifiedMetastatement = require("../../verify/metastatement/unqualified");
 
@@ -25,7 +26,9 @@ function verifyUnqualifiedMetastatementRule(ruleNode, rules, context) {
 
       if (unqualifiedMetastatementVerified) {
         const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
-              rule = Rule.fromMetastatementNodeAndLabels(metastatementNode, labels);
+              conclusion = Conclusion.fromMetastatementNode(metastatementNode),
+              premises = [],
+              rule = Rule.fromPremisesConclusionAndLabels(premises, conclusion, labels);
 
         rules.push(rule);
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "0.0.262",
+  "version": "0.0.263",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",
@@ -12,10 +12,10 @@
   "dependencies": {
     "argumentative": "^2.0.15",
     "necessary": "^11.0.40",
-    "occam-custom-grammars": "^5.0.342",
+    "occam-custom-grammars": "^5.0.344",
     "occam-dom": "^3.0.171",
     "occam-grammar-utilities": "^7.0.66",
-    "occam-grammars": "^1.0.309",
+    "occam-grammars": "^1.0.311",
     "occam-open-cli": "^5.0.37",
     "occam-parsers": "^16.0.122"
   },

package/bin/metaAntecedent.js

@@ -1,19 +0,0 @@
-"use strict";
-
-class MetaAntecedent {
-  constructor(metastatementNodes) {
-    this.metastatementNodes = metastatementNodes;
-  }
-
-  getMetastatementNodes() {
-    return this.metastatementNodes;
-  }
-
-  static fromMetastatementNodes(metastatementNodes) {
-    const metaAntecedent = new MetaAntecedent(metastatementNodes);
-
-    return metaAntecedent;
-  }
-}
-
-module.exports = MetaAntecedent;

package/bin/metaConsequent.js

@@ -1,19 +0,0 @@
-"use strict";
-
-class MetaConsequent {
-  constructor(metastatementNode) {
-    this.metastatementNode = metastatementNode;
-  }
-
-  getMetastatementNode() {
-    return this.metastatementNode;
-  }
-
-  static fromStatementNode(metastatementNode) {
-    const metaConsequent = new MetaConsequent(metastatementNode);
-
-    return metaConsequent;
-  }
-}
-
-module.exports = MetaConsequent;

package/bin/utilities/rule.js

@@ -1,279 +0,0 @@
-"use strict";
-
-const MetaSubstitution = require("../metaSubstitution");
-
-const { nodeAsString } = require("../utilities/string"),
-      { prune, someCombination } = require("../utilities/array"),
-      { METAVARIABLE_RULE_NAME } = require("../ruleNames"),
-      { metavariableNameFromMetavariableNode } = require("../utilities/query");
-
-function matchRule(rule, metastatementNode, context) {
-  let metastatementNodes = context.getMetastatementNodes();
-
-  const premiseMetastatementNodes = rule.getPremiseMetastatementNodes(),
-        conclusionMetastatementNode = rule.getConclusionMetastatementNode(),
-        premiseMetastatementNodesLength = premiseMetastatementNodes.length,
-        start = -premiseMetastatementNodesLength;
-
-  metastatementNodes = metastatementNodes.slice(start); ///
-
-  const ruleMatches = someCombination(metastatementNodes, (metastatementNodes) => {
-    const premisesMatchConclusion = matchPremisesAndConclusion(premiseMetastatementNodes, conclusionMetastatementNode, metastatementNodes, metastatementNode, context);
-
-    if (premisesMatchConclusion) {
-      return true;
-    }
-  });
-
-  return ruleMatches;
-}
-
-module.exports = {
-  matchRule
-};
-
-function matchPremisesAndConclusion(premiseMetastatementNodes, conclusionMetastatementNode, metastatementNodes, metastatementNode, context) {
-  let premisesMatchConclusion = false;
-
-  const metaSubstitutions = [],
-        premisesMatch = matchPremises(premiseMetastatementNodes, metastatementNodes, metaSubstitutions, context);
-
-  if (premisesMatch) {
-    const conclusionNonTerminalNode = matchConclusion(conclusionMetastatementNode, metaSubstitutions), ///
-          conclusionMetastatementString = nodeAsString(conclusionNonTerminalNode),
-          metastatementString = nodeAsString(metastatementNode);
-
-    premisesMatchConclusion = (metastatementString === conclusionMetastatementString);
-  }
-
-  return premisesMatchConclusion;
-}
-
-function matchPremises(premiseMetastatementNodes, metastatementNodes, metaSubstitutions) {
-  const premisesMatches = premiseMetastatementNodes.every((premiseMetastatementNode) => {
-    const premiseMatches = matchPremise(premiseMetastatementNode, metastatementNodes, metaSubstitutions);
-
-    if (premiseMatches) {
-      return true;
-    }
-  });
-
-  return premisesMatches;
-}
-
-function matchPremise(premiseMetastatementNode, metastatementNodes, metaSubstitutions) {
-  const metastatementNode = prune(metastatementNodes, (metastatementNode) => {
-    const nonTerminalNode = metastatementNode,  ///
-          premiseNonTerminalNode = premiseMetastatementNode,  ///
-          premiseNonTerminalNodeMatches = matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions);
-
-    if (!premiseNonTerminalNodeMatches) {
-      return true;
-    }
-  }) || null;
-
-  const premiseMatches = (metastatementNode !== null);
-
-  return premiseMatches;
-}
-
-function matchPremiseNode(premiseNode, node, metaSubstitutions) {
-  let premiseNodeMatches = false;
-
-  const nodeTerminalNode = node.isTerminalNode(),
-        ruleNodeTerminalNode = premiseNode.isTerminalNode();
-
-  if (nodeTerminalNode === ruleNodeTerminalNode) {
-    if (nodeTerminalNode) {
-      const terminalNode = node,  ///
-            premiseTerminalNode = premiseNode,  ///
-            premiseTerminalNodeMatches = matchPremiseTerminalNode(premiseTerminalNode, terminalNode, metaSubstitutions);
-
-      premiseNodeMatches = premiseTerminalNodeMatches;  ///
-    } else {
-      const nonTerminalNode = node, ///
-            premiseNonTerminalNode = premiseNode,  ///
-            premiseNonTerminalNodeMatches = matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions);
-
-      premiseNodeMatches = premiseNonTerminalNodeMatches; ///
-    }
-  }
-
-  return premiseNodeMatches;
-}
-
-function matchPremiseChildNodes(premiseChildNodes, childNodes, metaSubstitutions) {
-  let premiseChildNodesMatches = false;
-
-  const childNodesLength = childNodes.length,
-        premiseChildNodesLength = premiseChildNodes.length;
-
-  if (childNodesLength === premiseChildNodesLength) {
-    premiseChildNodesMatches = childNodes.every((childNode, index) => {
-      const premiseChildNode = premiseChildNodes[index],
-            premiseNode = premiseChildNode, ///
-            node = childNode, ///
-            premiseNodeMatches = matchPremiseNode(premiseNode, node, metaSubstitutions);
-
-      if (premiseNodeMatches) {
-        return true;
-      }
-    })
-  }
-
-  return premiseChildNodesMatches;
-}
-
-function matchPremiseMetavariable(premiseMetavariableNode, nonTerminalNode, metaSubstitutions) {
-  let premiseMetavariableMatches = false;
-
-  const premiseMetavariableName = metavariableNameFromMetavariableNode(premiseMetavariableNode),
-        nonTerminalString = nodeAsString(nonTerminalNode),
-        metaSubstitution = metaSubstitutions.find((metaSubstitution) => {
-          const metavariableName = metaSubstitution.getMetavariableName();
-
-          if (metavariableName === premiseMetavariableName) {
-            return true;
-          }
-        }) || null;
-
-  if (metaSubstitution !== null) {
-    const metaSubstitutionNonTerminalNode = metaSubstitution.getNonTerminalNode(),
-          metaSubstitutionNonTerminalString = nodeAsString(metaSubstitutionNonTerminalNode);
-
-    if (nonTerminalString === metaSubstitutionNonTerminalString) {
-      premiseMetavariableMatches = true;
-    }
-  } else {
-    const metavariableName = premiseMetavariableName, ///
-          metaSubstitution = MetaSubstitution.fromMetavariableNameAndNonTerminalNode(metavariableName, nonTerminalNode);
-
-    metaSubstitutions.push(metaSubstitution);
-
-    premiseMetavariableMatches = true;
-  }
-
-  return premiseMetavariableMatches;
-}
-
-function matchPremiseTerminalNode(premiseTerminalNode, terminalNode, metaSubstitutions) {
-  let premiseTerminalNodeMatches = false;
-
-  const matches = premiseTerminalNode.match(terminalNode);
-
-  if (matches) {
-    premiseTerminalNodeMatches = true;
-  }
-
-  return premiseTerminalNodeMatches;
-}
-
-function matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions) {
-  let premiseNonTerminalNodeMatches = false;
-
-  const premiseRuleName = premiseNonTerminalNode.getRuleName(); ///
-
-  switch (premiseRuleName) {
-    case METAVARIABLE_RULE_NAME: {
-      const premiseMetavariableNode = premiseNonTerminalNode, ///
-            premiseMetavariableMatches = matchPremiseMetavariable(premiseMetavariableNode, nonTerminalNode, metaSubstitutions);
-
-      premiseNonTerminalNodeMatches = premiseMetavariableMatches;
-
-      break;
-    }
-
-    default: {
-      const ruleName = nonTerminalNode.getRuleName();
-
-      if (ruleName === premiseRuleName) {
-        const childNodes = nonTerminalNode.getChildNodes(),
-              premiseChildNodes = premiseNonTerminalNode.getChildNodes(),
-              premiseChildNodesMatches = matchPremiseChildNodes(premiseChildNodes, childNodes, metaSubstitutions);
-
-        premiseNonTerminalNodeMatches = premiseChildNodesMatches; ///
-      }
-    }
-  }
-
-  return premiseNonTerminalNodeMatches;
-}
-
-function matchConclusion(conclusionMetastatementNode, metaSubstitutions) {
-  let conclusionNonTerminalNode = conclusionMetastatementNode;  ///
-
-  conclusionNonTerminalNode = conclusionNonTerminalNode.clone();
-
-  conclusionNonTerminalNode = matchConclusionNonTerminalNode(conclusionNonTerminalNode, metaSubstitutions);
-
-  return conclusionNonTerminalNode;
-}
-
-function matchConclusionNode(conclusionNode, metaSubstitutions) {
-  const conclusionNodeNonTerminalNode = conclusionNode.isNonTerminalNode();
-
-  if (conclusionNodeNonTerminalNode) {
-    let conclusionNonTerminalNode = conclusionNode; ///
-
-    conclusionNonTerminalNode = matchConclusionNonTerminalNode(conclusionNonTerminalNode, metaSubstitutions);
-
-    conclusionNode = conclusionNonTerminalNode; ///
-  }
-
-  return conclusionNode;
-}
-
-function matchConclusionChildNodes(conclusionChildNodes, metaSubstitutions) {
-  conclusionChildNodes = conclusionChildNodes.map((conclusionChildNode) => {
-    let conclusionNode = conclusionChildNode; ///
-
-    conclusionNode = matchConclusionNode(conclusionNode, metaSubstitutions);
-
-    conclusionChildNode = conclusionNode; ///
-
-    return conclusionChildNode;
-  });
-
-  return conclusionChildNodes;
-}
-
-function matchConclusionNonTerminalNode(conclusinNonTerminalNode, metaSubstitutions) {
-  const ruleName = conclusinNonTerminalNode.getRuleName();
-
-  if (ruleName === METAVARIABLE_RULE_NAME) {
-    let conclusionMetaVariableNode = conclusinNonTerminalNode; ///
-
-    conclusinNonTerminalNode = matchConclusionMetavariableNode(conclusionMetaVariableNode, metaSubstitutions);
-  } else {
-    let childNodes = conclusinNonTerminalNode.getChildNodes();
-
-    let conclusionChildNodes = childNodes;  ///
-
-    conclusionChildNodes = matchConclusionChildNodes(conclusionChildNodes, metaSubstitutions);
-
-    childNodes = conclusionChildNodes;  ///
-
-    conclusinNonTerminalNode.setChildNodes(childNodes);
-  }
-
-  return conclusinNonTerminalNode;
-}
-
-function matchConclusionMetavariableNode(conclusionMetavariableNode, metaSubstitutions) {
-  const conclusionMetavariableName = metavariableNameFromMetavariableNode(conclusionMetavariableNode),
-        metaSubstitution = metaSubstitutions.find((metaSubstitution) => {
-          const metavariableName = metaSubstitution.getMetavariableName();
-
-          if (metavariableName === conclusionMetavariableName) {
-            return true;
-          }
-        });
-
-  let nonTerminalNode = metaSubstitution.getNonTerminalNode();  ///
-
-  nonTerminalNode = nonTerminalNode.clone();  ///
-
-  const conclusionNonTerminalNode = nonTerminalNode;  ///
-
-  return conclusionNonTerminalNode;
-}