occam-verify-cli 0.0.876 → 0.0.878

package/src/verify/declaration.js

@@ -0,0 +1,52 @@
+"use strict";
+
+import labelMetaType from "../metaType/label";
+import metastatementNodeVerifier from "../verifier/node/metastatement";
+
+import { nodeQuery } from "../utilities/query";
+
+const metavariableNodeQuery = nodeQuery("/declaration/metavariable!"),
+      metastatementNodeQuery = nodeQuery("/declaration/metastatement!");
+
+export default function verifyDeclaration(declarationNode, derived, localMetaContext) {
+  let declarationVerified = false;
+
+  const declarationString = localMetaContext.nodeAsString(declarationNode);
+
+  localMetaContext.trace(`Verifying the '${declarationString}' declaration...`, declarationNode);
+
+  const metavariableNode = metavariableNodeQuery(declarationNode),
+        metavariable = localMetaContext.findMetavariableByMetavariableNode(metavariableNode, localMetaContext);
+
+  if (metavariable !== null) {
+    const metaType = metavariable.getMetaType();
+
+    if (metaType === labelMetaType) {
+      const metastatementNode = metastatementNodeQuery(declarationNode);
+
+      if (metastatementNode !== null) {
+        const { verifyMetastatement } = metastatementNodeVerifier,
+              assignments = [],
+              metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localMetaContext, () => {
+                const verifiedAhead = true;
+
+                return verifiedAhead;
+              });
+
+        declarationVerified = metastatementVerified;  ///
+      }
+    } else {
+      const metavariableString = localMetaContext.nodeAsString(metavariableNode),
+            labelMetaTypeName = labelMetaType.getName(),
+            metaTypeString = metaType.asString();
+
+      localMetaContext.debug(`The '${metavariableString}' metavariable's meta-type is '${metaTypeString}' when it should be '${labelMetaTypeName}'.`, declarationNode);
+    }
+  }
+
+  if (declarationVerified) {
+    localMetaContext.debug(`...verified the '${declarationString}' declaration.`, declarationNode);
+  }
+
+  return declarationVerified;
+}

package/src/verify/judgement.js

@@ -0,0 +1,48 @@
+"use strict";
+
+import verifyContext from "../verify/context";
+import contextMetaType from "../metaType/context";
+
+import { nodeQuery } from "../utilities/query";
+
+const contextNodeQuery = nodeQuery("/judgement/metastatement/context!"),
+      metavariableNodeQuery = nodeQuery("/judgement/metavariable!");
+
+export default function verifyJudgement(judgementNode, derived, localMetaContext) {
+  let judgementVerified = false;
+
+  const judgementString = localMetaContext.nodeAsString(judgementNode);
+
+  localMetaContext.trace(`Verifying the '${judgementString}' judgement...`, judgementNode);
+
+  const metavariableNode = metavariableNodeQuery(judgementNode),
+        metavariable = localMetaContext.findMetavariableByMetavariableNode(metavariableNode, localMetaContext);
+
+  if (metavariable !== null) {
+    const metaType = metavariable.getMetaType();
+
+    if (metaType === contextMetaType) {
+      const contextNode = contextNodeQuery(judgementNode);
+
+      if (contextNode !== null) {
+        const contextVerified = verifyContext(contextNode, derived, localMetaContext);
+
+        judgementVerified = contextVerified;  ///
+      } else {
+        localMetaContext.debug(`The right hand side of the '${judgementString}' judgement must be a context.`, judgementNode);
+      }
+    } else {
+      const contextMetaTypeName = contextMetaType.getName(),
+            metavariableString = localMetaContext.nodeAsString(metavariableNode),
+            metaTypeString = metaType.asString();
+
+      localMetaContext.debug(`The '${metavariableString}' metavariable's meta-type is '${metaTypeString}' when it should be '${contextMetaTypeName}'.`, judgementNode);
+    }
+  }
+
+  if (judgementVerified) {
+    localMetaContext.debug(`...verified the '${judgementString}' judgement.`, judgementNode);
+  }
+
+  return judgementVerified;
+}

package/src/verify/metaEquality.js

@@ -0,0 +1,83 @@
+"use strict";
+
+import MetaEquality from "../metaEquality";
+import MetaEqualityAssignment from "../assignment/metaEquality";
+
+import { nodeQuery } from "../utilities/query";
+
+const leftMetastatementNodeQuery = nodeQuery("/metaEquality/metastatement[0]"),
+      rightMetastatementNodeQuery = nodeQuery("/metaEquality/metastatement[1]");
+
+export default function verifyMetaEquality(metaEqualityNode, assignments, derived, localMetaContext) {
+  let metaEqualityVerified;
+
+  const metaEqualityString = localMetaContext.nodeAsString(metaEqualityNode);
+
+  localMetaContext.trace(`Verifying the '${metaEqualityString}' meta-equality...`, metaEqualityNode);
+
+  const verifyMetaEqualityFunctions = [
+    verifyDerivedMetaEquality,
+    verifyStatedMetaEquality
+  ];
+
+  metaEqualityVerified = verifyMetaEqualityFunctions.some((verifyMetaEqualityFunction) => {
+    const metaEqualityVerified = verifyMetaEqualityFunction(metaEqualityNode, assignments, derived, localMetaContext);
+
+    if (metaEqualityVerified) {
+      return true;
+    }
+  });
+
+  if (metaEqualityVerified) {
+    localMetaContext.debug(`...verified the '${metaEqualityString}' meta-equality.`, metaEqualityNode);
+  }
+
+  return metaEqualityVerified;
+}
+
+function verifyDerivedMetaEquality(metaEqualityNode, assignments, derived, localMetaContext) {
+  let derivedMetaEqualityVerified = false;
+
+  if (derived) {
+    const metaEqualityString = localMetaContext.nodeAsString(metaEqualityNode);
+
+    localMetaContext.trace(`Verifying the '${metaEqualityString}' derived meta-equality...`, metaEqualityNode);
+
+    const leftMetastatementNode = leftMetastatementNodeQuery(metaEqualityNode),
+          rightMetastatementNode = rightMetastatementNodeQuery(metaEqualityNode),
+          metaEquality = MetaEquality.fromLeftMetastatementNodeRightMetastatementNodeAndMetaEqualityNode(leftMetastatementNode, rightMetastatementNode, metaEqualityNode, localMetaContext);
+
+    if (metaEquality !== null) {
+      const metaEqualityAssignment = MetaEqualityAssignment.fromMetaEquality(metaEquality),
+            assignment = metaEqualityAssignment;  ///
+
+      assignments.push(assignment);
+
+      derivedMetaEqualityVerified = true;
+    }
+
+    if (derivedMetaEqualityVerified) {
+      localMetaContext.debug(`...verified the '${metaEqualityString}' derived meta-equality.`, metaEqualityNode);
+    }
+  }
+
+  return derivedMetaEqualityVerified;
+}
+
+function verifyStatedMetaEquality(metaEqualityNode, assignments, derived, localMetaContext) {
+  let statedMetaEqualityVerified = false;
+
+  if (!derived) {
+    const metaEqualityString = localMetaContext.nodeAsString(metaEqualityNode);
+
+    localMetaContext.trace(`Verifying the '${metaEqualityString}' stated meta-equality...`, metaEqualityNode);
+
+    debugger
+
+    if (statedMetaEqualityVerified) {
+      localMetaContext.debug(`...verified the '${metaEqualityString}' stated meta-equality.`, metaEqualityNode);
+    }
+  }
+
+  return statedMetaEqualityVerified;
+}

package/src/verify/metastatement/qualified.js

@@ -32,11 +32,11 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
               metavariablePresent = localMetaContext.isMetavariablePresentByMetavariableNode(metavariableNode, localMetaContext);
 
         if (metavariablePresent) {
-          const metastatementVerified = verifyMetastatement(metastatementNode, derived, localMetaContext, () => {
-            const verifiedAhead = true;
+          const metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localMetaContext, () => {
+                  const verifiedAhead = true;
 
-            return verifiedAhead;
-          });
+                  return verifiedAhead;
+                });
 
           qualifiedMetastatementVerified = metastatementVerified; ///
         }

package/src/verify/metastatement/unqualified.js

@@ -23,11 +23,11 @@ export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementN
     }
 
     if (!unqualifiedMetastatementVerified) {
-      const metastatementVerified = verifyMetastatement(metastatementNode, derived, localMetaContext, () => {
-        const verifiedAhead = true;
+      const metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localMetaContext, () => {
+              const verifiedAhead = true;
 
-        return verifiedAhead;
-      });
+              return verifiedAhead;
+            });
 
       unqualifiedMetastatementVerified = metastatementVerified; ///
     }

package/src/verify/metastatement.js

@@ -1,22 +1,34 @@
 "use strict";
 
+import verifyJudgement from "../verify/judgement";
+import verifyMetaEquality from "../verify/metaEquality";
 import metastatementNodeVerifier from "../verifier/node/metastatement";
 
-function verifyMetastatement(metastatementNode, derived, localMetaContext) {
+import { nodeQuery } from "../utilities/query";
+
+const judgementNodeQuery = nodeQuery("/metastatement/judgement!"),
+      metaEqualityNodeQuery = nodeQuery("/metastatement/metaEquality!");
+
+function verifyMetastatement(metastatementNode, assignments, derived, localMetaContext) {
   let metastatementVerified;
 
   const metastatementString = localMetaContext.nodeAsString(metastatementNode);
 
   localMetaContext.trace(`Verifying the '${metastatementString}' metastatement...`, metastatementNode);
 
-  const nonTerminalNode = metastatementNode, ///
-        nonTerminalNodeVerified = metastatementNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localMetaContext, () => {
-          const verifiedAhead = true;
+  const verifyMetaStatementFunctions = [
+    verifyMetastatementAsMetaEquality,
+    verifyMetastatementAsJudgement,
+    verifyMetastatementAsIs
+  ];
 
-          return verifiedAhead;
-        });
+  metastatementVerified = verifyMetaStatementFunctions.some((verifyStatementFunction) => {
+    const metastatementVerified = verifyStatementFunction(metastatementNode, assignments, derived, localMetaContext);
 
-  metastatementVerified = nonTerminalNodeVerified;  ///
+    if (metastatementVerified) {
+      return true;
+    }
+  });
 
   if (metastatementVerified) {
     localMetaContext.debug(`...verified the '${metastatementString}' metastatement.`, metastatementNode);
@@ -30,3 +42,75 @@ Object.assign(metastatementNodeVerifier, {
 });
 
 export default verifyMetastatement;
+
+function verifyMetastatementAsMetaEquality(metastatementNode, assignments, derived, localMetaContext) {
+  let metastatementVerifiedAsMetaEquality = false;
+
+  const metaEqualityNode = metaEqualityNodeQuery(metastatementNode);
+
+  if (metaEqualityNode !== null) {
+    const metastatementString = localMetaContext.nodeAsString(metastatementNode);
+
+    localMetaContext.trace(`Verifying the '${metastatementString}' metastatement as a meta-equality...`, metastatementNode);
+
+    const metaEqualityVerified = verifyMetaEquality(metaEqualityNode, assignments, derived, localMetaContext);
+
+    metastatementVerifiedAsMetaEquality = metaEqualityVerified;  ///
+
+    if (metastatementVerifiedAsMetaEquality) {
+      localMetaContext.debug(`...verified the '${metastatementString}' metastatement as a meta-equality.`, metastatementNode);
+    }
+  }
+
+  return metastatementVerifiedAsMetaEquality;
+}
+
+function verifyMetastatementAsJudgement(metastatementNode, assignments, derived, localMetaContext) {
+  let metastatementVerifiedAsJudgement = false;
+
+  const judgementNode = judgementNodeQuery(metastatementNode);
+
+  if (judgementNode !== null) {
+    const metastatementString = localMetaContext.nodeAsString(metastatementNode);
+
+    localMetaContext.trace(`Verifying the '${metastatementString}' metastatement as a judgement...`, metastatementNode);
+
+    const judgementVerified = verifyJudgement(judgementNode, derived, localMetaContext);
+
+    metastatementVerifiedAsJudgement = judgementVerified;  ///
+
+    if (metastatementVerifiedAsJudgement) {
+      localMetaContext.debug(`...verified the '${metastatementString}' metastatement as a judgement.`, metastatementNode);
+    }
+  }
+
+  return metastatementVerifiedAsJudgement;
+}
+
+function verifyMetastatementAsIs(metastatementNode, assignments, derived, localMetaContext) {
+  let metastatementVerifiedAsIs = false;
+
+  const judgementNode = judgementNodeQuery(metastatementNode),
+        metaEqualityNode = metaEqualityNodeQuery(metastatementNode);
+
+  if ((judgementNode === null) && (metaEqualityNode === null)) {
+    const metastatementString = localMetaContext.nodeAsString(metastatementNode);
+
+    localMetaContext.trace(`Verifying the '${metastatementString}' metastatement as is...`, metastatementNode);
+
+    const nonTerminalNode = metastatementNode, ///
+          nonTerminalNodeVerified = metastatementNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localMetaContext, () => {
+            const verifiedAhead = true;
+
+            return verifiedAhead;
+          });
+
+    metastatementVerifiedAsIs = nonTerminalNodeVerified;  ///
+
+    if (metastatementVerifiedAsIs) {
+      localMetaContext.debug(`...verified the '${metastatementString}' metastatement as is.`, metastatementNode);
+    }
+  }
+
+  return metastatementVerifiedAsIs;
+}

package/src/verify/premise.js

@@ -5,6 +5,7 @@ import MetaproofStep from "../step/metaproof";
 import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
+import { assignAssignment } from "../utilities/assignments";
 
 const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/premise/unqualifiedMetastatement!");
@@ -22,6 +23,12 @@ export default function verifyPremise(premiseNode, premises, localMetaContext) {
         unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext);
 
   if (unqualifiedMetastatementVerified) {
+    const assignmentAssigned = assignAssignment(assignments, localMetaContext);
+
+    premiseVerified = assignmentAssigned; ///
+  }
+
+  if (premiseVerified) {
     const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
           metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode),
           premise = Premise.fromMetastatementNode(metastatementNode);
@@ -30,10 +37,6 @@ export default function verifyPremise(premiseNode, premises, localMetaContext) {
 
     localMetaContext.addMetaproofStep(metaproofStep);
 
-    premiseVerified = true;
-  }
-
-  if (premiseVerified) {
     localMetaContext.debug(`...verified the '${premiseString}' premise.`, premiseNode);
   }
 

package/src/verify/ruleDerivation.js

@@ -6,6 +6,7 @@ import LocalMetaContext from "../context/localMeta";
 import verifyQualifiedMetastatement from "../verify/metastatement/qualified";
 import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
 
+import { assignAssignment } from "../utilities/assignments";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 import { RULE_SUBPROOF_RULE_NAME, QUALIFIED_METASTATEMENT_RULE_NAME, UNQUALIFIED_METASTATEMENT_RULE_NAME } from "../ruleNames";
 
@@ -89,11 +90,20 @@ function verifyChild(childNode, localMetaContext) {
     }
 
     case QUALIFIED_METASTATEMENT_RULE_NAME: {
+      let qualifiedMetastatementVerified;
+
       const derived = true,
             assignments = [],
             metavariableReferences = true,
-            qualifiedMetastatementNode = childNode,  ///
-            qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, metavariableReferences, assignments, derived, localMetaContext);
+            qualifiedMetastatementNode = childNode;  ///
+
+      qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, metavariableReferences, assignments, derived, localMetaContext);
+
+      if (qualifiedMetastatementVerified) {
+        const assignmentAssigned = assignAssignment(assignments, localMetaContext);
+
+        qualifiedMetastatementVerified = assignmentAssigned; ///
+      }
 
       if (qualifiedMetastatementVerified) {
         const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
@@ -108,10 +118,19 @@ function verifyChild(childNode, localMetaContext) {
     }
 
     case UNQUALIFIED_METASTATEMENT_RULE_NAME: {
+      let unqualifiedMetastatementVerified;
+
       const derived = true,
-            assignments = false,
-            unqualifiedMetastatementNode = childNode,  ///
-            unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext);
+            assignments = [],
+            unqualifiedMetastatementNode = childNode;  ///
+
+      unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext);
+
+      if (unqualifiedMetastatementVerified) {
+        const assignmentAssigned = assignAssignment(assignments, localMetaContext);
+
+        unqualifiedMetastatementVerified = assignmentAssigned; ///
+      }
 
       if (unqualifiedMetastatementVerified) {
         const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),