occam-verify-cli 0.0.470 → 0.0.472

package/src/context/metaproof.js

@@ -7,10 +7,10 @@ import callbacksMixins from "../mixins/callbacks";
 import { last } from "../utilities/array";
 
 class MetaproofContext {
-  constructor(context, derived, metaAssertions) {
+  constructor(context, derived, metaproofSteps) {
     this.context = context;
     this.derived = derived;
-    this.metaAssertions = metaAssertions;
+    this.metaproofSteps = metaproofSteps;
   }
 
   getContext() {
@@ -21,63 +21,64 @@ class MetaproofContext {
     return this.derived;
   }
 
-  getMetaAssertions() {
-    let metaAssertions = this.context.getMetaAssertions();
+  getMetaproofSteps() {
+    let metaproofSteps = this.context.getMetaproofSteps();
 
-    metaAssertions = [  ///
-      ...metaAssertions,
-      ...this.metaAssertions
+    metaproofSteps = [  ///
+      ...metaproofSteps,
+      ...this.metaproofSteps
     ];
 
-    return metaAssertions;
+    return metaproofSteps;
   }
 
-  getLastMetaAssertion() {
-    let lastMetaAssertion = null;
+  getLastMetaproofStep() {
+    let lastMetaproofStep = null;
 
-    const metaAssertionsLength = this.metaAssertions.length;
+    const metaproofStepsLength = this.metaproofSteps.length;
 
-    if (metaAssertionsLength > 0) {
-      lastMetaAssertion = last(this.metaAssertions);
+    if (metaproofStepsLength > 0) {
+      lastMetaproofStep = last(this.metaproofSteps);
     }
 
-    return lastMetaAssertion;
+    return lastMetaproofStep;
   }
 
-  setDerived(derived) {
+  setDerived(derived = true) {
     this.derived = derived;
   }
 
-  addMetaAssertion(metaAssertion) {
-    this.metaAssertions.push(metaAssertion);
+  resetDerived() {
+    this.derived = false;
   }
 
-  matchMetaAssertion(metaAssertion) {
-    let metaAssertionMatches;
+  addMetaproofStep(metaproofStep) {
+    this.metaproofSteps.push(metaproofStep);
+  }
 
-    const metaAssertionB = metaAssertion; ///
+  matchMetastatement(metastatementNode) {
+    let metastatementMatches;
 
-    metaAssertionMatches = this.metaAssertions.some((metaAssertion) => {
-      const metaAssertionA = metaAssertion, ///
-            matches = metaAssertionA.match(metaAssertionB);
+    metastatementMatches = this.metaproofSteps.some((metaproofStep) => {
+      metastatementMatches = metaproofStep.matchMetastatement(metastatementNode);
 
-      if (matches) {
+      if (metastatementMatches) {
         return true;
       }
     });
 
-    if (!metaAssertionMatches) {
-      metaAssertionMatches = this.context.matchMetaAssertion(metaAssertion);
+    if (!metastatementMatches) {
+      metastatementMatches = this.context.matchMetastatement(metastatementNode);
     }
 
-    return metaAssertionMatches;
+    return metastatementMatches;
   }
 
   static fromFileContext(fileContext) {
     const context = fileContext,  ///
           derived = false,
-          metaAssertions = [],
-          metaproofContext = new MetaproofContext(context, derived, metaAssertions);
+          metaproofSteps = [],
+          metaproofContext = new MetaproofContext(context, derived, metaproofSteps);
 
     return metaproofContext;
   }
@@ -85,9 +86,9 @@ class MetaproofContext {
   static fromMetaproofContext(metaproofContext) {
     const context = metaproofContext,  ///
           derived = false,
-          metaAssertions = [];
+          metaproofSteps = [];
 
-    metaproofContext = new MetaproofContext(context, derived, metaAssertions);  ///
+    metaproofContext = new MetaproofContext(context, derived, metaproofSteps);  ///
 
     return metaproofContext;
   }

package/src/context/proof.js

@@ -7,11 +7,11 @@ import callbacksMixins from "../mixins/callbacks";
 import { push, last } from "../utilities/array";
 
 class ProofContext {
-  constructor(context, derived, variables, assertions) {
+  constructor(context, derived, variables, proofSteps) {
     this.context = context;
     this.derived = derived;
     this.variables = variables;
-    this.assertions = assertions;
+    this.proofSteps = proofSteps;
   }
 
   getContext() {
@@ -22,15 +22,15 @@ class ProofContext {
     return this.derived;
   }
 
-  getAssertions() {
-    let assertions = this.context.getAssertions();
+  getProofSteps() {
+    let proofSteps = this.context.getProofSteps();
 
-    assertions = [
-      ...assertions,
-      ...this.assertions
+    proofSteps = [
+      ...proofSteps,
+      ...this.proofSteps
     ];
 
-    return assertions;
+    return proofSteps;
   }
 
   getTypes() { return this.context.getTypes(); }
@@ -57,43 +57,44 @@ class ProofContext {
     return variables;
   }
 
-  getLastAssertion() {
-    const lastAssertion = last(this.assertions);
+  getLastProofStep() {
+    const lastProofStep = last(this.proofSteps);
 
-    return lastAssertion;
+    return lastProofStep;
   }
 
-  setDerived(derived) {
+  setDerived(derived = true) {
     this.derived = derived;
   }
 
+  resetDerived() {
+    this.derived = false;
+  }
+
   addVariable(variable) {
     this.variables.push(variable);
   }
 
-  addAssertion(assertion) {
-    this.assertions.push(assertion);
+  addProofStep(proofStep) {
+    this.proofSteps.push(proofStep);
   }
 
-  matchAssertion(assertion) {
-    let assertionMatches;
-
-    const assertionB = assertion; ///
+  matchStatement(statementNode) {
+    let statementMatches;
 
-    assertionMatches = this.assertions.some((assertion) => {
-      const assertionA = assertion, ///
-            matches = assertionA.match(assertionB);
+    statementMatches = this.proofSteps.some((proofStep) => {
+      statementMatches = proofStep.matchStatement(statementNode);
 
-      if (matches) {
+      if (statementMatches) {
         return true;
       }
     });
 
-    if (!assertionMatches) {
-      assertionMatches = this.context.matchAssertion(assertion);
+    if (!statementMatches) {
+      statementMatches = this.context.matchStatement(statementNode);
     }
 
-    return assertionMatches;
+    return statementMatches;
   }
 
   findVariableByVariableName(variableName) {
@@ -137,8 +138,8 @@ class ProofContext {
     const context = fileContext,  ///
           derived = false,
           variables = [],
-          assertions = [],
-          proofContext = new ProofContext(context, derived, variables, assertions);
+          proofSteps = [],
+          proofContext = new ProofContext(context, derived, variables, proofSteps);
 
     return proofContext;
   }
@@ -147,9 +148,9 @@ class ProofContext {
     const context = proofContext,  ///
           derived = false,
           variables = [],
-          assertions = [];
+          proofSteps = [];
 
-    proofContext = new ProofContext(context, derived, variables, assertions);
+    proofContext = new ProofContext(context, derived, variables, proofSteps);
 
     return proofContext;
   }

package/src/equality.js

@@ -0,0 +1,8 @@
+"use strict";
+
+export default class Equality {
+  constructor(termNodeA, termNodeB) {
+    this.termNodeA = termNodeA;
+    this.termNodeB = termNodeB;
+  }
+}

package/src/metaSubstitution.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import { matchBracketedMetastatementChildNode, bracketedMetastatementChildNodeFromChildNodes } from "./utilities/metastatement";
+import { matchNodes, bracketedChildNodeFromChildNodes } from "./utilities/node";
 
 export default class MetaSubstitution {
   constructor(metavariableName, nodes) {
@@ -19,34 +19,34 @@ export default class MetaSubstitution {
   matchNodes(nodes) {
     let matches;
 
-    const metaSubstitutionNodes = this.nodes,  ///
-          metaSubstitutionNonTerminalNodeMatches = matchMetaSubstitutionNodes(metaSubstitutionNodes, nodes);
+    const nodesA = this.nodes,  ///
+          nodesB = nodes,
+          metaSubstitutionNodesMatch = matchNodes(nodesA, nodesB);
 
-    matches = metaSubstitutionNonTerminalNodeMatches;  ///
+    matches = metaSubstitutionNodesMatch;  ///
 
     if (!matches) {
       const childNodes = nodes, ///
-            bracketedMetastatementChildNodeMatches = matchBracketedMetastatementChildNode(childNodes, (bracketedMetastatementChildNode) => {
-              const nonTerminalNode = bracketedMetastatementChildNode,  ///
-                    childNodes = nonTerminalNode.getChildNodes(),
-                    nodes = childNodes, ///
-                    metaAssertionNonTerminalNodeMatches = matchMetaSubstitutionNodes(metaSubstitutionNodes, nodes),
-                    bracketedMetastatementChildNodeMatches = metaAssertionNonTerminalNodeMatches; ///
+            bracketedChildNode = bracketedChildNodeFromChildNodes(childNodes);
 
-              return bracketedMetastatementChildNodeMatches;
-            });
+      if (bracketedChildNode !== null) {
+        const nonTerminalNode = bracketedChildNode,  ///
+              childNodes = nonTerminalNode.getChildNodes(),
+              nodesB = childNodes, ///
+              nodesMatch = matchNodes(nodesA, nodesB);
 
-      matches = bracketedMetastatementChildNodeMatches; ///
+        matches = nodesMatch; ///
+      }
     }
 
     return matches;
   }
 
   static fromMetavariableNameAndNodes(metavariableName, nodes) {
-    const bracketedMetastatementChildNode = bracketedMetastatementChildNodeFromChildNodes(nodes);
+    const bracketedChildNode = bracketedChildNodeFromChildNodes(nodes);
 
-    if (bracketedMetastatementChildNode !== null) {
-      const nonTerminalNode = bracketedMetastatementChildNode,  ///
+    if (bracketedChildNode !== null) {
+      const nonTerminalNode = bracketedChildNode,  ///
             childNodes = nonTerminalNode.getChildNodes();
 
       nodes = childNodes; ///
@@ -57,74 +57,3 @@ export default class MetaSubstitution {
     return 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 matchMetaSubstitutionNodes(metaSubstitutionNodes, nodes) {
-  let metaSubstitutionNodesMatches = false;
-
-  const nodesLength = nodes.length,
-        metaSubstitutionNodesLength = metaSubstitutionNodes.length;
-
-  if (nodesLength === metaSubstitutionNodesLength) {
-    metaSubstitutionNodesMatches = nodes.every((node, index) => {
-      const metaSubstitutionNode = metaSubstitutionNodes[index],
-            metaSubstitutionNodeMatches = matchMetaSubstitutionNode(metaSubstitutionNode, node);
-
-      if (metaSubstitutionNodeMatches) {
-        return true;
-      }
-    })
-  }
-
-  return metaSubstitutionNodesMatches;
-}
-
-function matchMetaSubstitutionTerminalNode(metaSubstitutionTerminalNode, terminalNode) {
-  const matches = metaSubstitutionTerminalNode.match(terminalNode),
-        metaSubstitutionTerminalNodeMatches = matches;  ///
-
-  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(),
-          nodes = childNodes, ///
-          metaSubstitutionNodes = metaSubstitutionChildNodes, ///
-          metaSubstitutionNodesMatches = matchMetaSubstitutionNodes(metaSubstitutionNodes, nodes);
-
-    metaSubstitutionNonTerminalNodeMatches = metaSubstitutionNodesMatches; ///
-  }
-
-  return metaSubstitutionNonTerminalNodeMatches;
-}

package/src/rule.js

@@ -51,10 +51,19 @@ export default class Rule {
 
       metastatementNatches = conclusionMatches; ///
     } else {
-      const metaAssertions = metaproofContext.getMetaAssertions();
+      const metaproofSteps = metaproofContext.getMetaproofSteps();
 
-      metastatementNatches = someSubArray(metaAssertions, premisesLength, (metaAssertions) => {
-        const premisesMatchConclusion = matchPremisesAndConclusion(this.premises, this.conclusion, metaAssertions, metastatementNode);
+      metastatementNatches = someSubArray(metaproofSteps, premisesLength, (metaproofSteps) => {
+        let premisesMatchConclusion = false;
+
+        const metaSubstitutions = [],
+              premisesMatches = matchPremises(this.premises, metaproofSteps, metaSubstitutions);
+
+        if (premisesMatches) {
+          const conclusionMatches = matchConclusion(this.conclusion, metastatementNode, metaSubstitutions);
+
+          premisesMatchConclusion = conclusionMatches;  ///
+        }
 
         if (premisesMatchConclusion) {
           return true;
@@ -136,10 +145,10 @@ export default class Rule {
   }
 }
 
-function matchPremise(premise, metaAssertions, metaSubstitutions) {
-  const metaAssertion = prune(metaAssertions, (metaAssertion) => {
-    const metaSubproofNode = metaAssertion.getMetaSubproofNode(),
-          metastatementNode = metaAssertion.getMetastatementNode()
+function matchPremise(premise, metaproofSteps, metaSubstitutions) {
+  const metaproofStep = prune(metaproofSteps, (metaproofStep) => {
+    const metaSubproofNode = metaproofStep.getMetaSubproofNode(),
+          metastatementNode = metaproofStep.getMetastatementNode()
 
     if (metaSubproofNode !== null) {
       const metaSubProofMatches = premise.matchMetaSubproofNode(metaSubproofNode, metaSubstitutions);
@@ -156,17 +165,16 @@ function matchPremise(premise, metaAssertions, metaSubstitutions) {
         return true;
       }
     }
-
   }) || null;
 
-  const premiseMatches = (metaAssertion !== null);
+  const premiseMatches = (metaproofStep !== null);
 
   return premiseMatches;
 }
 
-function matchPremises(premise, metaAssertions, metaSubstitutions) {
+function matchPremises(premise, metaproofSteps, metaSubstitutions) {
   const premisesMatches = premise.every((premise) => {
-    const premiseMatches = matchPremise(premise, metaAssertions, metaSubstitutions);
+    const premiseMatches = matchPremise(premise, metaproofSteps, metaSubstitutions);
 
     if (premiseMatches) {
       return true;
@@ -182,18 +190,3 @@ function matchConclusion(conclusion, metastatementNode, metaSubstitutions) {
 
   return conclusionMatches;
 }
-
-function matchPremisesAndConclusion(premises, conclusion, metaAssertions, metastatementNode) {
-  let premisesMatchConclusion = false;
-
-  const metaSubstitutions = [],
-        premisesMatches = matchPremises(premises, metaAssertions, metaSubstitutions);
-
-  if (premisesMatches) {
-    const conclusionMatches = matchConclusion(conclusion, metastatementNode, metaSubstitutions);
-
-    premisesMatchConclusion = conclusionMatches;  ///
-  }
-
-  return premisesMatchConclusion;
-}

package/src/step/metaproof.js

@@ -0,0 +1,99 @@
+"use strict";
+
+import { first, second } from "../utilities/array";
+import { nodeQuery, nodesQuery } from "../utilities/query";
+import { matchBracketedNonTerminalNode } from "../utilities/node";
+
+const metastatementNodesQuery = nodesQuery("/metaSubproofAssertion/metastatement"),
+      metaSubproofAssertionNodeQuery = nodeQuery("/metastatement/metaSubproofAssertion"),
+      qualifiedOrUnqualifiedMetastatementMetastatementNodesQuery = nodesQuery("/metaSubproof/qualifiedMetastatement|unqualifiedMetastatement/metastatement!");
+
+export default class MetaproofStep {
+  constructor(metaSubproofNode, metastatementNode) {
+    this.metaSubproofNode = metaSubproofNode;
+    this.metastatementNode = metastatementNode;
+  }
+
+  getMetaSubproofNode() {
+    return this.metaSubproofNode;
+  }
+
+  getMetastatementNode() {
+    return this.metastatementNode;
+  }
+
+  matchMetastatement(metastatementNode) {
+    let metastatementMatches;
+
+    const metaSubproofAssertionNode = metaSubproofAssertionNodeQuery(metastatementNode);
+
+    if (metaSubproofAssertionNode !== null) {
+      const metaSubproofAssertionMatches = this.matchMetaSubproofAssertion(metaSubproofAssertionNode);
+
+      metastatementMatches = metaSubproofAssertionMatches;  ///
+    } else {
+      const metastatementsMatch = this.matchMetastatements(metastatementNode);
+
+      metastatementMatches = metastatementsMatch; //
+    }
+
+    return metastatementMatches;
+  }
+
+  matchMetastatements(metastatementNode) {
+    let metastatementsMatch = false;
+
+    if (this.metastatementNode !== null) {
+      const nonTerminalNodeA = metastatementNode, ///
+            nonTerminalNodeB = this.metastatementNode,  ///
+            bracketedNodeMatches = matchBracketedNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB),
+            metastatementNodeMatches = bracketedNodeMatches;  ///
+
+      return metastatementNodeMatches;
+    }
+
+    return metastatementsMatch;
+  }
+
+  matchMetaSubproofAssertion(metaSubproofAssertionNode) {
+    let metaSubproofAssertionMatches = false;
+
+    if (this.metaSubproofNode !== null) {
+      const metaSubproofAssertionMetastatementNodes = metastatementNodesQuery(metaSubproofAssertionNode),
+            firstMetaSubproofAssertionMetastatementNode = first(metaSubproofAssertionMetastatementNodes),
+            qualifiedOrUnqualifiedMetastatementMetastatementNodes = qualifiedOrUnqualifiedMetastatementMetastatementNodesQuery(this.metaSubproofNode),
+            firstQualifiedOrUnqualifiedMetastatementMetastatementNode = first(qualifiedOrUnqualifiedMetastatementMetastatementNodes);
+
+      const nonTerminalNodeA = firstMetaSubproofAssertionMetastatementNode,  ///
+            nonTerminalNodeB = firstQualifiedOrUnqualifiedMetastatementMetastatementNode, ///
+            bracketedNodeMatches = matchBracketedNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB);
+
+      if (bracketedNodeMatches) {
+        const secondMetaSubproofAssertionMetastatementNode = second(metaSubproofAssertionMetastatementNodes),
+              secondQualifiedOrUnqualifiedMetastatementMetastatementNode = second(qualifiedOrUnqualifiedMetastatementMetastatementNodes);
+
+        const nonTerminalNodeA = secondMetaSubproofAssertionMetastatementNode, ///
+              nonTerminalNodeB = secondQualifiedOrUnqualifiedMetastatementMetastatementNode, ///
+              bracketedNodeMatches = matchBracketedNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB);
+
+        metaSubproofAssertionMatches = bracketedNodeMatches; ///
+      }
+    }
+
+    return metaSubproofAssertionMatches;
+  }
+
+  static fromMetaSubproofNode(metaSubproofNode) {
+    const metastatementNode = null,
+          metaProofStep = new MetaproofStep(metaSubproofNode, metastatementNode);
+
+    return metaProofStep;
+  }
+
+  static fromMetastatementNode(metastatementNode) {
+    const metaSubproofNode = null,
+          metaProofStep = new MetaproofStep(metaSubproofNode, metastatementNode);
+
+    return metaProofStep;
+  }
+}

package/src/step/proof.js

@@ -0,0 +1,30 @@
+"use strict";
+
+export default class ProofStep {
+  constructor(subproofNode, statementNode) {
+    this.subproofNode = subproofNode;
+    this.statementNode = statementNode;
+  }
+
+  getSubproofNode() {
+    return this.subproofNode;
+  }
+
+  getStatementNode() {
+    return this.statementNode;
+  }
+
+  static fromSubproofNode(subproofNode) {
+    const statementNode = null,
+          metaProofStep = new ProofStep(subproofNode, statementNode);
+
+    return metaProofStep;
+  }
+
+  static fromStatementNode(statementNode) {
+    const subproofNode = null,
+          metaProofStep = new ProofStep(subproofNode, statementNode);
+
+    return metaProofStep;
+  }
+}