occam-verify-cli 0.0.700 → 0.0.702

package/src/verifier/nodes/termForVariable.js

@@ -10,7 +10,7 @@ import { TERM_RULE_NAME } from "../../ruleNames";
 
 const variableNodeQuery = nodeQuery('/term/variable!');
 
-export default class TermForVariableNodesVerifier extends NodesVerifier {
+class TermForVariableNodesVerifier extends NodesVerifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead) {
     let nonTerminalNodeVerified = false;
 
@@ -74,47 +74,47 @@ export default class TermForVariableNodesVerifier extends NodesVerifier {
         variableVerified = verifiedAhead;  ///
       }
     } else {
-      const { createSubstitutions } = this.constructor;
+      const variableNode = variableNodeA, ///
+            localContext = localContextA, ///
+            variable = localContext.findVariableByVariableNode(variableNode);
 
-      if (createSubstitutions) {
-        const variableNode = variableNodeA, ///
-              localContext = localContextA, ///
-              variable = localContext.findVariableByVariableNode(variableNode);
+      if (variable !== null) {
+        const terms = [],
+              context = localContextB, ///
+              termNode = termNodeB, ///
+              termVerified = verifyTerm(termNode, terms, context, () => {
+                let verifiedAhead = false;
 
-        if (variable !== null) {
-          const terms = [],
-                context = localContextB, ///
-                termNode = termNodeB, ///
-                termVerified = verifyTerm(termNode, terms, context, () => {
-                  let verifiedAhead = false;
+                const firstTerm = first(terms),
+                      term = firstTerm, ///
+                      termType = term.getType(),
+                      variableType = variable.getType(),
+                      variableTypeEqualToOrSuperTypeOfTermType = variableType.isEqualToOrSuperTypeOf(termType);
 
-                  const firstTerm = first(terms),
-                        term = firstTerm, ///
-                        termType = term.getType(),
-                        variableType = variable.getType(),
-                        variableTypeEqualToOrSuperTypeOfTermType = variableType.isEqualToOrSuperTypeOf(termType);
+                if (variableTypeEqualToOrSuperTypeOfTermType) {
+                  const termForVariableSubstitution = TermForVariableSubstitution.fromVariableNodeAndTermNode(variableNode, termNode),
+                        substitution = termForVariableSubstitution;  ///
 
-                  if (variableTypeEqualToOrSuperTypeOfTermType) {
-                    const termForVariableSubstitution = TermForVariableSubstitution.fromVariableNodeAndTermNode(variableNode, termNode),
-                          substitution = termForVariableSubstitution;  ///
+                  substitutions.push(substitution);
 
-                    substitutions.push(substitution);
+                  verifiedAhead = verifyAhead();
 
-                    verifiedAhead = verifyAhead();
-
-                    if (!verifiedAhead) {
-                      substitutions.pop();
-                    }
+                  if (!verifiedAhead) {
+                    substitutions.pop();
                   }
+                }
 
-                  return verifiedAhead;
-                });
+                return verifiedAhead;
+              });
 
-          variableVerified = termVerified;  ///
-        }
+        variableVerified = termVerified;  ///
       }
     }
 
     return variableVerified;
   }
 }
+
+const termForVariableNodesVerifier = new TermForVariableNodesVerifier();
+
+export default termForVariableNodesVerifier;

package/src/verify/consequent.js

@@ -21,15 +21,15 @@ export default function verifyConsequent(consequentNode, consequents, localConte
         unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
 
   if (unqualifiedStatementVerified) {
+    consequentVerified = true;
+  }
+
+  if (consequentVerified) {
     const statementNode = statementNodeQuery(unqualifiedStatementNode),
           consequent = Consequent.fromStatementNode(statementNode);
 
     consequents.push(consequent);
 
-    consequentVerified = true;
-  }
-
-  if (consequentVerified) {
     localContext.debug(`...verified the '${consequentString}' consequent.`, consequentNode);
   }
 

package/src/verify/derivation.js

@@ -68,14 +68,17 @@ function verifySubproof(subproofNode, localContext) {
 }
 
 function verifyChild(childNode, localContext) {
-  let childVerified;
+  let childVerified = false;
 
   const childNodeRuleName = childNode.getRuleName();
 
   switch (childNodeRuleName) {
     case SUBPROOF_RULE_NAME: {
-      const subproofNode = childNode,  ///
-            subproofVerified = verifySubproof(subproofNode, localContext);
+      let subproofVerified;
+
+      const subproofNode = childNode;  ///
+
+      subproofVerified = verifySubproof(subproofNode, localContext);
 
       if (subproofVerified) {
         const proofStep = ProofStep.fromSubproofNode(subproofNode);
@@ -89,10 +92,23 @@ function verifyChild(childNode, localContext) {
     }
 
     case QUALIFIED_STATEMENT_RULE_NAME: {
+      let qualifiedStatementVerified;
+
       const derived = true,
             assignments = [],
-            qualifiedStatementNode = childNode,  ///
-            qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, assignments, derived, localContext);
+            qualifiedStatementNode = childNode;  ///
+
+      qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, assignments, derived, localContext);
+
+      if (qualifiedStatementVerified) {
+        qualifiedStatementVerified = assignments.every((assignment) => {  ///
+          const assigned = assignment.assign(localContext);
+
+          if (assigned) {
+            return true;
+          }
+        });
+      }
 
       if (qualifiedStatementVerified) {
         const statementNode = statementNodeQuery(qualifiedStatementNode),
@@ -100,17 +116,30 @@ function verifyChild(childNode, localContext) {
 
         localContext.addProofStep(proofStep);
 
-        childVerified = qualifiedStatementVerified; ///
+        childVerified = true; ///
       }
 
       break;
     }
 
     case UNQUALIFIED_STATEMENT_RULE_NAME: {
+      let unqualifiedStatementVerified;
+
       const derived = true,
             assignments = [],
-            unqualifiedStatementNode = childNode,  ///
-            unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
+            unqualifiedStatementNode = childNode;  ///
+
+      unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
+
+      if (unqualifiedStatementVerified) {
+        unqualifiedStatementVerified = assignments.every((assignment) => {  ///
+          const assigned = assignment.assign(localContext);
+
+          if (assigned) {
+            return true;
+          }
+        });
+      }
 
       if (unqualifiedStatementVerified) {
         const statementNode = statementNodeQuery(unqualifiedStatementNode),

package/src/verify/equality.js

@@ -59,13 +59,22 @@ function verifyDerivedEquality(equalityNode, assignments, derived, context, veri
                   secondTerm = second(terms),
                   leftTerm = firstTerm, ///
                   rightTerm = secondTerm, ///
-                  equality = Equality.fromEqualityNodeLeftTermAndRightTerm(equalityNode, leftTerm, rightTerm);
+                  equality = Equality.fromLeftTermRightTermAndEqualityNode(leftTerm, rightTerm, equalityNode);
 
             if (equality !== null) {
-              const equalityEqual = context.isEqualityEqual(equality);
+              const equalityEqual = equality.isEqual(context);
 
               if (equalityEqual) {
+                const equalityAssignment = EqualityAssignment.fromEquality(equality),
+                      assignment = equalityAssignment; ///
+
+                assignments.push(assignment);
+
                 verifiedAhead = verifyAhead();
+
+                if (!verifiedAhead) {
+                  assignments.pop();
+                }
               }
             }
 
@@ -104,7 +113,7 @@ function verifyGivenEquality(equalityNode, assignments, derived, context, verify
                   secondTerm = second(terms),
                   leftTerm = firstTerm, ///
                   rightTerm = secondTerm, ///
-                  equality = Equality.fromEqualityNodeLeftTermAndRightTerm(equalityNode, leftTerm, rightTerm);
+                  equality = Equality.fromLeftTermRightTermAndEqualityNode(leftTerm, rightTerm, equalityNode);
 
             if (equality !== null) {
               const equalityAssignment = EqualityAssignment.fromEquality(equality),

package/src/verify/{standaloneType.js → givenType.js}

@@ -2,12 +2,12 @@
 
 import { typeNameFromTypeNode } from "../utilities/query";
 
-export default function verifyStandaloneType(typeNode, types, context, verifyAhead) {
-  let standaloneTypeVerified = false;
+export default function verifyGivenType(typeNode, types, context, verifyAhead) {
+  let givenTypeVerified = false;
 
   const typeString = context.nodeAsString(typeNode);
 
-  context.trace(`Verifying the standalone '${typeString}' type...`, typeNode);
+  context.trace(`Verifying the given '${typeString}' type...`, typeNode);
 
   const typeName = typeNameFromTypeNode(typeNode),
         type = context.findTypeByTypeName(typeName);
@@ -23,12 +23,12 @@ export default function verifyStandaloneType(typeNode, types, context, verifyAhe
       types.pop();
     }
 
-    standaloneTypeVerified = verifiedAhead; ///
+    givenTypeVerified = verifiedAhead; ///
   }
 
-  if (standaloneTypeVerified) {
-    context.debug(`...verified the standalone '${typeString}' type.`, typeNode);
+  if (givenTypeVerified) {
+    context.debug(`...verified the given '${typeString}' type.`, typeNode);
   }
 
-  return standaloneTypeVerified;
+  return givenTypeVerified;
 }

package/src/verify/metastatement.js

@@ -28,8 +28,8 @@ function verifyMetastatement(metastatementNode, derived, localMetaContext) {
   return metastatementVerified;
 }
 
-Object.assign(verifyMetastatement, {
-  metastatementNodeVerifier
+Object.assign(metastatementNodeVerifier, {
+  verifyMetastatement
 });
 
 export default verifyMetastatement;

package/src/verify/statement/qualified.js

@@ -1,9 +1,14 @@
 "use strict";
 
+import verifyEquality from "../equality";
+import verifyTypeAssertion from "../typeAssertion";
+
 import { nodeQuery, referenceNameFromReferenceNode } from "../../utilities/query";
 
-const referenceNodeQuery = nodeQuery("/qualifiedStatement/qualification!/reference!"),
-      statementNodeQuery = nodeQuery("/qualifiedStatement/statement!");
+const equalityNodeQuery = nodeQuery("/qualifiedStatement/statement/equality!"),
+      referenceNodeQuery = nodeQuery("/qualifiedStatement/qualification!/reference!"),
+      statementNodeQuery = nodeQuery("/qualifiedStatement/statement!"),
+      typeAssertionNodeQuery = nodeQuery("/qualifiedStatement/statement/typeAssertion!");
 
 export default function verifyQualifiedStatement(qualifiedStatementNode, assignments, derived, localContext) {
   let qualifiedStatementVerified = false;
@@ -11,68 +16,218 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
   const statementNode = statementNodeQuery(qualifiedStatementNode);
 
   if (statementNode !== null) {
-    const statementString = localContext.nodeAsString(statementNode),
-          statementLocalContext = localContext; ///
+    const qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${statementString}' qualified statement...`, qualifiedStatementNode);
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement...`, qualifiedStatementNode);
 
     const referenceNode = referenceNodeQuery(qualifiedStatementNode),
-          referenceName = referenceNameFromReferenceNode(referenceNode);
+          referenceName = referenceNameFromReferenceNode(referenceNode),
+          verifyQualifiedStatementFunctions = [
+            verifyQualifiedStatementAAgainstRule,
+            verifyQualifiedStatementAAgainstAxiom,
+            verifyQualifiedStatementAAgainstLemma,
+            verifyQualifiedStatementAAgainstTheorem,
+            verifyQualifiedStatementAAgainstConjecture
+          ];
+
+    qualifiedStatementVerified = verifyQualifiedStatementFunctions.some((verifyQualifiedStatementFunction) => {  ///
+      const qualifiedStatementVerified = verifyQualifiedStatementFunction(qualifiedStatementNode, referenceName, localContext);
+
+      if (qualifiedStatementVerified) {
+        return true;
+      }
+    });
 
-    if (!qualifiedStatementVerified) {
-      const rule = localContext.findRuleByReferenceName(referenceName);
+    if (qualifiedStatementVerified) {
+      derived = false;  ///
 
-      if (rule !== null) {
-        const ruleMatchesStatement = rule.matchStatement(statementNode, statementLocalContext);
+      const context = localContext, ///
+            verifyQualifiedStatementFunctions = [
+              verifyQualifiedStatementAsEquality,
+              verifyQualifiedStatementAsTypeAssertion
+            ];
 
-        qualifiedStatementVerified = ruleMatchesStatement;  ///
-      }
+      qualifiedStatementVerified = verifyQualifiedStatementFunctions.every((verifyQualifiedStatementFunction) => { ///
+        const qualifiedStatementVerified = verifyQualifiedStatementFunction(qualifiedStatementNode, assignments, derived, context, () => {
+          const verifiedAhead = true;
+
+          return verifiedAhead;
+        });
+
+        if (qualifiedStatementVerified) {
+          return true;
+        }
+      });
     }
 
-    if (!qualifiedStatementVerified) {
-      const axiom = localContext.findAxiomByReferenceName(referenceName);
+    if (qualifiedStatementVerified) {
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement.`, qualifiedStatementNode);
+    }
+  }
 
-      if (axiom !== null) {
-        const axiomMatchesStatement = axiom.matchStatement(statementNode, statementLocalContext);
+  return qualifiedStatementVerified;
+}
 
-        qualifiedStatementVerified = axiomMatchesStatement; ///
-      }
+function verifyQualifiedStatementAAgainstRule(qualifiedStatementNode, referenceName, localContext) {
+  let qualifiedStatementVerifiedAgainstRule = false;
+
+  const rule = localContext.findRuleByReferenceName(referenceName);
+
+  if (rule !== null) {
+    const statementNode = statementNodeQuery(qualifiedStatementNode),
+          statementLocalContext = localContext, ///
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceName}' rule...`, statementNode);
+
+    const ruleMatchesStatement = rule.matchStatement(statementNode, statementLocalContext);
+
+    qualifiedStatementVerifiedAgainstRule = ruleMatchesStatement;  ///
+
+    if (qualifiedStatementVerifiedAgainstRule) {
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceName}' rule.`, statementNode);
     }
+  }
 
-    if (!qualifiedStatementVerified) {
-      const lemma = localContext.findLemmaByReferenceName(referenceName);
+  return qualifiedStatementVerifiedAgainstRule;
+}
 
-      if (lemma !== null) {
-        const lemmaMatchesStatement = lemma.matchStatement(statementNode, statementLocalContext);
+function verifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, referenceName, localContext) {
+  let qualifiedStatementVerifiedAgainstAxiom = false;
 
-        qualifiedStatementVerified = lemmaMatchesStatement; ///
-      }
+  const axiom = localContext.findAxiomByReferenceName(referenceName);
+
+  if (axiom !== null) {
+    const statementNode = statementNodeQuery(qualifiedStatementNode),
+          statementLocalContext = localContext, ///
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceName}' axiom...`, statementNode);
+
+    const axiomMatchesStatement = axiom.matchStatement(statementNode, statementLocalContext);
+
+    qualifiedStatementVerifiedAgainstAxiom = axiomMatchesStatement; ///
+
+    if (qualifiedStatementVerifiedAgainstAxiom) {
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceName}' axiom.`, statementNode);
     }
+  }
 
-    if (!qualifiedStatementVerified) {
-      const theorem = localContext.findTheoremByReferenceName(referenceName);
+  return qualifiedStatementVerifiedAgainstAxiom;
+}
 
-      if (theorem !== null) {
-        const theoremMatchesStatement = theorem.matchStatement(statementNode, statementLocalContext);
+function verifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, referenceName, localContext) {
+  let qualifiedStatementVerifiedAgainstLemma = false;
 
-        qualifiedStatementVerified = theoremMatchesStatement; ///
-      }
+  const lemma = localContext.findLemmaByReferenceName(referenceName);
+
+  if (lemma !== null) {
+    const statementNode = statementNodeQuery(qualifiedStatementNode),
+          statementLocalContext = localContext, ///
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceName}' lemma...`, statementNode);
+
+    const lemmaMatchesStatement = lemma.matchStatement(statementNode, statementLocalContext);
+
+    qualifiedStatementVerifiedAgainstLemma = lemmaMatchesStatement; ///
+
+    if (qualifiedStatementVerifiedAgainstLemma) {
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceName}' lemma.`, statementNode);
     }
+  }
+
+  return qualifiedStatementVerifiedAgainstLemma;
+}
 
-    if (!qualifiedStatementVerified) {
-      const conjecture = localContext.findConjectureByReferenceName(referenceName);
+function verifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, referenceName, localContext) {
+  let qualifiedStatementVerifiedAgainstTheorem = false;
 
-      if (conjecture !== null) {
-        const conjectureMatchesStatement = conjecture.matchStatement(statementNode, statementLocalContext);
+  const theorem = localContext.findTheoremByReferenceName(referenceName);
 
-        qualifiedStatementVerified = conjectureMatchesStatement; ///
-      }
+  if (theorem !== null) {
+    const statementNode = statementNodeQuery(qualifiedStatementNode),
+          statementLocalContext = localContext, ///
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceName}' theorem...`, statementNode);
+
+    const theoremMatchesStatement = theorem.matchStatement(statementNode, statementLocalContext);
+
+    qualifiedStatementVerifiedAgainstTheorem = theoremMatchesStatement; ///
+
+    if (qualifiedStatementVerifiedAgainstTheorem) {
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceName}' theorem.`, statementNode);
     }
+  }
 
-    if (qualifiedStatementVerified) {
-      localContext.debug(`...verified the '${statementString}' qualified statement.`, qualifiedStatementNode);
+  return qualifiedStatementVerifiedAgainstTheorem;
+}
+
+function verifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, referenceName, localContext) {
+  let qualifiedStatementVerifiedAgainstConjecture = false;
+
+  const conjecture = localContext.findConjectureByReferenceName(referenceName);
+
+  if (conjecture !== null) {
+    const statementNode = statementNodeQuery(qualifiedStatementNode),
+          statementLocalContext = localContext, ///
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceName}' conjecture...`, statementNode);
+
+    const conjectureMatchesStatement = conjecture.matchStatement(statementNode, statementLocalContext);
+
+    qualifiedStatementVerifiedAgainstConjecture = conjectureMatchesStatement; ///
+
+    if (qualifiedStatementVerifiedAgainstConjecture) {
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceName}' conjecture.`, statementNode);
     }
   }
 
-  return qualifiedStatementVerified;
+  return qualifiedStatementVerifiedAgainstConjecture;
+}
+
+function verifyQualifiedStatementAsEquality(qualifiedStatementNode, assignments, derived, context, verifyAhead) {
+  let statementVerifiedAsEquality = true; ///
+
+  const equalityNode = equalityNodeQuery(qualifiedStatementNode);
+
+  if (equalityNode !== null) {
+    const qualifiedStatementString = context.nodeAsString(qualifiedStatementNode);
+
+    context.trace(`Verifying the '${qualifiedStatementString}' qualified statement as an equality...`, qualifiedStatementNode);
+
+    const equalityVerified = verifyEquality(equalityNode, assignments, derived, context, verifyAhead);
+
+    statementVerifiedAsEquality = equalityVerified; ///
+
+    if (statementVerifiedAsEquality) {
+      context.debug(`...verified the '${qualifiedStatementString}' qualified statement as an equality.`, qualifiedStatementNode);
+    }
+  }
+
+  return statementVerifiedAsEquality;
+}
+
+function verifyQualifiedStatementAsTypeAssertion(qualifiedStatementNode, assignments, derived, context, verifyAhead) {
+  let statementVerifiedAsTypeAssertion = true;  ///
+
+  const typeAssertionNode = typeAssertionNodeQuery(qualifiedStatementNode);
+
+  if (typeAssertionNode !== null) {
+    const qualifiedStatementString = context.nodeAsString(qualifiedStatementNode);
+
+    context.trace(`Verifying the '${qualifiedStatementString}' qualified statement as a type assertion...`, qualifiedStatementNode);
+
+    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, context, verifyAhead);
+
+    statementVerifiedAsTypeAssertion = typeAssertionVerified; ///
+
+    if (statementVerifiedAsTypeAssertion) {
+      context.debug(`...verified the '${qualifiedStatementString}' qualified statement as a type assertion.`, qualifiedStatementNode);
+    }
+  }
+
+  return statementVerifiedAsTypeAssertion;
 }