occam-verify-cli 0.0.537 → 0.0.539

package/src/verify/metastatement/qualified.js

@@ -1,7 +1,5 @@
 "use strict";
 
-import verifyMetastatement from "../../verify/metastatement";
-
 import { nodeQuery, referenceNameFromReferenceNode } from "../../utilities/query";
 
 const referenceNodeQuery = nodeQuery("/qualifiedMetastatement/qualification!/reference!"),
@@ -13,27 +11,19 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
   const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode);
 
   if (metastatementNode !== null) {
-    const metastatementString = metaproofContext.nodeAsString(metastatementNode);
+    const metastatementString = metaproofContext.nodeAsString(metastatementNode),
+          metastatementMetaproofContext = metaproofContext; ///
 
     metaproofContext.debug(`Verifying the '${metastatementString}' qualified metastatement...`, qualifiedMetastatementNode);
 
-    let ruleMatchesMetastatement = true;
-
-    const referenceNode = referenceNodeQuery(qualifiedMetastatementNode);
-
-    if (referenceNode !== null) {
-      const referenceName = referenceNameFromReferenceNode(referenceNode),
-            rule = metaproofContext.findRuleByReferenceName(referenceName);
-
-      if (rule !== null) {
-        ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, metaproofContext);
-      }
-    }
+    const referenceNode = referenceNodeQuery(qualifiedMetastatementNode),
+          referenceName = referenceNameFromReferenceNode(referenceNode),
+          rule = metaproofContext.findRuleByReferenceName(referenceName);
 
-    if (ruleMatchesMetastatement) {
-      const metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, metaproofContext);
+    if (rule !== null) {
+      const ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, metastatementMetaproofContext);
 
-      qualifiedMetastatementVerified = metastatementVerified; ///
+      qualifiedMetastatementVerified = ruleMatchesMetastatement;  ///
     }
   }
 

package/src/verify/metastatement/unqualified.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import verifyMetastatement from "../metastatement";
+import verifyMetastatement from "../../verify/metastatement";
 
 import { nodeQuery } from "../../utilities/query";
 
@@ -16,13 +16,13 @@ export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementN
 
     metaproofContext.debug(`Verifying the '${metastatementString}' unqualified metastatement...`, unqualifiedMetastatementNode);
 
-    let metastatementMatches = true;
-
     if (derived) {
-      metastatementMatches = metaproofContext.matchMetastatement(metastatementNode);
+      const metastatementMatches = metaproofContext.matchMetastatement(metastatementNode);
+
+      unqualifiedMetastatementVerified = metastatementMatches;  ///
     }
 
-    if (metastatementMatches) {
+    if (!unqualifiedMetastatementVerified) {
       const metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, metaproofContext);
 
       unqualifiedMetastatementVerified = metastatementVerified; ///

package/src/verify/metavariable.js

@@ -0,0 +1,32 @@
+"use strict";
+
+import Metavariable from "../metavariable";
+
+import { metaTypeNameFromMetaTypeNode, metavariableNameFromMetavariableNode } from "../utilities/query";
+
+export default function verifyMetavariable(metavariableNode, metaTypeNode, fileContext) {
+  let metavariableVerified = false;
+
+  const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+        metavariableString = fileContext.nodeAsString(metavariableNode),
+        metavariablePresent = fileContext.isMetavariablePresentByMetavariableName(metavariableName);
+
+  if (metavariablePresent) {
+    fileContext.error(`The metavariable '${metavariableName}' is already present.`, metavariableNode);
+  } else {
+    const metaTypeName = metaTypeNameFromMetaTypeNode(metaTypeNode),
+          metaType = fileContext.findMetaTypeByMetaTypeName(metaTypeName),
+          name = metavariableName,  ///
+          metavariable = Metavariable.fromNameAndMetaType(name, metaType);
+
+    fileContext.addMetavariable(metavariable);
+
+    metavariableVerified = true;
+  }
+
+  if (metavariableVerified) {
+    fileContext.info(`Verified the '${metavariableString}' metavariable.`, metavariableNode);
+  }
+
+  return metavariableVerified;
+}

package/src/verify/rule.js

@@ -55,7 +55,7 @@ export default function verifyRule(ruleNode, fileContext) {
         }
 
         if (ruleProofVerified) {
-          const rule = Rule.fromLabelsPremisesAndConclusion(labels, premises, conclusion);
+          const rule = Rule.fromLabelsPremisesConclusionAndFileContext(labels, premises, conclusion, fileContext);
 
           fileContext.addRule(rule);
 

package/src/verify/statement/qualified.js

@@ -1,7 +1,5 @@
 "use strict";
 
-import verifyStatement from "../../verify/statement";
-
 import { nodeQuery, referenceNameFromReferenceNode } from "../../utilities/query";
 
 const referenceNodeQuery = nodeQuery("/qualifiedStatement/qualification!/reference!"),
@@ -13,68 +11,61 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
   const statementNode = statementNodeQuery(qualifiedStatementNode);
 
   if (statementNode !== null) {
-    const statementString = proofContext.nodeAsString(statementNode);
+    const statementString = proofContext.nodeAsString(statementNode),
+          statementProofContext = proofContext; ///
 
     proofContext.debug(`Verifying the '${statementString}' qualified statement...`, qualifiedStatementNode);
 
-    const referenceNode = referenceNodeQuery(qualifiedStatementNode);
-
-    if (referenceNode === null) {
-      const context = proofContext,
-            statementVerified = verifyStatement(statementNode, assignments, derived, context);
-
-      qualifiedStatementVerified = statementVerified; ///
-    } else {
-      const referenceName = referenceNameFromReferenceNode(referenceNode);
+    const referenceNode = referenceNodeQuery(qualifiedStatementNode),
+          referenceName = referenceNameFromReferenceNode(referenceNode);
 
-      if (!qualifiedStatementVerified) {
-        const rule = proofContext.findRuleByReferenceName(referenceName);
+    if (!qualifiedStatementVerified) {
+      const rule = proofContext.findRuleByReferenceName(referenceName);
 
-        if (rule !== null) {
-          const ruleMatchesStatement = rule.matchStatement(statementNode, proofContext);
+      if (rule !== null) {
+        const ruleMatchesStatement = rule.matchStatement(statementNode, statementProofContext);
 
-          qualifiedStatementVerified = ruleMatchesStatement;  ///
-        }
+        qualifiedStatementVerified = ruleMatchesStatement;  ///
       }
+    }
 
-      if (!qualifiedStatementVerified) {
-        const axiom = proofContext.findAxiomByReferenceName(referenceName);
+    if (!qualifiedStatementVerified) {
+      const axiom = proofContext.findAxiomByReferenceName(referenceName);
 
-        if (axiom !== null) {
-          const axiomMatchesStatement = axiom.matchStatement(statementNode, proofContext);
+      if (axiom !== null) {
+        const axiomMatchesStatement = axiom.matchStatement(statementNode, statementProofContext);
 
-          qualifiedStatementVerified = axiomMatchesStatement; ///
-        }
+        qualifiedStatementVerified = axiomMatchesStatement; ///
       }
+    }
 
-      if (!qualifiedStatementVerified) {
-        const lemma = proofContext.findLemmaByReferenceName(referenceName);
+    if (!qualifiedStatementVerified) {
+      const lemma = proofContext.findLemmaByReferenceName(referenceName);
 
-        if (lemma !== null) {
-          const lemmaMatchesStatement = lemma.matchStatement(statementNode, proofContext);
+      if (lemma !== null) {
+        const lemmaMatchesStatement = lemma.matchStatement(statementNode, statementProofContext);
 
-          qualifiedStatementVerified = lemmaMatchesStatement; ///
-        }
+        qualifiedStatementVerified = lemmaMatchesStatement; ///
       }
+    }
 
-      if (!qualifiedStatementVerified) {
-        const theorem = proofContext.findTheoremByReferenceName(referenceName);
+    if (!qualifiedStatementVerified) {
+      const theorem = proofContext.findTheoremByReferenceName(referenceName);
 
-        if (theorem !== null) {
-          const theoremMatchesStatement = theorem.matchStatement(statementNode, proofContext);
+      if (theorem !== null) {
+        const theoremMatchesStatement = theorem.matchStatement(statementNode, statementProofContext);
 
-          qualifiedStatementVerified = theoremMatchesStatement; ///
-        }
+        qualifiedStatementVerified = theoremMatchesStatement; ///
       }
+    }
 
-      if (!qualifiedStatementVerified) {
-        const conjecture = proofContext.findConjectureByReferenceName(referenceName);
+    if (!qualifiedStatementVerified) {
+      const conjecture = proofContext.findConjectureByReferenceName(referenceName);
 
-        if (conjecture !== null) {
-          const conjectureMatchesStatement = conjecture.matchStatement(statementNode, proofContext);
+      if (conjecture !== null) {
+        const conjectureMatchesStatement = conjecture.matchStatement(statementNode, statementProofContext);
 
-          qualifiedStatementVerified = conjectureMatchesStatement; ///
-        }
+        qualifiedStatementVerified = conjectureMatchesStatement; ///
       }
     }
   }

package/src/verify/statement/unqualified.js

@@ -16,13 +16,13 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, ass
 
     proofContext.debug(`Verifying the '${statementString}' unqualified statement...`, unqualifiedStatementNode);
 
-    let statementMatches = true;
-
     if (derived) {
-      statementMatches = proofContext.matchStatement(statementNode);
+      const statementMatches = proofContext.matchStatement(statementNode);
+
+      unqualifiedStatementVerified = statementMatches;  ///
     }
 
-    if (statementMatches) {
+    if (!unqualifiedStatementVerified) {
       const context = proofContext, ///
             statementVerified = verifyStatement(statementNode, assignments, derived, context);
 

package/src/verify/statement.js

@@ -254,18 +254,18 @@ function verifyStatementAsEquality(statementNode, assignments, derived, context)
                 rightVariableTypeSuperTypeOfLeftVariableType = rightVariableType.isSuperTypeOf(leftVariableType);
 
           if (leftVariableTypeSuperTypeOfRightVariableType) {
-            const type = rightVariableType,  ///
-                  name = leftVariableName, ///
-                  variable = Variable.fromTypeAndName(type, name),
+            const name = leftVariableName, ///
+                  type = rightVariableType,  ///
+                  variable = Variable.fromNameAndType(name, type),
                   assignment = Assignment.fromVariable(variable);
 
             assignments.push(assignment);
           }
 
           if (rightVariableTypeSuperTypeOfLeftVariableType) {
-            const type = leftVariableType,  ///
-                  name = rightVariableName, ///
-                  variable = Variable.fromTypeAndName(type, name),
+            const name = rightVariableName, ///
+                  type = leftVariableType,  ///
+                  variable = Variable.fromNameAndType(name, type),
                   assignment = Assignment.fromVariable(variable);
 
             assignments.push(assignment);
@@ -293,9 +293,9 @@ function verifyStatementAsEquality(statementNode, assignments, derived, context)
 
           context.error(`The left '${leftVariableName}' variable's '${leftVariableTypeName}' type is not equal to or a super-type of the right '${rightTermString}' term's '${rightTermTypeName}' type.`, statementNode);
         } else {
-          const type = rightTermType, ///
-                name = leftVariableName,  ///
-                variable = Variable.fromTypeAndName(type, name),
+          const name = leftVariableName,  ///
+                type = rightTermType, ///
+                variable = Variable.fromNameAndType(name, type),
                 assignment = Assignment.fromVariable(variable);
 
           assignments.push(assignment);
@@ -322,9 +322,9 @@ function verifyStatementAsEquality(statementNode, assignments, derived, context)
 
           context.error(`The right '${rightVariableName}' variable's '${rightVariableTypeName}' type is not equal to or a super-type of the left '${leftTermString}' term's '${leftTermTypeName}' type.`, statementNode);
         } else {
-          const type = leftTermType, ///
-                name = rightVariableName,  ///
-                variable = Variable.fromTypeAndName(type, name),
+          const name = rightVariableName,  ///
+                type = leftTermType, ///
+                variable = Variable.fromNameAndType(name, type),
                 assignment = Assignment.fromVariable(variable);
 
           assignments.push(assignment);

package/src/verify/theorem.js

@@ -9,6 +9,7 @@ import verifyConsequence from "./consequence";
 
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
+import proof from "../context/proof";
 
 const proofNodeQuery = nodeQuery("/theorem/proof!"),
       labelNodesQuery = nodesQuery("/theorem/label"),
@@ -50,7 +51,7 @@ export default function verifyTheorem(theoremNode, fileContext) {
               proofVerified = verifyProof(proofNode, consequence, proofContext);
 
         if (proofVerified) {
-          const theorem = Theorem.fromLabelsSuppositionsAndConsequence(labels, suppositions, consequence);
+          const theorem = Theorem.fromLabelsSuppositionsConsequenceAndProofContext(labels, suppositions, consequence, proofContext);
 
           fileContext.addTheorem(theorem);
 

package/src/verify/variable.js

@@ -20,10 +20,10 @@ export default function verifyVariable(variableNode, typeNode, fileContext) {
     const typeName = typeNameFromTypeNode(typeNode);
     
     if (typeName === null) {
-      const type = objectType,
-            name = variableName;  ///
+      const name = variableName,  ///
+            type = objectType;
 
-      variable = Variable.fromTypeAndName(type, name);
+        variable = Variable.fromNameAndType(name, type);
     } else {
       const type = fileContext.findTypeByTypeName(typeName);
 
@@ -32,7 +32,7 @@ export default function verifyVariable(variableNode, typeNode, fileContext) {
       } else {
         const name = variableName;  ///
 
-        variable = Variable.fromTypeAndName(type, name);
+        variable = Variable.fromNameAndType(name, type);
       }
     }