occam-verify-cli 0.0.478 → 0.0.480

package/src/rule.js

@@ -40,6 +40,40 @@ export default class Rule {
     return matchesLabelName;
   }
 
+  matchStatement(statementNode, proofContext) {
+    let statementNatches;
+
+    const premisesLength = this.premises.length;
+
+    if (premisesLength === 0) {
+      const substitutions = [],
+            conclusionMatches = matchConclusion(this.conclusion, statementNode, substitutions);
+
+      statementNatches = conclusionMatches; ///
+    } else {
+      const proofSteps = proofContext.getProofSteps();
+
+      statementNatches = someSubArray(proofSteps, premisesLength, (proofSteps) => {
+        let premisesMatchConclusion = false;
+
+        const substitutions = [],
+              premisesMatch = matchPremises(this.premises, proofSteps, substitutions);
+
+        if (premisesMatch) {
+          const conclusionMatches = matchConclusion(this.conclusion, statementNode, substitutions);
+
+          premisesMatchConclusion = conclusionMatches;  ///
+        }
+
+        if (premisesMatchConclusion) {
+          return true;
+        }
+      });
+    }
+
+    return statementNatches;
+  }
+
   matchMetastatement(metastatementNode, metaproofContext) {
     let metastatementNatches;
 
@@ -47,7 +81,7 @@ export default class Rule {
 
     if (premisesLength === 0) {
       const metaSubstitutions = [],
-            conclusionMatches = matchConclusion(this.conclusion, metastatementNode, metaSubstitutions);
+            conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, metaSubstitutions);
 
       metastatementNatches = conclusionMatches; ///
     } else {
@@ -57,10 +91,10 @@ export default class Rule {
         let premisesMatchConclusion = false;
 
         const metaSubstitutions = [],
-              premisesMatches = matchPremises(this.premises, metaproofSteps, metaSubstitutions);
+              premisesMatch = metaMatchPremises(this.premises, metaproofSteps, metaSubstitutions);
 
-        if (premisesMatches) {
-          const conclusionMatches = matchConclusion(this.conclusion, metastatementNode, metaSubstitutions);
+        if (premisesMatch) {
+          const conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, metaSubstitutions);
 
           premisesMatchConclusion = conclusionMatches;  ///
         }
@@ -145,23 +179,69 @@ export default class Rule {
   }
 }
 
-function matchPremise(premise, metaproofSteps, metaSubstitutions) {
+function matchPremise(premise, proofSteps, substitutions) {
+  const proofStep = prune(proofSteps, (proofStep) => {
+    const subproofNode = proofStep.getSubproofNode(),
+          statementNode = proofStep.getStatementNode()
+
+    if (subproofNode !== null) {
+      const subProofNodeMatches = premise.matchSubproofNode(subproofNode, substitutions);
+
+      if (!subProofNodeMatches) {  ///
+        return true;
+      }
+    }
+
+    if (statementNode !== null) {
+      const statementNodeMatches = premise.matchStatementNode(statementNode, substitutions);
+
+      if (!statementNodeMatches) {  ///
+        return true;
+      }
+    }
+  }) || null;
+
+  const premiseMatches = (proofStep !== null);
+
+  return premiseMatches;
+}
+
+function matchPremises(premise, proofSteps, substitutions) {
+  const premisesMatch = premise.every((premise) => {
+    const premiseMatches = matchPremise(premise, proofSteps, substitutions);
+
+    if (premiseMatches) {
+      return true;
+    }
+  });
+
+  return premisesMatch;
+}
+
+function matchConclusion(conclusion, statementNode, substitutions) {
+  const statementNodeMatches = conclusion.matchStatementNode(statementNode, substitutions),
+        conclusionMatches = statementNodeMatches; ///
+
+  return conclusionMatches;
+}
+
+function metaMatchPremise(premise, metaproofSteps, metaSubstitutions) {
   const metaproofStep = prune(metaproofSteps, (metaproofStep) => {
     const metaSubproofNode = metaproofStep.getMetaSubproofNode(),
           metastatementNode = metaproofStep.getMetastatementNode()
 
     if (metaSubproofNode !== null) {
-      const metaSubProofMatches = premise.matchMetaSubproofNode(metaSubproofNode, metaSubstitutions);
+      const metaSubProofNodeMatches = premise.matchMetaSubproofNode(metaSubproofNode, metaSubstitutions);
 
-      if (!metaSubProofMatches) {  ///
+      if (!metaSubProofNodeMatches) {  ///
         return true;
       }
     }
 
     if (metastatementNode !== null) {
-      const metastatementMatches = premise.matchMetastatementNode(metastatementNode, metaSubstitutions);
+      const metastatementNodeMatches = premise.matchMetastatementNode(metastatementNode, metaSubstitutions);
 
-      if (!metastatementMatches) {  ///
+      if (!metastatementNodeMatches) {  ///
         return true;
       }
     }
@@ -172,21 +252,21 @@ function matchPremise(premise, metaproofSteps, metaSubstitutions) {
   return premiseMatches;
 }
 
-function matchPremises(premise, metaproofSteps, metaSubstitutions) {
-  const premisesMatches = premise.every((premise) => {
-    const premiseMatches = matchPremise(premise, metaproofSteps, metaSubstitutions);
+function metaMatchPremises(premise, metaproofSteps, metaSubstitutions) {
+  const premisesMatch = premise.every((premise) => {
+    const premiseMatches = metaMatchPremise(premise, metaproofSteps, metaSubstitutions);
 
     if (premiseMatches) {
       return true;
     }
   });
 
-  return premisesMatches;
+  return premisesMatch;
 }
 
-function matchConclusion(conclusion, metastatementNode, metaSubstitutions) {
-  const nonTerminalNodeMatches = conclusion.matchMetastatementNode(metastatementNode, metaSubstitutions),
-        conclusionMatches = nonTerminalNodeMatches; ///
+function metaMatchConclusion(conclusion, metastatementNode, metaSubstitutions) {
+  const metastatementNodeMatches = conclusion.matchMetastatementNode(metastatementNode, metaSubstitutions),
+        conclusionMatches = metastatementNodeMatches; ///
 
   return conclusionMatches;
 }

package/src/ruleNames.js

@@ -4,12 +4,13 @@ export const TERM_RULE_NAME = "term";
 export const TYPE_RULE_NAME = "type";
 export const LABEL_RULE_NAME = "label";
 export const ARGUMENT_RULE_NAME = "argument";
+export const SUBPROOF_RULE_NAME = "subproof";
+export const STATEMENT_RULE_NAME = "statement";
 export const METAVARIABLE_RULE_NAME = "metavariable";
 export const METASTATEMENT_RULE_NAME = "metastatement";
 export const META_SUBPROOF_RULE_NAME = "metaSubproof";
+export const QUALIFIED_STATEMENT_RULE_NAME = "qualifiedStatement";
 export const UNQUALIFIED_STATEMENT_RULE_NAME = "unqualifiedStatement";
 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";
 export const UNQUALIFIED_METASTATEMENT_RULE_NAME = "unqualifiedMetastatement";

package/src/substitution.js

@@ -1,59 +1,63 @@
 "use strict";
 
-import { matchNodes, bracketedChildNodeFromChildNodes } from "./utilities/node";
+import { STATEMENT_RULE_NAME } from "./ruleNames";
+import { matchNode, bracketedNonTerminalChildNodeFromChildNodes } from "./utilities/node";
 
 export default class Substitution {
-  constructor(variableName, nodes) {
-    this.variableName = variableName;
-    this.nodes = nodes;
+  constructor(metavariableName, statementNode) {
+    this.metavariableName = metavariableName;
+    this.statementNode = statementNode;
   }
 
-  getVariableName() {
-    return this.variableName;
+  getMetavariableName() {
+    return this.metavariableName;
   }
 
-  getNodes() {
-    return this.nodes;
+  getStatementNode() {
+    return this.statementNode;
   }
 
-  matchNodes(nodes) {
-    let matches;
+  matchStatementNode(statementNode) {
+    let matchesStatementNode;
 
-    const nodesA = this.nodes,  ///
-          nodesB = nodes,
-          metaSubstitutionNodesMatch = matchNodes(nodesA, nodesB);
+    const nodeA = this.statementNode,  ///
+          nodeB = statementNode,
+          nodeMatches = matchNode(nodeA, nodeB);
 
-    matches = metaSubstitutionNodesMatch;  ///
+    matchesStatementNode = nodeMatches;  ///
 
-    if (!matches) {
-      const childNodes = nodes, ///
-            bracketedChildNode = bracketedChildNodeFromChildNodes(childNodes);
+    if (!matchesStatementNode) {
+      const nonTerminalNode = statementNode,  ///
+            childNodes = nonTerminalNode.getChildNodes(), ///
+            ruleName = STATEMENT_RULE_NAME;
 
-      if (bracketedChildNode !== null) {
-        const nonTerminalNode = bracketedChildNode,  ///
-              childNodes = nonTerminalNode.getChildNodes(),
-              nodesB = childNodes, ///
-              nodesMatch = matchNodes(nodesA, nodesB);
+      statementNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
 
-        matches = nodesMatch; ///
+      if (statementNode !== null) {
+        const nodeA = this.statementNode,  ///
+              nodeB = statementNode,
+              nodeMatches = matchNode(nodeA, nodeB);
+
+        matchesStatementNode = nodeMatches;  ///
       }
     }
 
-    return matches;
+    return matchesStatementNode;
   }
 
-  static fromMetavariableNameAndNodes(variableName, nodes) {
-    const bracketedChildNode = bracketedChildNodeFromChildNodes(nodes);
+  static fromMetavariableNameAndStatementNode(metavariableName, statementNode) {
+    let substitution = new Substitution(metavariableName, statementNode);
 
-    if (bracketedChildNode !== null) {
-      const nonTerminalNode = bracketedChildNode,  ///
-            childNodes = nonTerminalNode.getChildNodes();
+    const nonTerminalNode = statementNode,  ///
+          childNodes = nonTerminalNode.getChildNodes(),
+          ruleName = STATEMENT_RULE_NAME;
 
-      nodes = childNodes; ///
-    }
+    statementNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
 
-    const metaSubstitution = new Substitution(variableName, nodes);
+    if (statementNode !== null) {
+      substitution = new Substitution(metavariableName, statementNode);
+    }
 
-    return metaSubstitution;
+    return substitution;
   }
 }

package/src/type.js

@@ -17,39 +17,45 @@ export default class Type {
   }
 
   isEqualTo(type) {
-    const equalToType = (this === type);
+    const equalTo = (this === type);
 
-    return equalToType;
+    return equalTo;
   }
 
   isSubTypeOf(type) {
-    let subTypeOfType = false;
+    let subTypeOf = false;
 
-    if (this.superType === type) {
-      subTypeOfType = true;
-    } else {
-      if (this.superType !== null) {
-        subTypeOfType = this.superType.isSubTypeOf(type);
+    let superType = this.superType;
+
+    while (superType !== null) {
+      if (superType === type) {
+        subTypeOf = true;
+
+        break;
       }
+
+      superType = superType.getSuperType();
     }
 
-    return subTypeOfType;
+    return subTypeOf;
   }
 
   isSuperTypeOf(type) {
-    let superTypeOfType = false;
+    let superTypeOf = false;
 
-    const superType = type.getSuperType();
+    let superType = type.getSuperType();
 
-    if (superType === this) {
-      superTypeOfType = true;
-    } else {
-      if (superType !== null) {
-        superTypeOfType = superType.isSuperTypeOf(this);
+    while (superType !== null) {
+      if (superType === this) {
+        superTypeOf = true;
+
+        break;
       }
+
+      superType = superType.getSuperType();
     }
 
-    return superTypeOfType;
+    return superTypeOf;
   }
 
   isEqualToOrSubTypeOf(type) {
@@ -68,13 +74,13 @@ export default class Type {
     return equalToTypeOrSuperTypeOf;
   }
 
-  isEqualToSubTypeOfOrSuperTypeOf(type) {
+  match(type) {
     const equalToType = this.isEqualTo(type),
           subTypeOfType = this.isSubTypeOf(type),
           superTypeOfType = this.isSuperTypeOf(type),
-          equalToTypeSubTypeOfOrSuperTypeOf = (equalToType || subTypeOfType || superTypeOfType);
+          matches = (equalToType || subTypeOfType || superTypeOfType);
 
-    return equalToTypeSubTypeOfOrSuperTypeOf;
+    return matches;
   }
 
   matchName(name) {

package/src/utilities/node.js

@@ -61,10 +61,10 @@ export function matchBracketedNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB
   if (!bracketedNodeMatches) {
     const nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
           childNodesA = nonTerminalNodeAChildNodes, ///
-          bracketedChildNodeA = bracketedChildNodeFromChildNodes(childNodesA);
+          bracketedNonTerminalChildNodeA = bracketedNonTerminalChildNodeFromChildNodes(childNodesA);
 
-    if (bracketedChildNodeA !== null) {
-      const nodeA = bracketedChildNodeA,  ///
+    if (bracketedNonTerminalChildNodeA !== null) {
+      const nodeA = bracketedNonTerminalChildNodeA,  ///
             nodeB = nonTerminalNodeB, ///
             nodeMatches = matchNode(nodeA, nodeB);
 
@@ -75,10 +75,10 @@ export function matchBracketedNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB
   if (!bracketedNodeMatches) {
     const nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
           childNodesB = nonTerminalNodeBChildNodes, ///
-          bracketedChildNodeB = bracketedChildNodeFromChildNodes(childNodesB);
+          bracketedNonTerminalChildNodeB = bracketedNonTerminalChildNodeFromChildNodes(childNodesB);
 
-    if (bracketedChildNodeB !== null) {
-      const nodeB = bracketedChildNodeB,  ///
+    if (bracketedNonTerminalChildNodeB !== null) {
+      const nodeB = bracketedNonTerminalChildNodeB,  ///
             nodeA = nonTerminalNodeA, ///
             nodeMatches = matchNode(nodeA, nodeB);
 
@@ -89,8 +89,8 @@ export function matchBracketedNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB
   return bracketedNodeMatches;
 }
 
-export function bracketedChildNodeFromChildNodes(childNodes) {
-  let bracketedChildNode = null;
+export function bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName = METASTATEMENT_RULE_NAME) {
+  let bracketedNonTerminalChildNode = null;
 
   const childNodesLength = childNodes.length;
 
@@ -109,17 +109,17 @@ export function bracketedChildNodeFromChildNodes(childNodes) {
             nonTerminalNodeRuleName = nonTerminalNode.getRuleName(),
             firstTerminalNodeContent = firstTerminalNode.getContent(),
             secondTerminalNodeContent = secondTerminalNode.getContent(),
+            nonTerminalNodeRuleNameRuleName = (nonTerminalNodeRuleName === ruleName),
             firstTerminalNodeContentLeftBracket = (firstTerminalNodeContent === LEFT_BRACKET),
-            secondTerminalNodeContentRightBracket = (secondTerminalNodeContent === RIGHT_BRACKET),
-            nonTerminalNodeRuleNameMetastatementRuleName = (nonTerminalNodeRuleName === METASTATEMENT_RULE_NAME);
+            secondTerminalNodeContentRightBracket = (secondTerminalNodeContent === RIGHT_BRACKET);
 
-      if (firstTerminalNodeContentLeftBracket && nonTerminalNodeRuleNameMetastatementRuleName && secondTerminalNodeContentRightBracket) {
-        bracketedChildNode = nonTerminalNode;  ///
+      if (nonTerminalNodeRuleNameRuleName && firstTerminalNodeContentLeftBracket && secondTerminalNodeContentRightBracket) {
+        bracketedNonTerminalChildNode = nonTerminalNode;  ///
       }
     }
   }
 
-  return bracketedChildNode;
+  return bracketedNonTerminalChildNode;
 }
 
 function matchTerminalNode(terminalNodeA, terminalNodeB) {

package/src/variable.js

@@ -1,10 +1,10 @@
 "use strict";
 
 export default class Variable {
-  constructor(type, name, value) {
+  constructor(type, name, termNode) {
     this.type = type;
     this.name = name;
-    this.value = value;
+    this.termNode = termNode;
   }
 
   getType() {
@@ -15,18 +15,12 @@ export default class Variable {
     return this.name;
   }
 
-  getValue() {
-    return this.value;
+  getTermNode() {
+    return this.termNode;
   }
 
-  isDefined() {
-    const defined = (this.value !== undefined);
-
-    return defined;
-  }
-
-  setValue(value) {
-    this.value = value;
+  setTermNode(termNode) {
+    this.termNode = termNode;
   }
 
   matchName(name) {
@@ -41,9 +35,9 @@ export default class Variable {
     if (variable === this) {
       equalTo = true;
     } else {
-      const value = variable.getValue();
+      const termNode = variable.getTermNode();
 
-      if (value === this.value) {
+      if (termNode === this.termNode) {
         equalTo = true;
       }
     }
@@ -66,8 +60,8 @@ export default class Variable {
   }
 
   static fromTypeAndName(type, name) {
-    const value = undefined,
-          variable = new Variable(type, name, value);
+    const termNode = null,
+          variable = new Variable(type, name, termNode);
 
     return variable;
   }

package/src/verify/statement/qualified.js

@@ -22,9 +22,14 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, proofCo
 
       qualifiedStatementVerified = statementVerified; ///
     } else {
-      const referenceName = referenceNameFromReferenceNode(referenceNode);
+      const referenceName = referenceNameFromReferenceNode(referenceNode),
+            rule = proofContext.findRuleByReferenceName(referenceName);
 
-      debugger
+      if (rule !== null) {
+        const ruleMatchesStatement = rule.matchStatement(statementNode, proofContext);
+
+        qualifiedStatementVerified = ruleMatchesStatement;  ///
+      }
     }
   }
 

package/src/verify/statement.js

@@ -1,35 +1,33 @@
 "use strict";
 
-import verifyEquality from "../verify/equality";
-import verifyTypeAssertion from "../verify/assertion/type";
+import verifyStatementAsEquality from "../verify/statementAsEquality";
+import verifyStatementTypeAssertion from "../verify/statementTypeAssertion";
 
-import { nodeQuery } from "../utilities/query";
 import { nodeAsString } from "../utilities/string";
 
-const equalityNodeQuery = nodeQuery("/statement/equality!"),
-      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
-
 export default function verifyStatement(statementNode, proofContext) {
   let statementVerified = false;
 
   proofContext.begin(statementNode);
 
-  const equalityNode = equalityNodeQuery(statementNode),
-        statementString = nodeAsString(statementNode),
-        typeAssertionNode = typeAssertionNodeQuery(statementNode);
+  const statementString = nodeAsString(statementNode);
 
   proofContext.debug(`Verifying the '${statementString}' statement...`);
 
-  if (equalityNode !== null) {
-    const equalityVerified = verifyEquality(equalityNode, proofContext);
+  if (!statementVerified) {
+    const equalityVerifiedAsEquality = verifyStatementAsEquality(statementNode, proofContext);
 
-    statementVerified = equalityVerified; ///
+    statementVerified = equalityVerifiedAsEquality; ///
   }
 
-  if (typeAssertionNode !== null) {
-    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, proofContext);
+  if (!statementVerified) {
+    const statementTypeAssertionVerified = verifyStatementTypeAssertion(statementNode, proofContext);
+
+    statementVerified = statementTypeAssertionVerified; ///
+  }
 
-    statementVerified = typeAssertionVerified; ///
+  if (!statementVerified) {
+    statementVerified = true; ///
   }
 
   statementVerified ?