occam-verify-cli 0.0.933 → 0.0.934

package/src/verify/declaration.js

@@ -1,14 +1,13 @@
 "use strict";
 
+import shim from "../shim";
 import Declaration from "../declaration"
-import metaLevelUnifier from "../unifier/metaLevel";
 import referenceMetaType from "../metaType/reference";
 
 import { nodeQuery } from "../utilities/query";
 
-const referenceNodeQuery = nodeQuery("/declaration/reference!"),
-      statementNodeQuery = nodeQuery("/declaration/statement!"),
-      metavariableNodeQuery = nodeQuery("/metavariable!");
+const statementNodeQuery = nodeQuery("/declaration/statement!"),
+      metavariableNodeQuery = nodeQuery("/declaration/metavariable!");
 
 export default function verifyDeclaration(declarationNode, declarations, localContext) {
   let declarationVerified = false;
@@ -17,20 +16,19 @@ export default function verifyDeclaration(declarationNode, declarations, localCo
 
   localContext.trace(`Verifying the '${declarationString}' declaration...`, declarationNode);
 
-  const referenceNode = referenceNodeQuery(declarationNode),
-        referenceVerified = verifyReference(referenceNode, localContext);
+  const metavariableNode = metavariableNodeQuery(declarationNode),
+        metavariableVerified = verifyMetavariable(metavariableNode, localContext);
 
-  if (referenceVerified) {
+  if (metavariableVerified) {
     const statementNode = statementNodeQuery(declarationNode);
 
-    const { verifyStatement } = metaLevelUnifier,
+    const { verifyStatement } = shim,
           derived = false,
           assignments = [],
           statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
 
     if (statementVerified) {
-      const metavariableNode = metavariableNodeQuery(referenceNode),
-            declaration = Declaration.fromMetavariableNodeAndStatementNode(metavariableNode, statementNode);
+      const declaration = Declaration.fromMetavariableNodeAndStatementNode(metavariableNode, statementNode);
 
       declarations.push(declaration);
 
@@ -45,34 +43,33 @@ export default function verifyDeclaration(declarationNode, declarations, localCo
   return declarationVerified;
 }
 
-function verifyReference(referenceNode, localContext) {
-  let referenceVerified = false;
+function verifyMetavariable(metavariableNode, localContext) {
+  let metavariableVerified = false;
 
-  const referenceString = localContext.nodeAsString(referenceNode);
+  const metavariableString = localContext.nodeAsString(metavariableNode);
 
-  localContext.trace(`Verifying the '${referenceString}' reference...`, referenceNode);
+  localContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
 
-  const metavariableNode = metavariableNodeQuery(referenceNode),
-        metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode);
+  const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode);
 
   if (metavariable !== null) {
     const metaType = metavariable.getMetaType();
 
     if (metaType === referenceMetaType) {
-      referenceVerified = true;
+      metavariableVerified = true;
     } else {
       const referenceMetaTypeName = referenceMetaType.getName(),
             metaTypeString = metaType.asString();
 
-      localContext.debug(`The '${referenceString}' metavariable's meta-type is '${metaTypeString}' when it should be '${referenceMetaTypeName}'.`, referenceNode);
+      localContext.debug(`The '${metavariableString}' metavariable's meta-type is '${metaTypeString}' when it should be '${referenceMetaTypeName}'.`, metavariableNode);
     }
   } else {
-    localContext.debug(`The '${referenceString}' metavariable is not present'.`, referenceNode);
+    localContext.debug(`The '${metavariableString}' metavariable is not present'.`, metavariableNode);
   }
 
-  if (referenceVerified) {
-    localContext.debug(`...verified the '${referenceString}' reference.`, referenceNode);
+  if (metavariableVerified) {
+    localContext.debug(`...verified the '${metavariableString}' metavariable.`, metavariableNode);
   }
 
-  return referenceVerified;
-}
+  return metavariableVerified;
+}

package/src/verify/judgement.js

@@ -9,7 +9,7 @@ import { first } from "../utilities/array";
 import { nodeQuery } from "../utilities/query";
 
 const frameNodeQuery = nodeQuery("/judgement/frame!"),
-      metavariableNodeQuery = nodeQuery("/judgement/statement/metavariable!");
+      metavariableNodeQuery = nodeQuery("/judgement/metavariable!");
 
 export default function verifyJudgement(judgementNode, assignments, derived, localContext) {
   let judgementVerified;

package/src/verify/proofStep.js

@@ -1,8 +1,8 @@
 "use strict";
 
+import shim from "../shim";
 import ProofStep from "../proofStep";
 import verifySubproof from "../verify/subproof";
-import verifySubDerivation from "../verify/subDerivation";
 import verifyQualifiedStatement from "../verify/statement/qualified";
 import verifyUnqualifiedStatement from "../verify/statement/unqualified";
 
@@ -83,6 +83,6 @@ export default function verifyProofStep(proofStepNode, substitutions, localConte
   return proofStepVerified;
 }
 
-Object.assign(verifySubDerivation, {
+Object.assign(shim, {
   verifyProofStep
 });

package/src/verify/statement/qualified.js

@@ -1,12 +1,17 @@
 "use strict";
 
+import verifyEquality from "../equality";
+import verifyJudgement from "../judgement";
+import verifyTypeAssertion from "../assertion/type";
 import unifyMetavariableAgainstStatement from "../../unify/metavariableAgainstStatement";
 
 import { nodeQuery } from "../../utilities/query";
-import { verifyStatementAsEquality, verifyStatementAsTypeAssertion } from "../../verify/statement";
 
 const statementNodeQuery = nodeQuery("/qualifiedStatement/statement!"),
-      metavariableNodeQuery = nodeQuery("/qualifiedStatement/reference/metavariable!");
+      equalityNodeQuery = nodeQuery("/statement/equality!"),
+      judgementNodeQuery = nodeQuery("/statement/judgement!"),
+      metavariableNodeQuery = nodeQuery("/qualifiedStatement/reference/metavariable!"),
+      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
 
 export default function verifyQualifiedStatement(qualifiedStatementNode, substitutions, assignments, localContext) {
   let qualifiedStatementVerified;
@@ -188,7 +193,7 @@ function verifyQualifiedStatementAAgainstReference(qualifiedStatementNode, subst
           localContextB = localContext, ///
           statementNodeB = statementNode, ///
           substitutionNode = null,
-          metavariableNodeA = metavariableString, ///
+          metavariableNodeA = metavariableNode, ///
           metavariableVerifiedAgainstStatement = unifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNode, substitutions, localContextA, localContextB, () => {
             const verifiedAhead = true;
 
@@ -212,13 +217,14 @@ function verifyStatedStatement(statementNode, assignments, derived, localContext
 
   localContext.trace(`Verifying the '${statementString}' stated statement...`, statementNode);
 
-  const verifyStatementFunctions = [
-    verifyStatementAsEquality,
-    verifyStatementAsTypeAssertion
+  const verifyStatedStatementFunctions = [
+    verifyStatedStatementAsEquality,
+    verifyStatedStatementAsJudgement,
+    verifyStatedStatementAsTypeAssertion
   ];
 
-  verifyStatementFunctions.some((verifyStatementFunction) => {
-    const statedStatementVerified = verifyStatementFunction(statementNode, assignments, derived, localContext);
+  verifyStatedStatementFunctions.every((verifyStatedStatementFunction) => { ///
+    const statedStatementVerified = verifyStatedStatementFunction(statementNode, assignments, derived, localContext);
 
     if (statedStatementVerified) {
       return true;
@@ -233,3 +239,73 @@ function verifyStatedStatement(statementNode, assignments, derived, localContext
 
   return statedStatementVerified;
 }
+
+function verifyStatedStatementAsEquality(statementNode, assignments, derived, localContext) {
+  let statedStatementVerifiedAsEquality = true; ///
+
+  const equalityNode = equalityNodeQuery(statementNode);
+
+  if (equalityNode !== null) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the '${statementString}' stated statement as an equality...`, statementNode);
+
+    const equalityVerified = verifyEquality(equalityNode, assignments, derived, localContext, () => {
+      const verifiedAhead = true;
+
+      return verifiedAhead;
+    });
+
+    statedStatementVerifiedAsEquality = equalityVerified; ///
+
+    if (statedStatementVerifiedAsEquality) {
+      localContext.debug(`...verified the '${statementString}' stated statement as an equality.`, statementNode);
+    }
+  }
+
+  return statedStatementVerifiedAsEquality;
+}
+
+function verifyStatedStatementAsJudgement(statementNode, assignments, derived, localContext) {
+  let statedStatementVerifiedAsJudgement = true;
+
+  const judgementNode = judgementNodeQuery(statementNode);
+
+  if (judgementNode !== null) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the '${statementString}' stated statement as a judgement...`, statementNode);
+
+    const judgementVerified = verifyJudgement(judgementNode, assignments, derived, localContext);
+
+    statedStatementVerifiedAsJudgement = judgementVerified;  ///
+
+    if (statedStatementVerifiedAsJudgement) {
+      localContext.debug(`...verified the '${statementString}' stated statement as a judgement.`, statementNode);
+    }
+  }
+
+  return statedStatementVerifiedAsJudgement;
+}
+
+function verifyStatedStatementAsTypeAssertion(statementNode, assignments, derived, localContext) {
+  let statementVerifiedAsTypeAssertion = true;  ///
+
+  const typeAssertionNode = typeAssertionNodeQuery(statementNode);
+
+  if (typeAssertionNode !== null) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the '${statementString}' stated statement as a type assertion...`, statementNode);
+
+    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, localContext);
+
+    statementVerifiedAsTypeAssertion = typeAssertionVerified; ///
+
+    if (statementVerifiedAsTypeAssertion) {
+      localContext.debug(`...verified the '${statementString}' stated statement as a type assertion.`, statementNode);
+    }
+  }
+
+  return statementVerifiedAsTypeAssertion;
+}

package/src/verify/statement/unqualified.js

@@ -1,11 +1,16 @@
 "use strict";
 
+import verifyEquality from "../../verify/equality";
+import verifyJudgement from "../../verify/judgement";
 import verifyStatement from "../../verify/statement";
+import verifyTypeAssertion from "../assertion/type";
 
 import { nodeQuery } from "../../utilities/query";
-import { verifyStatementAsEquality, verifyStatementAsJudgement, verifyStatementAsTypeAssertion } from "../../verify/statement";
 
-const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
+const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
+      equalityNodeQuery = nodeQuery("/statement/equality!"),
+      judgementNodeQuery = nodeQuery("/statement/judgement!"),
+      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
 
 export default function verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext) {
   let unqualifiedStatementVerified;
@@ -43,9 +48,9 @@ function verifyDerivedUnqualifiedStatement(unqualifiedStatementNode, assignments
 
     localContext.trace(`Verifying the '${unqualifiedStatementString}' derived unqualified statement...`, unqualifiedStatementNode);
 
-    const matchesStatementNode = localContext.matchStatementNode(statementNode);
+    const statementUnified = localContext.unifyStatement(statementNode);
 
-    if (matchesStatementNode) {
+    if (statementUnified) {
       derivedUnqualifiedStatementVerified = true;
     } else {
       const statementNode = statementNodeQuery(unqualifiedStatementNode),
@@ -90,25 +95,93 @@ function verifyDerivedStatement(statementNode, assignments, derived, localContex
 
   localContext.trace(`Verifying the '${statementString}' derived statement...`, statementNode);
 
-  const verifyStatementFunctions = [
-    verifyStatementAsEquality,
-    verifyStatementAsJudgement,
-    verifyStatementAsTypeAssertion
+  const verifyDerivedStatementFunctions = [
+    verifyDerivedStatementAsEquality,
+    verifyDerivedStatementAsJudgement,
+    verifyDerivedStatementAsTypeAssertion
   ];
 
-  verifyStatementFunctions.some((verifyStatementFunction) => {
-    const derivedStatementVerified = verifyStatementFunction(statementNode, assignments, derived, localContext);
+  derivedStatementVerified = verifyDerivedStatementFunctions.every((verifyDerivedStatementFunction) => {  ///
+    const derivedStatementVerified = verifyDerivedStatementFunction(statementNode, assignments, derived, localContext);
 
     if (derivedStatementVerified) {
       return true;
     }
   });
 
-  derivedStatementVerified = true; ///
-
   if (derivedStatementVerified) {
     localContext.debug(`...verified the '${statementString}' derived statement.`, statementNode);
   }
 
   return derivedStatementVerified;
 }
+
+function verifyDerivedStatementAsEquality(statementNode, assignments, derived, localContext) {
+  let derivedStatementVerifiedAsEquality = true; ///
+
+  const equalityNode = equalityNodeQuery(statementNode);
+
+  if (equalityNode !== null) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the '${statementString}' derived statement as an equality...`, statementNode);
+
+    const equalityVerified = verifyEquality(equalityNode, assignments, derived, localContext, () => {
+      const verifiedAhead = true;
+
+      return verifiedAhead;
+    });
+
+    derivedStatementVerifiedAsEquality = equalityVerified; ///
+
+    if (derivedStatementVerifiedAsEquality) {
+      localContext.debug(`...verified the '${statementString}' derived statement as an equality.`, statementNode);
+    }
+  }
+
+  return derivedStatementVerifiedAsEquality;
+}
+
+function verifyDerivedStatementAsJudgement(statementNode, assignments, derived, localContext) {
+  let derivedStatementVerifiedAsJudgement = true;
+
+  const judgementNode = judgementNodeQuery(statementNode);
+
+  if (judgementNode !== null) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the '${statementString}' derived statement as a judgement...`, statementNode);
+
+    const judgementVerified = verifyJudgement(judgementNode, assignments, derived, localContext);
+
+    derivedStatementVerifiedAsJudgement = judgementVerified;  ///
+
+    if (derivedStatementVerifiedAsJudgement) {
+      localContext.debug(`...verified the '${statementString}' derived statement as a judgement.`, statementNode);
+    }
+  }
+
+  return derivedStatementVerifiedAsJudgement;
+}
+
+function verifyDerivedStatementAsTypeAssertion(statementNode, assignments, derived, localContext) {
+  let statementVerifiedAsTypeAssertion = true;  ///
+
+  const typeAssertionNode = typeAssertionNodeQuery(statementNode);
+
+  if (typeAssertionNode !== null) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the '${statementString}' derived statement as a type assertion...`, statementNode);
+
+    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, localContext);
+
+    statementVerifiedAsTypeAssertion = typeAssertionVerified; ///
+
+    if (statementVerifiedAsTypeAssertion) {
+      localContext.debug(`...verified the '${statementString}' derived statement as a type assertion.`, statementNode);
+    }
+  }
+
+  return statementVerifiedAsTypeAssertion;
+}

package/src/verify/statement.js

@@ -1,8 +1,8 @@
 "use strict";
 
+import shim from "../shim";
 import verifyEquality from "../verify/equality";
 import verifyJudgement from "../verify/judgement";
-import metaLevelUnifier from "../unifier/metaLevel";
 import bracketedCombinator from "../ocmbinator/bracketed";
 import verifyTypeAssertion from "../verify/assertion/type";
 import verifyDefinedAssertion from "../verify/assertion/defined";
@@ -81,17 +81,43 @@ export function verifyStandaloneStatement(statementNode, localContext, verifyAhe
   return standaloneStatementVerified;
 }
 
-Object.assign(metaLevelUnifier, {
+Object.assign(shim, {
   verifyStatement
 });
 
-Object.assign(statementAgainstCombinatorUnifier, {
-  verifyStatement
-});
 
 export default verifyStatement;
 
-export function verifyStatementAsEquality(statementNode, assignments, derived, localContext) {
+function verifyStatementAsMetavariable(statementNode, assignments, derived, localContext) {
+  let statementVerifiedAsMetavariable = false;
+
+  const metavariableNode = metavariableNodeQuery(statementNode);
+
+  if (metavariableNode !== null) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the '${statementString}' statement as a metavariable...`, statementNode);
+
+    const metavariableVerified = verifyMetavariable(metavariableNode, localContext);
+
+    if (metavariableVerified) {
+      const substitutionNode = substitutionNodeQuery(statementNode),
+            substitutionVerified = verifySubstitution(substitutionNode, localContext);
+
+      if (substitutionVerified) {
+        statementVerifiedAsMetavariable = true;
+      }
+    }
+
+    if (statementVerifiedAsMetavariable) {
+      localContext.debug(`...verified the '${statementString}' statement as a metavariable.`, statementNode);
+    }
+  }
+
+  return statementVerifiedAsMetavariable;
+}
+
+function verifyStatementAsEquality(statementNode, assignments, derived, localContext) {
   let statementVerifiedAsEquality = false;
 
   const equalityNode = equalityNodeQuery(statementNode);
@@ -117,7 +143,7 @@ export function verifyStatementAsEquality(statementNode, assignments, derived, l
   return statementVerifiedAsEquality;
 }
 
-export function verifyStatementAsJudgement(statementNode, assignments, derived, localContext) {
+function verifyStatementAsJudgement(statementNode, assignments, derived, localContext) {
   let statementVerifiedAsJudgement = false;
 
   const judgementNode = judgementNodeQuery(statementNode);
@@ -139,7 +165,7 @@ export function verifyStatementAsJudgement(statementNode, assignments, derived,
   return statementVerifiedAsJudgement;
 }
 
-export function verifyStatementAsTypeAssertion(statementNode, assignments, derived, localContext) {
+function verifyStatementAsTypeAssertion(statementNode, assignments, derived, localContext) {
   let statementVerifiedAsTypeAssertion = false;
 
   const typeAssertionNode = typeAssertionNodeQuery(statementNode);
@@ -161,35 +187,6 @@ export function verifyStatementAsTypeAssertion(statementNode, assignments, deriv
   return statementVerifiedAsTypeAssertion;
 }
 
-function verifyStatementAsMetavariable(statementNode, assignments, derived, localContext) {
-  let statementVerifiedAsMetavariable = false;
-
-  const metavariableNode = metavariableNodeQuery(statementNode);
-
-  if (metavariableNode !== null) {
-    const statementString = localContext.nodeAsString(statementNode);
-
-    localContext.trace(`Verifying the '${statementString}' statement as a metavariable...`, statementNode);
-
-    const metavariableVerified = verifyMetavariable(metavariableNode, localContext);
-
-    if (metavariableVerified) {
-      const substitutionNode = substitutionNodeQuery(statementNode),
-            substitutionVerified = verifySubstitution(substitutionNode, localContext);
-
-      if (substitutionVerified) {
-        statementVerifiedAsMetavariable = true;
-      }
-    }
-
-    if (statementVerifiedAsMetavariable) {
-      localContext.debug(`...verified the '${statementString}' statement as a metavariable.`, statementNode);
-    }
-  }
-
-  return statementVerifiedAsMetavariable;
-}
-
 function verifyStatementAsDefinedAssertion(statementNode, assignments, derived, localContext) {
   let statementVerifiedAsDefinedAssertion = false;
 

package/src/verify/subDerivation.js

@@ -1,5 +1,7 @@
 "use strict";
 
+import shim from "../shim";
+
 import { nodesQuery } from "../utilities/query";
 
 const proofStepNodesQuery = nodesQuery("/subDerivation/proofStep|lastProofStep");
@@ -10,7 +12,7 @@ export default function verifySubDerivation(subDerivationNode, substitutions, lo
   const proofStepNodes = proofStepNodesQuery(subDerivationNode);
 
   subDerivationVerified = proofStepNodes.every((proofStepNode) => {
-    const { verifyProofStep } = verifySubDerivation,
+    const { verifyProofStep } = shim,
           proofStepVerified = verifyProofStep(proofStepNode, substitutions, localContext);
 
     if (proofStepVerified) {

package/src/verify/term.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import shim from "../shim";
 import Term from "../term";
 import bracketedConstructor from "../constructor/bracketed";
 import termAgainstConstructorUnifier from "../unifier/termAgainstConstructor";
@@ -57,7 +58,7 @@ export function verifyStandaloneTerm(termNode, localContext, verifyAhead) {
   return standaloneTermVerified;
 }
 
-Object.assign(termAgainstConstructorUnifier, {
+Object.assign(shim, {
   verifyTerm
 });