occam-verify-cli 0.0.1094 → 0.0.1096

package/src/context/file.js

@@ -2,7 +2,7 @@
 
 import { arrayUtilities } from "necessary";
 
-import LocalContext from "./local";
+import shim from "../shim";
 import metavariableUnifier from "../unifier/metavariable";
 
 import { objectType } from "../type";
@@ -30,9 +30,8 @@ import { typesFromJSON,
          constructorsToConstructorsJSON,
          metatheoremsToMetatheoremsJSON,
          metavariablesToMetavariablesJSON } from "../utilities/json";
-import local from "./local";
 
-const { push } = arrayUtilities;
+const { push, filter } = arrayUtilities;
 
 export default class FileContext {
   constructor(releaseContext, filePath, tokens, node, types, rules, axioms, lemmas, theorems, variables, metaLemmas, conjectures, combinators, constructors, metatheorems, metavariables) {
@@ -407,11 +406,11 @@ export default class FileContext {
 
   findRuleByReference(reference) {
     const rules = this.getRules(),
-          metavariableNode = reference.getMetavariableNode(),
+          metavariableName = reference.getMetavariableName(),
           rule = rules.find((rule) => {
-            const metavariableNodeMatches = rule.matchMetavariableNode(metavariableNode);
+            const metavariableNameMatches = rule.matchMetavariableName(metavariableName);
 
-            if (metavariableNodeMatches) {
+            if (metavariableNameMatches) {
               return true;
             }
           }) || null;
@@ -421,11 +420,11 @@ export default class FileContext {
 
   findAxiomByReference(reference) {
     const axioms = this.getAxioms(),
-          metavariableNode = reference.getMetavariableNode(),
+          metavariableName = reference.getMetavariableName(),
           axiom = axioms.find((axiom) => {
-            const metavariableNodeMatches = axiom.matchMetavariableNode(metavariableNode);
+            const metavariableNameMatches = axiom.matchMetavariableName(metavariableName);
 
-            if (metavariableNodeMatches) {
+            if (metavariableNameMatches) {
               return true;
             }
           }) || null;
@@ -435,11 +434,11 @@ export default class FileContext {
 
   findLemmaByReference(reference) {
     const lemmas = this.getLemmas(),
-          metavariableNode = reference.getMetavariableNode(),
+          metavariableName = reference.getMetavariableName(),
           lemma = lemmas.find((lemma) => {
-            const metavariableNodeMatches = lemma.matchMetavariableNode(metavariableNode);
+            const metavariableNameMatches = lemma.matchMetavariableName(metavariableName);
 
-            if (metavariableNodeMatches) {
+            if (metavariableNameMatches) {
               return true;
             }
           }) || null;
@@ -449,11 +448,11 @@ export default class FileContext {
 
   findTheoremByReference(reference) {
     const theorems = this.getTheorems(),
-          metavariableNode = reference.getMetavariableNode(),
+          metavariableName = reference.getMetavariableName(),
           theorem = theorems.find((theorem) => {
-            const metavariableNodeMatches = theorem.matchMetavariableNode(metavariableNode);
+            const metavariableNameMatches = theorem.matchMetavariableName(metavariableName);
 
-            if (metavariableNodeMatches) {
+            if (metavariableNameMatches) {
               return true;
             }
           }) || null;
@@ -463,11 +462,11 @@ export default class FileContext {
 
   findConjectureByReference(reference) {
     const conjectures = this.getConjectures(),
-          metavariableNode = reference.getMetavariableNode(),
+          metavariableName = reference.getMetavariableName(),
           conjecture = conjectures.find((conjecture) => {
-            const metavariableNodeMatches = conjecture.matchMetavariableNode(metavariableNode);
+            const metavariableNameMatches = conjecture.matchMetavariableName(metavariableName);
 
-            if (metavariableNodeMatches) {
+            if (metavariableNameMatches) {
               return true;
             }
           }) || null;
@@ -475,30 +474,38 @@ export default class FileContext {
     return conjecture;
   }
 
-  findMetaLemmaByReference(reference, specificContext) {
-    const metaLemmas = this.getMetaLemmas(),
-          metaLemma = metaLemmas.find((metaLemma) => {
-            const referenceUnified = metaLemma.unifyReference(reference, specificContext);
+  findMetaLemmasByReference(reference) {
+    const metaLemmas = this.getMetaLemmas();
 
-            if (referenceUnified) {
-              return true;
-            }
-          }) || null;
+    filter(metaLemmas, (metaLemma) => {
+      const { Substitutions } = shim,
+            context = this, ///
+            substitutions = Substitutions.fromNothing(),
+            referenceUnified = metaLemma.unifyReference(reference, substitutions, context);
 
-    return metaLemma;
+      if (referenceUnified) {
+        return true;
+      }
+    });
+
+    return metaLemmas;
   }
 
-  findMetatheoremByReference(reference, specificContext) {
-    const metatheorems = this.getMetatheorems(),
-          metatheorem = metatheorems.find((metatheorem) => {
-            const referenceUnified = metatheorem.unifyReference(reference, specificContext);
+  findMetatheoremsByReference(reference) {
+    const metatheorems = this.getMetatheorems();
 
-            if (referenceUnified) {
-              return true;
-            }
-          }) || null;
+    filter(metatheorems, (metatheorem) => {
+      const { Substitutions } = shim,
+            context = this, ///
+            substitutions = Substitutions.fromNothing(),
+            referenceUnified = metatheorem.unifyReference(reference, substitutions, context);
 
-    return metatheorem;
+      if (referenceUnified) {
+        return true;
+      }
+    });
+
+    return metatheorems;
   }
 
   findVariableByVariableName(variableName) {
@@ -542,13 +549,13 @@ export default class FileContext {
   }
 
   findMetavariableByMetavariableNode(metavariableNode, specificContext) {
-    const metavariableNodeB = metavariableNode, ///
+    const specificMetavariableNode = metavariableNode, ///
           generalContext = this,  ///
           metavariables = this.getMetavariables(),
           metavariable = metavariables.find((metavariable) => {
-            const metavariableA = metavariable, ///
-                  metavariableNodeA = metavariableA.getNode(), ///
-                  metavariableUnified = metavariableUnifier.unify(metavariableNodeA, metavariableNodeB, generalContext, specificContext);
+            const generalMetavariable = metavariable, ///
+                  generalMetavariableNode = generalMetavariable.getNode(), ///
+                  metavariableUnified = metavariableUnifier.unify(generalMetavariableNode, specificMetavariableNode, generalContext, specificContext);
 
             if (metavariableUnified) {
               return true;
@@ -586,18 +593,20 @@ export default class FileContext {
     return conjecturePresent;
   }
 
-  isMetaLemmaPresentByReference(reference, specificContext) {
-    const metaLemma = this.findMetaLemmaByReference(reference, specificContext),
-          metaLemmaPresent = (metaLemma !== null);
+  areMetaLemmaPresentByReference(reference) {
+    const metaLemmas = this.findMetaLemmasByReference(reference),
+          metaLemmasLength = metaLemmas.length,
+          metaLemmasPresent = (metaLemmasLength > 0);
 
-    return metaLemmaPresent;
+    return metaLemmasPresent;
   }
 
-  isMetatheoremPresentByReference(reference, specificContext) {
-    const metatheorem = this.findMetatheoremByReference(reference, specificContext),
-          metatheoremPresent = (metatheorem !== null);
+  areMetatheoremPresentByReference(reference) {
+    const metatheorems = this.findMetatheoremsByReference(reference),
+          metatheoremsLength = metatheorems.length, ///
+          metatheoremsPresent = (metatheoremsLength > 0);
 
-    return metatheoremPresent;
+    return metatheoremsPresent;
   }
 
   nodeAsString(node, tokens = null) {

package/src/context/local.js

@@ -340,9 +340,9 @@ class LocalContext {
 
   findConjectureByReference(reference) { return this.context.findConjectureByReference(reference); }
 
-  findMetaLemmaByReference(reference, specificContext) { return this.context.findMetaLemmaByReference(reference, specificContext); }
+  findMetaLemmasByReference(reference) { return this.context.findMetaLemmasByReference(reference); }
 
-  findMetatheoremByReference(reference, specificContext) { return this.context.findMetatheoremByReference(reference, specificContext); }
+  findMetatheoremsByReference(reference) { return this.context.findMetatheoremsByReference(reference); }
 
   isAxiomPresentByReference(reference) { return this.context.isAxiomPresentByReference(reference); }
 
@@ -352,9 +352,9 @@ class LocalContext {
 
   isConjecturePresentByReference(reference) { return this.context.isConjecturePresentByReference(reference); }
 
-  isMetaLemmaPresentByReference(reference, specificContext) { return this.context.isMetaLemmaPresentByReference(reference, specificContext); }
+  areMetaLemmaPresentByReference(reference) { return this.context.areMetaLemmaPresentByReference(reference); }
 
-  isMetatheoremPresentByReference(reference, specificContext) { return this.context.isMetatheoremPresentByReference(reference, specificContext); }
+  areMetatheoremPresentByReference(reference) { return this.context.areMetatheoremPresentByReference(reference); }
 
   nodeAsString(node, tokens = null) {
     if (tokens === null) {

package/src/declaration.js

@@ -93,30 +93,154 @@ class Declaration {
     return substitutionUnified;
   }
 
-  verify(assignments, stated, context) {
+  unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context) {
+    let metaLemmaMetatheoremUnified = false;
+
+    const declarationString = this.string,  ///
+          metalemmaMetatheoremString = metaLemmaMetatheorem.getString();
+
+    context.trace(`Unifying the '${metalemmaMetatheoremString}' meta-lemma or metatheorem with the '${declarationString}' declaration...`);
+
+    const { Substitutions } = shim,
+          substitutions = Substitutions.fromNothing(),
+          referenceUnified = metaLemmaMetatheorem.unifyReference(this.reference, substitutions, context);
+
+    if (referenceUnified) {
+      const statementUnified = metaLemmaMetatheorem.unifyStatement(this.statement, substitutions, context);
+
+      if (statementUnified) {
+        metaLemmaMetatheoremUnified = true;
+      }
+    }
+
+    if (metaLemmaMetatheoremUnified) {
+      context.debug(`...unified the '${metalemmaMetatheoremString}' meta-lemma or metatheorem with the '${declarationString}' declaration.`);
+    }
+
+    return metaLemmaMetatheoremUnified;
+  }
+
+  verify(frame, assignments, stated, context) {
     let verified = false;
 
     const declarationString = this.string;  ///
 
     context.trace(`Verifying the '${declarationString}' declaration...`);
 
+    const statementVerified = this.verifyStatement(this.statement, assignments, stated, context);
+
+    if (statementVerified) {
+      let verifiedWhenStated = false,
+          verifiedWhenDerived = false;
+
+      if (stated) {
+        verifiedWhenStated = this.verifyWhenStated(context);
+      } else {
+        verifiedWhenDerived = this.verifyWhenDerived(frame, context);
+      }
+
+      verified = (verifiedWhenStated || verifiedWhenDerived);
+    }
+
+    if (verified) {
+      context.debug(`...verified the '${declarationString}' declaration.`);
+    }
+
+    return verified;
+  }
+
+  verifyStatement(statement, assignments, stated, context) {
     stated = true;  ///
 
     assignments = null; ///
 
+    const statementVerified = statement.verify(assignments, stated, context);
+
+    return statementVerified;
+  }
+
+  verifyWhenStated(context) {
+    let verifiedWhenStated;
+
+    const declarationString = this.string;  ///
+
+    context.trace(`Verifying the '${declarationString}' declaration when stated...`);
+
     const referenceVerified = this.reference.verify(context);
 
     if (referenceVerified) {
-      const statementVerified = this.statement.verify(assignments, stated, context);
+      verifiedWhenStated = true;
+    } else {
+      const metaLemmas = context.findMetaLemmasByReference(this.reference),
+            metatheorems = context.findMetatheoremsByReference(this.reference),
+            metaLemmaMetatheorems = [
+              ...metaLemmas,
+              ...metatheorems
+            ],
+            metaLemmaMetatheoremUnified = metaLemmaMetatheorems.every((metaLemmaMetatheorem) => {
+              const metaLemmaMetatheoremUnified = this.unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context);
+
+              if (metaLemmaMetatheoremUnified) {
+                return true;
+              }
+            });
+
+      verifiedWhenStated = metaLemmaMetatheoremUnified; ///
+    }
 
-      verified = statementVerified; ///
+    if (verifiedWhenStated) {
+      context.debug(`...verified the '${declarationString}' declaration when stated.`);
     }
 
-    if (verified) {
-      context.debug(`...verified the '${declarationString}' declaration.`);
+    return verifiedWhenStated;
+  }
+
+  verifyWhenDerived(frame, context) {
+    let verifiedWhenDerived;
+
+    const declarationString = this.string;  ///
+
+    context.trace(`Verifying the '${declarationString}' declaration when derived...`);
+
+    const referenceVerified = this.reference.verify(context);
+
+    if (referenceVerified) {
+      verifiedWhenDerived = true;
+    } else {
+      const metaLemmas = context.findMetaLemmasByReference(this.reference),
+            metatheorems = context.findMetatheoremsByReference(this.reference),
+            metaLemmaMetatheorems = [
+              ...metaLemmas,
+              ...metatheorems
+            ],
+            metaLemmaMetatheoremsLength = metaLemmaMetatheorems.length;
+
+      if (metaLemmaMetatheoremsLength > 0) {
+        const metaLemmaMetatheoremsUnified = metaLemmaMetatheorems.every((metaLemmaMetatheorem) => {
+          let metaLemmaMetatheoremUnified = true;
+
+          if (metaLemmaMetatheoremUnified) {
+            metaLemmaMetatheoremUnified = frame.unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context);
+          }
+
+          if (metaLemmaMetatheoremUnified) {
+            metaLemmaMetatheoremUnified = this.unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context);
+          }
+
+          if (metaLemmaMetatheoremUnified) {
+            return true;
+          }
+        });
+
+        verifiedWhenDerived = metaLemmaMetatheoremsUnified;  ///
+      }
     }
 
-    return verified;
+    if (verifiedWhenDerived) {
+      context.debug(`...verified the '${declarationString}' declaration when derived.`);
+    }
+
+    return verifiedWhenDerived;
   }
 
   static fromDeclarationNode(declarationNode, context) {

package/src/frame.js

@@ -89,9 +89,10 @@ class Frame {
   unifySubstitution(substitution, context) {
     let substitutionUnified = false;
 
-    const substitutionString = substitution.getString();
+    const frameString = this.string,  ///
+          substitutionString = substitution.getString();
 
-    context.trace(`Unifying the '${substitutionString}' substitution...`)
+    context.trace(`Unifying the '${substitutionString}' substitution with the '${frameString}' frame...`)
 
     if (!substitutionUnified) {
       substitutionUnified = this.declarations.some((declaration) => {
@@ -114,18 +115,19 @@ class Frame {
     }
 
     if (substitutionUnified) {
-      context.debug(`...unified the '${substitutionString}' substitution...`)
+      context.debug(`...unified the '${substitutionString}' substitution with the '${frameString}' frame...`)
     }
 
     return substitutionUnified;
   }
 
-  unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem, context) {
+  unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context) {
     let metaLemmaMetatheoremUnified;
 
-    const metaLemmaMetatheoremString = metaLemmaMetatheorem.getString();
+    const frameString = this.string,  ///
+          metaLemmaMetatheoremString = metaLemmaMetatheorem.getString();
 
-    context.trace(`Unifying the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem...`);
+    context.trace(`Unifying the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${frameString}' frame...`);
 
     const substitutions = metaLemmaMetatheorem.getSubstitutions(),
           substitutionsUnified = substitutions.everySubstitution((substitution) => {
@@ -139,7 +141,7 @@ class Frame {
     metaLemmaMetatheoremUnified = substitutionsUnified; ///
 
     if (metaLemmaMetatheoremUnified) {
-      context.debug(`...unified the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem.`);
+      context.debug(`...unified the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${frameString}' frame.`);
     }
 
     return metaLemmaMetatheoremUnified;
@@ -148,9 +150,10 @@ class Frame {
   unifyAxiomLemmaTheoremOrConjecture(axiomLemmaTheoremOrConjecture, context) {
     let axiomLemmaTheoremOrConjectureUnified;
 
-    const axiomLemmaTheoremStringOrConjecture = axiomLemmaTheoremOrConjecture.getString();
+    const frameString = this.string,  ///
+          axiomLemmaTheoremStringOrConjecture = axiomLemmaTheoremOrConjecture.getString();
 
-    context.trace(`Unifying the '${axiomLemmaTheoremStringOrConjecture}' axiom, lemma, theorem or conjecture...`);
+    context.trace(`Unifying the '${axiomLemmaTheoremStringOrConjecture}' axiom, lemma, theorem or conjecture with the '${frameString}' frame...`);
 
     const substitutions = axiomLemmaTheoremOrConjecture.getSubstitutions(),
           substitutionsUnified = substitutions.everySubstitution((substitution) => {
@@ -164,7 +167,7 @@ class Frame {
     axiomLemmaTheoremOrConjectureUnified = substitutionsUnified; ///
 
     if (axiomLemmaTheoremOrConjectureUnified) {
-      context.debug(`...unified the '${axiomLemmaTheoremStringOrConjecture}' axiom, lemma, theorem or conjecture.`);
+      context.debug(`...unified the '${axiomLemmaTheoremStringOrConjecture}' axiom, lemma, theorem or conjecture with the '${frameString}' frame.`);
     }
 
     return axiomLemmaTheoremOrConjectureUnified;
@@ -177,11 +180,7 @@ class Frame {
 
     context.trace(`Verifying the '${frameString}' frame...`);
 
-    const declarationsVerified = this.declarations.every((declaration) => {
-      const declarationVerified = declaration.verify(assignments, stated, context);
-
-      return declarationVerified;
-    });
+    const declarationsVerified = this.verifyDeclarations(this.declarations, assignments, stated, context);
 
     if (declarationsVerified) {
       const  metavariablesVerified = this.metavariables.every((metavariable) => {
@@ -213,6 +212,22 @@ class Frame {
     return verified;
   }
 
+  verifyDeclarations(declarations, assignments, stated, context) {
+    stated = true;  ///
+
+    assignments = null; ///
+
+    const frame = null; ///
+
+    const declarationsVerified = declarations.every((declaration) => {
+      const declarationVerified = declaration.verify(frame, assignments, stated, context);
+
+      return declarationVerified;
+    });
+
+    return declarationsVerified;
+  }
+
   verifyWhenStated(assignments, context) {
     let verifiedWhenStated = false;
 

package/src/judgement.js

@@ -32,7 +32,7 @@ class Judgement {
   matchMetavariableNode(metavariableNode) { return this.frame.matchMetavariableNode(metavariableNode); }
 
   verify(assignments, stated, context) {
-    let verified;
+    let verified = false;
 
     const judgementString = this.string;  ///
 
@@ -41,7 +41,7 @@ class Judgement {
     const frameVerified = this.frame.verify(assignments, stated, context);
 
     if (frameVerified) {
-      const declarationVerified = this.declaration.verify(assignments, stated, context);
+      const declarationVerified = this.declaration.verify(this.frame, assignments, stated, context);
 
       if (declarationVerified) {
         let verifiedWhenStated = false,
@@ -50,12 +50,10 @@ class Judgement {
         if (stated) {
           verifiedWhenStated = this.verifyWhenStated(assignments, context);
         } else {
-          verifiedWhenDerived = this.verifyWhenDerived(assignments, context);
+          verifiedWhenDerived = this.verifyWhenDerived(context);
         }
 
-        if (verifiedWhenStated || verifiedWhenDerived) {
-          verified = true;
-        }
+        verified = (verifiedWhenStated || verifiedWhenDerived);
       }
     }
 
@@ -90,40 +88,14 @@ class Judgement {
     return verifiedWhenStated;
   }
 
-  verifyWhenDerived(assignments, context) {
-    let verifiedWhenDerived = false;
+  verifyWhenDerived(context) {
+    let verifiedWhenDerived ;
 
     const judgementString = this.string;  ///
 
     context.trace(`Verifying the '${judgementString}' judgement when derived...`);
 
-    if (!verifiedWhenDerived) {
-      const reference = this.declaration.getReference(),
-            metaLemma = context.findMetaLemmaByReference(reference),
-            metatheorem = context.findMetatheoremByReference(reference),
-            metaLemmaMetatheorem = (metaLemma || metatheorem);  ///
-
-      if (metaLemmaMetatheorem !== null) {
-        const metaLemmaMetatheoremUnified = this.frame.unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem, context);
-
-        verifiedWhenDerived = metaLemmaMetatheoremUnified; ///
-      }
-    }
-
-    if (!verifiedWhenDerived) {
-      const reference = this.declaration.getReference(),
-            axiom = context.findAxiomByReference(reference),
-            lemma = context.findLemmaByReference(reference),
-            theorem = context.findTheoremByReference(reference),
-            conjecture = context.findConjectureByReference(reference),
-            axiomLemmaTheoremOrConjecture = (axiom || lemma || theorem || conjecture);
-
-      if (axiomLemmaTheoremOrConjecture !== null) {
-        const axiomLemmaTheoremOrConjectureUnified = this.frame.unifyAxiomLemmaTheoremOrConjecture(axiomLemmaTheoremOrConjecture, context);
-
-        verifiedWhenDerived = axiomLemmaTheoremOrConjectureUnified; ///
-      }
-    }
+    verifiedWhenDerived = true;
 
     if (verifiedWhenDerived) {
       context.debug(`...verified the '${judgementString}' judgement when derived.`);

package/src/label.js

@@ -2,7 +2,7 @@
 
 import shim from "./shim";
 import LocalContext from "./context/local";
-import intrinsicLevelUnifier from "./unifier/intrinsicLevel";
+import labelUnifier from "./unifier/label";
 
 import { nodeQuery } from "./utilities/query";
 import { metavariableFromJSON, metavariableToMetavariableJSON } from "./utilities/json";
@@ -20,20 +20,9 @@ class Label {
 
   getString() { return this.metavariable.getString(); }
 
-  matchMetavariableNode(metavariableNode) { return this.metavariable.matchMetavariableNode(metavariableNode); }
+  matchMetavariableName(metavariableName) { return this.metavariable.matchMetavariableName(metavariableName); }
 
-  unifyReference(reference, generalContext, specificContext) {
-    const { Substitutions } = shim,
-          metavariableNode = this.metavariable.getNode(),
-          referenceMetavariable = reference.getMetavariable(),
-          referenceMetavariableNode = referenceMetavariable.getNode(),
-          metavariableNodeA = referenceMetavariableNode,  ///
-          metavariableNodeB = metavariableNode, ///
-          substitutions = Substitutions.fromNothing(),
-          metavariableUnified = intrinsicLevelUnifier.unify(metavariableNodeA, metavariableNodeB, substitutions, generalContext, specificContext);
-
-    return metavariableUnified;
-  }
+  matchMetavariableNode(metavariableNode) { return this.metavariable.matchMetavariableNode(metavariableNode); }
 
   verifyWhenDeclared(fileContext) {
     let verifiedAtTopLevel = false;

package/src/lemma.js

@@ -9,8 +9,9 @@ class Lemma extends TopLevelAssertion {
   verify() {
     let verified;
 
-    const fileContext = this.getFileContext(),
-          lemmaString = this.string;  ///
+    const lemma = this, ///
+          fileContext = this.getFileContext(),
+          lemmaString = lemma.getString();
 
     (lemmaString === EMPTY_STRING) ?
       fileContext.trace(`Verifying a lemma...`) :