occam-verify-cli 0.0.262 → 0.0.264

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/ruleNames.js

@@ -4,7 +4,7 @@ const TERM_RULE_NAME = "term",
       TYPE_RULE_NAME = "type",
       ARGUMENT_RULE_NAME = "argument",
       METAVARIABLE_RULE_NAME = "metavariable",
-      META_SUBLEMMA_RULE_NAME = "metaSublemma",
+      META_CONDITIONAL_PROOF_RULE_NAME = "metaConditionalProof",
       QUALIFIED_METASTATEMENT_RULE_NAME = "qualifiedMetastatement",
       UNQUALIFIED_METASTATEMENT_RULE_NAME = "unqualifiedMetastatement";
 
@@ -13,7 +13,7 @@ module.exports = {
   TYPE_RULE_NAME,
   ARGUMENT_RULE_NAME,
   METAVARIABLE_RULE_NAME,
-  META_SUBLEMMA_RULE_NAME,
+  META_CONDITIONAL_PROOF_RULE_NAME,
   QUALIFIED_METASTATEMENT_RULE_NAME,
   UNQUALIFIED_METASTATEMENT_RULE_NAME
 };

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;