occam-verify-cli 0.0.697 → 0.0.700

package/src/verify/derivation.js

@@ -2,7 +2,7 @@
 
 import ProofStep from "../step/proof";
 import LocalContext from "../context/local";
-import verifySupposition from "./supposition";
+import verifySuppositions from "../verify/suppositions";
 import verifyQualifiedStatement from "../verify/statement/qualified";
 import verifyUnqualifiedStatement from "../verify/statement/unqualified";
 
@@ -53,13 +53,7 @@ function verifySubproof(subproofNode, localContext) {
 
   const suppositions = [],
         suppositionNodes = suppositionNodesQuery(subproofNode),
-        suppositionsVerified = suppositionNodes.every((suppositionNode) => {
-          const suppositionVerified = verifySupposition(suppositionNode, suppositions, localContext);
-
-          if (suppositionVerified) {
-            return true;
-          }
-        });
+        suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
 
   if (suppositionsVerified) {
     const subDerivationNode = subDerivationNodeQuery(subproofNode),

package/src/verify/equality.js

@@ -19,7 +19,7 @@ export default function verifyEquality(equalityNode, assignments, derived, conte
 
   const verifyEqualityFunctions = [
     verifyDerivedEquality,
-    verifyStandaloneEquality
+    verifyGivenEquality
   ];
 
   equalityVerified = verifyEqualityFunctions.some((verifyEqualityFunction) => {
@@ -59,7 +59,7 @@ function verifyDerivedEquality(equalityNode, assignments, derived, context, veri
                   secondTerm = second(terms),
                   leftTerm = firstTerm, ///
                   rightTerm = secondTerm, ///
-                  equality = Equality.fromLeftTermAndRightTerm(leftTerm, rightTerm);
+                  equality = Equality.fromEqualityNodeLeftTermAndRightTerm(equalityNode, leftTerm, rightTerm);
 
             if (equality !== null) {
               const equalityEqual = context.isEqualityEqual(equality);
@@ -82,13 +82,13 @@ function verifyDerivedEquality(equalityNode, assignments, derived, context, veri
   return derivedEqualityVerified;
 }
 
-function verifyStandaloneEquality(equalityNode, assignments, derived, context, verifyAhead) {
-  let standaloneEqualityVerified = false;
+function verifyGivenEquality(equalityNode, assignments, derived, context, verifyAhead) {
+  let givenEqualityVerified = false;
 
   if (!derived) {
     const equalityString = context.nodeAsString(equalityNode);
 
-    context.trace(`Verifying the '${equalityString}' standalone equality...`, equalityNode);
+    context.trace(`Verifying the '${equalityString}' given equality...`, equalityNode);
 
     const terms = [],
           leftTermNode = leftTermNodeQuery(equalityNode),
@@ -104,7 +104,7 @@ function verifyStandaloneEquality(equalityNode, assignments, derived, context, v
                   secondTerm = second(terms),
                   leftTerm = firstTerm, ///
                   rightTerm = secondTerm, ///
-                  equality = Equality.fromLeftTermAndRightTerm(leftTerm, rightTerm);
+                  equality = Equality.fromEqualityNodeLeftTermAndRightTerm(equalityNode, leftTerm, rightTerm);
 
             if (equality !== null) {
               const equalityAssignment = EqualityAssignment.fromEquality(equality),
@@ -122,12 +122,12 @@ function verifyStandaloneEquality(equalityNode, assignments, derived, context, v
             return verifiedAhead;
           });
 
-    standaloneEqualityVerified = termsVerified; ///
+    givenEqualityVerified = termsVerified; ///
 
-    if (standaloneEqualityVerified) {
-      context.trace(`...verified the '${equalityString}' standalone equality.`, equalityNode);
+    if (givenEqualityVerified) {
+      context.trace(`...verified the '${equalityString}' given equality.`, equalityNode);
     }
   }
 
-  return standaloneEqualityVerified;
+  return givenEqualityVerified;
 }

package/src/verify/file.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import FileContext from "../context/file";
-import verifyTopLevelDeclaration from "./declaration/topLevel";
+import verifyTopLevelDeclaration from "../verify/declaration/topLevel";
 
 import { nodesQuery } from "../utilities/query";
 

package/src/verify/lemma.js

@@ -4,8 +4,8 @@ import Lemma from "../lemma";
 import verifyProof from "../verify/proof";
 import LocalContext from "../context/local";
 import verifyLabels from "../verify/labels";
-import verifyConsequent from "./consequent";
-import verifySupposition from "./supposition";
+import verifyConsequent from "../verify/consequent";
+import verifySuppositions from "../verify/suppositions";
 
 import { first } from "../utilities/array";
 import { EMPTY_STRING } from "../constants";
@@ -33,13 +33,7 @@ export default function verifyLemma(lemmaNode, fileContext) {
   if (labelsVerified) {
     const suppositions = [],
           suppositionNodes = suppositionsNodeQuery(lemmaNode),
-          suppositionsVerified = suppositionNodes.every((suppositionNode) => {
-            const suppositionVerified = verifySupposition(suppositionNode, suppositions, localContext);
-
-            if (suppositionVerified) {
-              return true;
-            }
-          });
+          suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
 
     if (suppositionsVerified) {
       const consequents = [],

package/src/verify/metavariable.js

@@ -1,8 +1,9 @@
 "use strict";
 
 import Metavariable from "../metavariable";
+import MetavariableAssignment from "../assignment/metavariable";
 
-import { metaTypeNameFromMetaTypeNode, metavariableNameFromMetavariableNode } from "../utilities/query";
+import { metaTypeNameFromMetaTypeNode } from "../utilities/query";
 
 export default function verifyMetavariable(metavariableNode, metaTypeNode, fileContext) {
   let metavariableVerified = false;
@@ -11,20 +12,20 @@ export default function verifyMetavariable(metavariableNode, metaTypeNode, fileC
 
   fileContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
 
-  const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-        metavariablePresent = fileContext.isMetavariablePresentByMetavariableName(metavariableName);
+  const metavariablePresent = fileContext.isMetavariablePresentByMetavariableNode(metavariableNode);
 
   if (metavariablePresent) {
-    fileContext.debug(`The metavariable '${metavariableName}' is already present.`, metavariableNode);
+    fileContext.debug(`The metavariable '${metavariableString}' is already present.`, metavariableNode);
   } else {
     const metaTypeName = metaTypeNameFromMetaTypeNode(metaTypeNode),
           metaType = fileContext.findMetaTypeByMetaTypeName(metaTypeName),
-          name = metavariableName,  ///
-          metavariable = Metavariable.fromNameAndMetaType(name, metaType);
+          metavariable = Metavariable.fromMetavariableNodeAndMetaType(metavariableNode, metaType),
+          metavariableAssignment = MetavariableAssignment.fromMetavariable(metavariable),
+          metavariableAssigned = metavariableAssignment.assign(fileContext);
 
-    fileContext.addMetavariable(metavariable);
-
-    metavariableVerified = true;
+    if (metavariableAssigned) {
+      metavariableVerified = true;
+    }
   }
 
   if (metavariableVerified) {

package/src/verify/premises.js

@@ -0,0 +1,17 @@
+"use strict";
+
+import verifyPremise from "../verify/premise";
+
+export default function verifyPremises(premiseNodes, premises, localMetaContext) {
+  let premisesVerified;
+
+  premisesVerified = premiseNodes.every((premiseNode) => {
+    const premiseVerified = verifyPremise(premiseNode, premises, localMetaContext);
+
+    if (premiseVerified) {
+      return true;
+    }
+  });
+
+  return premisesVerified;
+}

package/src/verify/rule.js

@@ -2,7 +2,7 @@
 
 import Rule from "../rule";
 import verifyLabels from "../verify/labels";
-import verifyPremise from "../verify/premise";
+import verifyPremises from "../verify/premises";
 import verifyRuleProof from "../verify/ruleProof";
 import LocalMetaContext from "../context/localMeta";
 import verifyConclusion from "../verify/conclusion";
@@ -30,13 +30,7 @@ export default function verifyRule(ruleNode, fileContext) {
   if (labelsVerified) {
     const premises = [],
           premiseNodes = premisesNodeQuery(ruleNode),
-          premisesVerified = premiseNodes.every((premiseNode) => {
-            const premiseVerified = verifyPremise(premiseNode, premises, localMetaContext);
-
-            if (premiseVerified) {
-              return true;
-            }
-          });
+          premisesVerified = verifyPremises(premiseNodes, premises, localMetaContext);
 
     if (premisesVerified) {
       const conclusions = [],

package/src/verify/ruleDerivation.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import MetaproofStep from "../step/metaproof";
-import verifyPremise from "../verify/premise";
+import verifyPremises from "../verify/premises";
 import LocalMetaContext from "../context/localMeta";
 import verifyQualifiedMetastatement from "../verify/metastatement/qualified";
 import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
@@ -53,13 +53,11 @@ function verifyRuleSubproof(ruleSubproofNode, localMetaContext) {
 
   const premises = [],
         premiseNodes = premiseNodesQuery(ruleSubproofNode),
-        premisesVerified = premiseNodes.every((premiseNode) => {
-          const premiseVerified = verifyPremise(premiseNode, premises, localMetaContext);
+        premisesVerified = verifyPremises(premiseNodes, premises, localMetaContext);
 
-          if (premiseVerified) {
-            return true;
-          }
-        });
+        if (premiseVerified) {
+          return true;
+        }
 
   if (premisesVerified) {
     const ruleSubDerivationNode = ruleSubDerivationNodeQuery(ruleSubproofNode),

package/src/verify/standaloneType.js

@@ -0,0 +1,34 @@
+"use strict";
+
+import { typeNameFromTypeNode } from "../utilities/query";
+
+export default function verifyStandaloneType(typeNode, types, context, verifyAhead) {
+  let standaloneTypeVerified = false;
+
+  const typeString = context.nodeAsString(typeNode);
+
+  context.trace(`Verifying the standalone '${typeString}' type...`, typeNode);
+
+  const typeName = typeNameFromTypeNode(typeNode),
+        type = context.findTypeByTypeName(typeName);
+
+  if (type !== null) {
+    let verifiedAhead;
+
+    types.push(type)
+
+    verifiedAhead = verifyAhead();
+
+    if (!verifiedAhead) {
+      types.pop();
+    }
+
+    standaloneTypeVerified = verifiedAhead; ///
+  }
+
+  if (standaloneTypeVerified) {
+    context.debug(`...verified the standalone '${typeString}' type.`, typeNode);
+  }
+
+  return standaloneTypeVerified;
+}

package/src/verify/statement/unqualified.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import verifyStatement from "../statement";
+import verifyStatement from "../../verify/statement";
 
 import { nodeQuery } from "../../utilities/query";
 

package/src/verify/supposition.js

@@ -2,14 +2,14 @@
 
 import ProofStep from "../step/proof";
 import Supposition from "../supposition";
-import verifyUnqualifiedStatement from "./statement/unqualified";
+import verifyUnqualifiedStatement from "../verify/statement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
 
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
       unqualifiedStatementNodeQuery = nodeQuery("/supposition/unqualifiedStatement!");
 
-export default function verifySupposition(suppositionNode, suppositions, localContext) {
+export default function verifySupposition(suppositionNode, suppositions, assignments, localContext) {
   let suppositionVerified;
 
   const suppositionString = localContext.nodeAsString(suppositionNode);
@@ -17,7 +17,6 @@ export default function verifySupposition(suppositionNode, suppositions, localCo
   localContext.trace(`Verifying the '${suppositionString}' supposition...`, suppositionNode);
 
   const derived = false,
-        assignments = [],
         unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
         unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
 
@@ -30,10 +29,6 @@ export default function verifySupposition(suppositionNode, suppositions, localCo
 
     localContext.addProofStep(proofStep);
 
-    assignments.forEach((assignment) => {
-      assignment.assign(localContext);
-    });
-
     suppositionVerified = true;
   }
 

package/src/verify/suppositions.js

@@ -0,0 +1,29 @@
+"use strict";
+
+import verifySupposition from "../verify/supposition";
+
+export default function verifySuppositions(suppositionNodes, suppositions, localContext) {
+  let suppositionsVerified;
+
+  const assignments = [];
+
+  suppositionsVerified = suppositionNodes.every((suppositionNode) => {
+    const suppositionVerified = verifySupposition(suppositionNode, suppositions, assignments, localContext);
+
+    if (suppositionVerified) {
+      return true;
+    }
+  });
+
+  if (suppositionsVerified) {
+    suppositionsVerified = assignments.every((assignment) => {  ///
+      const assigned = assignment.assign(localContext);
+
+      if (assigned) {
+        return true;
+      }
+    });
+  }
+
+  return suppositionsVerified;
+}

package/src/verify/term.js

@@ -4,7 +4,7 @@ import Term from "../term";
 import termNodesVerifier from "../verifier/nodes/term";
 
 import { first } from "../utilities/array";
-import { nodeQuery, variableNameFromVariableNode } from "../utilities/query";
+import { nodeQuery } from "../utilities/query";
 
 const variableNodeQuery = nodeQuery("/term/variable!");
 
@@ -67,14 +67,11 @@ export function verifyTermAsVariable(termNode, variables, context, verifyAhead)
 
     context.trace(`Verifying the '${termString}' term as a variable...`, termNode);
 
-    const variableName = variableNameFromVariableNode(variableNode),
-          variablePresent = context.isVariablePresentByVariableName(variableName);
+    const variable = context.findVariableByVariableNode(variableNode);
 
-    if (variablePresent) {
+    if (variable !== null) {
       let verifiedAhead;
 
-      const variable = context.findVariableByVariableName(variableName);
-
       variables.push(variable);
 
       verifiedAhead = verifyAhead();

package/src/verify/termAndStandaloneType.js

@@ -0,0 +1,37 @@
+"use strict";
+
+import verifyTerm from "../verify/term";
+import verifyStandaloneType from "../verify/standaloneType";
+
+export default function verifyTermAndStandaloneType(termNode, typeNode, terms, types, context, verifyAhead) {
+  let termAndStandaloneTypeVerified;
+
+  const termString = context.nodeAsString(termNode),
+        typeString = context.nodeAsString(typeNode);
+
+  context.trace(`Verifying the '${termString}' term and the standalone '${typeString}' type...`, termNode);
+
+  const termVerified = verifyTerm(termNode, terms, context, () => {
+          let verifiedAhead;
+
+          const standaloneTypeVerified = verifyStandaloneType(typeNode, types, context, () => {
+            let verifiedAhead;
+
+            verifiedAhead = verifyAhead();
+
+            return verifiedAhead;
+          });
+
+          verifiedAhead = standaloneTypeVerified;  ///
+
+          return verifiedAhead;
+        });
+
+  termAndStandaloneTypeVerified = termVerified; ///
+
+  if (termAndStandaloneTypeVerified) {
+    context.debug(`...verified the '${termString}' term and the standalone '${typeString}' type.`, termNode);
+  }
+
+  return termAndStandaloneTypeVerified
+}

package/src/verify/termAsVariableAndStandaloneType.js

@@ -0,0 +1,38 @@
+"use strict";
+
+import verifyStandaloneType from "../verify/standaloneType";
+
+import { verifyTermAsVariable } from "../verify/term";
+
+export default function verifyTermAsVariableAndStandaloneType(termNode, typeNode, variables, types, context, verifyAhead) {
+  let termAsVariableAndStandaloneTypeVerified;
+
+  const termString = context.nodeAsString(termNode),
+        typeString = context.nodeAsString(typeNode);
+
+  context.trace(`Verifying the '${termString}' term as a variable and the standalone '${typeString}' type...`, termNode);
+
+  const termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context, () => {
+          let verifiedAhead;
+
+          const standaloneTypeVerified = verifyStandaloneType(typeNode, types, context, () => {
+            let verifiedAhead;
+
+            verifiedAhead = verifyAhead();
+
+            return verifiedAhead;
+          });
+
+          verifiedAhead = standaloneTypeVerified;  ///
+
+          return verifiedAhead;
+        });
+
+  termAsVariableAndStandaloneTypeVerified = termVerifiedAsVariable; ///
+
+  if (termAsVariableAndStandaloneTypeVerified) {
+    context.debug(`...verified the '${termString}' term as a variable and the standalone '${typeString}' type.`, termNode);
+  }
+
+  return termAsVariableAndStandaloneTypeVerified
+}

package/src/verify/theorem.js

@@ -4,8 +4,8 @@ import Theorem from "../theorem";
 import verifyProof from "../verify/proof";
 import LocalContext from "../context/local";
 import verifyLabels from "../verify/labels";
-import verifyConsequent from "./consequent";
-import verifySupposition from "./supposition";
+import verifyConsequent from "../verify/consequent";
+import verifySuppositions from "../verify/suppositions";
 
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
@@ -30,13 +30,7 @@ export default function verifyTheorem(theoremNode, fileContext) {
   if (labelsVerified) {
     const suppositions = [],
           suppositionNodes = suppositionsNodeQuery(theoremNode),
-          suppositionsVerified = suppositionNodes.every((suppositionNode) => {
-            const suppositionVerified = verifySupposition(suppositionNode, suppositions, localContext);
-
-            if (suppositionVerified) {
-              return true;
-            }
-          });
+          suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
 
     if (suppositionsVerified) {
       const consequents = [],

package/src/verify/type.js

@@ -9,7 +9,7 @@ export default function verifyType(typeNode, superTypeNode, fileContext) {
 
   const typeString = fileContext.nodeAsString(typeNode);
 
-  fileContext.trace(`Verifying the '${typeString}' type.`, typeNode);
+  fileContext.trace(`Verifying the '${typeString}' type...`, typeNode);
 
   const typeName = typeNameFromTypeNode(typeNode),
         typePresent = fileContext.isTypePresentByTypeName(typeName);