occam-verify-cli 0.0.866 → 0.0.868

package/src/mixins/context.js

@@ -30,15 +30,15 @@ function findTypeByTypeNode(labelNode) { return this.context.findTypeByTypeNode(
 
 function findLabelByLabelNode(labelNode) { return this.context.findLabelByLabelNode(labelNode); }
 
-function findRuleByReferenceNode(referenceNode) { return this.context.findRuleByReferenceNode(referenceNode); }
+function findRuleByLabelNode(labelNode) { return this.context.findRuleByLabelNode(labelNode); }
 
-function findAxiomByReferenceNode(referenceNode) { return this.context.findAxiomByReferenceNode(referenceNode); }
+function findAxiomByLabelNode(labelNode) { return this.context.findAxiomByLabelNode(labelNode); }
 
-function findLemmaByReferenceNode(referenceNode) { return this.context.findLemmaByReferenceNode(referenceNode); }
+function findLemmaByLabelNode(labelNode) { return this.context.findLemmaByLabelNode(labelNode); }
 
-function findTheoremByReferenceNode(referenceNode) { return this.context.findTheoremByReferenceNode(referenceNode); }
+function findTheoremByLabelNode(labelNode) { return this.context.findTheoremByLabelNode(labelNode); }
 
-function findConjectureByReferenceNode(referenceNode) { return this.context.findConjectureByReferenceNode(referenceNode); }
+function findConjectureByLabelNode(labelNode) { return this.context.findConjectureByLabelNode(labelNode); }
 
 function isTypePresentByTypeName(typeName) { return this.context.isTypePresentByTypeName(typeName); }
 
@@ -66,11 +66,11 @@ const contextMixins = {
   findTypeByTypeName,
   findTypeByTypeNode,
   findLabelByLabelNode,
-  findRuleByReferenceNode,
-  findAxiomByReferenceNode,
-  findLemmaByReferenceNode,
-  findTheoremByReferenceNode,
-  findConjectureByReferenceNode,
+  findRuleByLabelNode,
+  findAxiomByLabelNode,
+  findLemmaByLabelNode,
+  findTheoremByLabelNode,
+  findConjectureByLabelNode,
   isTypePresentByTypeName,
   isTypePresentByTypeNode,
   isLabelPresentByLabelNode,

package/src/utilities/name.js

@@ -4,8 +4,7 @@ import { nodeQuery } from "../utilities/query";
 
 const typeTerminalNodeQuery = nodeQuery("/type/@type"),
       metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type"),
-      labelNameTerminalNodeQuery = nodeQuery("/label/@name"),
-      referenceNameTerminalNodeQuery = nodeQuery("/reference/@name");
+      labelNameTerminalNodeQuery = nodeQuery("/label/@name");
 
 export function typeNameFromTypeNode(typeNode) {
   let typeName = null;
@@ -40,11 +39,3 @@ export function metaTypeNameFromMetaTypeNode(metaTypeNode) {
 
   return metaTypeName;
 }
-
-export function referenceNameFromReferenceNode(referenceNode) {
-  const referenceNameTerminalNode = referenceNameTerminalNodeQuery(referenceNode),
-        referenceNameTerminalNodeContent = referenceNameTerminalNode.getContent(),
-        referenceName = referenceNameTerminalNodeContent; ///
-
-  return referenceName;
-}

package/src/verify/axiom.js

@@ -9,7 +9,7 @@ import verifySuppositions from "../verify/suppositions";
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const labelNodesQuery = nodesQuery("/axiom//labels/label"),
+const labelNodesQuery = nodesQuery("/axiom//reference/label"),
       consequentNodeQuery = nodeQuery("/axiom/consequent!"),
       suppositionsNodeQuery = nodesQuery("/axiom/supposition");
 

package/src/verify/conjecture.js

@@ -11,7 +11,7 @@ import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const proofNodeQuery = nodeQuery("/conjecture/proof!"),
-      labelNodesQuery = nodesQuery("/conjecture//labels/label"),
+      labelNodesQuery = nodesQuery("/conjecture//reference/label"),
       consequentNodeQuery = nodeQuery("/conjecture/consequent!"),
       suppositionsNodeQuery = nodesQuery("/conjecture/supposition");
 

package/src/verify/lemma.js

@@ -12,7 +12,7 @@ import { EMPTY_STRING } from "../constants";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const proofNodeQuery = nodeQuery("/lemma/proof!"),
-      labelNodesQuery = nodesQuery("/lemma//labels/label"),
+      labelNodesQuery = nodesQuery("/lemma//reference/label"),
       consequentNodeQuery = nodeQuery("/lemma/consequent!"),
       suppositionsNodeQuery = nodesQuery("/lemma/supposition");
 

package/src/verify/metaLemma.js

@@ -11,7 +11,7 @@ import { first } from "../utilities/array";
 import { EMPTY_STRING } from "../constants";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const labelNodesQuery = nodesQuery("/metaLemma//labels/label"),
+const labelNodesQuery = nodesQuery("/metaLemma//reference/label"),
       metaproofNodeQuery = nodeQuery("/metaLemma/metaproof!"),
       metaConsequentNodeQuery = nodeQuery("/metaLemma/metaConsequent!"),
       metaSuppositionsNodeQuery = nodesQuery("/metaLemma/metaSupposition");

package/src/verify/metastatement/qualified.js

@@ -2,7 +2,7 @@
 
 import { nodeQuery } from "../../utilities/query";
 
-const referenceNodeQuery = nodeQuery("/qualifiedMetastatement/qualification!/reference!"),
+const labelNodeQuery = nodeQuery("/qualifiedMetastatement/qualification!/label!"),
       metastatementNodeQuery = nodeQuery("/qualifiedMetastatement/metastatement!");
 
 export default function verifyQualifiedMetastatement(qualifiedMetastatementNode, assignments, derived, localMetaContext) {
@@ -16,8 +16,8 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
 
     localMetaContext.trace(`Verifying the '${metastatementString}' qualified metastatement...`, qualifiedMetastatementNode);
 
-    const referenceNode = referenceNodeQuery(qualifiedMetastatementNode),
-          rule = localMetaContext.findRuleByReferenceNode(referenceNode);
+    const labelNode = labelNodeQuery(qualifiedMetastatementNode),
+          rule = localMetaContext.findRuleByLabelNode(labelNode);
 
     if (rule !== null) {
       const ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, metastatementLocalMetaContext);

package/src/verify/metatheorem.js

@@ -10,7 +10,7 @@ import verifyMetaSuppositions from "../verify/metaSuppositions";
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const labelNodesQuery = nodesQuery("/metatheorem//labels/label"),
+const labelNodesQuery = nodesQuery("/metatheorem//reference/label"),
       metaproofNodeQuery = nodeQuery("/metatheorem/metaproof!"),
       metaConsequentNodeQuery = nodeQuery("/metatheorem/metaConsequent!"),
       metaSuppositionsNodeQuery = nodesQuery("/metatheorem/metaSupposition");

package/src/verify/rule.js

@@ -10,7 +10,7 @@ import verifyConclusion from "../verify/conclusion";
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const labelNodesQuery = nodesQuery("/rule//labels/label"),
+const labelNodesQuery = nodesQuery("/rule//reference/label"),
       premisesNodeQuery = nodesQuery("/rule/premise"),
       ruleProofNodeQuery = nodeQuery("/rule/ruleProof!"),
       conclusionNodeQuery = nodeQuery("/rule/conclusion!");

package/src/verify/statement/qualified.js

@@ -5,8 +5,8 @@ import verifyTypeAssertion from "../typeAssertion";
 
 import { nodeQuery } from "../../utilities/query";
 
-const equalityNodeQuery = nodeQuery("/qualifiedStatement/statement/equality!"),
-      referenceNodeQuery = nodeQuery("/qualifiedStatement/qualification!/reference!"),
+const labelNodeQuery = nodeQuery("/qualifiedStatement/qualification!/label!"),
+      equalityNodeQuery = nodeQuery("/qualifiedStatement/statement/equality!"),
       statementNodeQuery = nodeQuery("/qualifiedStatement/statement!"),
       typeAssertionNodeQuery = nodeQuery("/qualifiedStatement/statement/typeAssertion!");
 
@@ -20,7 +20,7 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
 
     localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement...`, qualifiedStatementNode);
 
-    const referenceNode = referenceNodeQuery(qualifiedStatementNode),
+    const labelNode = labelNodeQuery(qualifiedStatementNode),
           verifyQualifiedStatementFunctions = [
             verifyQualifiedStatementAAgainstRule,
             verifyQualifiedStatementAAgainstAxiom,
@@ -30,7 +30,7 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
           ];
 
     qualifiedStatementVerified = verifyQualifiedStatementFunctions.some((verifyQualifiedStatementFunction) => {  ///
-      const qualifiedStatementVerified = verifyQualifiedStatementFunction(qualifiedStatementNode, referenceNode, localContext);
+      const qualifiedStatementVerified = verifyQualifiedStatementFunction(qualifiedStatementNode, labelNode, localContext);
 
       if (qualifiedStatementVerified) {
         return true;
@@ -66,125 +66,125 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
   return qualifiedStatementVerified;
 }
 
-function verifyQualifiedStatementAAgainstRule(qualifiedStatementNode, referenceNode, localContext) {
+function verifyQualifiedStatementAAgainstRule(qualifiedStatementNode, labelNode, localContext) {
   let qualifiedStatementVerifiedAgainstRule = false;
 
-  const rule = localContext.findRuleByReferenceNode(referenceNode);
+  const rule = localContext.findRuleByLabelNode(labelNode);
 
   if (rule !== null) {
-    const statementNode = statementNodeQuery(qualifiedStatementNode),
-          referenceString = localContext.nodeAsString(referenceNode),
+    const labelString = localContext.nodeAsString(labelNode),
+          statementNode = statementNodeQuery(qualifiedStatementNode),
           statementLocalContext = localContext, ///
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceString}' rule...`, statementNode);
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${labelString}' rule...`, statementNode);
 
     const ruleMatchesStatement = rule.matchStatement(statementNode, statementLocalContext);
 
     qualifiedStatementVerifiedAgainstRule = ruleMatchesStatement;  ///
 
     if (qualifiedStatementVerifiedAgainstRule) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceString}' rule.`, statementNode);
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${labelString}' rule.`, statementNode);
     }
   }
 
   return qualifiedStatementVerifiedAgainstRule;
 }
 
-function verifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, referenceNode, localContext) {
+function verifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, labelNode, localContext) {
   let qualifiedStatementVerifiedAgainstAxiom = false;
 
-  const axiom = localContext.findAxiomByReferenceNode(referenceNode);
+  const axiom = localContext.findAxiomByLabelNode(labelNode);
 
   if (axiom !== null) {
-    const statementNode = statementNodeQuery(qualifiedStatementNode),
-          referenceString = localContext.nodeAsString(referenceNode),
+    const labelString = localContext.nodeAsString(labelNode),
+          statementNode = statementNodeQuery(qualifiedStatementNode),
           statementLocalContext = localContext, ///
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceString}' axiom...`, statementNode);
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${labelString}' axiom...`, statementNode);
 
     const axiomMatchesStatement = axiom.matchStatement(statementNode, statementLocalContext);
 
     qualifiedStatementVerifiedAgainstAxiom = axiomMatchesStatement; ///
 
     if (qualifiedStatementVerifiedAgainstAxiom) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceString}' axiom.`, statementNode);
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${labelString}' axiom.`, statementNode);
     }
   }
 
   return qualifiedStatementVerifiedAgainstAxiom;
 }
 
-function verifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, referenceNode, localContext) {
+function verifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, labelNode, localContext) {
   let qualifiedStatementVerifiedAgainstLemma = false;
 
-  const lemma = localContext.findLemmaByReferenceNode(referenceNode);
+  const lemma = localContext.findLemmaByLabelNode(labelNode);
 
   if (lemma !== null) {
-    const statementNode = statementNodeQuery(qualifiedStatementNode),
-          referenceString = localContext.nodeAsString(referenceNode),
+    const labelString = localContext.nodeAsString(labelNode),
+          statementNode = statementNodeQuery(qualifiedStatementNode),
           statementLocalContext = localContext, ///
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceString}' lemma...`, statementNode);
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${labelString}' lemma...`, statementNode);
 
     const lemmaMatchesStatement = lemma.matchStatement(statementNode, statementLocalContext);
 
     qualifiedStatementVerifiedAgainstLemma = lemmaMatchesStatement; ///
 
     if (qualifiedStatementVerifiedAgainstLemma) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceString}' lemma.`, statementNode);
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${labelString}' lemma.`, statementNode);
     }
   }
 
   return qualifiedStatementVerifiedAgainstLemma;
 }
 
-function verifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, referenceNode, localContext) {
+function verifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, labelNode, localContext) {
   let qualifiedStatementVerifiedAgainstTheorem = false;
 
-  const theorem = localContext.findTheoremByReferenceNode(referenceNode);
+  const theorem = localContext.findTheoremByLabelNode(labelNode);
 
   if (theorem !== null) {
-    const statementNode = statementNodeQuery(qualifiedStatementNode),
-          referenceString = localContext.nodeAsString(referenceNode),
+    const labelString = localContext.nodeAsString(labelNode),
+          statementNode = statementNodeQuery(qualifiedStatementNode),
           statementLocalContext = localContext, ///
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceString}' theorem...`, statementNode);
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${labelString}' theorem...`, statementNode);
 
     const theoremMatchesStatement = theorem.matchStatement(statementNode, statementLocalContext);
 
     qualifiedStatementVerifiedAgainstTheorem = theoremMatchesStatement; ///
 
     if (qualifiedStatementVerifiedAgainstTheorem) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceString}' theorem.`, statementNode);
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${labelString}' theorem.`, statementNode);
     }
   }
 
   return qualifiedStatementVerifiedAgainstTheorem;
 }
 
-function verifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, referenceNode, localContext) {
+function verifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, labelNode, localContext) {
   let qualifiedStatementVerifiedAgainstConjecture = false;
 
-  const conjecture = localContext.findConjectureByReferenceNode(referenceNode);
+  const conjecture = localContext.findConjectureByLabelNode(labelNode);
 
   if (conjecture !== null) {
-    const statementNode = statementNodeQuery(qualifiedStatementNode),
-          referenceString = localContext.nodeAsString(referenceNode),
+    const labelString = localContext.nodeAsString(labelNode),
+          statementNode = statementNodeQuery(qualifiedStatementNode),
           statementLocalContext = localContext, ///
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceString}' conjecture...`, statementNode);
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${labelString}' conjecture...`, statementNode);
 
     const conjectureMatchesStatement = conjecture.matchStatement(statementNode, statementLocalContext);
 
     qualifiedStatementVerifiedAgainstConjecture = conjectureMatchesStatement; ///
 
     if (qualifiedStatementVerifiedAgainstConjecture) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceString}' conjecture.`, statementNode);
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${labelString}' conjecture.`, statementNode);
     }
   }
 

package/src/verify/theorem.js

@@ -11,7 +11,7 @@ import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const proofNodeQuery = nodeQuery("/theorem/proof!"),
-      labelNodesQuery = nodesQuery("/theorem//labels/label"),
+      labelNodesQuery = nodesQuery("/theorem//reference/label"),
       consequentNodeQuery = nodeQuery("/theorem/consequent!"),
       suppositionsNodeQuery = nodesQuery("/theorem/supposition");