occam-verify-cli 0.0.922 → 0.0.924

package/src/verify/{statementAsContainedAssertion.js → containedAssertion.js}

@@ -2,23 +2,21 @@
 
 import metaLevelNodeVerifier from "../verifier/node/metaLevel";
 
-import { CONTAINED } from "../constants";
 import { isStatementNegated } from "../utilities/verify";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const termNodeQuery = nodeQuery("/statement/term!"),
-      statementTermNodesQuery = nodesQuery("/statement/metaArgument/statement//term"),
-      operatorTerminalNodesQuery = nodesQuery("/statement/@operator");
+      statementTermNodesQuery = nodesQuery("/statement/metaArgument/statement//term");
 
-export default function verifyStatementAsContainedAssertion(statementNode, assignments, derived, localContext) {
+export default function verifyContainedAssertion(containedAssertionNode, assignments, derived, localContext) {
   let statementVerifiedAsContainedAssertion;
 
-  const statementContainedAssertion = isStatementContainedAssertion(statementNode);
+  const statementContainedAssertion = isStatementContainedAssertion(containedAssertionNode);
 
   if (statementContainedAssertion) {
-    const statementString = localContext.nodeAsString(statementNode);
+    const containedAssertionString = localContext.nodeAsString(containedAssertionNode);
 
-    localContext.trace(`Verifying the '${statementString}' statement as a contained assertion...`, statementNode);
+    localContext.trace(`Verifying the '${containedAssertionString}' statement as a contained assertion...`, containedAssertionNode);
 
     const statementFunctions = [
       verifyStatementAsDerivedContainedAssertion,
@@ -26,7 +24,7 @@ export default function verifyStatementAsContainedAssertion(statementNode, assig
     ];
 
     statementVerifiedAsContainedAssertion = statementFunctions.some((statementFunction) => {
-      const statementVerifiedAsContainedAssertion = statementFunction(statementNode, assignments, derived, localContext);
+      const statementVerifiedAsContainedAssertion = statementFunction(containedAssertionNode, assignments, derived, localContext);
 
       if (statementVerifiedAsContainedAssertion) {
         return true;
@@ -34,25 +32,25 @@ export default function verifyStatementAsContainedAssertion(statementNode, assig
     });
 
     if (statementVerifiedAsContainedAssertion) {
-      localContext.debug(`...verified the '${statementString}' statement as a contained assertion.`, statementNode);
+      localContext.debug(`...verified the '${containedAssertionString}' statement as a contained assertion.`, containedAssertionNode);
     }
   }
 
   return statementVerifiedAsContainedAssertion;
 }
 
-function verifyStatementAsDerivedContainedAssertion(statementNode, assignments, derived, localContext) {
+function verifyStatementAsDerivedContainedAssertion(containedAssertionNode, assignments, derived, localContext) {
   let statementVerifiedAsDefinedContainedAssertion = false;
 
   if (derived) {
-    const statementString = localContext.nodeAsString(statementNode);
+    const containedAssertionString = localContext.nodeAsString(containedAssertionNode);
 
-    localContext.trace(`Verifying the derived '${statementString}' statement as a contained assertion...`, statementNode);
+    localContext.trace(`Verifying the '${containedAssertionString}' derived statement as a contained assertion...`, containedAssertionNode);
 
-    const statementNegated = isStatementNegated(statementNode),
-          termNode = termNodeQuery(statementNode),
+    const statementNegated = isStatementNegated(containedAssertionNode),
+          termNode = termNodeQuery(containedAssertionNode),
           negated = statementNegated, ///
-          statementTermNodes = statementTermNodesQuery(statementNode),
+          statementTermNodes = statementTermNodesQuery(containedAssertionNode),
           termNodeMatchesMetaArgumentVariableNode = statementTermNodes.some((statementTermNode) => {
             const termNodeMatchesMetaArgumentVariableNode = termNode.match(statementTermNode);
 
@@ -74,27 +72,27 @@ function verifyStatementAsDerivedContainedAssertion(statementNode, assignments,
     }
 
     if (statementVerifiedAsDefinedContainedAssertion) {
-      localContext.debug(`...verified the derived '${statementString}' statement as a contained assertion.`, statementNode);
+      localContext.debug(`...verified the '${containedAssertionString}' derived statement as a contained assertion.`, containedAssertionNode);
     }
   }
 
   return statementVerifiedAsDefinedContainedAssertion;
 }
 
-function verifyStatementAsStatedContainedAssertion(statementNode, assignments, derived, localContext) {
+function verifyStatementAsStatedContainedAssertion(containedAssertionNode, assignments, derived, localContext) {
   let statementVerifiedAsStatedContainedAssertion = false;
 
   if (!derived) {
-    const statementString = localContext.nodeAsString(statementNode);
+    const containedAssertionString = localContext.nodeAsString(containedAssertionNode);
 
-    localContext.trace(`Verifying the stated '${statementString}' statement as a contained assertion...`, statementNode);
+    localContext.trace(`Verifying the '${containedAssertionString}' stated statement as a contained assertion...`, containedAssertionNode);
 
     const intrinsicLevel = localContext.isIntrinsicLevel();
 
     if (intrinsicLevel) {
-      localContext.debug(`The stated '${statementString}' statement as a contained assertion cannot be verified at intrinsic level.`, statementNode);
+      localContext.debug(`The '${containedAssertionString}' stated statement as a contained assertion cannot be verified at intrinsic level.`, containedAssertionNode);
     } else {
-      const nonTerminalNode = statementNode, ///
+      const nonTerminalNode = containedAssertionNode, ///
             nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
               const verifiedAhead = true;
 
@@ -105,23 +103,9 @@ function verifyStatementAsStatedContainedAssertion(statementNode, assignments, d
     }
 
     if (statementVerifiedAsStatedContainedAssertion) {
-      localContext.debug(`...verified the stated '${statementString}' statement as a contained assertion.`, statementNode);
+      localContext.debug(`...verified the '${containedAssertionString}' stated statement as a contained assertion.`, containedAssertionNode);
     }
   }
 
   return statementVerifiedAsStatedContainedAssertion;
 }
-
-export function isStatementContainedAssertion(statementNode) {
-  const operatorTerminalNodes = operatorTerminalNodesQuery(statementNode),
-        statementContainedAssertion = operatorTerminalNodes.some((operatorTerminalNode) => {
-          const content = operatorTerminalNode.getContent(),
-                contentContained = (content === CONTAINED);
-
-          if (contentContained) {
-            return true;
-          }
-        });
-
-  return statementContainedAssertion;
-}

package/src/verify/declaration.js

@@ -7,8 +7,8 @@ import metaLevelNodeVerifier from "../verifier/node/metaLevel";
 import { nodeQuery } from "../utilities/query";
 
 const referenceNodeQuery = nodeQuery("/declaration/reference!"),
-      metavariableNodeQuery = nodeQuery("/reference/metavariable!"),
-      metastatementNodeQuery = nodeQuery("/declaration/metastatement!");
+      statementNodeQuery = nodeQuery("/declaration/statement!"),
+      metavariableNodeQuery = nodeQuery("/reference/metavariable!");
 
 export default function verifyDeclaration(declarationNode, declarations, localContext) {
   let declarationVerified = false;
@@ -21,20 +21,20 @@ export default function verifyDeclaration(declarationNode, declarations, localCo
         referenceVerified = verifyReference(referenceNode, localContext);
 
   if (referenceVerified) {
-    const metastatementNode = metastatementNodeQuery(declarationNode);
+    const statementNode = statementNodeQuery(declarationNode);
 
-    const { verifyMetastatement } = metaLevelNodeVerifier,
+    const { verifyStatement } = metaLevelNodeVerifier,
           derived = false,
           assignments = [],
-          metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localContext, () => {
+          statementVerified = verifyStatement(statementNode, assignments, derived, localContext, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;
           });
 
-    if (metastatementVerified) {
+    if (statementVerified) {
       const metavariableNode = metavariableNodeQuery(referenceNode),
-            declaration = Declaration.fromMetavariableNodeAndMetastatementNode(metavariableNode, metastatementNode);
+            declaration = Declaration.fromMetavariableNodeAndStatementNode(metavariableNode, statementNode);
 
       declarations.push(declaration);
 
@@ -57,7 +57,7 @@ function verifyReference(referenceNode, localContext) {
   localContext.trace(`Verifying the '${referenceString}' reference...`, referenceNode);
 
   const metavariableNode = metavariableNodeQuery(referenceNode),
-        metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode, localContext);
+        metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode);
 
   if (metavariable !== null) {
     const metaType = metavariable.getMetaType();

package/src/verify/{statementAsDefinedAssertion.js → definedAssertion.js}

@@ -5,22 +5,21 @@ import metaLevelNodeVerifier from "../verifier/node/metaLevel";
 
 import { first } from "../utilities/array";
 import { DEFINED } from "../constants";
-import { isStatementNegated } from "../utilities/verify";
-import { nodeQuery, nodesQuery } from "../utilities/query";
+import { nodeQuery } from "../utilities/query";
+import { isAssertionNegated } from "../utilities/verify";
 
 const termNodeQuery = nodeQuery("/statement/term!"),
-      variableNodeQuery = nodeQuery("/statement/term/variable!"),
-      operatorTerminalNodesQuery = nodesQuery("/statement/@operator");
+      variableNodeQuery = nodeQuery("/statement/term/variable!");
 
-export default function verifyStatementAsDefinedAssertion(statementNode, assignments, derived, localContext) {
+export default function verifyDefinedAssertion(definedAssertionNode, assignments, derived, localContext) {
   let statementVerifiedAsDefinedAssertion = false;
 
-  const statementDefinedAssertion = isStatementDefinedAssertion(statementNode);
+  const statementDefinedAssertion = isStatementDefinedAssertion(definedAssertionNode);
 
   if (statementDefinedAssertion) {
-    const statementString = localContext.nodeAsString(statementNode);
+    const definedAssertionString = localContext.nodeAsString(definedAssertionNode);
 
-    localContext.trace(`Verifying the '${statementString}' statement as a defined assertion...`, statementNode);
+    localContext.trace(`Verifying the '${definedAssertionString}' statement as a defined assertion...`, definedAssertionNode);
 
     const definedAssertionFunctions = [
       verifyDerivedStatementAsDefinedAssertion,
@@ -28,7 +27,7 @@ export default function verifyStatementAsDefinedAssertion(statementNode, assignm
     ];
 
     statementVerifiedAsDefinedAssertion = definedAssertionFunctions.some((definedAssertionFunction) => {
-      const statementVerifiedAsDefinedAssertion = definedAssertionFunction(statementNode, assignments, derived, localContext);
+      const statementVerifiedAsDefinedAssertion = definedAssertionFunction(definedAssertionNode, assignments, derived, localContext);
 
       if (statementVerifiedAsDefinedAssertion) {
         return true;
@@ -36,24 +35,24 @@ export default function verifyStatementAsDefinedAssertion(statementNode, assignm
     });
 
     if (statementVerifiedAsDefinedAssertion) {
-      localContext.debug(`...verified the '${statementString}' statement as a defined assertion.`, statementNode);
+      localContext.debug(`...verified the '${definedAssertionString}' statement as a defined assertion.`, definedAssertionNode);
     }
   }
 
   return statementVerifiedAsDefinedAssertion;
 }
 
-function verifyDerivedStatementAsDefinedAssertion(statementNode, assignments, derived, localContext) {
+function verifyDerivedStatementAsDefinedAssertion(definedAssertionNode, assignments, derived, localContext) {
   let derivedStatementVerifiedAsDefeindAssertion = false;
 
   if (derived) {
-    const statementString = localContext.nodeAsString(statementNode);
+    const definedAssertionString = localContext.nodeAsString(definedAssertionNode);
 
-    localContext.trace(`Verifying the derived '${statementString}' statement as a defined assertion...`, statementNode);
+    localContext.trace(`Verifying the '${definedAssertionString}' derived statement as a defined assertion...`, definedAssertionNode);
 
-    const statementNegated = isStatementNegated(statementNode),
-          variableNode = variableNodeQuery(statementNode),
-          termNode = termNodeQuery(statementNode);
+    const statementNegated = isAssertionNegated(definedAssertionNode),
+          variableNode = variableNodeQuery(definedAssertionNode),
+          termNode = termNodeQuery(definedAssertionNode);
 
     if (false) {
       ///
@@ -103,27 +102,27 @@ function verifyDerivedStatementAsDefinedAssertion(statementNode, assignments, de
     }
 
     if (derivedStatementVerifiedAsDefeindAssertion) {
-      localContext.debug(`...verified the derived '${statementString}' statement as a defined assertion.`, statementNode);
+      localContext.debug(`...verified the '${definedAssertionString}' derived statement as a defined assertion.`, definedAssertionNode);
     }
   }
 
   return derivedStatementVerifiedAsDefeindAssertion;
 }
 
-function verifyStatedStatementAsDefinedAssertion(statementNode, assignments, derived, localContext) {
+function verifyStatedStatementAsDefinedAssertion(definedAssertionNode, assignments, derived, localContext) {
   let statedStatementVerifiedAsDefinedAssertion = false;
 
   if (!derived) {
-    const statementString = localContext.nodeAsString(statementNode);
+    const definedAssertionString = localContext.nodeAsString(definedAssertionNode);
 
-    localContext.trace(`Verifying the stated '${statementString}' statement as a defined assertion...`, statementNode);
+    localContext.trace(`Verifying the '${definedAssertionString}' stated statement as a defined assertion...`, definedAssertionNode);
 
     const intrinsicLevel = localContext.isIntrinsicLevel();
 
     if (intrinsicLevel) {
-      localContext.debug(`The stated '${statementString}' statement as a defined assertion cannot be verified at intrinsic level.`, statementNode);
+      localContext.debug(`The '${definedAssertionString}' stated statement as a defined assertion cannot be verified at intrinsic level.`, definedAssertionNode);
     } else {
-      const nonTerminalNode = statementNode, ///
+      const nonTerminalNode = definedAssertionNode, ///
             nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
               const verifiedAhead = true;
 
@@ -134,23 +133,9 @@ function verifyStatedStatementAsDefinedAssertion(statementNode, assignments, der
     }
 
     if (statedStatementVerifiedAsDefinedAssertion) {
-      localContext.debug(`...verified the stated '${statementString}' statement as a defined assertion.`, statementNode);
+      localContext.debug(`...verified the '${definedAssertionString}' stated statement as a defined assertion.`, definedAssertionNode);
     }
   }
 
   return statedStatementVerifiedAsDefinedAssertion;
 }
-
-export function isStatementDefinedAssertion(statementNode) {
-  const operatorTerminalNodes = operatorTerminalNodesQuery(statementNode),
-        statementDefinedAssertion = operatorTerminalNodes.some((operatorTerminalNode) => {
-          const content = operatorTerminalNode.getContent(),
-                contentDefined = (content === DEFINED);
-
-          if (contentDefined) {
-            return true;
-          }
-        });
-
-  return statementDefinedAssertion;
-}

package/src/verify/derivation.js

@@ -6,18 +6,18 @@ import { nodesQuery } from "../utilities/query";
 
 const proofStepNodesQuery = nodesQuery("/derivation/proofStep|lastProofStep");
 
-export default function verifyDerivation(ruleDerivationNode, localContext) {
-  let ruleDerivationVerified;
+export default function verifyDerivation(derivationNode, substitutions, localContext) {
+  let derivationVerified;
 
-  const proofStepNodes = proofStepNodesQuery(ruleDerivationNode);
+  const proofStepNodes = proofStepNodesQuery(derivationNode);
 
-  ruleDerivationVerified = proofStepNodes.every((proofStepNode) => {
-    const proofStepVerified = verifyProofStep(proofStepNode, localContext);
+  derivationVerified = proofStepNodes.every((proofStepNode) => {
+    const proofStepVerified = verifyProofStep(proofStepNode, substitutions, localContext);
 
     if (proofStepVerified) {
       return true;
     }
   });
 
-  return ruleDerivationVerified;
+  return derivationVerified;
 }

package/src/verify/frame.js

@@ -56,7 +56,7 @@ function verifyMetavariable(metavariableNode, declarations, localContext) {
 
   localContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
 
-  const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode, localContext);
+  const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode);
 
   if (metavariable !== null) {
     const metaType = metavariable.getMetaType();

package/src/verify/judgement.js

@@ -144,7 +144,7 @@ function verifyMetavariable(metavariableNode, localContext) {
 
   localContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
 
-  const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode, localContext);
+  const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode);
 
   if (metavariable !== null) {
     const metaType = metavariable.getMetaType();

package/src/verify/lemma.js

@@ -20,8 +20,7 @@ export default function verifyLemma(lemmaNode, fileContext) {
   let lemmaVerified = false;
 
   const labelNodes = labelNodesQuery(lemmaNode),
-        labelsString = fileContext.nodesAsString(labelNodes),
-        localContext = LocalContext.fromFileContext(fileContext);
+        labelsString = fileContext.nodesAsString(labelNodes);
 
   (labelsString === EMPTY_STRING) ?
     fileContext.trace(`Verifying a lemma...`, lemmaNode) :
@@ -31,7 +30,8 @@ export default function verifyLemma(lemmaNode, fileContext) {
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
 
   if (labelsVerified) {
-    const suppositions = [],
+    const localContext = LocalContext.fromFileContext(fileContext),
+          suppositions = [],
           suppositionNodes = suppositionsNodeQuery(lemmaNode),
           suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
 
@@ -44,10 +44,13 @@ export default function verifyLemma(lemmaNode, fileContext) {
         const proofNode = proofNodeQuery(lemmaNode),
               firstConsequent = first(consequents),
               consequent = firstConsequent, ///
-              proofVerified = verifyProof(proofNode, consequent, localContext);
+              statementNode = consequent.getStatementNode(),
+              substitutions = [],
+              proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);
 
         if (proofVerified) {
-          const lemma = Lemma.fromLabelsSuppositionsConsequentAndLocalContext(labels, suppositions, consequent, localContext);
+          const substitutions = [],
+                lemma = Lemma.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext);
 
           fileContext.addLemma(lemma);
 

package/src/verify/metaLemma.js

@@ -1,20 +1,20 @@
 "use strict";
 
 import MetaLemma from "../metaLemma";
+import verifyProof from "../verify/proof";
 import LocalContext from "../context/local";
 import verifyLabels from "../verify/labels";
-import verifyMetaproof from "../verify/metaproof";
-import verifyMetaConsequent from "../verify/metaConsequent";
-import verifyMetaSuppositions from "../verify/metaSuppositions";
+import verifyConsequent from "../verify/consequent";
+import verifySuppositions from "../verify/suppositions";
 
 import { first } from "../utilities/array";
 import { EMPTY_STRING } from "../constants";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const labelNodesQuery = nodesQuery("/metaLemma/label"),
-      metaproofNodeQuery = nodeQuery("/metaLemma/metaproof!"),
-      metaConsequentNodeQuery = nodeQuery("/metaLemma/metaConsequent!"),
-      metaSuppositionsNodeQuery = nodesQuery("/metaLemma/metaSupposition");
+const proofNodeQuery = nodeQuery("/metaLemma/proof!"),
+      labelNodesQuery = nodesQuery("/metaLemma/label"),
+      consequentNodeQuery = nodeQuery("/metaLemma/consequent!"),
+      suppositionsNodeQuery = nodesQuery("/metaLemma/supposition");
 
 export default function verifyMetaLemma(metaLemmaNode, fileContext) {
   let metaLemmaVerified = false;
@@ -30,26 +30,26 @@ export default function verifyMetaLemma(metaLemmaNode, fileContext) {
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
 
   if (labelsVerified) {
-    const localContext = LocalContext.fromFileContext(fileContext), ///
-          substitutions = [],
-          metaSuppositions = [],
-          metaSuppositionNodes = metaSuppositionsNodeQuery(metaLemmaNode),
-          metaSuppositionsVerified = verifyMetaSuppositions(metaSuppositionNodes, metaSuppositions, substitutions, localContext);
+    const localContext = LocalContext.fromFileContext(fileContext),
+          suppositions = [],
+          suppositionNodes = suppositionsNodeQuery(metaLemmaNode),
+          suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
 
-    if (metaSuppositionsVerified) {
-      const metaConsequents = [],
-            metaConsequentNode = metaConsequentNodeQuery(metaLemmaNode),
-            metaConsequentVerified = verifyMetaConsequent(metaConsequentNode, metaConsequents, substitutions, localContext);
+    if (suppositionsVerified) {
+      const consequents = [],
+            consequentNode = consequentNodeQuery(metaLemmaNode),
+            consequentVerified = verifyConsequent(consequentNode, consequents, localContext);
 
-      if (metaConsequentVerified) {
-        const metaproofNode = metaproofNodeQuery(metaLemmaNode),
-              firstMetaConsequent = first(metaConsequents),
-              metaConsequent = firstMetaConsequent, ///
-              metastatementNode = metaConsequent.getMetastatementNode(),
-              metaproofVerified = verifyMetaproof(metaproofNode, metastatementNode, substitutions, localContext);
+      if (consequentVerified) {
+        const proofNode = proofNodeQuery(metaLemmaNode),
+              firstConsequent = first(consequents),
+              consequent = firstConsequent, ///
+              statementNode = consequent.getStatementNode(),
+              substitutions = [],
+              proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);
 
-        if (metaproofVerified) {
-          const metaLemma = MetaLemma.fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(labels, metaSuppositions, metaConsequent, substitutions, fileContext);
+        if (proofVerified) {
+          const metaLemma = MetaLemma.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext);
 
           fileContext.addMetaLemma(metaLemma);