occam-verify-cli 0.0.1245 → 0.0.1247

package/src/dom/label.js

@@ -7,14 +7,19 @@ import { domAssigned } from "../dom";
 import { metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
 
 export default domAssigned(class Label {
-  constructor(metavariable) {
+  constructor(metavariable, fileContext) {
     this.metavariable = metavariable;
+    this.fileContext = fileContext;
   }
 
   getMetavariable() {
     return this.metavariable;
   }
 
+  getFileContext() {
+    return this.fileContext;
+  }
+
   getString() { return this.metavariable.getString(); }
 
   getMetavariableName() {
@@ -33,36 +38,36 @@ export default domAssigned(class Label {
 
   matchMetavariableNode(metavariableNode) { return this.metavariable.matchMetavariableNode(metavariableNode); }
 
-  verifyWhenDeclared(fileContext, nameOnly) {
-    let verifiedWhenDeclared = false;
+  verify(nameOnly) {
+    let verified = false;
 
     const labelString = this.getString(); ///
 
-    fileContext.trace(`Verifying the '${labelString}' label when declared...`);
+    this.fileContext.trace(`Verifying the '${labelString}' label when declared...`);
 
     let labelPresent;
 
     if (nameOnly) {
       const metavariableName = this.getMetavariableName();
 
-      labelPresent = fileContext.isLabelPresentByMetavariableName(metavariableName);
+      labelPresent = this.fileContext.isLabelPresentByMetavariableName(metavariableName);
     } else {
       const metavariableNode = this.getMetavariableNode();
 
-      labelPresent = fileContext.isLabelPresentByMetavariableNode(metavariableNode);
+      labelPresent = this.fileContext.isLabelPresentByMetavariableNode(metavariableNode);
     }
 
     if (labelPresent) {
-      fileContext.debug(`The '${labelString}' label is already present.`);
+      this.fileContext.debug(`The '${labelString}' label is already present.`);
     } else {
-      verifiedWhenDeclared = true;
+      verified = true;
     }
 
-    if (verifiedWhenDeclared) {
-      fileContext.debug(`...verified the '${labelString}' label when declared.`);
+    if (verified) {
+      this.fileContext.debug(`...verified the '${labelString}' label when declared.`);
     }
 
-    return verifiedWhenDeclared;
+    return verified;
   }
 
   toJSON() {
@@ -79,7 +84,7 @@ export default domAssigned(class Label {
 
   static fromJSON(json, fileContext) {
     const metavariable = metavariableFromJSON(json, fileContext),
-          label = new Label(metavariable);
+          label = new Label(metavariable, fileContext);
 
     return label;
   }
@@ -88,7 +93,7 @@ export default domAssigned(class Label {
     const { Metavariable } = dom,
           localContext = LocalContext.fromFileContext(fileContext),
           metavariable = Metavariable.fromLabelNode(labelNode, localContext),
-          label = new Label(metavariable);
+          label = new Label(metavariable, fileContext);
 
     return label;
   }

package/src/dom/metaLemma.js

@@ -6,36 +6,39 @@ import TopLevelAssertion from "./topLevelAssertion";
 import { domAssigned } from "../dom";
 
 export default domAssigned(class MetaLemma extends TopLevelAssertion {
-  unifyReference(reference, substitutions, context) {
-    let referenceUnified;
+  verify() {
+    let verified;
 
     const metaLemma = this, ///
-          referenceString = reference.getString(),
+          fileContext = this.getFileContext(),
           metaLemmaString = metaLemma.getString();
 
-    context.trace(`Unifying the '${referenceString}' reference with the '${metaLemmaString}' meta-lemma...`);
-
-    const fileContext = this.getFileContext(),
-          localContext = LocalContext.fromFileContext(fileContext),
-          generalContext = localContext,  ///
-          specificContext = context, ///
-          labelUnified = this.labels.some((label) => {
-            substitutions.clear();
+    fileContext.trace(`Verifying the '${metaLemmaString}' meta-lemma...`);
 
-            const referenceUnified = reference.unifyLabel(label, substitutions, generalContext, specificContext);
+    verified = super.verify();
 
-            if (referenceUnified) {
-              return true;
-            }
-          });
+    if (verified) {
+      const metaTheorem = this; ///
 
-    referenceUnified = labelUnified;  ///
+      fileContext.addMetatheorem(metaTheorem);
 
-    if (referenceUnified) {
-      context.debug(`...unified the '${referenceString}' reference with the '${metaLemmaString}' meta-lemma.`);
+      fileContext.debug(`...verified the '${metaLemmaString}' meta-lemma.`);
     }
 
-    return referenceUnified;
+    return verified;
+  }
+
+  verifyLabels() {
+    const labelsVerified = this.labels.every((label) => {
+      const nameOnly = false,
+            labelVerified = label.verify(nameOnly);
+
+      if (labelVerified) {
+        return true;
+      }
+    });
+
+    return labelsVerified;
   }
 
   unifyStatement(statement, substitutions, context) {
@@ -67,41 +70,6 @@ export default domAssigned(class MetaLemma extends TopLevelAssertion {
     return statementUnified;
   }
 
-  verify() {
-    let verified;
-
-    const metaLemma = this, ///
-          fileContext = this.getFileContext(),
-          metaLemmaString = metaLemma.getString();
-
-    fileContext.trace(`Verifying the '${metaLemmaString}' meta-lemma...`);
-
-    verified = super.verify();
-
-    if (verified) {
-      const metaTheorem = this; ///
-
-      fileContext.addMetatheorem(metaTheorem);
-
-      fileContext.debug(`...verified the '${metaLemmaString}' meta-lemma.`);
-    }
-
-    return verified;
-  }
-
-  verifyLabels() {
-    const labelsVerified = this.labels.every((label) => {
-      const nameOnly = false,
-            labelVVerifiedWhenDeclared = label.verifyWhenDeclared(this.fileContext, nameOnly);
-
-      if (labelVVerifiedWhenDeclared) {
-        return true;
-      }
-    });
-
-    return labelsVerified;
-  }
-
   static name = "MetaLemma";
 
   static fromMetaLemmaNode(metaLemmaNode, fileContext) { return TopLevelAssertion.fromNode(MetaLemma, metaLemmaNode, fileContext); }

package/src/dom/metatheorem.js

@@ -15,36 +15,39 @@ import { labelsFromJSON,
          substitutionsToSubstitutionsJSON } from "../utilities/json";
 
 export default domAssigned(class Metatheorem extends TopLevelAssertion {
-  unifyReference(reference, substitutions, context) {
-    let referenceUnified;
+  verify() {
+    let verified;
 
     const metatheorem = this, ///
-          referenceString = reference.getString(),
+          fileContext = this.getFileContext(),
           metatheoremString = metatheorem.getString();
 
-    context.trace(`Unifying the '${referenceString}' reference with the '${metatheoremString}' metatheorem...`);
-
-    const fileContext = this.getFileContext(),
-          localContext = LocalContext.fromFileContext(fileContext),
-          generalContext = localContext,  ///
-          specificContext = context, ///
-          labelUnified = this.labels.some((label) => {
-            substitutions.clear();
+    fileContext.trace(`Verifying the '${metatheoremString}' metatheorem...`);
 
-            const referenceUnified = reference.unifyLabel(label, substitutions, generalContext, specificContext);
+    verified = super.verify();
 
-            if (referenceUnified) {
-              return true;
-            }
-          });
+    if (verified) {
+      const metaTheorem = this; ///
 
-    referenceUnified = labelUnified;  ///
+      fileContext.addMetatheorem(metaTheorem);
 
-    if (referenceUnified) {
-      context.debug(`...unified the '${referenceString}' reference with the '${metatheoremString}' metatheorem.`);
+      fileContext.debug(`...verified the '${metatheoremString}' metatheorem.`);
     }
 
-    return referenceUnified;
+    return verified;
+  }
+
+  verifyLabels() {
+    const labelsVerified = this.labels.every((label) => {
+      const nameOnly = false,
+            labelVerified = label.verify(nameOnly);
+
+      if (labelVerified) {
+        return true;
+      }
+    });
+
+    return labelsVerified;
   }
 
   unifyStatement(statement, substitutions, context) {
@@ -76,41 +79,6 @@ export default domAssigned(class Metatheorem extends TopLevelAssertion {
     return statementUnified;
   }
 
-  verify() {
-    let verified;
-
-    const metatheorem = this, ///
-          fileContext = this.getFileContext(),
-          metatheoremString = metatheorem.getString();
-
-    fileContext.trace(`Verifying the '${metatheoremString}' metatheorem...`);
-
-    verified = super.verify();
-
-    if (verified) {
-      const metaTheorem = this; ///
-
-      fileContext.addMetatheorem(metaTheorem);
-
-      fileContext.debug(`...verified the '${metatheoremString}' metatheorem.`);
-    }
-
-    return verified;
-  }
-
-  verifyLabels() {
-    const labelsVerified = this.labels.every((label) => {
-      const nameOnly = false,
-            labelVVerifiedWhenDeclared = label.verifyWhenDeclared(this.fileContext, nameOnly);
-
-      if (labelVVerifiedWhenDeclared) {
-        return true;
-      }
-    });
-
-    return labelsVerified;
-  }
-
   toJSON() {
     const labelsJSON = labelsToLabelsJSON(this.labels),
           consequentJSON = consequentToConsequentJSON(this.consequent),

package/src/dom/metavariable.js

@@ -380,9 +380,9 @@ export default domAssigned(class Metavariable {
     const metavariable = this, ///
           generalContext = context,  ///
           specificContext = context,  ///
-          metavariableDeclared = generalContext.isMetavariableDeclared(metavariable, generalContext, specificContext);
+          metavariablePresent = generalContext.isMetavariablePresent(metavariable, generalContext, specificContext);
 
-    verified = metavariableDeclared; ///
+    verified = metavariablePresent; ///
 
     if (verified) {
       context.debug(`...verified the '${metavariableString}' metavariable.`);
@@ -437,15 +437,15 @@ export default domAssigned(class Metavariable {
       fileContext.debug(`A term was found in the '${metavariableString}' metavariable when a type should have been present.`);
     } else {
       const metavariableName = this.name, ///
-            metavariableDeclared = fileContext.isMetavariableDeclaredByMetavariableName(metavariableName);
+            metavariablePresent = fileContext.isMetavariablePresentByMetavariableName(metavariableName);
 
-      if (metavariableDeclared) {
+      if (metavariablePresent) {
         fileContext.debug(`The '${metavariableName}' metavariable has already been declared.`);
       } else {
         const variableName = this.name, ///
-              variableDeclared = fileContext.isVariableDeclaredByVariableName(variableName);
+              variablePresent = fileContext.isVariablePresentByVariableName(variableName);
 
-        if (variableDeclared) {
+        if (variablePresent) {
           fileContext.debug(`A '${metavariableName}' variable has already been declared.`);
         } else {
           const typeVerified = this.verifyType(fileContext);

package/src/dom/reference.js

@@ -6,8 +6,8 @@ import LocalContext from "../context/local";
 import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { referenceMetaType } from "../dom/metaType";
-import { unifyLabelWithReference } from "../utilities/unification";
 import { metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
+import { unifyLabelWithReference, unifyMetavariableWithReference } from "../utilities/unification";
 
 const proofStepReferenceNodeQuery = nodeQuery("/proofStep/reference"),
       procedureCallReferenceNodeQuery = nodeQuery("/procedureCall/reference"),
@@ -42,26 +42,6 @@ export default domAssigned(class Reference {
 
   matchMetavariableNode(metavariableNode) { return this.metavariable.matchMetavariableNode(metavariableNode); }
 
-  unifyLabel(label, substitutions, generalContext, specificContext) {
-    let labelUnified;
-
-    const reference = this, ///
-          labelString = label.getString(),
-          referenceString = reference.getString();
-
-    specificContext.trace(`Unifying the '${labelString}' label with the '${referenceString}' reference...`);
-
-    const labelUnifiedWithReference = unifyLabelWithReference(label, reference, substitutions, generalContext, specificContext);
-
-    labelUnified = labelUnifiedWithReference; ///
-
-    if (labelUnified) {
-      specificContext.debug(`...unified the '${labelString}' label with the '${referenceString}' reference.`);
-    }
-
-    return labelUnified;
-  }
-
   verify(context) {
     let verified = false;
 
@@ -77,11 +57,9 @@ export default domAssigned(class Reference {
 
     if (!verified) {
       const reference = this, ///
-            rulePresent = context.isRulePresentByReference(reference),
-            metaLemmasMetaTheoremsPresent = context.areMetaLemmasMetaTheoremsPresentByReference(reference),
-            axiomLemmaTheoremConjecturePresent = context.isAxiomLemmaTheoremConjecturePresentByReference(reference);
+            labelPresent = context.isLabelPresentByReference(reference);
 
-      verified = (rulePresent || metaLemmasMetaTheoremsPresent || axiomLemmaTheoremConjecturePresent);
+      verified = labelPresent;  ///
     }
 
     if (verified) {
@@ -102,6 +80,46 @@ export default domAssigned(class Reference {
     return metavariableVerified;
   }
 
+  unifyLabel(label, substitutions, context) {
+    let labelUnified;
+
+    const reference = this, ///
+          labelString = label.getString(),
+          referenceString = reference.getString();
+
+    context.trace(`Unifying the '${labelString}' label with the '${referenceString}' reference...`);
+
+    const labelUnifiedWithReference = unifyLabelWithReference(label, reference, substitutions,  context);
+
+    labelUnified = labelUnifiedWithReference; ///
+
+    if (labelUnified) {
+      context.debug(`...unified the '${labelString}' label with the '${referenceString}' reference.`);
+    }
+
+    return labelUnified;
+  }
+
+  unifyMetavariable(metavariable, context) {
+    let metavariableUnified;
+
+    const reference = this, ///
+          metavariableString = metavariable.getString(),
+          referenceString = reference.getString();
+
+    context.trace(`Unifying the '${metavariableString}' metavariable with the '${referenceString}' reference...`);
+
+    const metavariableUnifiedWithReference = unifyMetavariableWithReference(metavariable, reference,  context);
+
+    metavariableUnified = metavariableUnifiedWithReference; ///
+
+    if (metavariableUnified) {
+      context.debug(`...unified the '${metavariableString}' metavariable with the '${referenceString}' reference.`);
+    }
+
+    return metavariableUnified;
+  }
+
   toJSON() {
     const metavariableJSON = metavariableToMetavariableJSON(this.metavariable),
           metavariable = metavariableJSON,  ///

package/src/dom/rule.js

@@ -195,9 +195,9 @@ export default domAssigned(class Rule {
   verifyLabels() {
     const labelsVerified = this.labels.every((label) => {
       const nameOnly = true,
-            labelVVerifiedWhenDeclared = label.verifyWhenDeclared(this.fileContext, nameOnly);
+            labelVerified = label.verify(nameOnly);
 
-      if (labelVVerifiedWhenDeclared) {
+      if (labelVerified) {
         return true;
       }
     });

package/src/dom/statement.js

@@ -168,7 +168,7 @@ export default domAssigned(class Statement {
     let unifiedIndependently = false;
 
     const statement = this, ///
-          statementString = this.string;
+          statementString = this.string;  ///
 
     context.trace(`Unifying the '${statementString}' statement independently...`);
 

package/src/dom/term.js

@@ -181,7 +181,7 @@ export default domAssigned(class Term {
     let verifiedGivenType;
 
     const typeName = type.getName(),
-          termString = this.getString();
+          termString = this.getString();  ///
 
     specificContext.trace(`Verifying the '${termString}' term given the '${typeName}' type...`);
 

package/src/dom/topLevelAssertion.js

@@ -77,37 +77,51 @@ export default class TopLevelAssertion {
     return metavariableNameMatches;
   }
 
-  unifyReference(reference, context) {
-    let referenceUnified;
-
-    const referenceString = reference.getString(),
-          axiomLemmaTheoremConjecture = this, ///
-          axiomLemmaTheoremConjectureString = axiomLemmaTheoremConjecture.getString();
+  verify() {
+    let verified = false;
 
-    context.trace(`Unifying the '${referenceString}' reference with the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture...`);
+    const labelsVerified = this.verifyLabels();
 
-    const substitutions = Substitutions.fromNothing(),
-          fileContext = this.getFileContext(),
-          localContext = LocalContext.fromFileContext(fileContext),
-          generalContext = localContext,  ///
-          specificContext = context, ///
-          labelUnified = this.labels.some((label) => {
-            substitutions.clear();
+    if (labelsVerified) {
+      const localContext = LocalContext.fromFileContext(this.fileContext),
+        context = localContext, ///
+        suppositionsVerified = this.suppositions.every((supposition) => {
+          const suppositionVerified = supposition.verify(context);
 
-            const referenceUnified = reference.unifyLabel(label, substitutions, generalContext, specificContext);
+          if (suppositionVerified) {
+            return true;
+          }
+        });
 
-            if (referenceUnified) {
-              return true;
-            }
-          });
+      if (suppositionsVerified) {
+        const consequentVerified = this.consequent.verify(context);
 
-    referenceUnified = labelUnified;  ///
+        if (consequentVerified) {
+          if (this.proof === null) {
+            verified = true;
+          } else {
+            const proofVerified = this.proof.verify(this.substitutions, this.consequent, context);
 
-    if (referenceUnified) {
-      context.debug(`...unified the '${referenceString}' reference with the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture.`);
+            verified = proofVerified; ///
+          }
+        }
+      }
     }
 
-    return referenceUnified;
+    return verified;
+  }
+
+  verifyLabels() {
+    const labelsVerified = this.labels.every((label) => {
+      const nameOnly = true,
+        labelVerified = label.verify(nameOnly);
+
+      if (labelVerified) {
+        return true;
+      }
+    });
+
+    return labelsVerified;
   }
 
   unifyStatement(statement, context) {
@@ -139,6 +153,16 @@ export default class TopLevelAssertion {
     return statementUnified;
   }
 
+  unifyStatementWithConsequent(statement, substitutions, generalContext, specificContext) {
+    let consequentUnified;
+
+    const statementUnified = this.consequent.unifyStatement(statement, substitutions, generalContext, specificContext);  ///
+
+    consequentUnified = statementUnified; ///
+
+    return consequentUnified;
+  }
+
   unifyStatementAndProofStepSubproofs(statement, proofStepSubproofs, context) {
     let statementAndProofStepSubproofsUnified = false;
 
@@ -162,30 +186,6 @@ export default class TopLevelAssertion {
     return statementAndProofStepSubproofsUnified;
   }
 
-  unifyStatementWithConsequent(statement, substitutions, generalContext, specificContext) {
-    let consequentUnified;
-
-    const statementUnified = this.consequent.unifyStatement(statement, substitutions, generalContext, specificContext);  ///
-
-    consequentUnified = statementUnified; ///
-
-    return consequentUnified;
-  }
-
-  unifyProofStepSubproofsWithSuppositions(proofStepSubproofs, substitutions, generalContext, specificContext) {
-    proofStepSubproofs = reverse(proofStepSubproofs); ///
-
-    const proofStepSubproofsUnifiedWithSuppositions = backwardsEvery(this.suppositions, (supposition) => {
-      const proofStepSubproofsUnifiedWithSupposition = this.unifyProofStepSubproofsWithSupposition(proofStepSubproofs, supposition, substitutions, generalContext, specificContext);
-
-      if (proofStepSubproofsUnifiedWithSupposition) {
-        return true;
-      }
-    });
-
-    return proofStepSubproofsUnifiedWithSuppositions;
-  }
-
   unifyProofStepSubproofsWithSupposition(proofStepSubproofs, supposition, substitutions, generalContext, specificContext) {
     let proofStepSubproofsUnifiedWithSupposition  =false;
 
@@ -211,51 +211,18 @@ export default class TopLevelAssertion {
     return proofStepSubproofsUnifiedWithSupposition;
   }
 
-  verify() {
-    let verified = false;
-
-    const labelsVerified = this.verifyLabels();
-
-    if (labelsVerified) {
-      const localContext = LocalContext.fromFileContext(this.fileContext),
-            context = localContext, ///
-            suppositionsVerified = this.suppositions.every((supposition) => {
-              const suppositionVerified = supposition.verify(context);
-
-              if (suppositionVerified) {
-                return true;
-              }
-            });
-
-      if (suppositionsVerified) {
-        const consequentVerified = this.consequent.verify(context);
-
-        if (consequentVerified) {
-          if (this.proof === null) {
-            verified = true;
-          } else {
-            const proofVerified = this.proof.verify(this.substitutions, this.consequent, context);
-
-            verified = proofVerified; ///
-          }
-        }
-      }
-    }
-
-    return verified;
-  }
+  unifyProofStepSubproofsWithSuppositions(proofStepSubproofs, substitutions, generalContext, specificContext) {
+    proofStepSubproofs = reverse(proofStepSubproofs); ///
 
-  verifyLabels() {
-    const labelsVerified = this.labels.every((label) => {
-      const nameOnly = true,
-            labelVVerifiedWhenDeclared = label.verifyWhenDeclared(this.fileContext, nameOnly);
+    const proofStepSubproofsUnifiedWithSuppositions = backwardsEvery(this.suppositions, (supposition) => {
+      const proofStepSubproofsUnifiedWithSupposition = this.unifyProofStepSubproofsWithSupposition(proofStepSubproofs, supposition, substitutions, generalContext, specificContext);
 
-      if (labelVVerifiedWhenDeclared) {
+      if (proofStepSubproofsUnifiedWithSupposition) {
         return true;
       }
     });
 
-    return labelsVerified;
+    return proofStepSubproofsUnifiedWithSuppositions;
   }
 
   toJSON() {

package/src/dom/type.js

@@ -110,9 +110,9 @@ class Type {
 
     fileContext.trace(`Verifying the '${typeString}' type when declared...`);
 
-    const typeDeclared = fileContext.isTypeDeclaredByTypeName(this.name);
+    const typePresent = fileContext.isTypePresentByTypeName(this.name);
 
-    if (typeDeclared) {
+    if (typePresent) {
       fileContext.debug(`The type '${typeString}' has already been declared.`);
     } else {
       const superTypeName = this.superType.getName(),

package/src/dom/variable.js

@@ -142,15 +142,15 @@ export default domAssigned(class Variable {
     fileContext.trace(`Verifying the '${variableString}' variable when declared...`);
 
     const variableName = this.name, ///
-          variableDeclared = fileContext.isVariableDeclaredByVariableName(variableName);
+          variablePresent = fileContext.isVariablePresentByVariableName(variableName);
 
-    if (variableDeclared) {
+    if (variablePresent) {
       fileContext.debug(`The '${variableName}' variable has already been declared.`);
     } else {
       const metavariableName = this.name, ///
-            metavariableDeclared = fileContext.isMetavariableDeclaredByMetavariableName(metavariableName);
+            metavariablePresent = fileContext.isMetavariablePresentByMetavariableName(metavariableName);
 
-      if (metavariableDeclared) {
+      if (metavariablePresent) {
         fileContext.debug(`A '${metavariableName}' variable has already been declared.`);
       } else {
         const typeVerified = this.verifyType(fileContext);

package/src/equivalence.js

@@ -16,7 +16,7 @@ export default class Equivalence {
 
   addTerm(term, context) {
     const termString = term.getString(),
-          equivalenceString = this.getString();
+          equivalenceString = this.getString(); ///
 
     context.trace(`Adding the '${termString}' term to the '${equivalenceString}' equivalence.`);