occam-verify-cli 0.0.881 → 0.0.882

package/src/verify/declaration.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import Declaration from "../declaration"
 import referenceMetaType from "../metaType/reference";
 import metastatementNodeVerifier from "../verifier/node/metastatement";
 
@@ -8,7 +9,7 @@ import { nodeQuery } from "../utilities/query";
 const metavariableNodeQuery = nodeQuery("/declaration/metavariable!"),
       metastatementNodeQuery = nodeQuery("/declaration/metastatement!");
 
-export default function verifyDeclaration(declarationNode, derived, localMetaContext) {
+export default function verifyDeclaration(declarationNode, declarations, localMetaContext) {
   let declarationVerified = false;
 
   const declarationString = localMetaContext.nodeAsString(declarationNode);
@@ -16,31 +17,26 @@ export default function verifyDeclaration(declarationNode, derived, localMetaCon
   localMetaContext.trace(`Verifying the '${declarationString}' declaration...`, declarationNode);
 
   const metavariableNode = metavariableNodeQuery(declarationNode),
-        metavariable = localMetaContext.findMetavariableByMetavariableNode(metavariableNode, localMetaContext);
+        metavariableVerified = verifyMetavariable(metavariableNode, localMetaContext);
 
-  if (metavariable !== null) {
-    const metaType = metavariable.getMetaType();
+  if (metavariableVerified) {
+    const metastatementNode = metastatementNodeQuery(declarationNode);
 
-    if (metaType === referenceMetaType) {
-      const metastatementNode = metastatementNodeQuery(declarationNode);
+    const { verifyMetastatement } = metastatementNodeVerifier,
+          derived = false,
+          assignments = [],
+          metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localMetaContext, () => {
+            const verifiedAhead = true;
 
-      if (metastatementNode !== null) {
-        const { verifyMetastatement } = metastatementNodeVerifier,
-              assignments = [],
-              metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localMetaContext, () => {
-                const verifiedAhead = true;
+            return verifiedAhead;
+          });
 
-                return verifiedAhead;
-              });
+    if (metastatementVerified) {
+      const declaration = Declaration.fromMetavariableNodeAndMetastatementNode(metavariableNode, metastatementNode);
 
-        declarationVerified = metastatementVerified;  ///
-      }
-    } else {
-      const referenceMetaTypeName = referenceMetaType.getName(),
-            metavariableString = localMetaContext.nodeAsString(metavariableNode),
-            metaTypeString = metaType.asString();
+      declarations.push(declaration);
 
-      localMetaContext.debug(`The '${metavariableString}' metavariable's meta-type is '${metaTypeString}' when it should be '${referenceMetaTypeName}'.`, declarationNode);
+      declarationVerified = true;
     }
   }
 
@@ -49,4 +45,35 @@ export default function verifyDeclaration(declarationNode, derived, localMetaCon
   }
 
   return declarationVerified;
+}
+
+function verifyMetavariable(metavariableNode, localMetaContext) {
+  let metavariableVerified = false;
+
+  const metavariableString = localMetaContext.nodeAsString(metavariableNode);
+
+  localMetaContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
+
+  const metavariable = localMetaContext.findMetavariableByMetavariableNode(metavariableNode, localMetaContext);
+
+  if (metavariable !== null) {
+    const metaType = metavariable.getMetaType();
+
+    if (metaType === referenceMetaType) {
+      metavariableVerified = true;
+    } else {
+      const referenceMetaTypeName = referenceMetaType.getName(),
+            metaTypeString = metaType.asString();
+
+      localMetaContext.debug(`The '${metavariableString}' metavariable's meta-type is '${metaTypeString}' when it should be '${referenceMetaTypeName}'.`, metavariableNode);
+    }
+  } else {
+    localMetaContext.debug(`The '${metavariableString}' metavariable is not present'.`, metavariableNode);
+  }
+
+  if (metavariableVerified) {
+    localMetaContext.debug(`...verified the '${metavariableString}' metavariable.`, metavariableNode);
+  }
+
+  return metavariableVerified;
 }

package/src/verify/frame.js

@@ -1,30 +1,91 @@
 "use strict";
 
+import Frame from "../frame";
+import frameMetaType from "../metaType/frame";
 import verifyDeclaration from "../verify/declaration";
 
+import { push } from "../utilities/array";
 import { nodesQuery } from "../utilities/query";
 
-const declarationNodesQuery = nodesQuery("/frame/declaration");
+const declarationNodesQuery = nodesQuery("/frame/declaration"),
+      metavariableNodesQuery = nodesQuery("/frame/metavariable");
 
-export default function verifyFrame(frameNode, derived, localMetaContext) {
+export default function verifyFrame(frameNode, frames, derived, localMetaContext) {
   let frameVerified;
 
   const frameString = localMetaContext.nodeAsString(frameNode);
 
   localMetaContext.trace(`Verifying the '${frameString}' frame...`, frameNode);
 
-  const declarationNodes = declarationNodesQuery(frameNode),
+  const declarations = [],
+        declarationNodes = declarationNodesQuery(frameNode),
         declarationsVerified = declarationNodes.every((declarationNode) => {
-          const declarationVerified = verifyDeclaration(declarationNode, derived, localMetaContext);
+          const declarationVerified = verifyDeclaration(declarationNode, declarations, localMetaContext);
 
           return declarationVerified;
         });
 
-  frameVerified = declarationsVerified; ///
+  if (declarationsVerified) {
+    const metavariableNodes = metavariableNodesQuery(frameNode),
+          metavariablesVerified = metavariableNodes.every((metavariableNode) => {
+            const metavariableVerified = verifyMetavariable(metavariableNode, declarations, localMetaContext);
+
+            return metavariableVerified;
+          });
+
+    if (metavariablesVerified) {
+      const frame = Frame.fromDeclarations(declarations);
+
+      frames.push(frame);
+
+      frameVerified = true;
+    }
+  }
 
   if (frameVerified) {
     localMetaContext.debug(`...verified the '${frameString}' frame.`, frameNode);
   }
 
   return frameVerified;
+}
+
+function verifyMetavariable(metavariableNode, declarations, localMetaContext) {
+  let metavariableVerified = false;
+
+  const metavariableString = localMetaContext.nodeAsString(metavariableNode);
+
+  localMetaContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
+
+  const metavariable = localMetaContext.findMetavariableByMetavariableNode(metavariableNode, localMetaContext);
+
+  if (metavariable !== null) {
+    const metaType = metavariable.getMetaType();
+
+    if (metaType === frameMetaType) {
+      const judgement = localMetaContext.findJudgementByMetavariableNode(metavariableNode);
+
+      if (judgement !== null) {
+        const judgementDeclarations = judgement.getDeclarations();
+
+        push(declarations, judgementDeclarations);
+
+        metavariableVerified = true;
+      } else {
+        localMetaContext.debug(`There is no judgement for the '${metavariableString}' metavariable.`, metavariableNode);
+      }
+    } else {
+      const frameMetaTypeName = frameMetaType.getName(),
+            metaTypeString = metaType.asString();
+
+      localMetaContext.debug(`The '${metavariableString}' metavariable's meta-type is '${metaTypeString}' when it should be '${frameMetaTypeName}'.`, metavariableNode);
+    }
+  } else {
+    localMetaContext.debug(`The '${metavariableString}' metavariable is not present'.`, metavariableNode);
+  }
+
+  if (metavariableVerified) {
+    localMetaContext.debug(`...verified the '${metavariableString}' metavariable.`, metavariableNode);
+  }
+
+  return metavariableVerified;
 }

package/src/verify/judgement.js

@@ -1,8 +1,11 @@
 "use strict";
 
+import Judgement from "../judgement";
 import verifyFrame from "../verify/frame";
 import frameMetaType from "../metaType/frame";
+import JudgementAssignment from "../assignment/judgement";
 
+import { first } from "../utilities/array";
 import { nodeQuery } from "../utilities/query";
 
 const frameNodeQuery = nodeQuery("/judgement/frame!"),
@@ -39,38 +42,59 @@ function verifyDerivedJudgement(judgementNode, assignments, derived, localMetaCo
   let derivedJudgementVerified = false;
 
   if (derived) {
-    // const judgementString = localMetaContext.nodeAsString(judgementNode);
-    //
-    // localMetaContext.trace(`Verifying the '${judgementString}' derived judgement...`, judgementNode);
-    //
-    // const metavariableNode = metavariableNodeQuery(judgementNode),
-    //       metavariable = localMetaContext.findMetavariableByMetavariableNode(metavariableNode, localMetaContext);
-    //
-    // if (metavariable !== null) {
-    //   const metaType = metavariable.getMetaType();
-    //
-    //   if (metaType === frameMetaType) {
-    //     const frameNode = frameNodeQuery(judgementNode);
-    //
-    //     if (frameNode !== null) {
-    //       const frameVerified = verifyFrame(frameNode, derived, localMetaContext);
-    //
-    //       derivedJudgementVerified = frameVerified;  ///
-    //     } else {
-    //       localMetaContext.debug(`The right hand side of the '${judgementString}' judgement must be a frame.`, judgementNode);
-    //     }
-    //   } else {
-    //     const frameMetaTypeName = frameMetaType.getName(),
-    //       metavariableString = localMetaContext.nodeAsString(metavariableNode),
-    //       metaTypeString = metaType.asString();
-    //
-    //     localMetaContext.debug(`The '${metavariableString}' metavariable's meta-type is '${metaTypeString}' when it should be '${frameMetaTypeName}'.`, judgementNode);
-    //   }
-    // }
-    //
-    // if (derivedJudgementVerified) {
-    //   localMetaContext.debug(`...verified the '${judgementString}' derived judgement.`, judgementNode);
-    // }
+    const judgementString = localMetaContext.nodeAsString(judgementNode);
+
+    localMetaContext.trace(`Verifying the '${judgementString}' derived judgement...`, judgementNode);
+
+    const metavariableNode = metavariableNodeQuery(judgementNode),
+          metavariableVerified = verifyMetavariable(metavariableNode, localMetaContext);
+
+    if (metavariableVerified) {
+      const judgement = localMetaContext.findJudgementByMetavariableNode(metavariableNode);
+
+      if (judgement !== null) {
+        const frames = [],
+              frameNode = frameNodeQuery(judgementNode),
+              frameVerified = verifyFrame(frameNode, frames, derived, localMetaContext);
+
+        if (frameVerified) {
+          const firstFrame = first(frames),
+                frame = firstFrame, ///
+                frameSingular = frame.isSingular();
+
+          if (frameSingular) {
+            const declaration = frame.getDeclaration(),
+                  metavariableNode = declaration.getMetavariableNode(),
+                  metaLemma = localMetaContext.findMetaLemmaByMetavariableNode(metavariableNode),
+                  metatheorem = localMetaContext.findMetatheoremByMetavariableNode(metavariableNode),
+                  metaLemmaMetatheorem = (metaLemma || metatheorem);  ///
+
+            if (metaLemmaMetatheorem !== null) {
+              const judgementMatchesMetaLemmaMetatheorem = judgement.matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem),
+                    declarationMatchesMetaLemmaMetatheorem = declaration.matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem);
+
+              derivedJudgementVerified = (judgementMatchesMetaLemmaMetatheorem && declarationMatchesMetaLemmaMetatheorem);
+            } else {
+              const metavariableString = localMetaContext.nodeAsString(metavariableNode);
+
+              localMetaContext.debug(`There are no meta-lemmas or metatheorems corresponding to the '${metavariableString}' metavariable.`, judgementNode);
+            }
+          } else {
+            const frameString = localMetaContext.nodeAsString(frameNode);
+
+            localMetaContext.debug(`The '${frameString}' is not singular.`, judgementNode);
+          }
+        }
+      } else {
+        const metavariableString = localMetaContext.nodeAsString(metavariableNode);
+
+        localMetaContext.debug(`There is no judgement present for the '${metavariableString}' metavariable.`, judgementNode);
+      }
+    }
+
+    if (derivedJudgementVerified) {
+      localMetaContext.debug(`...verified the '${judgementString}' derived judgement.`, judgementNode);
+    }
   }
 
   return derivedJudgementVerified;
@@ -85,27 +109,23 @@ function verifyStatedJudgement(judgementNode, assignments, derived, localMetaCon
     localMetaContext.trace(`Verifying the '${judgementString}' stated judgement...`, judgementNode);
 
     const metavariableNode = metavariableNodeQuery(judgementNode),
-          metavariable = localMetaContext.findMetavariableByMetavariableNode(metavariableNode, localMetaContext);
+          metavariableVerified = verifyMetavariable(metavariableNode, localMetaContext);
 
-    if (metavariable !== null) {
-      const metaType = metavariable.getMetaType();
+    if (metavariableVerified) {
+      const frames = [],
+            frameNode = frameNodeQuery(judgementNode),
+            frameVerified = verifyFrame(frameNode, frames, derived, localMetaContext);
 
-      if (metaType === frameMetaType) {
-        const frameNode = frameNodeQuery(judgementNode);
+      if (frameVerified) {
+        const firstFrame = first(frames),
+              frame = firstFrame, ///
+              judgement = Judgement.fromJudgementNodeFrameAndMetavariableNode(judgementNode, frame, metavariableNode),
+              judgementAssignment = JudgementAssignment.fromJudgement(judgement),
+              assignment = judgementAssignment;
 
-        if (frameNode !== null) {
-          const frameVerified = verifyFrame(frameNode, derived, localMetaContext);
-
-          statedJudgementVerified = frameVerified;  ///
-        } else {
-          localMetaContext.debug(`The right hand side of the '${judgementString}' judgement must be a frame.`, judgementNode);
-        }
-      } else {
-        const frameMetaTypeName = frameMetaType.getName(),
-              metavariableString = localMetaContext.nodeAsString(metavariableNode),
-              metaTypeString = metaType.asString();
+        assignments.push(assignment);
 
-        localMetaContext.debug(`The '${metavariableString}' metavariable's meta-type is '${metaTypeString}' when it should be '${frameMetaTypeName}'.`, judgementNode);
+        statedJudgementVerified = true;
       }
     }
 
@@ -115,4 +135,35 @@ function verifyStatedJudgement(judgementNode, assignments, derived, localMetaCon
   }
 
   return statedJudgementVerified;
-}
+}
+
+function verifyMetavariable(metavariableNode, localMetaContext) {
+  let metavariableVerified = false;
+
+  const metavariableString = localMetaContext.nodeAsString(metavariableNode);
+
+  localMetaContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
+
+  const metavariable = localMetaContext.findMetavariableByMetavariableNode(metavariableNode, localMetaContext);
+
+  if (metavariable !== null) {
+    const metaType = metavariable.getMetaType();
+
+    if (metaType === frameMetaType) {
+      metavariableVerified = true;
+    } else {
+      const frameMetaTypeName = frameMetaType.getName(),
+            metaTypeString = metaType.asString();
+
+      localMetaContext.debug(`The '${metavariableString}' metavariable's meta-type is '${metaTypeString}' when it should be '${frameMetaTypeName}'.`, metavariableNode);
+    }
+  } else {
+    localMetaContext.debug(`The '${metavariableString}' metavariable is not present'.`, metavariableNode);
+  }
+
+  if (metavariableVerified) {
+    localMetaContext.debug(`...verified the '${metavariableString}' metavariable.`, metavariableNode);
+  }
+
+  return metavariableVerified;
+}

package/src/verify/label.js

@@ -2,20 +2,19 @@
 
 import Label from "../label";
 
-export default function verifyLabel(labelsMetavariableNode, labels, fileContext) {
+export default function verifyLabel(metavariableNode, labels, fileContext) {
   let labelVerified = false;
 
-  const labelMetavariableString = fileContext.nodeAsString(labelsMetavariableNode);
+  const labelMetavariableString = fileContext.nodeAsString(metavariableNode);
 
-  fileContext.trace(`Verifying the '${labelMetavariableString}' label...`, labelsMetavariableNode);
+  fileContext.trace(`Verifying the '${labelMetavariableString}' label...`, metavariableNode);
 
-  const labelPresent = fileContext.isLabelPresentByLabelMetavariableNode(labelsMetavariableNode);
+  const labelPresent = fileContext.isLabelPresentByMetavariableNode(metavariableNode);
 
   if (labelPresent) {
-    fileContext.debug(`The '${labelMetavariableString}' label is already present.`, labelsMetavariableNode);
+    fileContext.debug(`The '${labelMetavariableString}' label is already present.`, metavariableNode);
   } else {
-    const metavariableNode = labelsMetavariableNode,  ///
-          label = Label.fromMetavariableNode(metavariableNode);
+    const label = Label.fromMetavariableNode(metavariableNode);
 
     labels.push(label);
 
@@ -23,7 +22,7 @@ export default function verifyLabel(labelsMetavariableNode, labels, fileContext)
   }
 
   if (labelVerified) {
-    fileContext.debug(`...verified the '${labelMetavariableString}' label.`, labelsMetavariableNode);
+    fileContext.debug(`...verified the '${labelMetavariableString}' label.`, metavariableNode);
   }
 
   return labelVerified;

package/src/verify/labels.js

@@ -12,10 +12,11 @@ export default function verifyLabels(labelsNode, labels, fileContext) {
   if (labelsNode === null) {
     labelsVerified = true;
   } else {
-    const labelsMetavariableNodes = labelsMetavariableNodesQuery(labelsNode);
+    const labelsMetavariableNodes = labelsMetavariableNodesQuery(labelsNode),
+          metavariableNodes = labelsMetavariableNodes;  ///
 
-    labelsVerified = labelsMetavariableNodes.every((labelsMetavariableNode) => {
-      const labelVerified = verifyLabel(labelsMetavariableNode, labels, fileContext);
+    labelsVerified = metavariableNodes.every((metavariableNode) => {
+      const labelVerified = verifyLabel(metavariableNode, labels, fileContext);
 
       if (labelVerified) {
         return true;

package/src/verify/metastatement/qualified.js

@@ -5,8 +5,8 @@ import verifyMetavariableAgainstMetastatement from "../../verify/metavariableAga
 
 import { nodeQuery } from "../../utilities/query";
 
-const metastatementNodeQuery = nodeQuery("/qualifiedMetastatement/metastatement!"),
-      referenceMetavariableNodeQuery = nodeQuery("/qualifiedMetastatement/reference!/metavariable!");
+const metavariableNodeQuery = nodeQuery("/qualifiedMetastatement/reference!/metavariable!"),
+      metastatementNodeQuery = nodeQuery("/qualifiedMetastatement/metastatement!");
 
 export default function verifyQualifiedMetastatement(qualifiedMetastatementNode, substitutions, assignments, derived, localMetaContext) {
   let qualifiedMetastatementVerified = false;
@@ -19,18 +19,21 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
 
     localMetaContext.trace(`Verifying the '${metastatementString}' qualified metastatement...`, qualifiedMetastatementNode);
 
-    const referenceMetavariableNode = referenceMetavariableNodeQuery(qualifiedMetastatementNode),
-          labelMetavariableNode = referenceMetavariableNode,  ///
-          rule = localMetaContext.findRuleByLabelMetavariableNode(labelMetavariableNode);
+    const metavariableNode = metavariableNodeQuery(qualifiedMetastatementNode);
 
-    if (rule !== null) {
-      const ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, metastatementLocalMetaContext);
+    if (!qualifiedMetastatementVerified) {
+      const rule = localMetaContext.findRuleByMetavariableNode(metavariableNode);
 
-      qualifiedMetastatementVerified = ruleMatchesMetastatement;  ///
-    } else {
+      if (rule !== null) {
+        const ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, metastatementLocalMetaContext);
+
+        qualifiedMetastatementVerified = ruleMatchesMetastatement;  ///
+      }
+    }
+
+    if (!qualifiedMetastatementVerified) {
       if (substitutions !== null) {
-        const metavariableNode = referenceMetavariableNode, ///
-              metavariablePresent = localMetaContext.isMetavariablePresentByMetavariableNode(metavariableNode, localMetaContext);
+        const metavariablePresent = localMetaContext.isMetavariablePresentByMetavariableNode(metavariableNode, localMetaContext);
 
         if (metavariablePresent) {
           const metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localMetaContext, () => {

package/src/verify/statement/qualified.js

@@ -69,8 +69,8 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
 function verifyQualifiedStatementAAgainstRule(qualifiedStatementNode, referenceMetavariableNode, localContext) {
   let qualifiedStatementVerifiedAgainstRule = false;
 
-  const labelMetavariableNode = referenceMetavariableNode,  ///
-        rule = localContext.findRuleByLabelMetavariableNode(labelMetavariableNode);
+  const metavariableNode = referenceMetavariableNode,  ///
+        rule = localContext.findRuleByMetavariableNode(metavariableNode);
 
   if (rule !== null) {
     const referenceMetavariableString = localContext.nodeAsString(referenceMetavariableNode),
@@ -95,8 +95,8 @@ function verifyQualifiedStatementAAgainstRule(qualifiedStatementNode, referenceM
 function verifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, referenceMetavariableNode, localContext) {
   let qualifiedStatementVerifiedAgainstAxiom = false;
 
-  const labelMetavariableNode = referenceMetavariableNode,  ///
-        axiom = localContext.findAxiomByLabelMetavariableNode(labelMetavariableNode);
+  const metavariableNode = referenceMetavariableNode,  ///
+        axiom = localContext.findAxiomByMetavariableNode(metavariableNode);
 
   if (axiom !== null) {
     const referenceMetavariableString = localContext.nodeAsString(referenceMetavariableNode),
@@ -121,8 +121,8 @@ function verifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, reference
 function verifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, referenceMetavariableNode, localContext) {
   let qualifiedStatementVerifiedAgainstLemma = false;
 
-  const labelMetavariableNode = referenceMetavariableNode,  ///
-        lemma = localContext.findLemmaByLabelMetavariableNode(labelMetavariableNode);
+  const metavariableNode = referenceMetavariableNode,  ///
+        lemma = localContext.findLemmaByMetavariableNode(metavariableNode);
 
   if (lemma !== null) {
     const referenceMetavariableString = localContext.nodeAsString(referenceMetavariableNode),
@@ -147,8 +147,8 @@ function verifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, reference
 function verifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, referenceMetavariableNode, localContext) {
   let qualifiedStatementVerifiedAgainstTheorem = false;
 
-  const labelMetavariableNode = referenceMetavariableNode,  ///
-        theorem = localContext.findTheoremByLabelMetavariableNode(labelMetavariableNode);
+  const metavariableNode = referenceMetavariableNode,  ///
+        theorem = localContext.findTheoremByMetavariableNode(metavariableNode);
 
   if (theorem !== null) {
     const referenceMetavariableString = localContext.nodeAsString(referenceMetavariableNode),
@@ -173,8 +173,8 @@ function verifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, referen
 function verifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, referenceMetavariableNode, localContext) {
   let qualifiedStatementVerifiedAgainstConjecture = false;
 
-  const labelMetavariableNode = referenceMetavariableNode,  ///
-        conjecture = localContext.findConjectureByLabelMetavariableNode(labelMetavariableNode);
+  const metavariableNode = referenceMetavariableNode,  ///
+        conjecture = localContext.findConjectureByMetavariableNode(metavariableNode);
 
   if (conjecture !== null) {
     const referenceMetavariableString = localContext.nodeAsString(referenceMetavariableNode),