occam-verify-cli 0.0.489 → 0.0.491

package/src/verify/metaDerivation.js

@@ -18,8 +18,6 @@ export default function verifyMetaDerivation(metaDerivationNode, metaproofContex
 
   metaproofContext.begin(metaDerivationNode);
 
-  metaproofContext.setDerived();
-
   const childNodes = childNodesQuery(metaDerivationNode);
 
   metaDerivationVerified = childNodes.every((childNode) => {  ///
@@ -30,8 +28,6 @@ export default function verifyMetaDerivation(metaDerivationNode, metaproofContex
     }
   });
 
-  metaproofContext.resetDerived();
-
   metaDerivationVerified ?
     metaproofContext.complete(metaDerivationNode) :
       metaproofContext.halt(metaDerivationNode);
@@ -44,8 +40,6 @@ function verifyMetaSubDerivation(metaSubDerivationNode, metaproofContext) {
 
   metaproofContext.begin(metaSubDerivationNode);
 
-  metaproofContext.setDerived();
-
   const childNodes = childNodesQuery(metaSubDerivationNode);
 
   metaDerivationVerified = childNodes.every((childNode) => {  ///
@@ -56,8 +50,6 @@ function verifyMetaSubDerivation(metaSubDerivationNode, metaproofContext) {
     }
   });
 
-  metaproofContext.resetDerived();
-
   metaDerivationVerified ?
     metaproofContext.complete(metaSubDerivationNode) :
       metaproofContext.halt(metaSubDerivationNode);
@@ -72,17 +64,17 @@ function verifyMetaSubproof(metaSubproofNode, metaproofContext) {
 
   const unqualifiedMetastatementNodes = unqualifiedMetastatementNodesQuery(metaSubproofNode),
         unqualifiedMetastatementsVerified = unqualifiedMetastatementNodes.every((unqualifiedMetastatementNode) => {
-      const unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, metaproofContext);
+          const unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, metaproofContext);
 
-      if (unqualifiedMetastatementVerified) {
-        return true;
-      }
-    });
+          if (unqualifiedMetastatementVerified) {
+            return true;
+          }
+        });
 
   if (unqualifiedMetastatementsVerified) {
     unqualifiedMetastatementNodes.forEach((unqualifiedMetastatementNode) => {
       const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
-        metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
+            metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
 
       metaproofContext.addMetaproofStep(metaproofStep);
     });

package/src/verify/metaproof.js

@@ -27,12 +27,8 @@ export default function verifyMetaproof(metaproofNode, conclusion, metaproofCont
   }
 
   if (qualifiedMetastatementNode !== null) {
-    metaproofContext.setDerived();
-
     qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, metaproofContext);
 
-    metaproofContext.resetDerived();
-
     if (qualifiedMetastatementVerified) {
       const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
             metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);

package/src/verify/metastatement/unqualified.js

@@ -17,15 +17,9 @@ export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementN
 
     metaproofContext.debug(`Verifying the ${metastatementString} unqualified metastatement...`);
 
-    const derived = metaproofContext.isDerived();
+    const metaAssertionMatches = metaproofContext.matchMetastatement(metastatementNode);
 
-    if (derived) {
-      const metaAssertionMatches = metaproofContext.matchMetastatement(metastatementNode);
-
-      unqualifiedMetastatementVerified = metaAssertionMatches;  ///
-    } else {
-      unqualifiedMetastatementVerified = true;
-    }
+    unqualifiedMetastatementVerified = metaAssertionMatches;  ///
   }
 
   unqualifiedMetastatementVerified ?

package/src/verify/premise.js

@@ -6,7 +6,7 @@ import MetaproofStep from "../step/metaproof";
 import { nodeQuery } from "../utilities/query";
 import { nodeAsString } from "../utilities/string";
 
-const metastatementNodeQuery = nodeQuery("/premise/unqualifiedStatement!/metastatement!");
+const metastatementNodeQuery = nodeQuery("/premise/unqualifiedMetastatement!/metastatement!");
 
 export default function verifyPremise(premiseNode, premises, metaproofContext) {
   let premiseVerified;

package/src/verify/proof.js

@@ -27,12 +27,8 @@ export default function verifyProof(proofNode, conclusion, proofContext) {
   }
 
   if (qualifiedStatementNode !== null) {
-    proofContext.setDerived();
-
     qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, proofContext);
 
-    proofContext.resetDerived();
-
     if (qualifiedStatementVerified) {
       const statementNode = statementNodeQuery(qualifiedStatementNode),
             proofStep = ProofStep.fromStatementNode(statementNode);

package/src/verify/statement/qualified.js

@@ -23,7 +23,8 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, proofCo
     const referenceNode = referenceNodeQuery(qualifiedStatementNode);
 
     if (referenceNode === null) {
-      const statementVerified = verifyStatement(statementNode, proofContext);
+      const qualified = true,
+            statementVerified = verifyStatement(statementNode, qualified, proofContext);
 
       qualifiedStatementVerified = statementVerified; ///
     } else {

package/src/verify/statement/unqualified.js

@@ -17,15 +17,9 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, pro
 
     proofContext.debug(`Verifying the ${statementString} unqualified statement...`);
 
-    const derived = proofContext.isDerived();
+    const assertionMatches = proofContext.matchStatement(statementNode);
 
-    if (derived) {
-      const assertionMatches = proofContext.matchStatement(statementNode);
-
-      unqualifiedStatementVerified = assertionMatches;  ///
-    } else {
-      unqualifiedStatementVerified = true;
-    }
+    unqualifiedStatementVerified = assertionMatches;  ///
   }
 
   unqualifiedStatementVerified ?

package/src/verify/statement.js

@@ -3,19 +3,19 @@
 import verifyStatementAsEquality from "../verify/statementAsEquality";
 import verifyStatementTypeAssertion from "../verify/statementTypeAssertion";
 
-export default function verifyStatement(statementNode, proofContext) {
+export default function verifyStatement(statementNode, qualified, proofContext) {
   let statementVerified = false;
 
   proofContext.begin(statementNode);
 
   if (!statementVerified) {
-    const equalityVerifiedAsEquality = verifyStatementAsEquality(statementNode, proofContext);
+    const equalityVerifiedAsEquality = verifyStatementAsEquality(statementNode, qualified, proofContext);
 
     statementVerified = equalityVerifiedAsEquality; ///
   }
 
   if (!statementVerified) {
-    const statementTypeAssertionVerified = verifyStatementTypeAssertion(statementNode, proofContext);
+    const statementTypeAssertionVerified = verifyStatementTypeAssertion(statementNode, qualified, proofContext);
 
     statementVerified = statementTypeAssertionVerified; ///
   }

package/src/verify/statementAsEquality.js

@@ -1,20 +1,18 @@
 "use strict";
 
 import Equality from "../equality";
-import Variable from "../variable";
 import verifyTerm from "../verify/term";
 
 import { nodeQuery } from "../utilities/query";
 import { nodeAsString } from "../utilities/string";
 import { first, second } from "../utilities/array";
-import { verifyTermAsVariable } from "../verify/term";
 import { EQUALS_CHARACTER, MAXIMUM_INDEXES_LENGTH } from "../constants";
 
 const specialNodeQuery = nodeQuery("/statement/@special!"),
       leftTermNodeQuery = nodeQuery("/statement/term[0]"),
       rightTermNodeQuery = nodeQuery("/statement/term[1]");
 
-export default function verifyStatementAsEquality(statementNode, proofContext) {
+export default function verifyStatementAsEquality(statementNode, qualified, proofContext) {
   let statementVerifiedAsEquality = false;
 
   proofContext.begin(statementNode);
@@ -48,38 +46,16 @@ export default function verifyStatementAsEquality(statementNode, proofContext) {
         if ((leftType === null) && (rightType === null)) {
           proofContext.error(`The types of the '${leftTermString}' and '${rightTermString}' terms are both undefined and therefore the terms cannot be equated.`);
         } else if (rightType === null) {
-          const type = leftType,  ///
-                termNode = rightTermNode, ///
-                variable = addVariable(type, termNode, proofContext);
-
-          if (variable !== null) {
-            const leftTypeName = leftType.getName();
-
-            proofContext.info(`The '${rightTermString}' variable has been given the '${leftTypeName}' type.`);
-
-            statementVerifiedAsEquality = true;
-          }
+          proofContext.info(`The type of the right '${rightTermString}' term is undefined and therefore the types cannot be equated.`);
         } else if (leftType === null) {
-          const type = rightType,  ///
-                termNode = leftType, ///
-                variable = addVariable(type, termNode, proofContext);
-
-          if (variable !== null) {
-            const rightTypeName = rightType.getName();
-
-            proofContext.info(`The '${rightTermString}' variable has been given the '${rightTypeName}' type.`);
-
-            statementVerifiedAsEquality = true;
-          }
+          proofContext.info(`The type of the left '${leftTermString}' term is undefined and therefore the types cannot be equated.`);
         } else {
           const leftTypeMatchesRightType = leftType.match(rightType);
 
           if (!leftTypeMatchesRightType) {
             proofContext.error(`The types of the '${leftTermString}' and '${rightTermString}' terms do not match and therefore the terms cannot be equated.`);
           } else {
-            const derived = proofContext.isDerived();
-
-            if (!derived) {
+            if (!qualified) {
               statementVerifiedAsEquality = true;
             } else {
               const equality = Equality.fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode),
@@ -123,24 +99,3 @@ function equalitiesFromProofSteps(proofSteps) {
 
   return equalities;
 }
-
-function addVariable(type, termNode, proofContext) {
-  let variable = null;
-
-  const variables = [],
-        termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, proofContext);
-
-  if (termVerifiedAsVariable) {
-    const firstVariable = first(variables);
-
-    variable = firstVariable;  ///
-
-    const name = variable.getName();
-
-    variable = Variable.fromTypeAndName(type, name);  ///
-
-    proofContext.addVariable(variable);
-  }
-
-  return variable;
-}

package/src/verify/statementTypeAssertion.js

@@ -11,7 +11,7 @@ const termNodeQuery = nodeQuery("/typeAssertion/term"),
       typeNodeQuery = nodeQuery("/typeAssertion/type"),
       typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
 
-export default function verifyStatementTypeAssertion(statementNode, proofContext) {
+export default function verifyStatementTypeAssertion(statementNode, qualified, proofContext) {
   let statementTypeAssertionVerified = false;
 
   proofContext.begin(statementNode);
@@ -30,17 +30,14 @@ export default function verifyStatementTypeAssertion(statementNode, proofContext
     if (!typePresent) {
       proofContext.error(`The ${typeName} type is not present.`);
     } else {
-      const context = proofContext, ///
-            termNode = termNodeQuery(typeAssertionNode),
-            variables = [],
-            termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context);
-
-      if (termVerifiedAsVariable) {
-        const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, proofContext);
+      if (!statementTypeAssertionVerified) {
+        const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, qualified, proofContext);
 
         statementTypeAssertionVerified = variableTypeAssertionVerified;  ///
-      } else {
-        const termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, proofContext);
+      }
+
+      if (!statementTypeAssertionVerified) {
+        const termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, qualified, proofContext);
 
         statementTypeAssertionVerified = termTypeAssertionVerified;  ///
       }
@@ -58,7 +55,47 @@ export default function verifyStatementTypeAssertion(statementNode, proofContext
   return statementTypeAssertionVerified;
 }
 
-function verifyTermTypeAssertion(typeAssertionNode, proofContext) {
+function verifyVariableTypeAssertion(typeAssertionNode, qualified, proofContext) {
+  let variableTypeAssertionVerified = false;
+
+  const context = proofContext, ///
+        variables = [],
+        termNode = termNodeQuery(typeAssertionNode),
+        termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context);
+
+  if (termVerifiedAsVariable) {
+    const typeNode = typeNodeQuery(typeAssertionNode),
+          typeName = typeNameFromTypeNode(typeNode),
+          assertedTypeName = typeName,  ///
+          assertedType = proofContext.findTypeByTypeName(assertedTypeName),
+          firstVariable = first(variables),
+          variable = firstVariable, ///
+          variableName = variable.getName(),
+          variableType = variable.getType();
+
+    const assertedTypeEqualToOrSubTypeOfVariableType = (variableType === null) ?
+                                                         true : ///
+                                                           assertedType.isEqualToOrSubTypeOf(variableType);
+
+    if (!assertedTypeEqualToOrSubTypeOfVariableType) {
+      proofContext.error(`The asserted type is not equal to or a sub-type of the '${variableName}' variable type.`);
+    } else {
+      if (!qualified) {
+        const type = assertedType,  ///
+              name = variableName,  ///
+              variable = Variable.fromTypeAndName(type, name);
+
+        proofContext.addVariable(variable);
+      }
+
+      variableTypeAssertionVerified = true;
+    }
+  }
+
+  return variableTypeAssertionVerified;
+}
+
+function verifyTermTypeAssertion(typeAssertionNode, qualified, proofContext) {
   let termTypeAssertionVerified = false;
 
   const types = [],
@@ -73,13 +110,18 @@ function verifyTermTypeAssertion(typeAssertionNode, proofContext) {
           assertedType = proofContext.findTypeByTypeName(assertedTypeName),
           firstType = first(types),
           termType = firstType,
-          assertedTypeEqualToOrSubTypeOfTermType = assertedType.isEqualToOrSubTypeOf(termType);
+          termString = nodeAsString(termNode),
+          assertedTypeEqualToOrSubTypeOfTermType = (termType === null) ?
+                                                     true : ///
+                                                       assertedType.isEqualToOrSubTypeOf(termType);
 
     if (!assertedTypeEqualToOrSubTypeOfTermType) {
-      const termString = nodeAsString(termNode);
-
       proofContext.error(`The asserted type is not equal to or a sub-type of the '${termString}' term type.`);
     } else {
+      if (!qualified) {
+        debugger
+      }
+
       termTypeAssertionVerified = true;
     }
   }
@@ -87,43 +129,3 @@ function verifyTermTypeAssertion(typeAssertionNode, proofContext) {
   return termTypeAssertionVerified;
 }
 
-function verifyVariableTypeAssertion(typeAssertionNode, proofContext) {
-  let variableTypeAssertionVerified = false;
-
-  const context = proofContext, ///
-        variables = [],
-        termNode = termNodeQuery(typeAssertionNode);
-
-  verifyTermAsVariable(termNode, variables, context);
-
-  const typeNode = typeNodeQuery(typeAssertionNode),
-        typeName = typeNameFromTypeNode(typeNode),
-        assertedTypeName = typeName,  ///
-        assertedType = proofContext.findTypeByTypeName(assertedTypeName),
-        firstVariable = first(variables),
-        variable = firstVariable, ///
-        variableName = variable.getName(),
-        variableType = variable.getType();
-
-  const assertedTypeEqualToOrSubTypeOfVariableType = (variableType === null) ?
-                                                        true :  ///
-                                                          assertedType.isEqualToOrSubTypeOf(variableType);
-
-  if (!assertedTypeEqualToOrSubTypeOfVariableType) {
-    proofContext.error(`The asserted type is not equal to or a sub-type of the '${variableName}' variable type.`);
-  } else {
-    const derived = proofContext.isDerived();
-
-    if (!derived) {
-      const type = assertedType,  ///
-            name = variableName,  ///
-            variable = Variable.fromTypeAndName(type, name);
-
-      proofContext.addVariable(variable);
-    }
-
-    variableTypeAssertionVerified = true;
-  }
-
-  return variableTypeAssertionVerified;
-}