occam-verify-cli 0.0.965 → 0.0.967

package/src/verify/assertion/type.js

@@ -112,13 +112,8 @@ function verifyStatedTypeAssertion(typeAssertionNode, assignments, derived, loca
                 const variableNode = variableNodeQuery(termNode);
 
                 if (variableNode !== null) {
-                  let variable;
-
-                  variable = localContext.findVariableByVariableNode(variableNode);
-
-                  variable = Variable.fromVariableAndType(variable, type);  ///
-
-                  const variableAssignment = VariableAssignment.fromVariable(variable),
+                  const variable = Variable.fromVariableNodeAndType(variableNode, type),
+                        variableAssignment = VariableAssignment.fromVariable(variable),
                         assignment = variableAssignment;  ///
 
                   assignments.push(assignment);

package/src/verify/equality.js

@@ -54,6 +54,11 @@ function verifyDerivedEquality(equalityNode, assignments, derived, localContext)
               const equalityEqual = equality.isEqual(localContext);
 
               if (equalityEqual) {
+                const equalityAssignment = EqualityAssignment.fromEquality(equality),
+                      assignment = equalityAssignment; ///
+
+                assignments.push(assignment);
+
                 verifiedAhead = true;
               }
             }

package/src/verify/proofStep.js

@@ -7,6 +7,7 @@ import verifyQualifiedStatement from "../verify/statement/qualified";
 import verifyUnqualifiedStatement from "../verify/statement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
+import { assignAssignments } from "../utilities/assignments";
 
 const subproofNodeQuery = nodeQuery("/proofStep|lastProofStep/subproof!"),
       statementNodeQuery = nodeQuery("/qualifiedStatement|unqualifiedStatement/statement!"),
@@ -31,26 +32,35 @@ export default function verifyProofStep(proofStepNode, substitutions, localConte
       proofStep = ProofStep.fromSubproofNode(subproofNode);
     }
   } else {
-    const derived = true,
-          assignments = null;
-
     if (qualifiedStatementNode !== null) {
-      const qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, substitutions, assignments, derived, localContext);
+      const derived = false,  ///
+            assignments = [],
+            qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, substitutions, assignments, derived, localContext);
 
       if (qualifiedStatementVerified) {
-        const statementNode = statementNodeQuery(qualifiedStatementNode);
+        const assignmentsAssigned = assignAssignments(assignments, localContext);
+
+        if (assignmentsAssigned) {
+          const statementNode = statementNodeQuery(qualifiedStatementNode);
 
-        proofStep = ProofStep.fromStatementNode(statementNode);
+          proofStep = ProofStep.fromStatementNode(statementNode);
+        }
       }
     }
 
     if (unqualifiedStatementNode !== null) {
-      const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
+      const derived = true,
+            assignments = [],
+            unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
 
       if (unqualifiedStatementVerified) {
-        const statementNode = statementNodeQuery(unqualifiedStatementNode);
+        const assignmentsAssigned = assignAssignments(assignments, localContext);
+
+        if (assignmentsAssigned) {
+          const statementNode = statementNodeQuery(unqualifiedStatementNode);
 
-        proofStep = ProofStep.fromStatementNode(statementNode);
+          proofStep = ProofStep.fromStatementNode(statementNode);
+        }
       }
     }
   }

package/src/verify/statement/qualified.js

@@ -7,12 +7,6 @@ import { nodeQuery } from "../../utilities/query";
 const statementNodeQuery = nodeQuery("/qualifiedStatement/statement!"),
       metavariableNodeQuery = nodeQuery("/qualifiedStatement/reference/metavariable!");
 
-const equalityNodeQuery = nodeQuery("/statement/equality!"),
-      judgementNodeQuery = nodeQuery("/statement/judgement!"),
-      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!"),
-      definedAssertionNodeQuery = nodeQuery("/statement/definedAssertion!"),
-      containedAssertionNodeQuery = nodeQuery("/statement/containedAssertion!");
-
 const unifyDerivedQualifiedStatementFunctions = [
   unifyDerivedQualifiedStatementAWithRule,
   unifyDerivedQualifiedStatementAWithAxiom,
@@ -33,13 +27,9 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, substit
         statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
 
   if (statementVerified) {
-    if (derived) {
-      const derivedQualifiedStatementVerified = verifyDerivedQualifiedStatement(qualifiedStatementNode, substitutions, localContext);
+    const derivedQualifiedStatementUnified = unifyDerivedQualifiedStatement(qualifiedStatementNode, substitutions, localContext);
 
-      qualifiedStatementVerified = derivedQualifiedStatementVerified; ///
-    } else {
-      qualifiedStatementVerified = true;
-    }
+    qualifiedStatementVerified = derivedQualifiedStatementUnified; ///
   }
 
   if (qualifiedStatementVerified) {
@@ -49,56 +39,24 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, substit
   return qualifiedStatementVerified;
 }
 
-function verifyDerivedQualifiedStatement(qualifiedStatementNode, substitutions, localContext) {
-  let derivedQualifiedStatementVerified = false;
+function unifyDerivedQualifiedStatement(qualifiedStatementNode, substitutions, localContext) {
+  let derivedQualifiedStatementUnified;
 
   const qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-  localContext.trace(`Verifying the '${qualifiedStatementString}' derived qualified statement...`, qualifiedStatementNode);
-
-  if (!derivedQualifiedStatementVerified) {
-    const derivedQualifiedStatementVerifiedTrivially = verifyDerivedQualifiedStatementATrivially(qualifiedStatementNode, substitutions, localContext);
-
-    derivedQualifiedStatementVerified = derivedQualifiedStatementVerifiedTrivially; ///
-  }
-
-  if (!derivedQualifiedStatementVerified) {
-    const derivedQualifiedStatementUnified = unifyDerivedQualifiedStatementFunctions.some((unifyDerivedQualifiedStatementFunction) => {
-      const derivedQualifiedStatementUnified = unifyDerivedQualifiedStatementFunction(qualifiedStatementNode, substitutions, localContext);
+  localContext.trace(`Unifying the '${qualifiedStatementString}' derived qualified statement...`, qualifiedStatementNode);
 
-      return derivedQualifiedStatementUnified;
-    });
+  derivedQualifiedStatementUnified = unifyDerivedQualifiedStatementFunctions.some((unifyDerivedQualifiedStatementFunction) => {
+    const derivedQualifiedStatementUnified = unifyDerivedQualifiedStatementFunction(qualifiedStatementNode, substitutions, localContext);
 
-    derivedQualifiedStatementVerified = derivedQualifiedStatementUnified; ///
-  }
-
-  if (derivedQualifiedStatementVerified) {
-    localContext.debug(`...verified the '${qualifiedStatementString}' derived qualified statement.`, qualifiedStatementNode);
-  }
-
-  return derivedQualifiedStatementVerified;
-}
+    return derivedQualifiedStatementUnified;
+  });
 
-function verifyDerivedQualifiedStatementATrivially(qualifiedStatementNode, substitutions, localContext) {
-  let derivedQualifiedStatementVerifiedTrivially = false;
-
-  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode);
-
-  if (metavariableNode === null) {
-    const statementNode = statementNodeQuery(qualifiedStatementNode),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
-
-    localContext.trace(`Unifying the '${qualifiedStatementString}' derived qualified statement trivially...`, qualifiedStatementNode);
-
-    debugger
-
-
-    if (derivedQualifiedStatementVerifiedTrivially) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' derived qualified statement trivially.`, qualifiedStatementNode);
-    }
+  if (derivedQualifiedStatementUnified) {
+    localContext.debug(`...unified the '${qualifiedStatementString}' derived qualified statement.`, qualifiedStatementNode);
   }
 
-  return derivedQualifiedStatementVerifiedTrivially;
+  return derivedQualifiedStatementUnified;
 }
 
 function unifyDerivedQualifiedStatementAWithRule(qualifiedStatementNode, substitutions, localContext) {

package/src/verify/statement/unqualified.js

@@ -3,6 +3,7 @@
 import verifyStatement from "../../verify/statement";
 
 import { nodeQuery } from "../../utilities/query";
+import { verifyStatementTrivially } from "../../verify/statement";
 
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
 
@@ -18,9 +19,15 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, ass
 
   if (statementVerified) {
     if (derived) {
-      const derivedUnqualifiedStatementVerified = verifyDerivedUnqualifiedStatement(unqualifiedStatementNode, localContext);
+      const statementVerifiedTrivially = verifyStatementTrivially(statementNode, localContext);
 
-      unqualifiedStatementVerified = derivedUnqualifiedStatementVerified; ///
+      if (statementVerifiedTrivially) {
+        unqualifiedStatementVerified = true;
+      } else {
+        const derivedUnqualifiedStatementUnified = unifyDerivedUnqualifiedStatement(unqualifiedStatementNode, localContext);
+
+        unqualifiedStatementVerified = derivedUnqualifiedStatementUnified; ///
+      }
     } else {
       unqualifiedStatementVerified = true;
     }
@@ -33,21 +40,21 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, ass
   return unqualifiedStatementVerified;
 }
 
-function verifyDerivedUnqualifiedStatement(unqualifiedStatementNode, localContext) {
-  let derivedUnqualifiedStatementVerified;
+function unifyDerivedUnqualifiedStatement(unqualifiedStatementNode, localContext) {
+  let derivedUnqualifiedStatementUnified;
 
   const unqualifiedStatementString = localContext.nodeAsString(unqualifiedStatementNode);
 
-  localContext.trace(`Verifying the '${unqualifiedStatementString}' derived unqualified statement...`, unqualifiedStatementNode);
+  localContext.trace(`Unifying the '${unqualifiedStatementString}' derived unqualified statement...`, unqualifiedStatementNode);
 
   const statementNode = statementNodeQuery(unqualifiedStatementNode),
         statementUnified = localContext.unifyStatement(statementNode, localContext);
 
-  derivedUnqualifiedStatementVerified = statementUnified;  ///
+  derivedUnqualifiedStatementUnified = statementUnified;  ///
 
-  if (derivedUnqualifiedStatementVerified) {
-    localContext.debug(`...verified the '${unqualifiedStatementString}' derived unqualified statement.`, unqualifiedStatementNode);
+  if (derivedUnqualifiedStatementUnified) {
+    localContext.debug(`...unified the '${unqualifiedStatementString}' derived unqualified statement.`, unqualifiedStatementNode);
   }
 
-  return derivedUnqualifiedStatementVerified;
+  return derivedUnqualifiedStatementUnified;
 }

package/src/verify/statement.js

@@ -89,6 +89,30 @@ Object.assign(shim, {
 
 export default verifyStatement;
 
+export function verifyStatementTrivially(statementNode, localContext) {
+  let statementVerifiedTrivially = false;
+
+  const statementString = localContext.nodeAsString(statementNode);
+
+  localContext.trace(`Verifying the '${statementString}' statement trivially...`, statementNode);
+
+  const equalityNode = equalityNodeQuery(statementNode),
+        judgementNode = judgementNodeQuery(statementNode),
+        typeAssertionNode = typeAssertionNodeQuery(statementNode),
+        definedAssertionNode = definedAssertionNodeQuery(statementNode),
+        containedAssertionNode = containedAssertionNodeQuery(statementNode);
+
+  if ((equalityNode !== null) || (judgementNode !== null) || (typeAssertionNode !== null) || (definedAssertionNode !== null) || (containedAssertionNode !== null)) {
+    statementVerifiedTrivially = true;
+  }
+
+  if (statementVerifiedTrivially) {
+    localContext.debug(`...verified the '${statementString}' statement trivially.`, statementNode);
+  }
+
+  return statementVerifiedTrivially;
+}
+
 function verifyStatementAsMetavariable(statementNode, assignments, derived, localContext) {
   let statementVerifiedAsMetavariable = false;