occam-verify-cli 0.0.523 → 0.0.525

package/src/equality.js

@@ -1,9 +1,10 @@
 "use strict";
 
 import { nodeQuery } from "./utilities/query";
+import { TERM_RULE_NAME } from "./ruleNames";
 
-const leftTermNodeQuery = nodeQuery("/statement/term[0]"),
-      rightTermNodeQuery = nodeQuery("/statement/term[1]");
+const leftTermNodeQuery = nodeQuery("/statement/argument[0]/term!"),
+      rightTermNodeQuery = nodeQuery("/statement/argument[1]/term!");
 
 export default class Equality {
   constructor(leftTermNode, rightTermNode) {
@@ -11,7 +12,7 @@ export default class Equality {
     this.rightTermNode = rightTermNode;
   }
 
-  getLdftTermNode() {
+  getLeftTermNode() {
     return this.leftTermNode;
   }
 
@@ -19,8 +20,79 @@ export default class Equality {
     return this.rightTermNode;
   }
 
-  assert(proofContext) {
-    debugger
+  match(equality, equalities) {
+    let matches = false;
+
+    const leftTermNode = equality.getLeftTermNode(),
+          rightTermNode = equality.getRightTermNode();
+
+    if (!matches) {
+      const reversed = false,
+            leftTermNodeAndRightTermNodeMatch = this.matchLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode, reversed, equalities);
+
+      matches = leftTermNodeAndRightTermNodeMatch;  ///
+    }
+
+    if (!matches) {
+      const reversed = true,
+            leftTermNodeAndRightTermNodeMatch = this.matchLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode, reversed, equalities);
+
+      matches = leftTermNodeAndRightTermNodeMatch;  ///
+    }
+
+    return matches;
+  }
+
+  matchLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode, reversed, equalities) {
+    let leftTermNodeAndRightTermNodeMatch = true;
+
+    if (leftTermNodeAndRightTermNodeMatch) {
+      const leftNonTerminalNode = reversed ?
+                                    this.rightTermNode :
+                                      this.leftTermNode,  ///
+            rightNonTerminalNode = leftTermNode,  ///
+            nonTerminalNodeEquates = equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities);
+
+      leftTermNodeAndRightTermNodeMatch = nonTerminalNodeEquates; ///
+    }
+
+    if (leftTermNodeAndRightTermNodeMatch) {
+      const leftNonTerminalNode = reversed ?
+                                    this.leftTermNode :
+                                      this.rightTermNode,  ///
+            rightNonTerminalNode = rightTermNode,  ///
+            nonTerminalNodeEquates = equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities);
+
+      leftTermNodeAndRightTermNodeMatch = nonTerminalNodeEquates; ///
+    }
+
+    return leftTermNodeAndRightTermNodeMatch;
+  }
+
+  equate(equalities) {
+    const leftNonTerminalNode = this.leftTermNode,  ///
+          rightNonTerminalNode = this.rightTermNode,  ///
+          nonTerminalNodeEquates = equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities),
+          equates = nonTerminalNodeEquates; ///
+
+    return equates;
+  }
+
+  static fromProofStep(proofStep) {
+    let equality = null;
+
+    const statementNode = proofStep.getStatementNode();
+
+    if (statementNode !== null) {
+      const leftTermNode = leftTermNodeQuery(statementNode),
+            rightTermNode = rightTermNodeQuery(statementNode);
+
+      if ((leftTermNode !== null) && (rightTermNode !== null)) {
+        equality = new Equality(leftTermNode, rightTermNode);
+      }
+    }
+
+    return equality;
   }
 
   static fromStatementNode(statementNode) {
@@ -30,4 +102,129 @@ export default class Equality {
 
     return equality;
   }
+
+  static fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode) {
+    const equality = new Equality(leftTermNode, rightTermNode);
+
+    return equality;
+  }
+}
+
+function equateNode(nodeA, nodeB, equalities) {
+  let nodeEquates = false;
+
+  const nodeATerminalNode = nodeA.isTerminalNode(),
+        nodeBTerminalNode = nodeB.isTerminalNode();
+
+  if (nodeATerminalNode === nodeBTerminalNode) {
+    if (nodeATerminalNode) {
+      const terminalNodeA = nodeA,  ///
+            terminalNodeB = nodeB,  ///
+            terminalNodeEquates = equateTerminalNode(terminalNodeA, terminalNodeB, equalities);
+
+      nodeEquates = terminalNodeEquates;  ///
+    } else {
+      const nonTerminalNodeA = nodeA,  ///
+            nonTerminalNodeB = nodeB, ///
+            nonTerminalNodeEquates = equateNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, equalities);
+
+      nodeEquates = nonTerminalNodeEquates; ///
+    }
+  }
+
+  return nodeEquates;
+}
+
+function equateNodes(leftNodes, rightNodes, equalities) {
+  let nodesEquate = false;
+
+  const leftNodesLength = leftNodes.length,
+        rightNodesLength = rightNodes.length;
+
+  if (leftNodesLength === rightNodesLength) {
+    nodesEquate = leftNodes.every((LeftNode, index) => {
+      const rightNode = rightNodes[index],
+            nodeEquates = equateNode(LeftNode, rightNode, equalities);
+
+      if (nodeEquates) {
+        return true;
+      }
+    });
+  }
+
+  return nodesEquate;
+}
+
+function equateTerminalNode(terminalNodeA, terminalNodeB, equalities) {
+  const matches = terminalNodeA.match(terminalNodeB),
+        terminalNodeEquates = matches;  ///
+
+  return terminalNodeEquates;
+}
+
+function equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities) {
+  let nonTerminalNodeEquates = false;
+
+  const leftNonTerminalNodeRuleName = leftNonTerminalNode.getRuleName(),
+        rightNonTerminalNodeRuleName = rightNonTerminalNode.getRuleName();
+
+  if (leftNonTerminalNodeRuleName === rightNonTerminalNodeRuleName) {
+    const ruleName = leftNonTerminalNodeRuleName, ///
+          ruleNameTermRuleName = (ruleName === TERM_RULE_NAME);
+
+    if (ruleNameTermRuleName) {
+      const leftTermNode = leftNonTerminalNode, ///
+            rightTermNode = rightNonTerminalNode, ///
+            termNodeEquates = equateTermNode(leftTermNode, rightTermNode, equalities);
+
+      nonTerminalNodeEquates = termNodeEquates;  ///
+    }
+
+    if (!nonTerminalNodeEquates) {
+      const leftNonTerminalNodeChildNodes = leftNonTerminalNode.getChildNodes(),
+            rightNonTerminalNodeChildNodes = rightNonTerminalNode.getChildNodes(),
+            leftNodes = leftNonTerminalNodeChildNodes, ///
+            rightNodes = rightNonTerminalNodeChildNodes, ///
+            nodesEquate = equateNodes(leftNodes, rightNodes, equalities);
+
+      nonTerminalNodeEquates = nodesEquate; ///
+    }
+  }
+
+  return nonTerminalNodeEquates;
+}
+
+function equateTermNode(leftTermNode, rightTermNode, equalities) {
+  const equality = Equality.fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode),
+        equalityA = equality, ///
+        equalityMatches = equalities.some((equality) => { ///
+          let equalitiesB = equalities; ///
+
+          const equalityB = equality; ///
+
+          equalitiesB = filterEqualities(equalitiesB, equalityB);  ///
+
+          const equalityAMatchesEqualityB = equalityA.match(equalityB, equalitiesB);
+
+          if (equalityAMatchesEqualityB) {
+            return true;
+          }
+        }),
+        termNodeEquates = equalityMatches;  ///
+
+  return termNodeEquates;
+}
+
+function filterEqualities(equalities, equality) {
+  const equalityA = equality; ///
+
+  equalities = equalities.filter((equality) => {
+    const equalityB = equality; ///
+
+    if (equalityA !== equalityB) {
+      return true;
+    }
+  });
+
+  return equalities;
 }

package/src/ruleNames.js

@@ -13,6 +13,6 @@ export const RULE_SUBPROOF_RULE_NAME = "ruleSubproof";
 export const META_ARGUMENT_RULE_NAME = "metaArgument";
 export const QUALIFIED_STATEMENT_RULE_NAME = "qualifiedStatement";
 export const UNQUALIFIED_STATEMENT_RULE_NAME = "unqualifiedStatement";
-export const CONDITIONAL_INDICATIVE_RULE_NAME = "conditionalIndicative";
+export const CONSTRUCTOR_DECLARATIONRULE_NAME = "constructorDeclaration";
 export const QUALIFIED_METASTATEMENT_RULE_NAME = "qualifiedMetastatement";
 export const UNQUALIFIED_METASTATEMENT_RULE_NAME = "unqualifiedMetastatement";

package/src/utilities/string.js

@@ -2,14 +2,14 @@
 
 import { COMMA } from "../constants";
 import { nodeQuery } from "../utilities/query";
-import { TERM_RULE_NAME,
-         LABEL_RULE_NAME,
+import { LABEL_RULE_NAME,
          UNQUALIFIED_STATEMENT_RULE_NAME,
-         CONDITIONAL_INDICATIVE_RULE_NAME,
-         UNQUALIFIED_METASTATEMENT_RULE_NAME} from "../ruleNames";
+         CONSTRUCTOR_DECLARATIONRULE_NAME,
+         UNQUALIFIED_METASTATEMENT_RULE_NAME } from "../ruleNames";
 
-const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement"),
-      metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement");
+const termNodeQuery = nodeQuery("/constructorDeclaration/term!"),
+      statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
+      metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!");
 
 export function nodeAsString(node) {
   let string = null;
@@ -56,10 +56,12 @@ export function nodesAsString(nodes) {
 }
 
 export function termNodeFromTermString(termString, releaseContext) {
-  const ruleName = TERM_RULE_NAME,
-        content = termString, ///
+  const ruleName = CONSTRUCTOR_DECLARATIONRULE_NAME,
+        content = `Constructor ${termString}
+`,
         node = releaseContext.nodeFromContentAndRuleName(content, ruleName),
-        termNode = node;  ///
+        constructorDeclarationNode = node, ///
+        termNode = termNodeQuery(constructorDeclarationNode);
 
   return termNode;
 }
@@ -94,21 +96,3 @@ export function metastatementNodeFromMetastatementString(metastatementString, re
 
   return metastatementNode;
 }
-
-export function unqualifiedStatementNodeFromUnqualifiedStatementString(unqualifiedStatementString, releaseContext) {
-  const ruleName = UNQUALIFIED_STATEMENT_RULE_NAME,
-        content = unqualifiedStatementString, ///
-        node = releaseContext.nodeFromContentAndRuleName(content, ruleName),
-        unqualifiedStatementNode = node;  ///
-
-  return unqualifiedStatementNode;
-}
-
-export function conditionalIndicativeNodeFromConditionalIndicativeString(conditionalIndicativeString, releaseContext) {
-  const ruleName = CONDITIONAL_INDICATIVE_RULE_NAME,
-        content = conditionalIndicativeString, ///
-        node = releaseContext.nodeFromContentAndRuleName(content, ruleName),
-        conditionalIndicativeNode = node;  ///
-
-  return conditionalIndicativeNode;
-}

package/src/verify/derivation.js

@@ -107,8 +107,10 @@ function verifyChild(childNode, proofContext) {
     }
 
     case QUALIFIED_STATEMENT_RULE_NAME: {
-      const qualifiedStatementNode = childNode,  ///
-            qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, proofContext);
+      const derived = true,
+            assertions = [],
+            qualifiedStatementNode = childNode,  ///
+            qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, assertions, derived, proofContext);
 
       if (qualifiedStatementVerified) {
         const statementNode = statementNodeQuery(qualifiedStatementNode),

package/src/verify/metastatement/qualified.js

@@ -8,7 +8,7 @@ import { nodeQuery, referenceNameFromReferenceNode } from "../../utilities/query
 const referenceNodeQuery = nodeQuery("/qualifiedMetastatement/qualification!/reference!"),
       metastatementNodeQuery = nodeQuery("/qualifiedMetastatement/metastatement!");
 
-export default function verifyQualifiedMetastatement(qualifiedMetastatementNode, metaproofContext) {
+export default function verifyQualifiedMetastatement(qualifiedMetastatementNode, assertions, derived, metaproofContext) {
   let qualifiedMetastatementVerified = false;
 
   metaproofContext.begin(qualifiedMetastatementNode);
@@ -20,7 +20,7 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
 
     metaproofContext.debug(`Verifying the ${metastatementString} qualified metastatement...`);
 
-    let ruleMatchesStatement = true;
+    let ruleMatchesMetastatement = true;
 
     const referenceNode = referenceNodeQuery(qualifiedMetastatementNode);
 
@@ -29,15 +29,12 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
             rule = metaproofContext.findRuleByReferenceName(referenceName);
 
       if (rule !== null) {
-        const ruleMatchesStatement = rule.matchMetastatement(metastatementNode, metaproofContext);
-
-        qualifiedMetastatementVerified = ruleMatchesStatement;  ///
+        ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, metaproofContext);
       }
     }
 
-    if (ruleMatchesStatement) {
-      const assertions = [],
-            metastatementVerified = verifyMetastatement(metastatementNode, assertions, metaproofContext);
+    if (ruleMatchesMetastatement) {
+      const metastatementVerified = verifyMetastatement(metastatementNode, assertions, derived, metaproofContext);
 
       qualifiedMetastatementVerified = metastatementVerified; ///
     }

package/src/verify/metastatement/unqualified.js

@@ -26,7 +26,7 @@ export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementN
     }
 
     if (metastatementMatches) {
-      const metastatementVerified = verifyMetastatement(metastatementNode, assertions, metaproofContext);
+      const metastatementVerified = verifyMetastatement(metastatementNode, assertions, derived, metaproofContext);
 
       unqualifiedMetastatementVerified = metastatementVerified; ///
     }

package/src/verify/metastatement.js

@@ -1,6 +1,6 @@
 "use strict";
 
-export default function verifyMetastatement(metastatementNode, assertions, metaproofContext) {
+export default function verifyMetastatement(metastatementNode, assertions, derived, metaproofContext) {
   let metastatementVerified = true; ///
 
   metaproofContext.begin(metastatementNode);

package/src/verify/ruleDerivation.js

@@ -107,8 +107,10 @@ function verifyChild(childNode, metaproofContext) {
     }
 
     case QUALIFIED_METASTATEMENT_RULE_NAME: {
-      const qualifiedMetastatementNode = childNode,  ///
-            qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, metaproofContext);
+      const derived = true,
+            assertions = [],
+            qualifiedMetastatementNode = childNode,  ///
+            qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, assertions, derived, metaproofContext);
 
       if (qualifiedMetastatementVerified) {
         const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),

package/src/verify/statement/qualified.js

@@ -8,7 +8,7 @@ import { nodeQuery, referenceNameFromReferenceNode } from "../../utilities/query
 const referenceNodeQuery = nodeQuery("/qualifiedStatement/qualification!/reference!"),
       statementNodeQuery = nodeQuery("/qualifiedStatement/statement!");
 
-export default function verifyQualifiedStatement(qualifiedStatementNode, proofContext) {
+export default function verifyQualifiedStatement(qualifiedStatementNode, assertions, derived, proofContext) {
   let qualifiedStatementVerified = false;
 
   proofContext.begin(qualifiedStatementNode);
@@ -34,8 +34,8 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, proofCo
     }
 
     if (ruleMatchesStatement) {
-      const assertions = [],
-            statementVerified = verifyStatement(statementNode, assertions, proofContext);
+      const context = proofContext,
+            statementVerified = verifyStatement(statementNode, assertions, derived, context);
 
       qualifiedStatementVerified = statementVerified; ///
     }

package/src/verify/statement/unqualified.js

@@ -26,7 +26,8 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, ass
     }
 
     if (statementMatches) {
-      const statementVerified = verifyStatement(statementNode, assertions, proofContext);
+      const context = proofContext, ///
+            statementVerified = verifyStatement(statementNode, assertions, derived, context);
 
       unqualifiedStatementVerified = statementVerified;  ///
     }