occam-verify-cli 0.0.1087 → 0.0.1089

package/src/mixins/statement/qualified/unify.js

@@ -3,7 +3,6 @@
 import StatementForMetavariableSubstitution from "../../../substitution/statementForMetavariable";
 
 import { trim } from "../../../utilities/string";
-import { metavariableNameFromMetavariableNode } from "../../../utilities/name";
 
 function unifyAWithRule(qualifiedStatement, substitutions, localContext) {
   let unifiedWithRule = false;
@@ -30,143 +29,77 @@ function unifyAWithRule(qualifiedStatement, substitutions, localContext) {
   return unifiedWithRule;
 }
 
-function unifyAWithAxiom(qualifiedStatement, substitutions, localContext) {
-  let unifiedWithAxiom = false;
+function unifyAWithReference(qualifiedStatement, substitutions, localContext) {
+  let unifiedWithReference = false;
 
   const reference = qualifiedStatement.getReference(),
-        axiom = localContext.findAxiomByReference(reference);
-
-  if (axiom !== null) {
-    const referenceString = reference.getString(),
-          qualifiedStatementString = trim(qualifiedStatement.getString());  ///
-
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${referenceString}' axiom...`);
+        metavariableNode = reference.getMetavariableNode(),
+        metavariablePresent = localContext.isMetavariablePresentByMetavariableNode(metavariableNode, localContext);
 
+  if (metavariablePresent) {
     const statement = qualifiedStatement.getStatement(),
-          statementUnified = axiom.unifyStatement(statement, localContext);
-
-    unifiedWithAxiom = statementUnified; ///
-
-    if (unifiedWithAxiom) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${referenceString}' axiom.`);
-    }
-  }
-
-  return unifiedWithAxiom;
-}
-
-function unifyAWithLemma(qualifiedStatement, substitutions, localContext) {
-  let unifiedWithLemma = false;
-
-  const reference = qualifiedStatement.getReference(),
-        lemma = localContext.findLemmaByReference(reference);
+          statementString = statement.getString(),
+          referenceString = reference.getString();
 
-  if (lemma !== null) {
-    const referenceString = reference.getString(),
-          qualifiedStatementString = trim(qualifiedStatement.getString());  ///
+    localContext.trace(`Unifying the '${statementString}' qualified statement with the '${referenceString}' reference...`);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${referenceString}' lemma...`);
+    const metavariable = reference.getMetavariable(),
+          statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementAndMetavariable(statement, metavariable, localContext),
+          substitution = statementForMetavariableSubstitution; ///
 
-    const statement = qualifiedStatement.getStatement(),
-          statementUnified = lemma.unifyStatement(statement, localContext);
+    substitutions.addSubstitution(substitution, localContext);
 
-    unifiedWithLemma = statementUnified; ///
+    unifiedWithReference = true;
 
-    if (unifiedWithLemma) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${referenceString}' lemma.`);
+    if (unifiedWithReference) {
+      localContext.debug(`...unified the '${statementString}' qualified statement with the '${referenceString}' reference.`);
     }
   }
 
-  return unifiedWithLemma;
+  return unifiedWithReference;
 }
 
-function unifyAWithTheorem(qualifiedStatement, substitutions, localContext) {
-  let unifiedWithTheorem = false;
+function unifyAWithAxiomLemmaTheoremOrConjecture(qualifiedStatement, substitutions, localContext) {
+  let unifiedWithAxiomLemmaTheoremOrConjecture = false;
 
   const reference = qualifiedStatement.getReference(),
-        theorem = localContext.findTheoremByReference(reference);
+        axiom = localContext.findAxiomByReference(reference),
+        lemma = localContext.findLemmaByReference(reference),
+        theorem = localContext.findTheoremByReference(reference),
+        conjecture = localContext.findConjectureByReference(reference),
+        axiomLemmaTheoremConjecture = (axiom || lemma || theorem || conjecture);
 
-  if (theorem !== null) {
+  if (axiomLemmaTheoremConjecture !== null) {
     const referenceString = reference.getString(),
           qualifiedStatementString = trim(qualifiedStatement.getString());  ///
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${referenceString}' theorem...`);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${referenceString}' axiom, lemma, theorem or conjecture...`);
 
     const statement = qualifiedStatement.getStatement(),
-          statementUnified = theorem.unifyStatement(statement, localContext);
-
-    unifiedWithTheorem = statementUnified; ///
-
-    if (unifiedWithTheorem) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${referenceString}' theorem.`);
-    }
-  }
-
-  return unifiedWithTheorem;
-}
-
-function unifyAWithConjecture(qualifiedStatement, substitutions, localContext) {
-  let unifiedWithConjecture = false;
-
-  const reference = qualifiedStatement.getReference(),
-        conjecture = localContext.findConjectureByReference(reference);
-
-  if (conjecture !== null) {
-    const referenceString = reference.getString(),
-          qualifiedStatementString = trim(qualifiedStatement.getString());  ///
+          statementUnified = axiomLemmaTheoremConjecture.unifyStatement(statement, localContext);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${referenceString}' conjecture...`);
+    if (statementUnified) {
+      const metavariable = reference.getMetavariable(),
+            statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementAndMetavariable(statement, metavariable, localContext),
+            substitution = statementForMetavariableSubstitution; ///
 
-    const statement = qualifiedStatement.getStatement(),
-          statementUnified = conjecture.unifyStatement(statement, localContext);
+      substitutions.addSubstitution(substitution, localContext);
 
-    unifiedWithConjecture = statementUnified; ///
-
-    if (unifiedWithConjecture) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${referenceString}' conjecture.`);
+      unifiedWithAxiomLemmaTheoremOrConjecture = true;
     }
-  }
-
-  return unifiedWithConjecture;
-}
-
-function unifyAWithReference(qualifiedStatement, substitutions, localContext) {
-  let unifiedWithReference = false;
-
-  const reference = qualifiedStatement.getReference(),
-        metavariableNode = reference.getMetavariableNode(),
-        metavariablePresent = localContext.isMetavariablePresentByMetavariableNode(metavariableNode, localContext);
 
-  if (metavariablePresent) {
-    const statement = qualifiedStatement.getStatement(),
-          statementString = statement.getString(),
-          referenceString = reference.getString();
-
-    localContext.trace(`Unifying the '${statementString}' qualified statement with the '${referenceString}' reference...`);
-
-    const metavariable = reference.getMetavariable(),
-          statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementAndMetavariable(statement, metavariable, localContext),
-          substitution = statementForMetavariableSubstitution; ///
-
-    substitutions.addSubstitution(substitution, localContext);
-
-    unifiedWithReference = true;
-
-    if (unifiedWithReference) {
-      localContext.debug(`...unified the '${statementString}' qualified statement with the '${referenceString}' reference.`);
+    if (unifiedWithAxiomLemmaTheoremOrConjecture) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${referenceString}' axiom, lemma, theorem or conjecture.`);
     }
   }
 
-  return unifiedWithReference;
+  return unifiedWithAxiomLemmaTheoremOrConjecture;
 }
 
 const unifyMixins = [
   unifyAWithRule,
-  unifyAWithAxiom,
-  unifyAWithLemma,
-  unifyAWithTheorem,
-  unifyAWithConjecture,
-  unifyAWithReference
+  unifyAWithReference,
+  unifyAWithAxiomLemmaTheoremOrConjecture
 ];
 
 export default unifyMixins;

package/src/mixins/statement/verify.js

@@ -10,7 +10,6 @@ import { nodeQuery } from "../../utilities/query";
 
 const equalityNodeQuery = nodeQuery("/statement/equality"),
       judgementNodeQuery = nodeQuery("/statement/judgement"),
-      declarationNodeQuery = nodeQuery("/statement/declaration"),
       metavariableNodeQuery = nodeQuery("/statement/metavariable!"),
       typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion"),
       definedAssertionNodeQuery = nodeQuery("/statement/definedAssertion"),
@@ -92,31 +91,6 @@ function verifyAsJudgement(statement, assignments, stated, localContext) {
   return verifiedAsJudgement;
 }
 
-function verifyAsDeclaration(statement, assignments, stated, localContext) {
-  let verifiedAsDeclaration = false;
-
-  const { Declaration } = shim,
-        statementNode = statement.getNode(),
-        declarationNode = declarationNodeQuery(statementNode),
-        declaration = Declaration.fromDeclarationNode(declarationNode, localContext);
-
-  if (declaration !== null) {
-    const statementString = statement.getString();
-
-    localContext.trace(`Verifying the '${statementString}' statement as a declaration...`);
-
-    const declarationVerified = declaration.verify(assignments, stated, localContext);
-
-    verifiedAsDeclaration = declarationVerified;  ///
-
-    if (verifiedAsDeclaration) {
-      localContext.debug(`...verified the '${statementString}' statement as a declaration.`);
-    }
-  }
-
-  return verifiedAsDeclaration;
-}
-
 function verifyAsTypeAssertion(statement, assignments, stated, localContext) {
   let verifiedAsTypeAssertion = false;
 
@@ -217,7 +191,6 @@ const verifyMixins = [
   verifyAsMetavariable,
   verifyAsEquality,
   verifyAsJudgement,
-  verifyAsDeclaration,
   verifyAsTypeAssertion,
   verifyAsDefinedAssertion,
   verifyAsSubproofAssertion,

package/src/proofStep.js

@@ -137,15 +137,17 @@ class ProofStep {
         qualifiedStatementVerified = false,
         unqualifiedStatementVerified = false;
 
-    if (false) {
-      ///
-    } else if (this.subproof !== null) {
+    if (this.subproof !== null) {
       subproofVerified = this.subproof.verify(substitutions, localContext);
-    } else if (this.qualifiedStatement !== null) {
+    }
+
+    if (this.qualifiedStatement !== null) {
       stated = true;
 
       qualifiedStatementVerified = this.qualifiedStatement.verify(substitutions, assignments, stated, localContext);
-    } else if (this.unqualifiedStatement !== null) {
+    }
+
+    if (this.unqualifiedStatement !== null) {
       stated = false;
 
       unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, localContext);

package/src/reference.js

@@ -6,6 +6,7 @@ import LocalContext from "./context/local";
 import { nodeQuery } from "./utilities/query";
 import { referenceMetaType } from "./metaType";
 import { metavariableFromJSON, metavariableToMetavariableJSON } from "./utilities/json";
+import local from "./context/local";
 
 const metavariableNodeQuery = nodeQuery("//reference/metavariable");
 
@@ -29,16 +30,36 @@ export default class Reference {
   }
 
   verify(localContext) {
-    let verified;
+    let verified = false;
 
     const referenceString = this.getString(); ///
 
     localContext.trace(`Verifying the '${referenceString}' reference...`);
 
-    const metaType = referenceMetaType, ///
-          metavariableVerifiedGivenMetaType = this.metavariable.verifyGivenMetaType(metaType, localContext);
+    if (!verified) {
+      const metaType = referenceMetaType, ///
+            metavariableVerifiedGivenMetaType = this.metavariable.verifyGivenMetaType(metaType, localContext);
 
-    verified = metavariableVerifiedGivenMetaType; ///
+      verified = metavariableVerifiedGivenMetaType; ///
+    }
+
+    if (!verified) {
+      const reference = this, ///
+            metaLemmaPresent = localContext.isMetaLemmaPresentByReference(reference),
+            metatheoremPresent = localContext.isMetatheoremPresentByReference(reference);
+
+      verified = (metaLemmaPresent || metatheoremPresent);
+    }
+
+    if (!verified) {
+      const reference = this, ///
+            axiomPresent = localContext.isAxiomPresentByReference(reference),
+            lemmaPresent = localContext.isLemmaPresentByReference(reference),
+            theoremPresent = localContext.isTheoremPresentByReference(reference),
+            conjecturePresent = localContext.isConjecturePresentByReference(reference);
+
+      verified = (axiomPresent || lemmaPresent || theoremPresent || conjecturePresent);
+    }
 
     if (verified) {
       localContext.debug(`...verified the '${referenceString}' reference.`);

package/src/statement.js

@@ -173,25 +173,25 @@ class Statement {
     localContext.trace(`Verifying the '${statementString}' statement...`);
 
     if (!verified) {
-      const unified = unifyMixins.some((unifyMixin) => {
-        const unified = unifyMixin(statement, assignments, stated, localContext);
+      verified = verifyMixins.some((verifyMixin) => {
+        const verified = verifyMixin(statement, assignments, stated, localContext);
 
-        if (unified) {
+        if (verified) {
           return true;
         }
       });
-
-      verified = unified; ///
     }
 
     if (!verified) {
-      verified = verifyMixins.some((verifyMixin) => {
-        const verified = verifyMixin(statement, assignments, stated, localContext);
+      const unified = unifyMixins.some((unifyMixin) => {
+        const unified = unifyMixin(statement, assignments, stated, localContext);
 
-        if (verified) {
+        if (unified) {
           return true;
         }
       });
+
+      verified = unified; ///
     }
 
     if (verified) {

package/src/term.js

@@ -138,25 +138,25 @@ class Term {
     localContext.trace(`Verifying the '${termString}' term...`);
 
     if (!verified) {
-      const unified = unifyMixins.some((unifyMixin) => { ///
-        const unified = unifyMixin(term, localContext, verifyAhead);
+      verified = verifyMixins.some((verifyMixin) => {
+        const verified = verifyMixin(term, localContext, verifyAhead);
 
-        if (unified) {
+        if (verified) {
           return true;
         }
       });
-
-      verified = unified; ///
     }
 
     if (!verified) {
-      verified = verifyMixins.some((verifyMixin) => {
-        const verified = verifyMixin(term, localContext, verifyAhead);
+      const unified = unifyMixins.some((unifyMixin) => { ///
+        const unified = unifyMixin(term, localContext, verifyAhead);
 
-        if (verified) {
+        if (unified) {
           return true;
         }
       });
+
+      verified = unified; ///
     }
 
     if (verified) {

package/src/theorem.js

@@ -1,64 +1,25 @@
 "use strict";
 
 import shim from "./shim";
-import LocalContext from "./context/local";
 import TopLevelAssertion from "./topLevelAssertion";
 
-import { stringFromLabels } from "./topLevelAssertion";
-import { nodeQuery, nodesQuery } from "./utilities/query";
-
-const proofNodeQuery = nodeQuery("/theorem/proof"),
-      labelNodesQuery = nodesQuery("/theorem/label"),
-      consequentNodeQuery = nodeQuery("/theorem/consequent"),
-      suppositionNodesQuery = nodesQuery("/theorem/supposition");
-
 class Theorem extends TopLevelAssertion {
   verify() {
-    let verified = false;
-
-    const theoremString = this.string;  ///
-
-    this.fileContext.trace(`Verifying the '${theoremString}' theorem...`);
-
-    const labelsVerifiedWhenDeclared = this.labels.every((label) => {
-      const labelVVerifiedWhenDeclared = label.verifyWhenDeclared(this.fileContext);
-
-      if (labelVVerifiedWhenDeclared) {
-        return true;
-      }
-    });
-
-    if (labelsVerifiedWhenDeclared) {
-      const localContext = LocalContext.fromFileContext(this.fileContext),
-            suppositionsVerified = this.suppositions.every((supposition) => {
-              const suppositionVerified = supposition.verify(localContext);
-
-              if (suppositionVerified) {
-                return true;
-              }
-            });
+    let verified;
 
-      if (suppositionsVerified) {
-        const consequentVerified = this.consequent.verify(localContext);
+    const fileContext = this.getFileContext(),
+          theoremString = this.string;  ///
 
-        if (consequentVerified) {
-          const { Substitutions } = shim,
-                substitutions = Substitutions.fromNothing(),
-                proofVerified = this.proof.verify(substitutions, this.consequent, localContext);
+    fileContext.trace(`Verifying the '${theoremString}' theorem...`);
 
-          if (proofVerified) {
-            const theorem = this;  ///
+    verified = super.verify();
 
-            this.fileContext.addTheorem(theorem);
+    if (verified) {
+      const theorem = this; ///
 
-            verified = true;
-          }
-        }
-      }
-    }
+      fileContext.addTheorem(theorem);
 
-    if (verified) {
-      this.fileContext.debug(`...verified the '${theoremString}' theorem.`);
+      fileContext.debug(`...verified the '${theoremString}' theorem.`);
     }
 
     return verified;
@@ -66,29 +27,7 @@ class Theorem extends TopLevelAssertion {
 
   static fromJSON(json, fileContext) { return TopLevelAssertion.fromJSON(Theorem, json, fileContext); }
 
-  static fromTheoremNode(theoremNode, fileContext) {
-    const { Label, Proof, Consequent, Supposition } = shim,
-          proofNode = proofNodeQuery(theoremNode),
-          labelNodes = labelNodesQuery(theoremNode),
-          consequentNode = consequentNodeQuery(theoremNode),
-          suppositionNodes = suppositionNodesQuery(theoremNode),
-          labels = labelNodes.map((labelNode) => {
-            const label = Label.fromLabelNode(labelNode, fileContext);
-
-            return label;
-          }),
-          suppositions = suppositionNodes.map((suppositionNode) => {
-            const supposition = Supposition.fromSuppositionNode(suppositionNode, fileContext);
-
-            return supposition;
-          }),
-          consequent = Consequent.fromConsequentNode(consequentNode, fileContext),
-          string = stringFromLabels(labels),
-          proof = Proof.fromProofNode(proofNode, fileContext),
-          theorem = new Theorem(fileContext, string, labels, suppositions, consequent, proof);
-
-    return theorem;
-  }
+  static fromTheoremNode(metaLemmaNode, fileContext) { return TopLevelAssertion.fromNode(Theorem, metaLemmaNode, fileContext); }
 }
 
 Object.assign(shim, {

package/src/topLevelAssertion.js

@@ -5,20 +5,30 @@ import { arrayUtilities } from "necessary";
 import shim from "./shim";
 
 import { EMPTY_STRING } from "./constants";
+import { nodeQuery, nodesQuery } from "./utilities/query";
 import { labelsFromJSON,
          labelsToLabelsJSON,
          consequentFromJSON,
          suppositionsFromJSON,
+         substitutionsFromJSON,
          consequentToConsequentJSON,
-         suppositionsToSuppositionsJSON } from "./utilities/json";
+         suppositionsToSuppositionsJSON,
+         substitutionsToSubstitutionsJSON } from "./utilities/json";
+import LocalContext from "./context/local";
 
 const { extract, reverse, backwardsEvery } = arrayUtilities;
 
+const proofNodeQuery = nodeQuery("/*/proof"),
+      labelNodesQuery = nodesQuery("/*/label"),
+      consequentNodeQuery = nodeQuery("/*/consequent"),
+      suppositionNodesQuery = nodesQuery("/*/supposition");
+
 export default class TopLevelAssertion {
-  constructor(fileContext, string, labels, suppositions, consequent, proof) {
+  constructor(fileContext, string, labels, substitutions, suppositions, consequent, proof) {
     this.fileContext = fileContext;
     this.string = string;
     this.labels = labels;
+    this.substitutions = substitutions;
     this.suppositions = suppositions;
     this.consequent = consequent;
     this.proof = proof;
@@ -36,6 +46,10 @@ export default class TopLevelAssertion {
     return this.labels;
   }
 
+  getSubstitutions() {
+    return this.substitutions;
+  }
+
   getSuppositions() {
     return this.suppositions;
   }
@@ -148,17 +162,59 @@ export default class TopLevelAssertion {
     return suppositionUnified;
   }
 
+  verify() {
+    let verified = false;
+
+    const labelsVerifiedWhenDeclared = this.labels.every((label) => {
+      const labelVVerifiedWhenDeclared = label.verifyWhenDeclared(this.fileContext);
+
+      if (labelVVerifiedWhenDeclared) {
+        return true;
+      }
+    });
+
+    if (labelsVerifiedWhenDeclared) {
+      const localContext = LocalContext.fromFileContext(this.fileContext),
+            suppositionsVerified = this.suppositions.every((supposition) => {
+              const suppositionVerified = supposition.verify(localContext);
+
+              if (suppositionVerified) {
+                return true;
+              }
+            });
+
+      if (suppositionsVerified) {
+        const consequentVerified = this.consequent.verify(localContext);
+
+        if (consequentVerified) {
+          if (this.proof === null) {
+            verified = true;
+          } else {
+            const proofVerified = this.proof.verify(this.substitutions, this.consequent, localContext);
+
+            verified = proofVerified; ///
+          }
+        }
+      }
+    }
+
+    return verified;
+  }
+
   toJSON() {
     const labelsJSON = labelsToLabelsJSON(this.labels),
           consequentJSON = consequentToConsequentJSON(this.consequent),
           suppositionsJSON = suppositionsToSuppositionsJSON(this.suppositions),
+          substitutionsJSON = substitutionsToSubstitutionsJSON(this.substitutions),
           labels = labelsJSON,  ///
           consequent = consequentJSON,  ///
           suppositions = suppositionsJSON,  ///
+          substitutions = substitutionsJSON,  ///
           json = {
             labels,
             consequent,
-            suppositions
+            suppositions,
+            substitutions
           };
 
     return json;
@@ -168,12 +224,38 @@ export default class TopLevelAssertion {
     const labels = labelsFromJSON(json, fileContext),
           consequent = consequentFromJSON(json, fileContext),
           suppositions = suppositionsFromJSON(json, fileContext),
+          substitutions = substitutionsFromJSON(json, fileContext),
           string = stringFromLabels(labels),
           proof = null,
-          topLevelAssertion = new Class(fileContext, string, labels, suppositions, consequent, proof);
+          topLevelAssertion = new Class(fileContext, string, labels, substitutions, suppositions, consequent, proof);
 
     return topLevelAssertion;
   }
+
+  static fromNode(Class, node, fileContext) {
+    const { Label, Proof, Consequent, Supposition, Substitutions } = shim,
+          proofNode = proofNodeQuery(node),
+          labelNodes = labelNodesQuery(node),
+          consequentNode = consequentNodeQuery(node),
+          suppositionNodes = suppositionNodesQuery(node),
+          labels = labelNodes.map((labelNode) => {
+            const label = Label.fromLabelNode(labelNode, fileContext);
+
+            return label;
+          }),
+          substitutions = Substitutions.fromNothing(),
+          suppositions = suppositionNodes.map((suppositionNode) => {
+            const supposition = Supposition.fromSuppositionNode(suppositionNode, fileContext);
+
+            return supposition;
+          }),
+          consequent = Consequent.fromConsequentNode(consequentNode, fileContext),
+          proof = Proof.fromProofNode(proofNode, fileContext),
+          string = stringFromLabels(labels),
+          metaLemma = new Class(fileContext, string, labels, substitutions, suppositions, consequent, proof);
+
+    return metaLemma;
+  }
 }
 
 export function stringFromLabels(labels) {

package/src/utilities/json.js

@@ -302,7 +302,7 @@ export function suppositionsFromJSON(json, fileContext) {
 }
 
 export function substitutionsFromJSON(json, fileContext) {
-  let { substitutions } = json;
+  let { substitutions = [] } = json;  ///
 
   const { Substitution } = shim,
         substitutionsJSON = substitutions;  ///

package/src/variable.js

@@ -83,7 +83,7 @@ class Variable {
     if (verified) {
       const typeName = this.type.getName();
 
-      localContext.debug(`...verified the '${variableString};${typeName}' variable.`);
+      localContext.debug(`...verified the '${variableString}:${typeName}' variable.`);
     }
 
     return verified;