occam-verify-cli 0.0.893 → 0.0.895

package/src/verifier/nodes/intrinsicLevelAgainstMetaLevel.js

@@ -13,7 +13,6 @@ const termNodeQuery = nodeQuery("/term!"),
       termVariableNodeQuery = nodeQuery("/term/variable!"),
       metastatementNodeQuery = nodeQuery("/metastatement!"),
       metaArgumentStatementNodeQuery = nodeQuery("/metaArgument/statement!"),
-      metastatementStatementNodeQuery = nodeQuery("/metastatement/statement!"),
       metastatementMetavariableNodeQuery = nodeQuery("/metastatement/metavariable!"),
       metastatementSubstitutionNodeQuery = nodeQuery("/metastatement/substitution");
 
@@ -22,24 +21,6 @@ class IntrinsicLevelAgainstMetaLevelNodesVerifier extends NodesVerifier {
     let nonTerminalNodeVerified;
 
     const nodeQueryMaps = [
-      {
-        nodeQueryA: metastatementMetavariableNodeQuery,
-        nodeQueryB: metastatementStatementNodeQuery,
-        verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const metastatementStatementNodeB = nodeB,  ///
-                metastatementMetavariableNodeA = nodeA, ///
-                metastatementSubstitutionNodeA = metastatementSubstitutionNodeQuery(nonTerminalNodeA),
-                metastatementMetavariableNodeVerifiedAgainstMetastatementStatementNode =
-
-                  this.verifyMetastatementMetavariableNodeAgainstMetastatementStatementNode(metastatementMetavariableNodeA, metastatementStatementNodeB, metastatementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead);
-
-          nonTerminalNodeVerified = metastatementMetavariableNodeVerifiedAgainstMetastatementStatementNode;  ///
-
-          return nonTerminalNodeVerified;
-        }
-      },
       {
         nodeQueryA: metastatementMetavariableNodeQuery,
         nodeQueryB: metaArgumentStatementNodeQuery,
@@ -76,23 +57,6 @@ class IntrinsicLevelAgainstMetaLevelNodesVerifier extends NodesVerifier {
           return nonTerminalNodeVerified;
         }
       },
-      {
-        nodeQueryA: metastatementStatementNodeQuery,
-        nodeQueryB: statementNodeQuery,
-        verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const statementNodeB = nodeB, ///
-                metastatementStatementNodeA = nodeA,  ///
-                metastatementStatementNodeVerifiedAgainstStatementNode =
-
-                  this.verifyMetastatementStatementNodeAgainstStatementNode(metastatementStatementNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead);
-
-          nonTerminalNodeVerified = metastatementStatementNodeVerifiedAgainstStatementNode; ///
-
-          return nonTerminalNodeVerified;
-        }
-      },
       {
         nodeQueryA: metastatementNodeQuery,
         nodeQueryB: statementNodeQuery,
@@ -138,19 +102,6 @@ class IntrinsicLevelAgainstMetaLevelNodesVerifier extends NodesVerifier {
     return nonTerminalNodeVerified;
   }
 
-  verifyMetastatementMetavariableNodeAgainstMetastatementStatementNode(metastatementMetavariableNodeA, metastatementStatementNodeB, metastatementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead) {
-    let metastatementMetavariableNodeVerifiedAgainstMetastatementStatementNode;
-
-    const statementNode = metastatementStatementNodeB, ///
-          metavariableNode = metastatementMetavariableNodeA,  ///
-          substitutionNode = metastatementSubstitutionNodeA,  ///
-          metavariableVerifiedAgainstStatement = verifyMetavariableAgainstStatement(metavariableNode, statementNode, substitutionNode, substitutions, localContextA, localContextB, verifyAhead)
-
-    metastatementMetavariableNodeVerifiedAgainstMetastatementStatementNode = metavariableVerifiedAgainstStatement; ///
-
-    return metastatementMetavariableNodeVerifiedAgainstMetastatementStatementNode;
-  }
-
   verifyMetastatementMetavariableNodeAgainstMetaArgumentStatementNode(metastatementMetavariableNodeA, metaArgumentStatementNodeB, metastatementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead) {
     let metastatementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode;
 
@@ -177,18 +128,6 @@ class IntrinsicLevelAgainstMetaLevelNodesVerifier extends NodesVerifier {
     return metastatementMetavariableNodeVerifiedAgainstStatementNode;
   }
 
-  verifyMetastatementStatementNodeAgainstStatementNode(metastatementStatementNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead) {
-    let metastatementStatementNodeVerifiedAgainstStatementNode;
-
-    const nonTerminalNodeA = metastatementStatementNodeA, ///
-          nonTerminalNodeB = statementNodeB,  ///
-          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
-
-    metastatementStatementNodeVerifiedAgainstStatementNode = nonTerminalNodeVerified; ///
-
-    return metastatementStatementNodeVerifiedAgainstStatementNode;
-  }
-
   verifyMetastatementNodeAgainstStatementNode(metastatementNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead) {
     let metastatementNodeVerifiedAgainstStatementNode;
 

package/src/verify/metaProofStep.js

@@ -32,7 +32,7 @@ export default function verifyMetaProofStep(metaProofStepNode, substitutions, lo
   } else if (metaSubproofNode !== null) {
     let metaSubproofVerified;
 
-    metaSubproofVerified = verifyMetaSubproof(metaSubproofNode, localMetaContext);
+    metaSubproofVerified = verifyMetaSubproof(metaSubproofNode, substitutions, localMetaContext);
 
     if (metaSubproofVerified) {
       const metaproofStep = MetaproofStep.fromMetaSubproofNode(metaSubproofNode);

package/src/verify/metaSubDerivation.js

@@ -4,14 +4,14 @@ import { nodesQuery } from "../utilities/query";
 
 const metaProofStepNodesQuery = nodesQuery("/metaSubDerivation/metaProofStep|lastMetaProofStep");
 
-export default function verifyMetaSubDerivation(metaSubDerivationNode, localMetaContext) {
+export default function verifyMetaSubDerivation(metaSubDerivationNode, substitutions, localMetaContext) {
   let metaSubDerivationVerified;
 
   const metaProofStepNodes = metaProofStepNodesQuery(metaSubDerivationNode);
 
   metaSubDerivationVerified = metaProofStepNodes.every((metaProofStepNode) => {
     const { verifyMetaProofStep } = verifyMetaSubDerivation,
-          metaProofStepVerified = verifyMetaProofStep(metaProofStepNode, localMetaContext);
+          metaProofStepVerified = verifyMetaProofStep(metaProofStepNode, substitutions, localMetaContext);
 
     if (metaProofStepVerified) {
       return true;

package/src/verify/metaSubproof.js

@@ -9,7 +9,7 @@ import { nodeQuery, nodesQuery } from "../utilities/query";
 const suppositionNodesQuery = nodesQuery("/metaSubproof/supposition"),
       metaSubDerivationNodeQuery = nodeQuery("/metaSubproof/metaSubDerivation");
 
-export default function verifyMetaSubproof(metaSubproofNode, localMetaContext) {
+export default function verifyMetaSubproof(metaSubproofNode, substitutions, localMetaContext) {
   let metaSubproofVerified = false;
 
   localMetaContext = LocalMetaContext.fromLocalMetaContext(localMetaContext); ///
@@ -20,7 +20,7 @@ export default function verifyMetaSubproof(metaSubproofNode, localMetaContext) {
 
   if (metaSuppositionsVerified) {
     const metaSubDerivationNode = metaSubDerivationNodeQuery(metaSubproofNode),
-          metaSubDerivationVerified = verifyMetaSubDerivation(metaSubDerivationNode, localMetaContext);
+          metaSubDerivationVerified = verifyMetaSubDerivation(metaSubDerivationNode, substitutions, localMetaContext);
 
     if (metaSubDerivationVerified) {
       metaSubproofVerified = true;

package/src/verify/metastatement/qualified.js

@@ -1,6 +1,5 @@
 "use strict";
 
-import verifyMetastatement from "../../verify/metastatement";
 import verifyMetavariableAgainstMetastatement from "../../verify/metavariableAgainstMetastatement";
 
 import { nodeQuery } from "../../utilities/query";
@@ -15,28 +14,30 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
 
   localMetaContext.trace(`Verifying the '${qualifiedMetastatementString}' qualified metastatement...`, qualifiedMetastatementNode);
 
-  const derived = false,
-        metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
-        metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localMetaContext, () => {
-          const verifiedAhead = true;
+  const metavariableNode = metavariableNodeQuery(qualifiedMetastatementNode),
+        verifyQualifiedMetastatementFunctions = [
+          verifyQualifiedMetastatementAAgainstRule,
+          verifyQualifiedMetastatementAAgainstReference
+        ];
 
-          return verifiedAhead;
-        });
+  qualifiedMetastatementVerified = verifyQualifiedMetastatementFunctions.some((verifyQualifiedMetastatementFunction) => {  ///
+    const qualifiedMetastatementVerified = verifyQualifiedMetastatementFunction(qualifiedMetastatementNode, metavariableNode, substitutions, localMetaContext);
 
-  if (metastatementVerified) {
-    const metavariableNode = metavariableNodeQuery(qualifiedMetastatementNode),
-          verifyQualifiedMetastatementFunctions = [
-            verifyQualifiedMetastatementAAgainstRule,
-            verifyQualifiedMetastatementAAgainstReference
-          ];
-
-    qualifiedMetastatementVerified = verifyQualifiedMetastatementFunctions.some((verifyQualifiedMetastatementFunction) => {  ///
-      const qualifiedMetastatementVerified = verifyQualifiedMetastatementFunction(qualifiedMetastatementNode, metavariableNode, substitutions, localMetaContext);
-
-      if (qualifiedMetastatementVerified) {
-        return true;
-      }
-    });
+    if (qualifiedMetastatementVerified) {
+      return true;
+    }
+  });
+
+  if (qualifiedMetastatementVerified) {
+    const derived = false,
+          metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
+          metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localMetaContext, () => {
+            const verifiedAhead = true;
+
+            return verifiedAhead;
+          });
+
+    qualifiedMetastatementVerified = metastatementVerified; ///
   }
 
   if (qualifiedMetastatementVerified) {
@@ -98,3 +99,32 @@ function verifyQualifiedMetastatementAAgainstReference(qualifiedMetastatementNod
 
   return qualifiedMetastatementVerifiedAgainstReference;
 }
+
+function verifyMetastatement(metastatementNode, assignments, derived, localMetaContext) {
+  let metastatementVerified;
+
+  const metastatementString = localMetaContext.nodeAsString(metastatementNode);
+
+  localMetaContext.trace(`Verifying the '${metastatementString}' metastatement...`, metastatementNode);
+
+  const verifyMetaStatementFunctions = [
+    ///
+  ];
+
+  verifyMetaStatementFunctions.some((verifyStatementFunction) => {
+    const metastatementVerified = verifyStatementFunction(metastatementNode, assignments, derived, localMetaContext);
+
+    if (metastatementVerified) {
+      return true;
+    }
+  });
+
+  metastatementVerified = true; ///
+
+  if (metastatementVerified) {
+    localMetaContext.debug(`...verified the '${metastatementString}' metastatement.`, metastatementNode);
+  }
+
+  return metastatementVerified;
+}
+

package/src/verify/ruleProofStep.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import LocalContext from "../context/local";
 import MetaproofStep from "../step/metaproof";
 import verifyRuleSubproof from "../verify/ruleSubproof";
 import verifyRuleSubDerivation from "../verify/ruleSubDerivation";
@@ -11,7 +12,8 @@ import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified"
 import { nodeQuery } from "../utilities/query";
 import { assignAssignment } from "../utilities/assignments";
 
-const ruleSubproofNodeQuery = nodeQuery("/ruleProofStep|lastRuleProofStep/ruleSubproof!"),
+const statementNodeQuery = nodeQuery("/qualifiedStatement|unqualifiedStatement/statement!"),
+      ruleSubproofNodeQuery = nodeQuery("/ruleProofStep|lastRuleProofStep/ruleSubproof!"),
       metastatementNodeQuery = nodeQuery("/qualifiedMetastatement|unqualifiedMetastatement/metastatement!"),
       qualifiedStatementNodeQuery = nodeQuery("/ruleProofStep|lastRuleProofStep/qualifiedStatement!"),
       unqualifiedStatementNodeQuery = nodeQuery("/ruleProofStep|lastRuleProofStep/unqualifiedStatement!"),
@@ -42,7 +44,27 @@ export default function verifyRuleProofStep(ruleProofStepNode, localMetaContext)
       ruleProofStepVerified = true;
     }
   } else if (qualifiedStatementNode !== null) {
-    debugger
+    let qualifiedStatementVerified;
+
+    const assignments = [],
+          localContext = LocalContext.fromLocalMetaContext(localMetaContext);
+
+    qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, assignments, localContext);
+
+    if (qualifiedStatementVerified) {
+      const assignmentAssigned = assignAssignment(assignments, localContext);
+
+      qualifiedStatementVerified = assignmentAssigned; ///
+    }
+
+    if (qualifiedStatementVerified) {
+      const statementNode = statementNodeQuery(qualifiedStatementNode),
+            metaproofStep = MetaproofStep.fromStatementNode(statementNode);
+
+      localMetaContext.addMetaproofStep(metaproofStep);
+
+      ruleProofStepVerified = true;
+    }
   } else if (unqualifiedStatementNode !== null) {
     debugger
   } else if (qualifiedMetastatementNode !== null) {

package/src/verify/statement/qualified.js

@@ -1,8 +1,7 @@
 "use strict";
 
-import verifyStatement from "../../verify/statement";
-
 import { nodeQuery } from "../../utilities/query";
+import { verifyStatementAsEquality, verifyStatementAsTypeAssertion } from "../../verify/statement";
 
 const statementNodeQuery = nodeQuery("/qualifiedStatement/statement!"),
       metavariableNodeQuery = nodeQuery("/qualifiedStatement/reference!/metavariable!");
@@ -14,31 +13,33 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
 
   localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement...`, qualifiedStatementNode);
 
-  const derived = false,
-        statementNode = statementNodeQuery(qualifiedStatementNode),
-        statementVerified = verifyStatement(statementNode, assignments, derived, localContext, () => {
-          const verifiedAhead = true;
+  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
+        verifyQualifiedStatementFunctions = [
+          verifyQualifiedStatementAAgainstRule,
+          verifyQualifiedStatementAAgainstAxiom,
+          verifyQualifiedStatementAAgainstLemma,
+          verifyQualifiedStatementAAgainstTheorem,
+          verifyQualifiedStatementAAgainstConjecture
+        ];
 
-          return verifiedAhead;
-        });
+  qualifiedStatementVerified = verifyQualifiedStatementFunctions.some((verifyQualifiedStatementFunction) => {  ///
+    const qualifiedStatementVerified = verifyQualifiedStatementFunction(qualifiedStatementNode, metavariableNode, localContext);
 
-  if (statementVerified) {
-    const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
-          verifyQualifiedStatementFunctions = [
-            verifyQualifiedStatementAAgainstRule,
-            verifyQualifiedStatementAAgainstAxiom,
-            verifyQualifiedStatementAAgainstLemma,
-            verifyQualifiedStatementAAgainstTheorem,
-            verifyQualifiedStatementAAgainstConjecture
-          ];
-
-    qualifiedStatementVerified = verifyQualifiedStatementFunctions.some((verifyQualifiedStatementFunction) => {  ///
-      const qualifiedStatementVerified = verifyQualifiedStatementFunction(qualifiedStatementNode, metavariableNode, localContext);
-
-      if (qualifiedStatementVerified) {
-        return true;
-      }
-    });
+    if (qualifiedStatementVerified) {
+      return true;
+    }
+  });
+
+  if (qualifiedStatementVerified) {
+    const derived = false,
+          statementNode = statementNodeQuery(qualifiedStatementNode),
+          statementVerified = verifyStatement(statementNode, assignments, derived, localContext, () => {
+            const verifiedAhead = true;
+
+            return verifiedAhead;
+          });
+
+    qualifiedStatementVerified = statementVerified;  ///
   }
 
   if (qualifiedStatementVerified) {
@@ -167,3 +168,32 @@ function verifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, meta
 
   return qualifiedStatementVerifiedAgainstConjecture;
 }
+
+function verifyStatement(statementNode, assignments, derived, localContext, verifyAhead) {
+  let statementVerified;
+
+  const statementString = localContext.nodeAsString(statementNode);
+
+  localContext.trace(`Verifying the '${statementString}' statement...`, statementNode);
+
+  const verifyStatementFunctions = [
+    verifyStatementAsEquality,
+    verifyStatementAsTypeAssertion
+  ];
+
+  verifyStatementFunctions.some((verifyStatementFunction) => {
+    const statementVerified = verifyStatementFunction(statementNode, assignments, derived, localContext, verifyAhead);
+
+    if (statementVerified) {
+      return true;
+    }
+  });
+
+  statementVerified = true; ///
+
+  if (statementVerified) {
+    localContext.debug(`...verified the '${statementString}' statement.`, statementNode);
+  }
+
+  return statementVerified;
+}

package/src/verify/statement.js

@@ -71,7 +71,7 @@ Object.assign(statementAgainstCombinatorNodesVerifier, {
 
 export default verifyStatement;
 
-function verifyStatementAsEquality(statementNode, assignments, derived, localContext, verifyAhead) {
+export function verifyStatementAsEquality(statementNode, assignments, derived, localContext, verifyAhead) {
   let statementVerifiedAsEquality = false;
 
   const equalityNode = equalityNodeQuery(statementNode);
@@ -93,7 +93,7 @@ function verifyStatementAsEquality(statementNode, assignments, derived, localCon
   return statementVerifiedAsEquality;
 }
 
-function verifyStatementAsTypeAssertion(statementNode, assignments, derived, localContext, verifyAhead) {
+export function verifyStatementAsTypeAssertion(statementNode, assignments, derived, localContext, verifyAhead) {
   let statementVerifiedAsTypeAssertion = false;
 
   const typeAssertionNode = typeAssertionNodeQuery(statementNode);