occam-verify-cli 0.0.464 → 0.0.466

package/src/axiomLemmaTheorem.js

@@ -0,0 +1,190 @@
+"use strict";
+
+import Label from "./label";
+import Antecedent from "./antecedent";
+import Consequent from "./consequent";
+
+import { prune } from "./utilities/array";
+import { someSubArray } from "./utilities/array";
+
+export default class AxiomLemmaTheorem {
+  constructor(labels, antecedents, consequent) {
+    this.labels = labels;
+    this.antecedents = antecedents;
+    this.consequent = consequent;
+  }
+
+  getLabels() {
+    return this.labels;
+  }
+
+  getAntecedents() {
+    return this.antecedents;
+  }
+
+  getConsequent() {
+    return this.consequent;
+  }
+
+  matchLabelName(labelName) {
+    const matchesLabelName = this.labels.some((label) => {
+      const name = labelName, ///
+            labelMatchesName = label.matchName(name);
+
+      if (labelMatchesName) {
+        return true;
+      }
+    });
+
+    return matchesLabelName;
+  }
+
+  matchStatement(statementNode, proofContext) {
+    let statementNatches;
+
+    const antecedentsLength = this.antecedents.length;
+
+    if (antecedentsLength === 0) {
+      const substitutions = [],
+            consequentMatches = matchConsequent(this.consequent, statementNode, substitutions);
+
+      statementNatches = consequentMatches; ///
+    } else {
+      const assertions = proofContext.getAssertions();
+
+      statementNatches = someSubArray(assertions, antecedentsLength, (assertions) => {
+        const antecedentsMatchConsequent = matchAntecedentsAndConsequent(this.antecedents, this.consequent, assertions, statementNode);
+
+        if (antecedentsMatchConsequent) {
+          return true;
+        }
+      });
+    }
+
+    return statementNatches;
+  }
+
+  toJSON() {
+    const { kind } = this.constructor,
+          labelsJSON = this.labels.map((label) => {
+            const labelJSON = label.toJSON();
+
+            return labelJSON;
+          }),
+          antecedentsJSON = this.antecedents.map((antecedent) => {
+            const antecedentJSON = antecedent.toJSON();
+
+            return antecedentJSON;
+          }),
+          consequentJSON = this.consequent.toJSON(),
+          labels = labelsJSON,  ///
+          antecedents = antecedentsJSON,  ///
+          consequent = consequentJSON,  ///
+          json = {
+            kind,
+            labels,
+            antecedents,
+            consequent
+          };
+
+    return json;
+  }
+
+  static fromJSON(Class, json, releaseContext) {
+    let { labels } = json;
+
+    const labelsJSON = labels;  ///
+
+    labels = labelsJSON.map((labelJSON) => {
+      const json = labelJSON, ///
+            label = Label.fromJSON(json, releaseContext);
+
+      return label;
+    });
+
+    let { antecedents } = json;
+
+    const antecedentsJSON = antecedents;  ///
+
+    antecedents = antecedentsJSON.map((antecedentJSON) => {
+      const json = antecedentJSON, ///
+            antecedent = Antecedent.fromJSON(json, releaseContext);
+
+      return antecedent;
+    });
+
+    let { consequent } = json;
+
+    const consequentJSON = consequent;  ///
+
+    json = consequentJSON;  ///
+
+    consequent = Consequent.fromJSON(json, releaseContext);
+
+    return new Class(labels, antecedents, consequent);  ///
+  }
+
+  static fromLabelsAntecedentsAndConsequent(Class, labels, antecedents, consequent) { return new Class(labels, antecedents, consequent); }
+}
+
+function matchAntecedent(antecedent, assertions, substitutions) {
+  const assertion = prune(assertions, (assertion) => {
+    const subproofNode = assertion.getSubproofNode(),
+          statementNode = assertion.getStatementNode();
+
+    if (subproofNode !== null) {
+      const subProofMatches = antecedent.matchSubproofNode(subproofNode, substitutions);
+
+      if (!subProofMatches) {  ///
+        return true;
+      }
+    }
+
+    if (statementNode !== null) {
+      const statementMatches = antecedent.matchStatementNode(statementNode, substitutions);
+
+      if (!statementMatches) {  ///
+        return true;
+      }
+    }
+
+  }) || null;
+
+  const antecedentMatches = (assertion !== null);
+
+  return antecedentMatches;
+}
+
+function matchAntecedents(antecedent, assertions, substitutions) {
+  const antecedentsMatches = antecedent.every((antecedent) => {
+    const antecedentMatches = matchAntecedent(antecedent, assertions, substitutions);
+
+    if (antecedentMatches) {
+      return true;
+    }
+  });
+
+  return antecedentsMatches;
+}
+
+function matchConsequent(consequent, statementNode, substitutions) {
+  const nonTerminalNodeMatches = consequent.matchStatementNode(statementNode, substitutions),
+        consequentMatches = nonTerminalNodeMatches; ///
+
+  return consequentMatches;
+}
+
+function matchAntecedentsAndConsequent(antecedents, consequent, assertions, statementNode) {
+  let antecedentsMatchConsequent = false;
+
+  const substitutions = [],
+        antecedentsMatches = matchAntecedents(antecedents, assertions, substitutions);
+
+  if (antecedentsMatches) {
+    const consequentMatches = matchConsequent(consequent, statementNode, substitutions);
+
+    antecedentsMatchConsequent = consequentMatches;  ///
+  }
+
+  return antecedentsMatchConsequent;
+}

package/src/consequent.js

@@ -0,0 +1,187 @@
+"use strict";
+
+import { first } from "./utilities/array";
+import { nodeAsString } from "./utilities/string";
+import { variableNameFromVariableNode } from "./utilities/query";
+import { statementNodeFromStatementString } from "./utilities/string";
+import { VARIABLE_RULE_NAME, STATEMENT_RULE_NAME } from "./ruleNames";
+
+export default class Consequent {
+  constructor(statementNode) {
+    this.statementNode = statementNode;
+  }
+
+  getStatementNode() {
+    return this.statementNode;
+  }
+
+  matchStatementNode(statementNode, metaSubstitutions) {
+    const nonTerminalNode = statementNode,  ///
+          consequentNonTerminalNode = this.statementNode,  ///
+          consequentNonTerminalNodeMatches = matchConsequentNonTerminalNode(consequentNonTerminalNode, nonTerminalNode, metaSubstitutions),
+          statementNodeMatches = consequentNonTerminalNodeMatches; ///
+
+    return statementNodeMatches;
+  }
+
+  toJSON() {
+    const statementString = nodeAsString(this.statementNode),
+          statement = statementString,  ///
+          json = {
+            statement
+          };
+
+    return json;
+  }
+
+  static fromJSON(json, releaseContext) {
+    const { statement } = json,
+          statementString = statement,  ///
+          statementNode = statementNodeFromStatementString(statementString, releaseContext),
+          consequent = new Consequent(statementNode);
+
+    return consequent;
+  }
+
+  static fromStatementNode(statementNode) {
+    const consequent = new Consequent(statementNode);
+
+    return consequent;
+  }
+}
+
+function matchConsequentNode(consequentNode, node, metaSubstitutions) {
+  let consequentNodeMatches = false;
+
+  const nodeTerminalNode = node.isTerminalNode(),
+        ruleNodeTerminalNode = consequentNode.isTerminalNode();
+
+  if (nodeTerminalNode === ruleNodeTerminalNode) {
+    if (nodeTerminalNode) {
+      const terminalNode = node,  ///
+            consequentTerminalNode = consequentNode,  ///
+            consequentTerminalNodeMatches = matchConsequentTerminalNode(consequentTerminalNode, terminalNode, metaSubstitutions);
+
+      consequentNodeMatches = consequentTerminalNodeMatches;  ///
+    } else {
+      const nonTerminalNode = node, ///
+            consequentNonTerminalNode = consequentNode,  ///
+            consequentNonTerminalNodeMatches = matchConsequentNonTerminalNode(consequentNonTerminalNode, nonTerminalNode, metaSubstitutions);
+
+      consequentNodeMatches = consequentNonTerminalNodeMatches; ///
+    }
+  }
+
+  return consequentNodeMatches;
+}
+
+function matchConsequentNodes(consequentNodes, nodes, metaSubstitutions) {
+  let consequentNodesMatches = false;
+
+  const nodesLength = nodes.length,
+        consequentNodesLength = consequentNodes.length;
+
+  if (nodesLength === consequentNodesLength) {
+    consequentNodesMatches = nodes.every((node, index) => {
+      const consequentNode = consequentNodes[index],
+            consequentNodeMatches = matchConsequentNode(consequentNode, node, metaSubstitutions);
+
+      if (consequentNodeMatches) {
+        return true;
+      }
+    });
+  }
+
+  return consequentNodesMatches;
+}
+
+function matchConsequentVariable(consequentVariableNode, nodes, metaSubstitutions) {
+  let consequentVariableMatches = true;
+
+  const consequentVariableName = variableNameFromVariableNode(consequentVariableNode),
+        metaSubstitution = metaSubstitutions.find((metaSubstitution) => {
+          const variableName = metaSubstitution.getVariableName();
+
+          if (variableName === consequentVariableName) {
+            return true;
+          }
+        }) || null;
+
+  if (metaSubstitution !== null) {
+    const metaSubstitutionNodesMatch = metaSubstitution.matchNodes(nodes);
+
+    consequentVariableMatches = metaSubstitutionNodesMatch;  ///
+  }
+
+  return consequentVariableMatches;
+}
+
+function matchConsequentTerminalNode(consequentTerminalNode, terminalNode, metaSubstitutions) {
+  const matches = consequentTerminalNode.match(terminalNode),
+        consequentTerminalNodeMatches = matches;  ///
+
+  return consequentTerminalNodeMatches;
+}
+
+function matchConsequentNonTerminalNode(consequentNonTerminalNode, nonTerminalNode, metaSubstitutions) {
+  let consequentNonTerminalNodeMatches = false;
+
+  const ruleName = nonTerminalNode.getRuleName(),
+        consequentRuleName = consequentNonTerminalNode.getRuleName(); ///
+
+  if (ruleName === consequentRuleName) {
+    const childNodes = nonTerminalNode.getChildNodes(),
+          consequentChildNodes = consequentNonTerminalNode.getChildNodes(),
+          nodes = childNodes, ///
+          consequentNodes = consequentChildNodes, ///
+          consequentChildNodesMatches = matchConsequentNodes(consequentNodes, nodes, metaSubstitutions);
+
+    consequentNonTerminalNodeMatches = consequentChildNodesMatches; ///
+
+    if (!consequentNonTerminalNodeMatches) {
+      const ruleNameStatementRuleName = (ruleName === STATEMENT_RULE_NAME);
+
+      if (ruleNameStatementRuleName) {
+        const statementNode = nonTerminalNode,  ///
+              consequentStatementNode = consequentNonTerminalNode,  ///
+              consequentStatementNodeMatches = matchConsequentStatementNode(consequentStatementNode, statementNode, metaSubstitutions);
+
+        consequentNonTerminalNodeMatches = consequentStatementNodeMatches; ///
+      }
+    }
+  }
+
+  return consequentNonTerminalNodeMatches;
+}
+
+function matchConsequentStatementNode(consequentStatementNode, statementNode, metaSubstitutions) {
+  let consequentStatementNodeMatches = false;
+
+  const consequentNonTerminalNode = consequentStatementNode,  ///
+        consequentChildNodes = consequentNonTerminalNode.getChildNodes(),
+        consequentChildNodesLength = consequentChildNodes.length;
+
+  if (consequentChildNodesLength === 1) {
+    const firstConsequentChildNode = first(consequentChildNodes),
+          consequentChildNode = firstConsequentChildNode,  ///
+          consequentChildNodeNonTerminalNode = consequentChildNode.isNonTerminalNode();
+
+    if (consequentChildNodeNonTerminalNode) {
+      const consequentNonTerminalChildNode = consequentChildNode,  ///
+            consequentNonTerminalChildNodeRuleName = consequentNonTerminalChildNode.getRuleName(),
+            consequentNonTerminalChildNodeRuleNameVariableRuleName = (consequentNonTerminalChildNodeRuleName === VARIABLE_RULE_NAME);
+
+      if (consequentNonTerminalChildNodeRuleNameVariableRuleName) {
+        const consequentVariableNode = consequentNonTerminalChildNode,  ///
+              nonTerminalNode = statementNode,  ///
+              childNodes = nonTerminalNode.getChildNodes(),
+              nodes = childNodes, ///
+              consequentMetaVariableMatches = matchConsequentVariable(consequentVariableNode, nodes, metaSubstitutions);
+
+        consequentStatementNodeMatches = consequentMetaVariableMatches; ///
+      }
+    }
+  }
+
+  return consequentStatementNodeMatches;
+}

package/src/constants.js

@@ -4,8 +4,10 @@ export const COMMA = ',';
 export const STRING = "string";
 export const NUMBER = "number";
 export const BOOLEAN = "boolean";
+export const EMPTY_STRING = "";
 export const LEFT_BRACKET = "(";
 export const RIGHT_BRACKET = ")";
 export const MAXIMUM_INDEXES_LENGTH = 10;
 export const MAXIMUM_PERMUTATION_LENGTH = 5;
+export const BRACKETED_STATEMENT_CHILD_NODES_LENGTH = 3;
 export const BRACKETED_METASTATEMENT_CHILD_NODES_LENGTH = 3;

package/src/lemma.js

@@ -1,103 +1,13 @@
 "use strict";
 
-import Label from "./label";
+import AxiomLemmaTheorem from "./axiomLemmaTheorem";
 
 import { LEMMA_KIND } from "./kinds";
-import { nodeAsString } from "./utilities/string";
 
-import { unqualifiedStatementNodeFromUnqualifiedStatementString, indicativeConditionalNodeFromIndicativeConditionalString } from "./utilities/string";
+export default class Lemma extends AxiomLemmaTheorem {
+  static kind = LEMMA_KIND;
 
-export default class Lemma {
-  constructor(labels, unqualifiedStatementNode, indicativeConditionalNode) {
-    this.labels = labels;
-    this.unqualifiedStatementNode = unqualifiedStatementNode;
-    this.indicativeConditionalNode = indicativeConditionalNode;
-  }
+  static fromJSON(json, releaseContext) { return AxiomLemmaTheorem.fromJSON(Lemma, json); }
 
-  getLabels() {
-    return this.labels;
-  }
-
-  getUnqualifiedStatementNode() {
-    return this.unqualifiedStatementNode;
-  }
-
-  getIndicativeConditionalNode() {
-    return this.indicativeConditionalNode;
-  }
-
-  matchLabelName(labelName) {
-    const matchesLabelName = this.labels.some((label) => {
-      const name = labelName, ///
-        labelMatchesName = label.matchName(name);
-
-      if (labelMatchesName) {
-        return true;
-      }
-    });
-
-    return matchesLabelName;
-  }
-
-  toJSON() {
-    const labelsJSON = this.labels.map((label) => {
-            const labelJSON = label.toJSON();
-
-            return labelJSON;
-          }),
-          unqualifiedStatementString = nodeAsString(this.unqalifiedStatementNode),
-          indicativeConditionalString = nodeAsString(this.indicativeConditionalNode),
-          kind = LEMMA_KIND,
-          labels = labelsJSON,  ///
-          unqualifiedStatement = unqualifiedStatementString,  ///
-          indicativeConditional = indicativeConditionalString,  ///
-          json = {
-            kind,
-            labels,
-            unqualifiedStatement,
-            indicativeConditional
-          };
-
-    return json;
-  }
-
-  static fromJSON(json, releaseContext) {
-    let { labels } = json;
-
-    const labelsJSON = labels;  ///
-
-    labels = labelsJSON.map((labelJSON) => {
-      const json = labelJSON, ///
-            label = Label.fromJSON(json, releaseContext);
-
-      return label;
-    });
-
-    let { unqualifiedStatement, indicativeConditional } = json;
-
-    let unqualifiedStatementNode = null,
-        indicativeConditionalNode = null;
-
-    if (unqualifiedStatement !== null) {
-      const unqualifiedStatementString = unqualifiedStatement;  ///
-
-      unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementString(unqualifiedStatementString, releaseContext);
-    }
-
-    if (indicativeConditional !== null) {
-      const indicativeConditionalString = indicativeConditional;  ///
-
-      indicativeConditionalNode = indicativeConditionalNodeFromIndicativeConditionalString(indicativeConditionalString, releaseContext);
-    }
-
-    const lemma = new Lemma(labels, unqualifiedStatementNode, indicativeConditionalNode);
-
-    return lemma;
-  }
-
-  static fromLabelsUnqualifiedStatementNodeAndIndicativeConditionalNode(labels, unqualifiedStatementNode, indicativeConditionalNode) {
-    const lemma = new Lemma(labels, unqualifiedStatementNode, indicativeConditionalNode);
-
-    return lemma;
-  }
+  static fromLabelsAntecedentsAndConsequent(labels, antecedents, consequent) { return AxiomLemmaTheorem.fromLabelsAntecedentsAndConsequent(Lemma, labels, antecedents, consequent); }
 }

package/src/ruleNames.js

@@ -8,7 +8,7 @@ export const METAVARIABLE_RULE_NAME = "metavariable";
 export const METASTATEMENT_RULE_NAME = "metastatement";
 export const META_SUBPROOF_RULE_NAME = "metaSubproof";
 export const UNQUALIFIED_STATEMENT_RULE_NAME = "unqualifiedStatement";
-export const INDICATIVE_CONDITIONAL_RULE_NAME = "indicativeConditional";
+export const CONDITIONAL_INDICATIVE_RULE_NAME = "conditionalIndicative";
 export const COMBINATOR_DECLARATION_RULE_NAME = "combinatorDeclaration";
 export const CONSTRUCTOR_DECLARATION_RULE_NAME = "constructorDeclaration";
 export const QUALIFIED_METASTATEMENT_RULE_NAME = "qualifiedMetastatement";

package/src/substitution.js

@@ -0,0 +1,130 @@
+"use strict";
+
+import { matchBracketedStatementChildNode, bracketedStatementChildNodeFromChildNodes } from "./utilities/statement";
+
+export default class Substitution {
+  constructor(variableName, nodes) {
+    this.variableName = variableName;
+    this.nodes = nodes;
+  }
+
+  getVariableName() {
+    return this.variableName;
+  }
+
+  getNodes() {
+    return this.nodes;
+  }
+
+  matchNodes(nodes) {
+    let matches;
+
+    const substitutionNodes = this.nodes,  ///
+          substitutionNonTerminalNodeMatches = matchSubstitutionNodes(substitutionNodes, nodes);
+
+    matches = substitutionNonTerminalNodeMatches;  ///
+
+    if (!matches) {
+      const childNodes = nodes, ///
+            bracketedStatementChildNodeMatches = matchBracketedStatementChildNode(childNodes, (bracketedStatementChildNode) => {
+              const nonTerminalNode = bracketedStatementChildNode,  ///
+                    childNodes = nonTerminalNode.getChildNodes(),
+                    nodes = childNodes, ///
+                    assertionNonTerminalNodeMatches = matchSubstitutionNodes(substitutionNodes, nodes),
+                    bracketedStatementChildNodeMatches = assertionNonTerminalNodeMatches; ///
+
+              return bracketedStatementChildNodeMatches;
+            });
+
+      matches = bracketedStatementChildNodeMatches; ///
+    }
+
+    return matches;
+  }
+
+  static fromVariableNameAndNodes(variableName, nodes) {
+    const bracketedStatementChildNode = bracketedStatementChildNodeFromChildNodes(nodes);
+
+    if (bracketedStatementChildNode !== null) {
+      const nonTerminalNode = bracketedStatementChildNode,  ///
+            childNodes = nonTerminalNode.getChildNodes();
+
+      nodes = childNodes; ///
+    }
+
+    const substitution = new Substitution(variableName, nodes);
+
+    return substitution;
+  }
+}
+
+function matchSubstitutionNode(substitutionNode, node) {
+  let substitutionNodeMatches = false;
+
+  const nodeTerminalNode = node.isTerminalNode(),
+        ruleNodeTerminalNode = substitutionNode.isTerminalNode();
+
+  if (nodeTerminalNode === ruleNodeTerminalNode) {
+    if (nodeTerminalNode) {
+      const terminalNode = node,  ///
+            substitutionTerminalNode = substitutionNode,  ///
+            substitutionTerminalNodeMatches = matchSubstitutionTerminalNode(substitutionTerminalNode, terminalNode);
+
+      substitutionNodeMatches = substitutionTerminalNodeMatches;  ///
+    } else {
+      const nonTerminalNode = node, ///
+            substitutionNonTerminalNode = substitutionNode,  ///
+            substitutionNonTerminalNodeMatches = matchSubstitutionNonTerminalNode(substitutionNonTerminalNode, nonTerminalNode);
+
+      substitutionNodeMatches = substitutionNonTerminalNodeMatches; ///
+    }
+  }
+
+  return substitutionNodeMatches;
+}
+
+function matchSubstitutionNodes(substitutionNodes, nodes) {
+  let substitutionNodesMatches = false;
+
+  const nodesLength = nodes.length,
+        substitutionNodesLength = substitutionNodes.length;
+
+  if (nodesLength === substitutionNodesLength) {
+    substitutionNodesMatches = nodes.every((node, index) => {
+      const substitutionNode = substitutionNodes[index],
+            substitutionNodeMatches = matchSubstitutionNode(substitutionNode, node);
+
+      if (substitutionNodeMatches) {
+        return true;
+      }
+    })
+  }
+
+  return substitutionNodesMatches;
+}
+
+function matchSubstitutionTerminalNode(substitutionTerminalNode, terminalNode) {
+  const matches = substitutionTerminalNode.match(terminalNode),
+        substitutionTerminalNodeMatches = matches;  ///
+
+  return substitutionTerminalNodeMatches;
+}
+
+function matchSubstitutionNonTerminalNode(substitutionNonTerminalNode, nonTerminalNode) {
+  let substitutionNonTerminalNodeMatches = false;
+
+  const ruleName = nonTerminalNode.getRuleName(),
+        substitutionRuleName = substitutionNonTerminalNode.getRuleName(); ///
+
+  if (ruleName === substitutionRuleName) {
+    const childNodes = nonTerminalNode.getChildNodes(),
+          substitutionChildNodes = substitutionNonTerminalNode.getChildNodes(),
+          nodes = childNodes, ///
+          substitutionNodes = substitutionChildNodes, ///
+          substitutionNodesMatches = matchSubstitutionNodes(substitutionNodes, nodes);
+
+    substitutionNonTerminalNodeMatches = substitutionNodesMatches; ///
+  }
+
+  return substitutionNonTerminalNodeMatches;
+}