occam-verify-cli 0.0.1246 → 0.0.1248

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,88 @@ export default domAssigned(class Reference {
     return metavariableVerified;
   }
 
+  unifyLabel(label, 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,  context);
+
+    labelUnified = labelUnifiedWithReference; ///
+
+    if (labelUnified) {
+      context.debug(`...unified the '${labelString}' label with the '${referenceString}' reference.`);
+    }
+
+    return labelUnified;
+  }
+
+  unifyMetaLemma(metaLemma, context) {
+    let metaLemmaUnified;
+
+    const reference = this, ///
+          referenceString = reference.getString(),
+          metaLemmaString = metaLemma.getString();
+
+    context.trace(`Unifying the '${metaLemmaString}' meta-lemma with the '${referenceString}' reference...`);
+
+    const label = metaLemma.getLabel(),
+          labelUnified = this.unifyLabel(label, context);
+
+    metaLemmaUnified = labelUnified;  ///
+
+    if (metaLemmaUnified) {
+      context.trace(`...unified the '${metaLemmaString}' meta-lemma with the '${referenceString}' reference.`);
+    }
+
+    return metaLemmaUnified;
+  }
+
+  unifyMetatheorem(metatheorem, context) {
+    let metatheoremUnified;
+
+    const reference = this, ///
+          referenceString = reference.getString(),
+          metatheoremString = metatheorem.getString();
+
+    context.trace(`Unifying the '${metatheoremString}' metatheorem with the '${referenceString}' reference...`);
+
+    const label = metatheorem.getLabel(),
+          labelUnified = this.unifyLabel(label, context);
+
+    metatheoremUnified = labelUnified;  ///
+
+    if (metatheoremUnified) {
+      context.trace(`...unified the '${metatheoremString}' metatheorem with the '${referenceString}' reference.`);
+    }
+
+    return metatheoremUnified;
+  }
+
+  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

@@ -7,8 +7,8 @@ import LocalContext from "../context/local";
 import Substitutions from "../substitutions";
 
 import { domAssigned } from "../dom";
-import { stringFromLabels } from "./topLevelAssertion";
 import { nodeQuery, nodesQuery } from "../utilities/query";
+import { labelsStringFromLabels } from "./topLevelAssertion";
 import { labelsFromJSON,
          premisesFromJSON,
          conclusionFromJSON,
@@ -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;
       }
     });
@@ -230,7 +230,8 @@ export default domAssigned(class Rule {
           labels = labelsFromJSON(json, fileContext),
           premises = premisesFromJSON(json, fileContext),
           conclusion = conclusionFromJSON(json, fileContext),
-          string = stringFromLabels(labels);
+          labelsString = labelsStringFromLabels(labels),
+          string = labelsString;  ///
 
     rule = new Rule(fileContext, string, labels, premises, conclusion, proof);
 
@@ -242,7 +243,8 @@ export default domAssigned(class Rule {
           premises = premisesFromRuleNode(ruleNode, fileContext),
           conclusion = conclusionFromRuleNode(ruleNode, fileContext),
           proof = proofFromRuleNode(ruleNode, fileContext),
-          string = stringFromLabels(labels),
+          labelsString = labelsStringFromLabels(labels),
+          string = labelsString,  ///
           rule = new Rule(fileContext, string, labels, premises, conclusion, proof);
 
     return rule;

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

@@ -6,7 +6,6 @@ import dom from "../dom";
 import LocalContext from "../context/local";
 import Substitutions from "../substitutions";
 
-import { EMPTY_STRING } from "../constants";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 import { labelsFromJSON,
          labelsToLabelsJSON,
@@ -25,11 +24,10 @@ const proofNodeQuery = nodeQuery("/*/proof"),
       suppositionNodesQuery = nodesQuery("/*/supposition");
 
 export default class TopLevelAssertion {
-  constructor(fileContext, string, labels, substitutions, suppositions, consequent, proof) {
+  constructor(fileContext, string, labels, suppositions, consequent, proof) {
     this.fileContext = fileContext;
     this.string = string;
     this.labels = labels;
-    this.substitutions = substitutions;
     this.suppositions = suppositions;
     this.consequent = consequent;
     this.proof = proof;
@@ -47,10 +45,6 @@ export default class TopLevelAssertion {
     return this.labels;
   }
 
-  getSubstitutions() {
-    return this.substitutions;
-  }
-
   getSuppositions() {
     return this.suppositions;
   }
@@ -77,37 +71,52 @@ 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 substitutions = Substitutions.fromNothing(),
+                  proofVerified = this.proof.verify(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 +148,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 +181,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,67 +206,31 @@ 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() {
     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,
-            substitutions
+            suppositions
           };
 
     return json;
@@ -279,51 +238,29 @@ export default class TopLevelAssertion {
 
   static fromJSON(Class, json, fileContext) {
     const labels = labelsFromJSON(json, fileContext),
-          consequent = consequentFromJSON(json, fileContext),
+          labelsString = labelsStringFromLabels(labels),
           suppositions = suppositionsFromJSON(json, fileContext),
-          substitutions = substitutionsFromJSON(json, fileContext),
-          string = stringFromLabels(labels),
+          consequent = consequentFromJSON(json, fileContext),
           proof = null,
-          topLevelAssertion = new Class(fileContext, string, labels, substitutions, suppositions, consequent, proof);
+          string = labelsString,  ///
+          topLevelAssertion = new Class(fileContext, string, labels, suppositions, consequent, proof);
 
     return topLevelAssertion;
   }
 
   static fromNode(Class, node, fileContext) {
     const labels = labelsFromNode(node, fileContext),
-          substitutions = Substitutions.fromNothing(),
+          labelsString = labelsStringFromLabels(labels),
           suppositions = suppositionsFromNode(node, fileContext),
           consequent = consequentFromNode(node, fileContext),
           proof = proofFromNode(node, fileContext),
-          string = stringFromLabels(labels),
-          metaLemma = new Class(fileContext, string, labels, substitutions, suppositions, consequent, proof);
+          string = labelsString,  ///
+          metaLemma = new Class(fileContext, string, labels, suppositions, consequent, proof);
 
     return metaLemma;
   }
 }
 
-export function stringFromLabels(labels) {
-  const string = labels.reduce((string, label) => {
-    const labelString = label.getString();
-
-    string = (string === EMPTY_STRING) ?
-               labelString: ///
-                 `${string},${labelString}`;
-
-    return string;
-  }, EMPTY_STRING);
-
-  return string;
-}
-
-function proofFromNode(node, fileContext) {
-  const { Proof } = dom,
-        proofNode = proofNodeQuery(node),
-        proof = Proof.fromProofNode(proofNode, fileContext);
-
-  return proof;
-}
-
 function labelsFromNode(node, fileContext) {
   const { Label } = dom,
         labelNodes = labelNodesQuery(node),
@@ -336,7 +273,15 @@ function labelsFromNode(node, fileContext) {
   return labels;
 }
 
-function consequentFromNode(node, fileContext) {
+export function proofFromNode(node, fileContext) {
+  const { Proof } = dom,
+        proofNode = proofNodeQuery(node),
+        proof = Proof.fromProofNode(proofNode, fileContext);
+
+  return proof;
+}
+
+export function consequentFromNode(node, fileContext) {
   const { Consequent } = dom,
         consequentNode = consequentNodeQuery(node),
         consequent = Consequent.fromConsequentNode(consequentNode, fileContext);
@@ -344,7 +289,7 @@ function consequentFromNode(node, fileContext) {
   return consequent;
 }
 
-function suppositionsFromNode(node, fileContext) {
+export function suppositionsFromNode(node, fileContext) {
   const { Supposition } = dom,
         suppositionNodes = suppositionNodesQuery(node),
         suppositions = suppositionNodes.map((suppositionNode) => {
@@ -356,3 +301,16 @@ function suppositionsFromNode(node, fileContext) {
   return suppositions;
 }
 
+export function labelsStringFromLabels(labels) {
+  const labelsString = labels.reduce((labelsString, label) => {
+    const labelString = label.getString();
+
+    labelsString = (labelsString === null) ?
+                      labelString: ///
+                        `${labelsString},${labelString}`;
+
+    return labelsString;
+  }, null);
+
+  return labelsString;
+}