occam-verify-cli 0.0.269 → 0.0.271

package/bin/premise.js

@@ -2,8 +2,14 @@
 
 const MetaSubstitution = require("./metaSubstitution");
 
-const { METAVARIABLE_RULE_NAME } = require("./ruleNames"),
-      { metavariableNameFromMetavariableNode } = require("./utilities/query");
+const { first, second } = require("./utilities/array"),
+      { nodeQuery, nodesQuery } = require("./utilities/query"),
+      { metavariableNameFromMetavariableNode } = require("./utilities/query"),
+      { METAVARIABLE_RULE_NAME, METASTATEMENT_RULE_NAME } = require("./ruleNames");
+
+const metastatementNodesQuery = nodesQuery("/metaSubproofAssertion/metastatement"),
+      metaSubproofAssertionNodeQuery = nodeQuery("/metastatement/metaSubproofAssertion!"),
+      qualifiedOrUnqualifiedMetastatementMetastatementNodesQuery = nodesQuery("/metaSubproof/qualifiedMetastatement|unqualifiedMetastatement/metastatement!");
 
 class Premise {
   constructor(metastatementNode) {
@@ -14,12 +20,43 @@ class Premise {
     return this.metastatementNode;
   }
 
-  matchNonTerminalNode(nonTerminalNode, metaSubstitutions) {
-    const premiseNonTerminalNode = this.metastatementNode,  ///
+  matchMetaSubproofNode(metaSubproofNode, metaSubstitutions) {
+    let metaSubproofNodeMatches = false;
+
+    const metaSubproofAssertionNode = metaSubproofAssertionNodeQuery(this.metastatementNode);
+
+    if (metaSubproofAssertionNode !== null) {
+      const metaSubproofAssertionMetastatementNodes = metastatementNodesQuery(metaSubproofAssertionNode),
+            firstMetaSubproofAssertionMetastatementNode = first(metaSubproofAssertionMetastatementNodes),
+            qualifiedOrUnqualifiedMetastatementMetastatementNodes = qualifiedOrUnqualifiedMetastatementMetastatementNodesQuery(metaSubproofNode),
+            firstQualifiedOrUnqualifiedMetastatementMetastatementNode = first(qualifiedOrUnqualifiedMetastatementMetastatementNodes);
+
+      const nonTerminalNode = firstQualifiedOrUnqualifiedMetastatementMetastatementNode, ///
+            premiseNonTerminalNode = firstMetaSubproofAssertionMetastatementNode,  ///
+            premiseNonTerminalNodeMatches = matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions);
+
+      if (premiseNonTerminalNodeMatches) {
+        const secondMetaSubproofAssertionMetastatementNode = second(metaSubproofAssertionMetastatementNodes),
+              secondQualifiedOrUnqualifiedMetastatementMetastatementNode = second(qualifiedOrUnqualifiedMetastatementMetastatementNodes);
+
+        const nonTerminalNode = secondQualifiedOrUnqualifiedMetastatementMetastatementNode, ///
+              premiseNonTerminalNode = secondMetaSubproofAssertionMetastatementNode, ///
+              premiseNonTerminalNodeMatches = matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions);
+
+        metaSubproofNodeMatches = premiseNonTerminalNodeMatches; ///
+      }
+    }
+
+    return metaSubproofNodeMatches;
+  }
+
+  matchMetastatementNode(metastatementNode, metaSubstitutions) {
+    const nonTerminalNode = metastatementNode,  ///
+          premiseNonTerminalNode = this.metastatementNode,  ///
           premiseNonTerminalNodeMatches = matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions),
-          nonTerminalNodeMatches = premiseNonTerminalNodeMatches; ///
+          metastatementNodeMatches = premiseNonTerminalNodeMatches; ///
 
-    return nonTerminalNodeMatches;
+    return metastatementNodeMatches;
   }
 
   static fromMetastatementNode(metastatementNode) {
@@ -56,47 +93,45 @@ function matchPremiseNode(premiseNode, node, metaSubstitutions) {
   return premiseNodeMatches;
 }
 
-function matchPremiseChildNodes(premiseChildNodes, childNodes, metaSubstitutions) {
-  let premiseChildNodesMatches = false;
+function matchPremiseNodes(premiseNodes, nodes, metaSubstitutions) {
+  let premiseNodesMatches = false;
 
-  const childNodesLength = childNodes.length,
-      premiseChildNodesLength = premiseChildNodes.length;
+  const nodesLength = nodes.length,
+        premiseNodesLength = premiseNodes.length;
 
-  if (childNodesLength === premiseChildNodesLength) {
-    premiseChildNodesMatches = childNodes.every((childNode, index) => {
-      const premiseChildNode = premiseChildNodes[index],
-            premiseNode = premiseChildNode, ///
-            node = childNode, ///
+  if (nodesLength === premiseNodesLength) {
+    premiseNodesMatches = nodes.every((node, index) => {
+      const premiseNode = premiseNodes[index],
             premiseNodeMatches = matchPremiseNode(premiseNode, node, metaSubstitutions);
 
       if (premiseNodeMatches) {
         return true;
       }
-    })
+    });
   }
 
-  return premiseChildNodesMatches;
+  return premiseNodesMatches;
 }
 
-function matchPremiseMetavariable(premiseMetavariableNode, nonTerminalNode, metaSubstitutions) {
+function matchPremiseMetavariable(premiseMetavariableNode, nodes, metaSubstitutions) {
   let premiseMetavariableMatches;
 
   const premiseMetavariableName = metavariableNameFromMetavariableNode(premiseMetavariableNode),
         metaSubstitution = metaSubstitutions.find((metaSubstitution) => {
-        const metavariableName = metaSubstitution.getMetavariableName();
+          const metavariableName = metaSubstitution.getMetavariableName();
 
-        if (metavariableName === premiseMetavariableName) {
-          return true;
-        }
-      }) || null;
+          if (metavariableName === premiseMetavariableName) {
+            return true;
+          }
+        }) || null;
 
   if (metaSubstitution !== null) {
-    const nonTerminalNodeMatches = metaSubstitution.matchNonTerminalNode(nonTerminalNode);
+    const metaSubstitutionNodesMatch = metaSubstitution.matchNodes(nodes);
 
-    premiseMetavariableMatches = nonTerminalNodeMatches;  ///
+    premiseMetavariableMatches = metaSubstitutionNodesMatch;  ///
   } else {
     const metavariableName = premiseMetavariableName, ///
-          metaSubstitution = MetaSubstitution.fromMetavariableNameAndNonTerminalNode(metavariableName, nonTerminalNode);
+          metaSubstitution = MetaSubstitution.fromMetavariableNameAndNodes(metavariableName, nodes);
 
     metaSubstitutions.push(metaSubstitution);
 
@@ -107,13 +142,8 @@ function matchPremiseMetavariable(premiseMetavariableNode, nonTerminalNode, meta
 }
 
 function matchPremiseTerminalNode(premiseTerminalNode, terminalNode, metaSubstitutions) {
-  let premiseTerminalNodeMatches = false;
-
-  const matches = premiseTerminalNode.match(terminalNode);
-
-  if (matches) {
-    premiseTerminalNodeMatches = true;
-  }
+  const matches = premiseTerminalNode.match(terminalNode),
+        premiseTerminalNodeMatches = matches;
 
   return premiseTerminalNodeMatches;
 }
@@ -121,30 +151,62 @@ function matchPremiseTerminalNode(premiseTerminalNode, terminalNode, metaSubstit
 function matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions) {
   let premiseNonTerminalNodeMatches = false;
 
-  const premiseRuleName = premiseNonTerminalNode.getRuleName(); ///
+  const ruleName = nonTerminalNode.getRuleName(),
+        premiseRuleName = premiseNonTerminalNode.getRuleName(); ///
+
+  if (ruleName === premiseRuleName) {
+    const childNodes = nonTerminalNode.getChildNodes(),
+          premiseChildNodes = premiseNonTerminalNode.getChildNodes(),
+          nodes = childNodes, ///
+          premiseNodes = premiseChildNodes, ///
+          premiseChildNodesMatches = matchPremiseNodes(premiseNodes, nodes, metaSubstitutions);
+
+    premiseNonTerminalNodeMatches = premiseChildNodesMatches; ///
 
-  switch (premiseRuleName) {
-    case METAVARIABLE_RULE_NAME: {
-      const premiseMetavariableNode = premiseNonTerminalNode, ///
-            premiseMetavariableMatches = matchPremiseMetavariable(premiseMetavariableNode, nonTerminalNode, metaSubstitutions);
+    if (!premiseNonTerminalNodeMatches) {
+      const ruleNameMetastatementRuleName = (ruleName === METASTATEMENT_RULE_NAME);
 
-      premiseNonTerminalNodeMatches = premiseMetavariableMatches;
+      if (ruleNameMetastatementRuleName) {
+        const metastatementNode = nonTerminalNode,  ///
+              premiseMetastatementNode = premiseNonTerminalNode,  ///
+              premiseMetastatementNodeMatches = matchPremiseMetastatementNode(premiseMetastatementNode, metastatementNode, metaSubstitutions);
 
-      break;
+        premiseNonTerminalNodeMatches = premiseMetastatementNodeMatches; ///
+      }
     }
+  }
 
-    default: {
-      const ruleName = nonTerminalNode.getRuleName();
+  return premiseNonTerminalNodeMatches;
+}
+
+function matchPremiseMetastatementNode(premiseMetastatementNode, metastatementNode, metaSubstitutions) {
+  let premiseMetastatementNodeMatches = false;
+
+  const premiseNonTerminalNode = premiseMetastatementNode,  ///
+        premiseChildNodes = premiseNonTerminalNode.getChildNodes(),
+        premiseChildNodesLength = premiseChildNodes.length;
 
-      if (ruleName === premiseRuleName) {
-        const childNodes = nonTerminalNode.getChildNodes(),
-              premiseChildNodes = premiseNonTerminalNode.getChildNodes(),
-              premiseChildNodesMatches = matchPremiseChildNodes(premiseChildNodes, childNodes, metaSubstitutions);
+  if (premiseChildNodesLength === 1) {
+    const firstPremiseChildNode = first(premiseChildNodes),
+          premiseChildNode = firstPremiseChildNode,  ///
+          premiseChildNodeNonTerminalNode = premiseChildNode.isNonTerminalNode();
 
-        premiseNonTerminalNodeMatches = premiseChildNodesMatches; ///
+    if (premiseChildNodeNonTerminalNode) {
+      const premiseNonTerminalChildNode = premiseChildNode,  ///
+            premiseNonTerminalChildNodeRuleName = premiseNonTerminalChildNode.getRuleName(),
+            premiseNonTerminalChildNodeRuleNameMetavariableRuleName = (premiseNonTerminalChildNodeRuleName === METAVARIABLE_RULE_NAME);
+
+      if (premiseNonTerminalChildNodeRuleNameMetavariableRuleName) {
+        const premiseMetavariableNode = premiseNonTerminalChildNode,  ///
+              nonTerminalNode = metastatementNode,  ///
+              childNodes = nonTerminalNode.getChildNodes(),
+              nodes = childNodes, ///
+              premiseMetaVariableMatches = matchPremiseMetavariable(premiseMetavariableNode, nodes, metaSubstitutions);
+
+        premiseMetastatementNodeMatches = premiseMetaVariableMatches; ///
       }
     }
   }
 
-  return premiseNonTerminalNodeMatches;
+  return premiseMetastatementNodeMatches;
 }

package/bin/rule.js

@@ -1,7 +1,8 @@
 "use strict";
 
-const { labelsAsString } = require("./utilities/string"),
-      { prune, someCombination } = require("./utilities/array");
+const { prune } = require("./utilities/array"),
+      { someSubArray } = require("./utilities/array"),
+      { labelsAsString } = require("./utilities/string");
 
 class Rule {
   constructor(labels, premises, conclusion) {
@@ -23,20 +24,15 @@ class Rule {
   }
 
   matchMetastatement(metastatementNode, context) {
-    let metastatementNodes = context.getMetastatementNodes();
+    const metaAssertions = context.getMetaAssertions(),
+          premisesLength = this.premises.length,
+          matchesMetastatement = someSubArray(metaAssertions, premisesLength, (metaAssertions) => {
+            const premisesMatchConclusion = matchPremisesAndConclusion(this.premises, this.conclusion, metaAssertions, metastatementNode);
 
-    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);
-
-      if (premisesMatchConclusion) {
-        return true;
-      }
-    });
+            if (premisesMatchConclusion) {
+              return true;
+            }
+          });
 
     return matchesMetastatement;
   }
@@ -56,24 +52,37 @@ class Rule {
 
 module.exports = Rule;
 
-function matchPremise(premise, metastatementNodes, metaSubstitutions) {
-  const metastatementNode = prune(metastatementNodes, (metastatementNode) => {
-    const nonTerminalNode = metastatementNode,  ///
-          nonTerminalNodeMatches = premise.matchNonTerminalNode(nonTerminalNode, metaSubstitutions);
+function matchPremise(premise, metaAssertions, metaSubstitutions) {
+  const metaAssertion = prune(metaAssertions, (metaAssertion) => {
+    const metaSubproofNode = metaAssertion.getMetaSubproofNode(),
+          metastatementNode = metaAssertion.getMetastatementNode()
 
-    if (!nonTerminalNodeMatches) {  ///
-      return true;
+    if (metaSubproofNode !== null) {
+      const metaSubProofMatches = premise.matchMetaSubproofNode(metaSubproofNode, metaSubstitutions);
+
+      if (!metaSubProofMatches) {  ///
+        return true;
+      }
     }
+
+    if (metastatementNode !== null) {
+      const metastatementMatches = premise.matchMetastatementNode(metastatementNode, metaSubstitutions);
+
+      if (!metastatementMatches) {  ///
+        return true;
+      }
+    }
+
   }) || null;
 
-  const premiseMatches = (metastatementNode !== null);
+  const premiseMatches = (metaAssertion !== null);
 
   return premiseMatches;
 }
 
-function matchPremises(premise, metastatementNodes, metaSubstitutions) {
+function matchPremises(premise, metaAssertions, metaSubstitutions) {
   const premisesMatches = premise.every((premise) => {
-    const premiseMatches = matchPremise(premise, metastatementNodes, metaSubstitutions);
+    const premiseMatches = matchPremise(premise, metaAssertions, metaSubstitutions);
 
     if (premiseMatches) {
       return true;
@@ -84,18 +93,17 @@ function matchPremises(premise, metastatementNodes, metaSubstitutions) {
 }
 
 function matchConclusion(conclusion, metastatementNode, metaSubstitutions) {
-  const nonTerminalNode = metastatementNode,  ///
-        nonTerminalNodeMatches = conclusion.matchNonTerminalNode(nonTerminalNode, metaSubstitutions),
+  const nonTerminalNodeMatches = conclusion.matchMetastatementNode(metastatementNode, metaSubstitutions),
         conclusionMatches = nonTerminalNodeMatches; ///
 
   return conclusionMatches;
 }
 
-function matchPremisesAndConclusion(premises, conclusion, metastatementNodes, metastatementNode) {
+function matchPremisesAndConclusion(premises, conclusion, metaAssertions, metastatementNode) {
   let premisesMatchConclusion = false;
 
   const metaSubstitutions = [],
-        premisesMatches = matchPremises(premises, metastatementNodes, metaSubstitutions);
+        premisesMatches = matchPremises(premises, metaAssertions, metaSubstitutions);
 
   if (premisesMatches) {
     const conclusionMatches = matchConclusion(conclusion, metastatementNode, metaSubstitutions);

package/bin/ruleNames.js

@@ -4,7 +4,9 @@ const TERM_RULE_NAME = "term",
       TYPE_RULE_NAME = "type",
       ARGUMENT_RULE_NAME = "argument",
       METAVARIABLE_RULE_NAME = "metavariable",
+      METASTATEMENT_RULE_NAME = "metastatement",
       META_SUBPROOF_RULE_NAME = "metaSubproof",
+      META_SUBPROOF_ASSERTION_RULE_NAME = "metaSubproofAssertion",
       QUALIFIED_METASTATEMENT_RULE_NAME = "qualifiedMetastatement",
       UNQUALIFIED_METASTATEMENT_RULE_NAME = "unqualifiedMetastatement";
 
@@ -13,7 +15,9 @@ module.exports = {
   TYPE_RULE_NAME,
   ARGUMENT_RULE_NAME,
   METAVARIABLE_RULE_NAME,
+  METASTATEMENT_RULE_NAME,
   META_SUBPROOF_RULE_NAME,
+  META_SUBPROOF_ASSERTION_RULE_NAME,
   QUALIFIED_METASTATEMENT_RULE_NAME,
   UNQUALIFIED_METASTATEMENT_RULE_NAME
 };

package/bin/utilities/array.js

@@ -2,7 +2,49 @@
 
 const { arrayUtilities } = require("necessary");
 
-const { push, prune, first, second, filter } = arrayUtilities;
+const permutationsMatrix = require("../permutationsMatrix");
+
+const { MAXIMUM_INDEXES_LENGTH, MAXIMUM_PERMUTATION_LENGTH } = require("../constants");
+
+const { push, last, prune, first, third, second, filter } = arrayUtilities;
+
+function someSubArray(array, subArrayLength, callback) {
+  let found = false;
+
+  const arrayLength = array.length,
+        indexesLength = arrayLength, ///
+        permutationLength = subArrayLength; ///
+
+  if (permutationLength <= MAXIMUM_PERMUTATION_LENGTH) {
+    const offset = (indexesLength <= MAXIMUM_INDEXES_LENGTH) ?
+                     0 :
+                      indexesLength - MAXIMUM_INDEXES_LENGTH,
+          permutations = permutationsMatrix[indexesLength][permutationLength];
+
+    if (permutations !== null) {
+      found = permutations.some((permutation) => {
+        if (permutation !== null) {
+          const subArray = [];
+
+          for (let position = 0; position < permutationLength; position++) {
+            const index = permutation[position] + offset,
+                  element = array[index];
+
+            subArray.push(element);
+          }
+
+          const passed = callback(subArray);
+
+          if (passed) {
+            return true;
+          }
+        }
+      });
+    }
+  }
+
+  return found;
+}
 
 function leftDifference(arrayA, arrayB) {
   filter(arrayA, (elementA) => {
@@ -14,84 +56,25 @@ function leftDifference(arrayA, arrayB) {
   });
 }
 
-function someCombination(array, callback) {
-  const combinations = combinationsFromArray(array),
-        found = combinations.some((combination) => {
-          const array = combination,  ///
-                passed = callback(array);
+function rightDifference(arrayA, arrayB) {
+  filter(arrayB, (elementB) => {
+    const arrayAIncludesElementB = arrayA.includes(elementB);
 
-          if (passed) {
-            return true;
-          }
-        });
-
-  return found;
+    if (!arrayAIncludesElementB) {
+      return true;
+    }
+  });
 }
 
 module.exports = {
   push,
+  last,
   prune,
   first,
+  third,
   second,
   filter,
+  someSubArray,
   leftDifference,
-  someCombination
+  rightDifference
 };
-
-function combinationsFromArray(array) {
-  const arrayLength = array.length,
-        indexCombinations = indexCombinationsFromArrayLength(arrayLength),
-        combinations = indexCombinations.map((indexCombination) => {
-          const elements = [];
-
-          for (let position = 0; position < arrayLength; position++) {
-            const index = indexCombination[position],
-                  element = array[index];
-
-            elements.push(element);
-          }
-
-          const combination = elements; ///
-
-          return combination;
-        });
-
-  return combinations;
-}
-
-function indexCombinationsFromArrayLength(arrayLength) {
-  let indexCombinations;
-
-  if (arrayLength === 0) {
-    indexCombinations = [];
-  } else if (arrayLength === 1) {
-    const indexCombination = [
-      0
-    ];
-
-    indexCombinations = [
-      indexCombination
-    ];
-  } else {
-    const innerArrayLength = arrayLength - 1,
-          innerIndexCombinations = indexCombinationsFromArrayLength(innerArrayLength);
-
-    indexCombinations = [];
-
-    innerIndexCombinations.forEach((innerIndexCombination) => {
-      const outerIndex = innerArrayLength;  ///
-
-      for (let position = innerArrayLength; position >= 0; position--) {
-        const indexCombination = innerIndexCombination.slice(),
-              start = position, ///
-              deleteCount = 0;
-
-        indexCombination.splice(start, deleteCount, outerIndex);
-
-        indexCombinations.push(indexCombination);
-      }
-    });
-  }
-
-  return indexCombinations;
-}

package/bin/utilities/metastatement.js

@@ -0,0 +1,44 @@
+"use strict";
+
+const { first, second, third } = require("../utilities/array"),
+      { METASTATEMENT_RULE_NAME } = require("../ruleNames"),
+      { LEFT_BRACKET, RIGHT_BRACKET, BRACKETED_METASTATEMENT_CHILD_NODES_LENGTH } = require("../constants");
+
+function matchBracketedMetastatementChildNode(childNodes, callback) {
+  let bracketedMetastatementChildNodeMatches = false;
+
+  const childNodesLength = childNodes.length;
+
+  if (childNodesLength === BRACKETED_METASTATEMENT_CHILD_NODES_LENGTH) {
+    const firstChildNode = first(childNodes),
+          thirdChildNode = third(childNodes),
+          secondChildNode = second(childNodes),
+          firstChildNodeTerminalNode = firstChildNode.isTerminalNode(),
+          thirdChildNodeTerminalNode = thirdChildNode.isTerminalNode(),
+          secondChildNodeNonTerminalNode = secondChildNode.isNonTerminalNode();
+
+    if (firstChildNodeTerminalNode && secondChildNodeNonTerminalNode && thirdChildNodeTerminalNode) {
+      const nonTerminalNode = secondChildNode,  ///
+            firstTerminalNode = firstChildNode, ///
+            secondTerminalNode = thirdChildNode,  ///
+            nonTerminalNodeRuleName = nonTerminalNode.getRuleName(),
+            firstTerminalNodeContent = firstTerminalNode.getContent(),
+            secondTerminalNodeContent = secondTerminalNode.getContent(),
+            firstTerminalNodeContentLeftBracket = (firstTerminalNodeContent === LEFT_BRACKET),
+            secondTerminalNodeContentRightBracket = (secondTerminalNodeContent === RIGHT_BRACKET),
+            nonTerminalNodeRuleNameMetastatementRuleName = (nonTerminalNodeRuleName === METASTATEMENT_RULE_NAME);
+
+      if (firstTerminalNodeContentLeftBracket && nonTerminalNodeRuleNameMetastatementRuleName && secondTerminalNodeContentRightBracket) {
+        const bracketedMetastatementChildNode = nonTerminalNode;  ///
+
+        bracketedMetastatementChildNodeMatches = callback(bracketedMetastatementChildNode);
+      }
+    }
+  }
+
+  return bracketedMetastatementChildNodeMatches;
+}
+
+module.exports = {
+  matchBracketedMetastatementChildNode
+};