occam-verify-cli 0.0.864 → 0.0.866

package/src/verify/metatheorem.js

@@ -0,0 +1,62 @@
+"use strict";
+
+import Metatheorem from "../metatheorem";
+import verifyLabels from "../verify/labels";
+import verifyMetaproof from "../verify/metaproof";
+import LocalMetaContext from "../context/localMeta";
+import verifyMetaConsequent from "../verify/metaConsequent";
+import verifyMetaSuppositions from "../verify/metaSuppositions";
+
+import { first } from "../utilities/array";
+import { nodeQuery, nodesQuery } from "../utilities/query";
+
+const labelNodesQuery = nodesQuery("/metatheorem//labels/label"),
+      metaproofNodeQuery = nodeQuery("/metatheorem/metaproof!"),
+      metaConsequentNodeQuery = nodeQuery("/metatheorem/metaConsequent!"),
+      metaSuppositionsNodeQuery = nodesQuery("/metatheorem/metaSupposition");
+
+export default function verifyMetatheorem(metatheoremNode, fileContext) {
+  let metatheoremVerified = false;
+
+  const labelNodes = labelNodesQuery(metatheoremNode),
+        labelsString = fileContext.nodesAsString(labelNodes),
+        localMetaContext = LocalMetaContext.fromFileContext(fileContext);
+
+  fileContext.trace(`Verifying the '${labelsString}' metatheorem...`, metatheoremNode);
+
+  const labels = [],
+        labelsVerified = verifyLabels(labelNodes, labels, fileContext);
+
+  if (labelsVerified) {
+    const metaSuppositions = [],
+          metaSuppositionNodes = metaSuppositionsNodeQuery(metatheoremNode),
+          metaSuppositionsVerified = verifyMetaSuppositions(metaSuppositionNodes, metaSuppositions, localMetaContext);
+
+    if (metaSuppositionsVerified) {
+      const metaConsequents = [],
+            metaConsequentNode = metaConsequentNodeQuery(metatheoremNode),
+            metaConsequentVerified = verifyMetaConsequent(metaConsequentNode, metaConsequents, localMetaContext);
+
+      if (metaConsequentVerified) {
+        const metaproofNode = metaproofNodeQuery(metatheoremNode),
+              firstMetaConsequent = first(metaConsequents),
+              metaConsequent = firstMetaConsequent, ///
+              metaproofVerified = verifyMetaproof(metaproofNode, metaConsequent, localMetaContext);
+
+        if (metaproofVerified) {
+          const metatheorem = Metatheorem.fromLabelsMetaSuppositionsMetaConsequentAndLocalMetaContext(labels, metaSuppositions, metaConsequent, localMetaContext);
+
+          fileContext.addMetatheorem(metatheorem);
+
+          metatheoremVerified = true;
+        }
+      }
+    }
+  }
+
+  if (metatheoremVerified) {
+    fileContext.debug(`...verified the '${labelsString}' metatheorem.`, metatheoremNode);
+  }
+
+  return metatheoremVerified;
+}

package/src/verify/metavariable.js

@@ -2,8 +2,12 @@
 
 import Metavariable from "../metavariable";
 import MetavariableAssignment from "../assignment/metavariable";
+import verifyGivenMetavariable from "../verify/givenMetavariable";
 
-import { metaTypeNameFromMetaTypeNode } from "../utilities/query";
+import { nodeQuery } from "../utilities/query";
+
+const typeNodeQuery = nodeQuery("/argument/type"),
+      argumentNodeQuery = nodeQuery("/metavariable/argument!");
 
 export default function verifyMetavariable(metavariableNode, metaTypeNode, fileContext) {
   let metavariableVerified = false;
@@ -17,14 +21,18 @@ export default function verifyMetavariable(metavariableNode, metaTypeNode, fileC
   if (metavariablePresent) {
     fileContext.debug(`The metavariable '${metavariableString}' is already present.`, metavariableNode);
   } else {
-    const metaTypeName = metaTypeNameFromMetaTypeNode(metaTypeNode),
-          metaType = fileContext.findMetaTypeByMetaTypeName(metaTypeName),
-          metavariable = Metavariable.fromMetavariableNodeAndMetaType(metavariableNode, metaType),
-          metavariableAssignment = MetavariableAssignment.fromMetavariable(metavariable),
-          metavariableAssigned = metavariableAssignment.assign(fileContext);
-
-    if (metavariableAssigned) {
-      metavariableVerified = true;
+    const argumentNode = argumentNodeQuery(metavariableNode),
+          argumentVerified = verifyArgument(metavariableNode, argumentNode, fileContext);
+
+    if (argumentVerified) {
+      const metaType = fileContext.findMetaTypeByMetaTypeNode(metaTypeNode),
+            metavariable = Metavariable.fromMetavariableNodeAndMetaType(metavariableNode, metaType),
+            metavariableAssignment = MetavariableAssignment.fromMetavariable(metavariable),
+            metavariableAssigned = metavariableAssignment.assign(fileContext);
+
+      if (metavariableAssigned) {
+        metavariableVerified = true;
+      }
     }
   }
 
@@ -36,19 +44,16 @@ export default function verifyMetavariable(metavariableNode, metaTypeNode, fileC
 }
 
 export function verifyStandaloneMetavariable(metavariableNode, localMetaContext, verifyAhead) {
-  let standaloneMetavariableVerified = false;
+  let standaloneMetavariableVerified;
 
   const metavariableString = localMetaContext.nodeAsString(metavariableNode);
 
   localMetaContext.trace(`Verifying the '${metavariableString}' standalone metavariable...`, metavariableNode);
 
-  const metavariablePresent = localMetaContext.isMetavariablePresentByMetavariableNode(metavariableNode);
-
-  if (metavariablePresent) {
-    const verifiedAhead = verifyAhead();
+  const metavariables = [],
+        givenMetavariableVerified = verifyGivenMetavariable(metavariableNode, metavariables, localMetaContext, verifyAhead);
 
-    standaloneMetavariableVerified = verifiedAhead; ///
-  }
+  standaloneMetavariableVerified = givenMetavariableVerified; ///
 
   if (standaloneMetavariableVerified) {
     localMetaContext.debug(`...verified the '${metavariableString}' standalone metavariable.`, metavariableNode);
@@ -56,3 +61,28 @@ export function verifyStandaloneMetavariable(metavariableNode, localMetaContext,
 
   return standaloneMetavariableVerified;
 }
+
+function verifyArgument(metavariableNode, argumentNode, fileContext) {
+  let argumentVerified = false;
+
+  if (argumentNode === null) {
+    argumentVerified = true;
+  } else {
+    const typeNode = typeNodeQuery(argumentNode);
+
+    if (typeNode !== null) {
+      const type = fileContext.findTypeByTypeNode(typeNode);
+
+      if (type !== null) {
+        argumentVerified = true;
+      } else {
+        const typeString = fileContext.nodeAsString(typeNode),
+              metavariableString = fileContext.nodeAsString(metavariableNode);
+
+        fileContext.debug(`The '${metavariableString}' metavariable's '${typeString}' type is not present.`, metavariableNode);
+      }
+    }
+  }
+
+  return argumentVerified;
+}

package/src/verify/proof.js

@@ -22,9 +22,9 @@ export default function verifyProof(proofNode, conclusion, localContext) {
       const proofStep = lastProofStep, ///
             statementNode = proofStep.getStatementNode(),
             conclusionStatementNode = conclusion.getStatementNode(),
-            statementNodeMatchConclusionStatementNode = statementNode.match(conclusionStatementNode);
+            statementNodeMatchesConclusionStatementNode = statementNode.match(conclusionStatementNode);
 
-      proofVerified = statementNodeMatchConclusionStatementNode;  ///
+      proofVerified = statementNodeMatchesConclusionStatementNode;  ///
     }
   }
 

package/src/verify/statement/qualified.js

@@ -3,7 +3,7 @@
 import verifyEquality from "../equality";
 import verifyTypeAssertion from "../typeAssertion";
 
-import { nodeQuery, referenceNameFromReferenceNode } from "../../utilities/query";
+import { nodeQuery } from "../../utilities/query";
 
 const equalityNodeQuery = nodeQuery("/qualifiedStatement/statement/equality!"),
       referenceNodeQuery = nodeQuery("/qualifiedStatement/qualification!/reference!"),
@@ -21,7 +21,6 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
     localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement...`, qualifiedStatementNode);
 
     const referenceNode = referenceNodeQuery(qualifiedStatementNode),
-          referenceName = referenceNameFromReferenceNode(referenceNode),
           verifyQualifiedStatementFunctions = [
             verifyQualifiedStatementAAgainstRule,
             verifyQualifiedStatementAAgainstAxiom,
@@ -31,7 +30,7 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
           ];
 
     qualifiedStatementVerified = verifyQualifiedStatementFunctions.some((verifyQualifiedStatementFunction) => {  ///
-      const qualifiedStatementVerified = verifyQualifiedStatementFunction(qualifiedStatementNode, referenceName, localContext);
+      const qualifiedStatementVerified = verifyQualifiedStatementFunction(qualifiedStatementNode, referenceNode, localContext);
 
       if (qualifiedStatementVerified) {
         return true;
@@ -67,120 +66,125 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
   return qualifiedStatementVerified;
 }
 
-function verifyQualifiedStatementAAgainstRule(qualifiedStatementNode, referenceName, localContext) {
+function verifyQualifiedStatementAAgainstRule(qualifiedStatementNode, referenceNode, localContext) {
   let qualifiedStatementVerifiedAgainstRule = false;
 
-  const rule = localContext.findRuleByReferenceName(referenceName);
+  const rule = localContext.findRuleByReferenceNode(referenceNode);
 
   if (rule !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
+          referenceString = localContext.nodeAsString(referenceNode),
           statementLocalContext = localContext, ///
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceName}' rule...`, statementNode);
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceString}' rule...`, statementNode);
 
     const ruleMatchesStatement = rule.matchStatement(statementNode, statementLocalContext);
 
     qualifiedStatementVerifiedAgainstRule = ruleMatchesStatement;  ///
 
     if (qualifiedStatementVerifiedAgainstRule) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceName}' rule.`, statementNode);
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceString}' rule.`, statementNode);
     }
   }
 
   return qualifiedStatementVerifiedAgainstRule;
 }
 
-function verifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, referenceName, localContext) {
+function verifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, referenceNode, localContext) {
   let qualifiedStatementVerifiedAgainstAxiom = false;
 
-  const axiom = localContext.findAxiomByReferenceName(referenceName);
+  const axiom = localContext.findAxiomByReferenceNode(referenceNode);
 
   if (axiom !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
+          referenceString = localContext.nodeAsString(referenceNode),
           statementLocalContext = localContext, ///
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceName}' axiom...`, statementNode);
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceString}' axiom...`, statementNode);
 
     const axiomMatchesStatement = axiom.matchStatement(statementNode, statementLocalContext);
 
     qualifiedStatementVerifiedAgainstAxiom = axiomMatchesStatement; ///
 
     if (qualifiedStatementVerifiedAgainstAxiom) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceName}' axiom.`, statementNode);
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceString}' axiom.`, statementNode);
     }
   }
 
   return qualifiedStatementVerifiedAgainstAxiom;
 }
 
-function verifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, referenceName, localContext) {
+function verifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, referenceNode, localContext) {
   let qualifiedStatementVerifiedAgainstLemma = false;
 
-  const lemma = localContext.findLemmaByReferenceName(referenceName);
+  const lemma = localContext.findLemmaByReferenceNode(referenceNode);
 
   if (lemma !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
+          referenceString = localContext.nodeAsString(referenceNode),
           statementLocalContext = localContext, ///
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceName}' lemma...`, statementNode);
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceString}' lemma...`, statementNode);
 
     const lemmaMatchesStatement = lemma.matchStatement(statementNode, statementLocalContext);
 
     qualifiedStatementVerifiedAgainstLemma = lemmaMatchesStatement; ///
 
     if (qualifiedStatementVerifiedAgainstLemma) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceName}' lemma.`, statementNode);
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceString}' lemma.`, statementNode);
     }
   }
 
   return qualifiedStatementVerifiedAgainstLemma;
 }
 
-function verifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, referenceName, localContext) {
+function verifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, referenceNode, localContext) {
   let qualifiedStatementVerifiedAgainstTheorem = false;
 
-  const theorem = localContext.findTheoremByReferenceName(referenceName);
+  const theorem = localContext.findTheoremByReferenceNode(referenceNode);
 
   if (theorem !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
+          referenceString = localContext.nodeAsString(referenceNode),
           statementLocalContext = localContext, ///
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceName}' theorem...`, statementNode);
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceString}' theorem...`, statementNode);
 
     const theoremMatchesStatement = theorem.matchStatement(statementNode, statementLocalContext);
 
     qualifiedStatementVerifiedAgainstTheorem = theoremMatchesStatement; ///
 
     if (qualifiedStatementVerifiedAgainstTheorem) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceName}' theorem.`, statementNode);
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceString}' theorem.`, statementNode);
     }
   }
 
   return qualifiedStatementVerifiedAgainstTheorem;
 }
 
-function verifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, referenceName, localContext) {
+function verifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, referenceNode, localContext) {
   let qualifiedStatementVerifiedAgainstConjecture = false;
 
-  const conjecture = localContext.findConjectureByReferenceName(referenceName);
+  const conjecture = localContext.findConjectureByReferenceNode(referenceNode);
 
   if (conjecture !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
+          referenceString = localContext.nodeAsString(referenceNode),
           statementLocalContext = localContext, ///
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceName}' conjecture...`, statementNode);
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceString}' conjecture...`, statementNode);
 
     const conjectureMatchesStatement = conjecture.matchStatement(statementNode, statementLocalContext);
 
     qualifiedStatementVerifiedAgainstConjecture = conjectureMatchesStatement; ///
 
     if (qualifiedStatementVerifiedAgainstConjecture) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceName}' conjecture.`, statementNode);
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceString}' conjecture.`, statementNode);
     }
   }
 

package/src/verify/termAsConstructor.js

@@ -4,8 +4,6 @@ import Constructor from "../constructor";
 import LocalContext from "../context/local";
 import termAsConstructorNodeVerifier from "../verifier/node/termAsConstructor";
 
-import { typeNameFromTypeNode } from "../utilities/query";
-
 export default function verifyTermAsConstructor(termNode, typeNode, fileContext) {
   let termVerifiedAsConstructor = false;
 
@@ -28,14 +26,14 @@ export default function verifyTermAsConstructor(termNode, typeNode, fileContext)
     if (typeNode === null) {
       termVerifiedAsConstructor = true;
     } else {
-      const typeName = typeNameFromTypeNode(typeNode);
-
-      type = fileContext.findTypeByTypeName(typeName);
+      type = fileContext.findTypeByTypeNode(typeNode);
 
       if (type !== null) {
         termVerifiedAsConstructor = true;
       } else {
-        fileContext.debug(`The '${termString}' constructor's '${typeName}' type is not present.`, termNode);
+        const typeString = fileContext.nodeAsString(typeNode);
+
+        fileContext.debug(`The '${termString}' constructor's '${typeString}' type is not present.`, termNode);
       }
     }
 

package/src/verify/type.js

@@ -1,8 +1,9 @@
 "use strict";
 
 import Type from "../type";
+import verifyGivenType from "../verify/givenType";
 
-import { typeNameFromTypeNode } from "../utilities/query";
+import { typeNameFromTypeNode } from "../utilities/name";
 
 export default function verifyType(typeNode, superTypeNode, fileContext) {
   let typeVerified = false;
@@ -11,23 +12,26 @@ export default function verifyType(typeNode, superTypeNode, fileContext) {
 
   fileContext.trace(`Verifying the '${typeString}' type...`, typeNode);
 
-  const typeName = typeNameFromTypeNode(typeNode),
-        typePresent = fileContext.isTypePresentByTypeName(typeName);
+  const typePresent = fileContext.isTypePresentByTypeNode(typeNode);
 
   if (typePresent) {
-    fileContext.debug(`The type '${typeName}' is already present.`, typeNode);
+    const typeString = fileContext.nodeAsString(typeNode);
+
+    fileContext.debug(`The type '${typeString}' is already present.`, typeNode);
   } else {
     let type;
 
-    const superTypeName = typeNameFromTypeNode(superTypeNode);
+    const typeName = typeNameFromTypeNode(typeNode);
 
-    if (superTypeName === null) {
+    if (superTypeNode === null) {
       type = Type.fromTypeName(typeName);
     } else {
-      const superType = fileContext.findTypeByTypeName(superTypeName);
+      const superType = fileContext.findTypeByTypeNode(superTypeNode);
 
       if (superType === null) {
-        fileContext.debug(`The super-type '${superTypeName}' is not present.`, typeNode);
+        const superTypeString = fileContext.nodeAsString(superTypeNode);
+
+        fileContext.debug(`The super-type '${superTypeString}' is not present.`, typeNode);
       } else {
         type = Type.fromTypeNameAndSuperType(typeName, superType);
       }
@@ -47,26 +51,20 @@ export default function verifyType(typeNode, superTypeNode, fileContext) {
   return typeVerified;
 }
 
-export function verifyStandaloneType(typeNode, fileContext, verifyAhead) {
-  let standaloneTypeVerified = false;
-
-  const typeString = fileContext.nodeAsString(typeNode);
+export function verifyStandaloneType(typeNode, localContext, verifyAhead) {
+  let standaloneTypeVerified;
 
-  fileContext.trace(`Verifying the '${typeString}' standalone type...`, typeNode);
+  const typeString = localContext.nodeAsString(typeNode);
 
-  const typeName = typeNameFromTypeNode(typeNode),
-        typePresent = fileContext.isTypePresentByTypeName(typeName);
+  localContext.trace(`Verifying the '${typeString}' standalone type...`, typeNode);
 
-  if (!typePresent) {
-    fileContext.debug(`The type '${typeName}' is not present.`, typeNode);
-  } else {
-    const verifiedAhead = verifyAhead();
+  const types = [],
+        givenTypeVerified = verifyGivenType(typeNode, types, localContext, verifyAhead);
 
-    standaloneTypeVerified = verifiedAhead;  ///
-  }
+  standaloneTypeVerified = givenTypeVerified;  ///
 
   if (standaloneTypeVerified) {
-    fileContext.debug(`...verified the '${typeString}' standalone type.`, typeNode);
+    localContext.debug(`...verified the '${typeString}' standalone type.`, typeNode);
   }
 
   return standaloneTypeVerified;

package/src/verify/variable.js

@@ -2,9 +2,9 @@
 
 import Variable from "../variable";
 import VariableAssignment from "../assignment/variable";
+import verifyGivenVariable from "../verify/givenVariable";
 
 import { objectType } from "../type";
-import { typeNameFromTypeNode } from "../utilities/query";
 
 export default function verifyVariable(variableNode, typeNode, fileContext) {
   let variableVerified = false;
@@ -20,17 +20,17 @@ export default function verifyVariable(variableNode, typeNode, fileContext) {
   } else {
     let variable;
 
-    const typeName = typeNameFromTypeNode(typeNode);
-    
-    if (typeName === null) {
+    if (typeNode === null) {
       const type = objectType;
 
       variable = Variable.fromVariableNodeAndType(variableNode, type);
     } else {
-      const type = fileContext.findTypeByTypeName(typeName);
+      const type = fileContext.findTypeByTypeNode(typeNode);
 
       if (type === null) {
-        fileContext.debug(`The '${variableString}' variable's '${typeName}' type is not present.`, variableNode);
+        const typeString = fileContext.nodeAsString(typeNode);
+
+        fileContext.debug(`The '${variableString}' variable's '${typeString}' type is not present.`, variableNode);
       } else {
         variable = Variable.fromVariableNodeAndType(variableNode, type);
       }
@@ -53,23 +53,20 @@ export default function verifyVariable(variableNode, typeNode, fileContext) {
   return variableVerified;
 }
 
-export function verifyStandaloneVariable(variableNode, localMetaContext, verifyAhead) {
-  let standaloneVariableVerified = false;
-
-  const variableString = localMetaContext.nodeAsString(variableNode);
+export function verifyStandaloneVariable(variableNode, localContext, verifyAhead) {
+  let standaloneVariableVerified;
 
-  localMetaContext.trace(`Verifying the '${variableString}' standalone variable...`, variableNode);
+  const variableString = localContext.nodeAsString(variableNode);
 
-  const variablePresent = localMetaContext.isVariablePresentByVariableNode(variableNode);
+  localContext.trace(`Verifying the '${variableString}' standalone variable...`, variableNode);
 
-  if (variablePresent) {
-    const verifiedAhead = verifyAhead();
+  const variables = [],
+        givenVariableVerified = verifyGivenVariable(variableNode, variables, localContext, verifyAhead);
 
-    standaloneVariableVerified = verifiedAhead; ///
-  }
+  standaloneVariableVerified = givenVariableVerified; ///
 
   if (standaloneVariableVerified) {
-    localMetaContext.debug(`...verified the '${variableString}' standalone variable.`, variableNode);
+    localContext.debug(`...verified the '${variableString}' standalone variable.`, variableNode);
   }
 
   return standaloneVariableVerified;