occam-verify-cli 0.0.1094 → 0.0.1096

package/src/metaLemma.js

@@ -1,31 +1,79 @@
 "use strict";
 
 import shim from "./shim";
+import LocalContext from "./context/local";
 import TopLevelAssertion from "./topLevelAssertion";
 
-import { EMPTY_STRING } from "./constants";
-
 class MetaLemma extends TopLevelAssertion {
+  unifyReference(reference, substitutions, context) {
+    let referenceUnified;
+
+    const metaLemma = this, ///
+          referenceString = reference.getString(),
+          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();
+
+            const referenceUnified = reference.unifyLabel(label, substitutions, generalContext, specificContext);
+
+            if (referenceUnified) {
+              return true;
+            }
+          });
+
+    referenceUnified = labelUnified;  ///
+
+    if (referenceUnified) {
+      context.debug(`...unified the '${referenceString}' reference with the '${metaLemmaString}' meta-lemma.`);
+    }
+
+    return referenceUnified;
+  }
+
+  unifyStatement(statement, substitutions, context) {
+    let statementUnified;
+
+    const metaLemma = this, ///
+          statementString = statement.getString(),
+          metaLemmaString = metaLemma.getString();
+
+    context.trace(`Unifying the '${statementString}' reference with the '${metaLemmaString}' meta-lemma...`);
+
+    const consequent = this.getConsequent();
+
+    statementUnified = consequent.unifyStatement(statement, substitutions, context);
+
+    if (statementUnified) {
+      context.debug(`...unified the '${statementString}' reference with the '${metaLemmaString}' meta-lemma.`);
+    }
+
+    return statementUnified;
+  }
+
   verify() {
     let verified;
 
-    const fileContext = this.getFileContext(),
-          metaLemmaString = this.string;  ///
+    const metaLemma = this, ///
+          fileContext = this.getFileContext(),
+          metaLemmaString = metaLemma.getString();
 
-    (metaLemmaString === EMPTY_STRING) ?
-      fileContext.trace(`Verifying a meta-lemma...`) :
-        fileContext.trace(`Verifying the '${metaLemmaString}' meta-lemma...`);
+    fileContext.trace(`Verifying the '${metaLemmaString}' meta-lemma...`);
 
     verified = super.verify();
 
     if (verified) {
-      const metaLemma = this; ///
+      const metaTheorem = this; ///
 
-      fileContext.addMetaLemma(metaLemma);
+      fileContext.addMetatheorem(metaTheorem);
 
-      (metaLemmaString === EMPTY_STRING) ?
-        fileContext.debug(`...verified a meta-lemma.`) :
-          fileContext.debug(`...verified the '${metaLemmaString}' meta-lemma.`);
+      fileContext.debug(`...verified the '${metaLemmaString}' meta-lemma.`);
     }
 
     return verified;

package/src/metatheorem.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import shim from "./shim";
+import LocalContext from "./context/local";
 import TopLevelAssertion from "./topLevelAssertion";
 
 import { stringFromLabels } from "./topLevelAssertion";
@@ -14,11 +15,64 @@ import { labelsFromJSON,
          substitutionsToSubstitutionsJSON } from "./utilities/json";
 
 class Metatheorem extends TopLevelAssertion {
+  unifyReference(reference, substitutions, context) {
+    let referenceUnified;
+
+    const metatheorem = this, ///
+          referenceString = reference.getString(),
+          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();
+
+            const referenceUnified = reference.unifyLabel(label, substitutions, generalContext, specificContext);
+
+            if (referenceUnified) {
+              return true;
+            }
+          });
+
+    referenceUnified = labelUnified;  ///
+
+    if (referenceUnified) {
+      context.debug(`...unified the '${referenceString}' reference with the '${metatheoremString}' metatheorem.`);
+    }
+
+    return referenceUnified;
+  }
+
+  unifyStatement(statement, substitutions, context) {
+    let statementUnified;
+
+    const metatheorem = this, ///
+          statementString = statement.getString(),
+          metatheoremString = metatheorem.getString();
+
+    context.trace(`Unifying the '${statementString}' reference with the '${metatheoremString}' metatheorem...`);
+
+    const consequent = this.getConsequent();
+
+    statementUnified = consequent.unifyStatement(statement, substitutions, context);
+
+    if (statementUnified) {
+      context.debug(`...unified the '${statementString}' reference with the '${metatheoremString}' metatheorem.`);
+    }
+
+    return statementUnified;
+  }
+
   verify() {
     let verified;
 
-    const fileContext = this.getFileContext(),
-          metatheoremString = this.string;  ///
+    const metatheorem = this, ///
+          fileContext = this.getFileContext(),
+          metatheoremString = metatheorem.getString();
 
     fileContext.trace(`Verifying the '${metatheoremString}' metatheorem...`);
 

package/src/metavariable.js

@@ -71,14 +71,14 @@ class Metavariable {
     return metavariableNodeMatches;
   }
 
-  unifyFrame(frame, substitutions, generalContext, specificContext) {
+  unifyFrame(frame, substitutions, context) {
     let frameUnified = false;
 
     const frameNode = frame.getNode(),
           frameString = frame.getString(),
           metavariableString = this.string; ///
 
-    specificContext.trace(`Unifying the '${frameString}' frame with the '${metavariableString}' metavariable...`);
+    context.trace(`Unifying the '${frameString}' frame with the '${metavariableString}' metavariable...`);
 
     const metavariableNode = this.node, ///
           simpleSubstitutionPresent = substitutions.isSimpleSubstitutionPresentByMetavariableNode(metavariableNode);
@@ -92,7 +92,10 @@ class Metavariable {
         frameUnified = true;
       }
     } else {
-      const metavariableNode = this.node,  ///
+      const localContext = LocalContext.fromFileContext(this.fileContext),
+            generalContext = localContext,  ///
+            specificContext = context,  ///
+            metavariableNode = this.node,  ///
             metavariable = metavariableFromMetavariableNode(metavariableNode, generalContext, specificContext),
             frameMetavariable  = frameMetavariableFromStatementNode(frameNode, generalContext, specificContext);
 
@@ -100,7 +103,6 @@ class Metavariable {
         frameUnified = true;
       } else {
         const metavariable = this,  ///
-              context = specificContext, ///
               frameSubstitution = FrameSubstitution.fromFrameAndMetavariable(frame, metavariable, context),
               substitution = frameSubstitution;  ///
 
@@ -111,13 +113,13 @@ class Metavariable {
     }
 
     if (frameUnified) {
-      specificContext.debug(`...unified the '${frameString}' frame with the '${metavariableString}' metavariable.`);
+      context.debug(`...unified the '${frameString}' frame with the '${metavariableString}' metavariable.`);
     }
 
     return frameUnified;
   }
 
-  unifyStatement(statement, substitution, substitutions, generalContext, specificContext) {
+  unifyStatement(statement, substitution, substitutions, context) {
     let statementUnified = false;
 
     const statementString = statement.getString(),
@@ -126,7 +128,7 @@ class Metavariable {
                                   substitution.getString() :
                                     EMPTY_STRING;
 
-    specificContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}${substitutionString}' metavariable...`);
+    context.trace(`Unifying the '${statementString}' statement with the '${metavariableString}${substitutionString}' metavariable...`);
 
     const statementNode = statement.getNode(),
           metavariableNode = this.node, ///
@@ -143,15 +145,17 @@ class Metavariable {
         statementUnified = true;
       }
     } else {
-      const metavariableNode = this.node,  ///
+      const localContext = LocalContext.fromFileContext(this.fileContext),
+            generalContext = localContext,  ///
+            specificContext = context,  ///
+            metavariableNode = this.node,  ///
             metavariable = metavariableFromMetavariableNode(metavariableNode, generalContext, specificContext),
             statementMetavariable = statementMetavariableFromStatementNode(statementNode, generalContext, specificContext);
 
       if ((metavariable !== null) && (metavariable === statementMetavariable)) {
         statementUnified = true;
       } else {
-        const context = specificContext, ///
-              metavariable = this,  ///
+        const metavariable = this,  ///
               statementSubstitution = StatementSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context);
 
         substitution = statementSubstitution;  ///
@@ -163,7 +167,7 @@ class Metavariable {
     }
 
     if (statementUnified) {
-      specificContext.debug(`...unified the '${statementString}' statement with the '${metavariableString}${substitutionString}' metavariable.`);
+      context.debug(`...unified the '${statementString}' statement with the '${metavariableString}${substitutionString}' metavariable.`);
     }
 
     return statementUnified;
@@ -201,7 +205,9 @@ class Metavariable {
     context.trace(`Verifying the '${metavariableString}' metavariable...`);
 
     const metavariableNode = this.node,
-          metavariablePresent = context.isMetavariablePresentByMetavariableNode(metavariableNode);
+          generalContext = context,  ///
+          specificContext = context,  ///
+          metavariablePresent = generalContext.isMetavariablePresentByMetavariableNode(metavariableNode, specificContext);
 
     verified = metavariablePresent; ///
 
@@ -374,7 +380,7 @@ function statementMetavariableFromStatementNode(statementNode, generalContext, s
   const statementMetavariableNode = statementMetavariableNodeQuery(statementNode);
 
   if (statementMetavariableNode !== null) {
-    const context = generalContext;
+    const context = generalContext; ///
 
     statementMetavariable = context.findMetavariableByMetavariableNode(statementMetavariableNode, specificContext);
   }

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

@@ -33,8 +33,10 @@ function unifyAWithReference(qualifiedStatement, substitutions, context) {
   let unifiedWithReference = false;
 
   const reference = qualifiedStatement.getReference(),
+        generalContext = context,  ///
+        specificContext = context,  ///
         metavariableNode = reference.getMetavariableNode(),
-        metavariablePresent = context.isMetavariablePresentByMetavariableNode(metavariableNode);
+        metavariablePresent = generalContext.isMetavariablePresentByMetavariableNode(metavariableNode, specificContext);
 
   if (metavariablePresent) {
     const statement = qualifiedStatement.getStatement(),

package/src/nodeAndTokens/metavariable.js

@@ -33,16 +33,12 @@ export default class MetavariableNodeAndTokens extends NodeAndTokens {
     return metavariableNodeAndTokens;
   }
 
-  static fromMetavariableString(metavariableString, context) {
-    const string = metavariableString,  ///
-          metavariableNodeAndTokens = NodeAndTokens.fromString(MetavariableNodeAndTokens, string, context);
-
-    return metavariableNodeAndTokens;
-  }
+  static fromString(string, context) { return NodeAndTokens.fromString(MetavariableNodeAndTokens, string, context); }
 }
 
 export function metavariableNodeFromMetavariableString(metavariableString, context) {
-  const metavariableNodeAndTokens = MetavariableNodeAndTokens.fromMetavariableString(metavariableString, context),
+  const string = metavariableString,  ///
+        metavariableNodeAndTokens = MetavariableNodeAndTokens.fromString(string, context),
         metavariableNode = metavariableNodeAndTokens.getMetavariableNode();
 
   return metavariableNode;

package/src/nodeAndTokens/statement.js

@@ -33,17 +33,5 @@ export default class StatementNodeAndTokens extends NodeAndTokens {
     return statementNodeAndTokens;
   }
 
-  static fromStatementString(statementString, context) {
-    const string = statementString,  ///
-          statementNodeAndTokens = NodeAndTokens.fromString(StatementNodeAndTokens, string, context);
-
-    return statementNodeAndTokens;
-  }
-}
-
-export function statementNodeFromStatementString(statementString, context) {
-  const statementNodeAndTokens = StatementNodeAndTokens.fromStatementString(statementString, context),
-        statementNode = statementNodeAndTokens.getStatementNode();
-
-  return statementNode;
+  static fromString(string, context) { return NodeAndTokens.fromString(StatementNodeAndTokens, string, context); }
 }

package/src/nodeAndTokens/substitution/frame.js

@@ -14,10 +14,5 @@ const bnf = `
 export default class FrameSubstitutionNodeAndTokens extends NodeAndTokens {
   static rule = rule;
 
-  static fromFrameSubstitutionString(frameSubstitutionString, context) {
-    const string = frameSubstitutionString, ///
-          frameSubstitutionNodeAndTokens = NodeAndTokens.fromString(FrameSubstitutionNodeAndTokens, string, context);
-
-    return frameSubstitutionNodeAndTokens;
-  }
+  static fromString(string, context) { return NodeAndTokens.fromString(FrameSubstitutionNodeAndTokens, string, context); }
 }

package/src/nodeAndTokens/substitution/statement.js

@@ -14,10 +14,5 @@ const bnf = `
 export default class StatementSubstitutionNodeAndTokens extends NodeAndTokens {
   static rule = rule;
 
-  static fromStatementSubstitutionString(statementSubstitutionString, context) {
-    const string = statementSubstitutionString, ///
-          statementSubstitutionNodeAndTokens = NodeAndTokens.fromString(StatementSubstitutionNodeAndTokens, string, context);
-
-    return statementSubstitutionNodeAndTokens;
-  }
+  static fromString(string, context) { return NodeAndTokens.fromString(StatementSubstitutionNodeAndTokens, string, context); }
 }

package/src/nodeAndTokens/substitution/term.js

@@ -14,10 +14,5 @@ const bnf = `
 export default class TermSubstitutionNodeAndTokens extends NodeAndTokens {
   static rule = rule;
 
-  static fromTermSubstitutionString(termSubstitutionString, context) {
-    const string = termSubstitutionString,  ///
-          termSubstitutionNodeAndTokens = NodeAndTokens.fromString(TermSubstitutionNodeAndTokens, string, context);
-
-    return termSubstitutionNodeAndTokens;
-  }
+  static fromString(string, context) { return NodeAndTokens.fromString(TermSubstitutionNodeAndTokens, string, context); }
 }

package/src/nodeAndTokens/term.js

@@ -33,16 +33,12 @@ export default class TermNodeAndTokens extends NodeAndTokens {
     return termNodeAndTokens;
   }
 
-  static fromTermString(termString, context) {
-    const string = termString,  ///
-          termNodeAndTokens = NodeAndTokens.fromString(TermNodeAndTokens, string, context);
-
-    return termNodeAndTokens;
-  }
+  static fromString(string, context) { return NodeAndTokens.fromString(TermNodeAndTokens, string, context); }
 }
 
 export function termNodeFromTermString(termString, context) {
-  const termNodeAndTokens = TermNodeAndTokens.fromTermString(termString, context),
+  const string = termString,  ///
+        termNodeAndTokens = TermNodeAndTokens.fromString(string, context),
         termNode = termNodeAndTokens.getTermNode();
 
   return termNode;

package/src/nodeAndTokens/variable.js

@@ -33,16 +33,12 @@ export default class VariableNodeAndTokens extends NodeAndTokens {
     return variableNodeAndTokens;
   }
 
-  static fromVariableString(variableString, context) {
-    const string = variableString,  ///
-          variableNodeAndTokens = NodeAndTokens.fromString(VariableNodeAndTokens, string, context);
-
-    return variableNodeAndTokens;
-  }
+  static fromString(string, context) { return NodeAndTokens.fromString(VariableNodeAndTokens, string, context); }
 }
 
 export function variableNodeFromVariableString(variableString, context) {
-  const variableNodeAndTokens = VariableNodeAndTokens.fromVariableString(variableString, context),
+  const string = variableString,  ///
+        variableNodeAndTokens = VariableNodeAndTokens.fromString(string, context),
         variableNode = variableNodeAndTokens.getVariableNode();
 
   return variableNode;

package/src/premise.js

@@ -119,12 +119,24 @@ class Premise {
           premiseStatementString = premiseStatement.getString();
 
     const statement = this.unqualifiedStatement.getStatement(),
-          statementNode = statement.getNode();
+          statementNode = statement.getNode(),
+          statementTokens = statement.getTokens();
 
     specificContext.trace(`Unifying the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement...`);
 
-    const context = specificContext,  ///
-          subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, context);
+    let context;
+
+    const tokens = statementTokens; ///
+
+    context = generalContext; ///
+
+    const localContext = LocalContext.fromContextAndTokens(context, tokens);
+
+    generalContext = localContext;  ///
+
+    context = generalContext; ///
+
+    const subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, context);
 
     if (subproofAssertion !== null) {
       subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);

package/src/reference.js

@@ -6,7 +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";
+import labelUnifier from "./unifier/label";
 
 const metavariableNodeQuery = nodeQuery("//reference/metavariable");
 
@@ -23,12 +23,41 @@ export default class Reference {
 
   matchMetavariableNode(metavariableNode) { return this.metavariable.matchMetavariableNode(metavariableNode); }
 
+  getMetavariableName() {
+    const metavariableName = this.metavariable.getName();
+
+    return metavariableName;
+  }
+
   getMetavariableNode() {
     const metavariableNode = this.metavariable.getNode();
 
     return 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 labelMetavariable = label.getMetavariable(),
+          referenceMetavariable = reference.getMetavariable(),
+          labelMetavariableNode = labelMetavariable.getNode(),
+          referenceMetavariableNode = referenceMetavariable.getNode();
+
+    labelUnified = labelUnifier.unify(labelMetavariableNode, referenceMetavariableNode, substitutions, generalContext, specificContext);
+
+    if (labelUnified) {
+      specificContext.debug(`...unified the '${labelString}' label with the '${referenceString}' reference.`);
+    }
+
+    return labelUnified;
+  }
+
   verify(context) {
     let verified = false;
 
@@ -43,24 +72,6 @@ export default class Reference {
       verified = metavariableVerifiedGivenMetaType; ///
     }
 
-    if (!verified) {
-      const reference = this, ///
-            metaLemmaPresent = context.isMetaLemmaPresentByReference(reference),
-            metatheoremPresent = context.isMetatheoremPresentByReference(reference);
-
-      verified = (metaLemmaPresent || metatheoremPresent);
-    }
-
-    if (!verified) {
-      const reference = this, ///
-            axiomPresent = context.isAxiomPresentByReference(reference),
-            lemmaPresent = context.isLemmaPresentByReference(reference),
-            theoremPresent = context.isTheoremPresentByReference(reference),
-            conjecturePresent = context.isConjecturePresentByReference(reference);
-
-      verified = (axiomPresent || lemmaPresent || theoremPresent || conjecturePresent);
-    }
-
     if (verified) {
       context.debug(`...verified the '${referenceString}' reference.`);
     }

package/src/rule.js

@@ -55,16 +55,18 @@ class Rule {
     return this.proof;
   }
 
-  matchMetavariableNode(metavariableNode) {
-    const metavariableNodeMatches = this.labels.some((label) => {
-      const metavariableNodeMatches = label.matchMetavariableNode(metavariableNode);
+  matchStatementNode(statementNode) { return this.conclusion.matchStatementNode(statementNode); }
 
-      if (metavariableNodeMatches) {
+  matchMetavariableName(metavariableName) {
+    const metavariableNameMatches = this.labels.some((label) => {
+      const metavariableNameMatches = label.matchMetavariableName(metavariableName);
+
+      if (metavariableNameMatches) {
         return true;
       }
     });
 
-    return metavariableNodeMatches;
+    return metavariableNameMatches;
   }
 
   unifyStatement(statement, context) {

package/src/statement/qualified.js

@@ -36,13 +36,13 @@ class QualifiedStatement {
   unify(substitutions, context) {
     let unified;
 
-    const qualifiedStatement = this,  ///
-          qualifiedStatementString = this.string; ///
+    const qualifiedStatementString = this.string; ///
 
     context.trace(`Unifying the '${qualifiedStatementString}' qualified statement...`);
 
     unified = unifyMixins.some((unifyMixin) => {
-      const unified = unifyMixin(qualifiedStatement, substitutions, context);
+      const qualifiedStatement = this,  ///
+            unified = unifyMixin(qualifiedStatement, substitutions, context);
 
       return unified;
     });

package/src/statement/unqualified.js

@@ -27,36 +27,7 @@ class UnqualifiedStatement {
     return this.statement;
   }
 
-  verify(assignments, stated, context) {
-    let verified;
-
-    const unqualifiedStatement = this,  ///
-          unqualifiedStatementString = unqualifiedStatement.getString();  ///
-
-    if (this.statement !== null) {
-      context.trace(`Verifying the '${unqualifiedStatementString}' unqualified statement...`);
-
-      const statementVerified = this.statement.verify(assignments, stated, context);
-
-      if (statementVerified) {
-        verified = true;
-      } else {
-        const statementUnifiedWithProofSteps = this.unifyStatementWithProofSteps(this.statement, assignments, stated, context);
-
-        if (statementUnifiedWithProofSteps) {
-          verified = true;
-        }
-      }
-
-      if (verified) {
-        context.debug(`...verified the '${unqualifiedStatementString}' unqualified statement.`);
-      }
-    } else {
-      context.debug(`Cannot verify the '${unqualifiedStatementString}' unqualified statement because it is nonsense.`);
-    }
-
-    return verified;
-  }
+  matchStatementNode(statementNode) { return this.statement.matchStatementNode(statementNode); }
 
   unifyStatement(statement, substitutions, generalContext, specificContext) {
     let statementUnified;
@@ -113,6 +84,37 @@ class UnqualifiedStatement {
     return statementUnifiedWithProofSteps;
   }
 
+  verify(assignments, stated, context) {
+    let verified;
+
+    const unqualifiedStatement = this,  ///
+          unqualifiedStatementString = unqualifiedStatement.getString();  ///
+
+    if (this.statement !== null) {
+      context.trace(`Verifying the '${unqualifiedStatementString}' unqualified statement...`);
+
+      const statementVerified = this.statement.verify(assignments, stated, context);
+
+      if (statementVerified) {
+        verified = true;
+      } else {
+        const statementUnifiedWithProofSteps = this.unifyStatementWithProofSteps(this.statement, assignments, stated, context);
+
+        if (statementUnifiedWithProofSteps) {
+          verified = true;
+        }
+      }
+
+      if (verified) {
+        context.debug(`...verified the '${unqualifiedStatementString}' unqualified statement.`);
+      }
+    } else {
+      context.debug(`Cannot verify the '${unqualifiedStatementString}' unqualified statement because it is nonsense.`);
+    }
+
+    return verified;
+  }
+
   toJSON() {
     const statementJSON = statementToStatementJSON(this.statement),
           statement = statementJSON,  ///