occam-verify-cli 0.0.1248 → 0.0.1249

package/src/context/file.js

@@ -3,6 +3,7 @@
 import { arrayUtilities } from "necessary";
 
 import Equivalences from "../equivalences";
+import Substitutions from "../substitutions";
 import topLevelVerifier from "../verifier/topLevel";
 
 import { objectType } from "../dom/type";
@@ -373,6 +374,32 @@ export default class FileContext {
     return label;
   }
 
+  findMetaLemmaByReference(reference) {
+    const metaLemmas = this.getMetaLemmas(),
+          metaLemma = metaLemmas.find((metaLemma) => {
+            const referenceMatches = metaLemma.matchReference(reference);
+
+            if (referenceMatches) {
+              return true;
+            }
+          }) || null;
+
+    return metaLemma;
+  }
+
+  findMetatheoremByReference(reference) {
+    const metatheorems = this.getMetatheorems(),
+          metatheorem = metatheorems.find((metatheorem) => {
+            const referenceMatches = metatheorem.matchReference(reference);
+
+            if (referenceMatches) {
+              return true;
+            }
+          }) || null;
+
+    return metatheorem;
+  }
+
   findRuleByReference(reference) {
     const rules = this.getRules(),
           metavariableName = reference.getMetavariableName(),
@@ -462,9 +489,10 @@ export default class FileContext {
 
     filter(metaLemmas, (metaLemma) => {
       const context = this, ///
-            metaLemmaUnified = reference.unifyMetaLemma(metaLemma, context);
+            metaLemmaMetaTheorem = metaLemma, ///
+            metaLemmaMetatheoremUnified = reference.unifyMetaLemmaMetatheorem(metaLemmaMetaTheorem, context);
 
-      if (metaLemmaUnified) {
+      if (metaLemmaMetatheoremUnified) {
         return true;
       }
     });
@@ -475,11 +503,12 @@ export default class FileContext {
   findMetatheoremsByReference(reference) {
     const metatheorems = this.getMetatheorems();
 
-  filter(metatheorems, (metatheorem) => {
+    filter(metatheorems, (metatheorem) => {
       const context = this, ///
-            metatheoremUnified = reference.unifyMetatheorem(metatheorem, context);
+            metaLemmaMetaTheorem = metatheorem, ///
+            metaLemmaMetatheoremUnified = reference.unifyMetaLemmaMetatheorem(metaLemmaMetaTheorem, context);
 
-      if (metatheoremUnified) {
+      if (metaLemmaMetatheoremUnified) {
         return true;
       }
     });
@@ -487,6 +516,25 @@ export default class FileContext {
     return metatheorems;
   }
 
+  findMetaLemmaMetatheoremByReference(reference) {
+    const metaLemma = this.findMetaLemmaByReference(reference),
+          metatheorem = this.findMetatheoremByReference(reference),
+          metaLemmaMetatheorem = (metaLemma || metatheorem);  ///
+
+    return metaLemmaMetatheorem;
+  }
+
+  findMetaLemmaMetatheoremsByReference(reference) {
+    const metaLemmas = this.findMetaLemmasByReference(reference),
+          metatheorems = this.findMetatheoremsByReference(reference),
+          metaLemmaMetatheorems = [
+            ...metaLemmas,
+            ...metatheorems
+          ];
+
+    return metaLemmaMetatheorems;
+  }
+
   findAxiomLemmaTheoremConjectureByReference(reference) {
     const axiom = this.findAxiomByReference(reference),
           lemma = this.findLemmaByReference(reference),
@@ -571,10 +619,10 @@ export default class FileContext {
     return label;
   }
 
-  findLabelByMetavariableNode(metavariableNode) {
+  findLabelByMetavariable(metavariable) {
     const labels = this.getLabels(),
           label = labels.find((label) => {
-            const metavariableNodeMatches = label.matchMetavariableNode(metavariableNode);
+            const metavariableNodeMatches = label.matchMetavariable(metavariable);
 
             if (metavariableNodeMatches) {
               return true;
@@ -643,8 +691,8 @@ export default class FileContext {
     return labelPresent;
   }
 
-  isLabelPresentByMetavariableNode(metavariableNode) {
-    const label = this.findLabelByMetavariableNode(metavariableNode),
+  isLabelPresentByMetavariable(metavariable) {
+    const label = this.findLabelByMetavariable(metavariable),
           labelPresent = (label !== null);
 
     return labelPresent;
@@ -661,7 +709,8 @@ export default class FileContext {
     const labels = this.getLabels(),
           labelPresent = labels.some((label) => {
             const context = this, ///
-                  labelUnified = reference.unifyLabel(label, context);
+                  substitutions = Substitutions.fromNothing(),
+                  labelUnified = reference.unifyLabel(label, substitutions, context);
 
             if (labelUnified) {
               return true;

package/src/context/local.js

@@ -235,6 +235,10 @@ class LocalContext {
 
   findMetatheoremsByReference(reference) { return this.context.findMetatheoremsByReference(reference); }
 
+  findMetaLemmaMetatheoremByReference(reference) { return this.context.findMetaLemmaMetatheoremByReference(reference); }
+
+  findMetaLemmaMetatheoremsByReference(reference) { return this.context.findMetaLemmaMetatheoremsByReference(reference); }
+
   findVariableByVariableName(variableName, nested = true) {
     const variables = this.getVariables(nested),
           variable = variables.find((variable) => {
@@ -296,7 +300,7 @@ class LocalContext {
 
   isLabelPresentByMetavariableName(metavariableName) { return this.context.isLabelPresentByMetavariableName(metavariableName); }
 
-  isLabelPresentByMetavariableNode(metavariableNode) { return this.context.isLabelPresentByMetavariableNode(metavariableNode); }
+  isLabelPresentByMetavariable(metavariable) { return this.context.isLabelPresentByMetavariable(metavariable); }
 
   isMetavariablePresentByMetavariableName(metavariableNode) { return this.context.isMetavariablePresentByMetavariableName(metavariableNode); }
 

package/src/dom/conclusion.js

@@ -19,8 +19,6 @@ export  default domAssigned(class Conclusion {
     return this.statement;
   }
 
-  matchStatementNode(statementNode) { return this.statement.matchStatementNode(statementNode); }
-
   unifyStatement(statement, substitutions, generalContext, specificContext) {
     let statementUnified;
 

package/src/dom/consequent.js

@@ -19,8 +19,6 @@ export default domAssigned(class Consequent {
     return this.statement;
   }
 
-  matchStatementNode(statementNode) { return this.statement.matchStatementNode(statementNode); }
-
   unifyStatement(statement, substitutions, generalContext, specificContext) {
     let statementUnified;
 

package/src/dom/declaration.js

@@ -1,11 +1,12 @@
 "use strict";
 
 import dom from "../dom";
+import Substitutions from "../substitutions";
 
 import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
+import { unifyStatementIntrinsically } from "../utilities/unification";
 import { stripBracketsFromStatementNode } from "../utilities/brackets";
-import metaLemma from "./metaLemma";
 
 const statementNodeQuery = nodeQuery("/declaration/statement");
 
@@ -28,6 +29,28 @@ export default domAssigned(class Declaration {
     return this.statement;
   }
 
+  matchSubstitution(substitution, context) {
+    let substitutionMatches;
+
+    const declarationString = this.string,  ///
+          substitutionString = substitution.getString();
+
+    context.trace(`Matching the '${substitutionString}' substitution with the '${declarationString}' declaration...`);
+
+    const statement = substitution.getStatement(),
+          metavariable = substitution.getMetavariable(),
+          statementMatches = this.statement.match(statement),
+          metavariableMatchesReference = this.reference.matchMetavariable(metavariable);
+
+    substitutionMatches = (metavariableMatchesReference && statementMatches);
+
+    if (substitutionMatches) {
+      context.debug(`...matched the '${declarationString}' substitution with the '${substitutionString}' declaration.`);
+    }
+
+    return substitutionMatches;
+  }
+
   verify(frame, assignments, stated, context) {
     let verified = false;
 
@@ -46,12 +69,8 @@ export default domAssigned(class Declaration {
 
         if (stated) {
           verifiedWhenStated = this.verifyWhenStated(frame, assignments, context);
-
-          verified = verifiedWhenStated;  ///
         } else {
-          verifiedWhenDerived = this.verifyWhenDerived(context);
-
-          verified = verifiedWhenDerived; ///
+          verifiedWhenDerived = this.verifyWhenDerived(frame, context);
         }
 
         if (verifiedWhenStated || verifiedWhenDerived) {
@@ -117,21 +136,16 @@ export default domAssigned(class Declaration {
     if (metavariablePresent) {
       verifiedWhenStated = true;
     } else {
-      const metaLemmas = context.findMetaLemmasByReference(this.reference),
-            metatheorems = context.findMetatheoremsByReference(this.reference),
-            metaLemmaMetatheorems = [
-              ...metaLemmas,
-              ...metatheorems
-            ],
-            metaLemmaMetatheoremsVerifiedWhenStated = metaLemmaMetatheorems.every((metaLemmaMetatheorem) => {
-              const metaLemmaMetatheoremVerifiedWhenStated = metaLemmaMetatheorem.verifyWhenStated(this.statement, this.reference, context);
-
-              if (metaLemmaMetatheoremVerifiedWhenStated) {
+      const metaLemmaMetatheorems = context.findMetaLemmaMetatheoremsByReference(this.reference),
+            metaLemmaMetatheoremsUnified = metaLemmaMetatheorems.every((metaLemmaMetatheorem) => {
+              const metaLemmaMetatheoremUnified = this.unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context);
+
+              if (metaLemmaMetatheoremUnified) {
                 return true;
               }
             });
 
-      verifiedWhenStated = metaLemmaMetatheoremsVerifiedWhenStated; ///
+      verifiedWhenStated = metaLemmaMetatheoremsUnified; ///
     }
 
     if (verifiedWhenStated) {
@@ -148,47 +162,14 @@ export default domAssigned(class Declaration {
 
     context.trace(`Verifying the '${declarationString}' derived declaration...`);
 
-    debugger
-
-    // const metaLemmas = context.findMetaLemmasByReference(this.reference),
-    //       metatheorems = context.findMetatheoremsByReference(this.reference),
-    //       metaLemmaMetatheorems = [
-    //         ...metaLemmas,
-    //         ...metatheorems
-    //       ],
-    //       metaLemmaMetatheoremUnified = metaLemmaMetatheorems.some((metaLemmaMetatheorem) => {
-    //         let metaLemmaMetatheoremUnified = true;
-    //
-    //         if (metaLemmaMetatheoremUnified) {
-    //           metaLemmaMetatheoremUnified = frame.unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context);
-    //         }
-    //
-    //         if (metaLemmaMetatheoremUnified) {
-    //           metaLemmaMetatheoremUnified = this.unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context);
-    //         }
-    //
-    //         if (metaLemmaMetatheoremUnified) {
-    //           return true;
-    //         }
-    //       });
-    //
-    // if (metaLemmaMetatheoremUnified) {
-    //   verifiedWhenDerived = true;
-    // } else {
-    //   const axiom = context.findAxiomByReference(this.reference),
-    //         lemma = context.findLemmaByReference(this.reference),
-    //         theorem = context.findTheoremByReference(this.reference),
-    //         conjecture = context.findConjectureByReference(this.reference),
-    //         axiomLemmaTheoremConjecture = (axiom || lemma || theorem || conjecture);
-    //
-    //   if (axiomLemmaTheoremConjecture !== null) {
-    //     const axiomLemmaTheoremConjectureUnified = this.unifyAxiomLemmaTheoremConjecture(axiomLemmaTheoremConjecture, context);
-    //
-    //     if (axiomLemmaTheoremConjectureUnified) {
-    //       verifiedWhenDerived = true;
-    //     }
-    //   }
-    // }
+    const metaLemmaMetatheorem = context.findMetaLemmaMetatheoremByReference(this.reference);
+
+    if (metaLemmaMetatheorem !== null) {
+      const substitutions = metaLemmaMetatheorem.getSubstitutions(),
+            substitutionsMatches = frame.matchSubstitutions(substitutions, context);
+
+      verifiedWhenDerived = substitutionsMatches; ///
+    }
 
     if (verifiedWhenDerived) {
       context.trace(`...verified the '${declarationString}' derived declaration.`);
@@ -197,69 +178,84 @@ export default domAssigned(class Declaration {
     return verifiedWhenDerived;
   }
 
-  unifyStatement(statement, context) {
+  unifyStatement(statement, substitutions, generalContext, specificContext) {
     let statementUnified;
 
-    const statementString = statement.getString(),
-          declarationStatementString = this.statement.getString(); ///
+    const context = generalContext,  ///
+          statementString = statement.getString(),
+          declarationString = this.string,  ///
+          declarationStatementString = this.statement.getString();
 
-    context.trace(`Unifying the '${statementString}' statement with the '${declarationStatementString}' statement...`);
+    context.trace(`Unifying the '${statementString}' statement with the '${declarationString}' declaration's '${declarationStatementString}' statement...`);
 
-    let statementNode = statement.getNode();
+    const generalStatement = this.statement,
+          specificStatement = statement,  ///
+          statementUUnifiedIntrinsically = unifyStatementIntrinsically(generalStatement, specificStatement, substitutions, generalContext, specificContext);
 
-    statementNode = stripBracketsFromStatementNode(statementNode); ///
-
-    const statementNodeMatches = this.statement.matchStatementNode(statementNode);
-
-    statementUnified = statementNodeMatches;  ///
+    statementUnified = statementUUnifiedIntrinsically;  ///
 
     if (statementUnified) {
-      context.debug(`...unified the '${statementString}' statement with the '${declarationStatementString}' statement.`);
+      context.debug(`...unified the '${statementString}' statement with the '${declarationString}' declaration's '${declarationStatementString}' statement.`);
     }
 
     return statementUnified;
   }
 
-  unifyMetavariable(metavariable, context) {
-    let metavariableUnified;
+  unifyLabelWithReference(label, substitutions, generalContext, specificContext) {
+    let labelUnifiedWithReference;
 
-    const referenceString = this.reference.getString(),
-          metavariableString = metavariable.getString();
+    const context = generalContext, ///
+          labelString = label.getString(),
+          referenceString = this.reference.getString(),
+          declarationString = this.string;  ///
 
-    context.trace(`Unifying the '${metavariableString}' metavariable with the '${referenceString}' reference...`);
+    context.trace(`Unifying the '${labelString}' label with the '${declarationString}' declaration's '${referenceString}' reference...`);
 
-    const metavariableNode = metavariable.getNode(),
-          metavariableNodeMatches = this.reference.matchMetavariableNode(metavariableNode);
+    const labelUnified = this.reference.unifyLabel(label, substitutions, context);
 
-    metavariableUnified = metavariableNodeMatches;  ///
+    labelUnifiedWithReference = labelUnified; ///
 
-    if (metavariableUnified) {
-      context.debug(`...unified the '${metavariableString}' metavariable with the '${referenceString}' reference.`);
+    if (labelUnifiedWithReference) {
+      context.debug(`...unified the '${labelString}' label with the '${declarationString}' declaration's '${referenceString}' reference.`);
     }
 
-    return metavariableUnified;
+    return labelUnifiedWithReference;
   }
 
-  unifySubstitution(substitution, context) {
-    let substitutionUnified;
+  unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context) {
+    let metaLemmaMetatheoremUnified;
 
     const declarationString = this.string,  ///
-          substitutionString = substitution.getString();
+          metaLemmaMetatheoremString = metaLemmaMetatheorem.getString();
 
-    context.trace(`Unifying the '${substitutionString}' substitution with the '${declarationString}' declaration...`);
+    context.trace(`Unifying the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${declarationString}' declaration...`);
 
-    const statement = substitution.getStatement(),
-          metavariable = substitution.getMetavariable(),
-          statementUnified = this.unifyStatement(statement, context),
-          metavariableUnified = this.unifyMetavariable(metavariable, context);
+    const fileContext = metaLemmaMetatheorem.getFileContext(),
+          generalContext = context, ///
+          specificContext = fileContext,
+          labelSubstitutions = Substitutions.fromNothing(),
+          label = metaLemmaMetatheorem.getLabel(),
+          substitutions = labelSubstitutions, ///
+          labelUnifiedWithReference = this.unifyLabelWithReference(label, substitutions, generalContext, specificContext);
+
+    if (labelUnifiedWithReference) {
+      const statementSubstitutions = Substitutions.fromNothing(),
+            statement = metaLemmaMetatheorem.getStatement(),
+            substitutions = statementSubstitutions, ///
+            statementUUnified = this.unifyStatement(statement, substitutions, generalContext, specificContext);
 
-    substitutionUnified = (metavariableUnified && statementUnified);
+      if (statementUUnified) {
+        const labelSubstitutionsMatchStatementSubstitutions = labelSubstitutions.matchSubstitutions(statementSubstitutions);
+
+        metaLemmaMetatheoremUnified = labelSubstitutionsMatchStatementSubstitutions;  ///
+      }
+    }
 
-    if (substitutionUnified) {
-      context.debug(`...unified the '${declarationString}' substitution with the '${substitutionString}' declaration.`);
+    if (metaLemmaMetatheoremUnified) {
+      context.trace(`...unified the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${declarationString}' declaration...`);
     }
 
-    return substitutionUnified;
+    return metaLemmaMetatheoremUnified;
   }
 
   static name = "Declaration";