occam-verify-cli 0.0.1074 → 0.0.1075

package/src/context/file.js

@@ -2,6 +2,8 @@
 
 import { arrayUtilities } from "necessary";
 
+import metavariableUnifier from "../unifier/metavariable";
+
 import { objectType } from "../type";
 import { frameMetaType, referenceMetaType, statementMetaType } from "../metaType";
 import { nodeAsTokens, nodeAsString, nodesAsString, tokensAsString } from "../utilities/string";
@@ -302,6 +304,16 @@ export default class FileContext {
     return this.metavariables;
   }
 
+  getMetavariableNames(includeRelease = true) {
+    const metavariableNames = this.metavariables.map((metavariable) => {
+      const metavariableName = metavariable.getName();
+
+      return metavariableName;
+    });
+
+    return metavariableNames;
+  }
+
   setReleaseContext(releaseContext) {
     this.releaseContext = releaseContext;
   }
@@ -314,58 +326,6 @@ export default class FileContext {
     this.tokens = tokens;
   }
 
-  setNode(node) {
-    this.node = node;
-  }
-
-  setTypes(types) {
-    this.types = types;
-  }
-
-  setRules(rules) {
-    this.rules = rules;
-  }
-
-  setAxioms(axioms) {
-    this.axioms = axioms;
-  }
-
-  setLemmas(lemmas) {
-    this.lemmas = lemmas;
-  }
-
-  setTheorems(theorems) {
-    this.theorems = theorems;
-  }
-
-  setVariables(variables) {
-    this.variables = variables;
-  }
-
-  setMetaLemmas(metaLemmas) {
-    this.metaLemmas = metaLemmas;
-  }
-
-  setConjectures(conjectures) {
-    this.conjectures = conjectures;
-  }
-
-  setCombinators(combinators) {
-    this.combinators = combinators;
-  }
-
-  setConstructors(constructors) {
-    this.constructors = constructors;
-  }
-
-  setMetatheorems(metatheorems) {
-    this.metatheorems = metatheorems;
-  }
-
-  setMetavariables(metavariables) {
-    this.metavariables = metavariables;
-  }
-
   findTypeByTypeName(typeName) {
     let types = this.getTypes();
 
@@ -436,6 +396,13 @@ export default class FileContext {
     return metavariablePresent;
   }
 
+  isMetavariablePresentByMetavariableNode(metavariableNode, localContext) {
+    const metavariable = this.findMetavariableByMetavariableNode(metavariableNode, localContext),
+          metavariablePresent = (metavariable !== null);
+
+    return metavariablePresent;
+  }
+
   findRuleByReference(reference) {
     const rules = this.getRules(),
           metavariableNode = reference.getMetavariableNode(),
@@ -537,9 +504,9 @@ export default class FileContext {
   findVariableByVariableName(variableName) {
     const variables = this.getVariables(),
           variable = variables.find((variable) => {
-            const nameMatches = variable.matchVariableName(variableName);
+            const variableNameMatches = variable.matchVariableName(variableName);
 
-            if (nameMatches) {
+            if (variableNameMatches) {
               return true;
             }
           }) || null;
@@ -547,12 +514,12 @@ export default class FileContext {
     return variable;
   }
 
-  findJudgementByMetavariableName(metavariableName) {
+  findJudgementByMetavariableNode(metavariableNode) {
     const judgements = this.getJudgements(),
           judgement = judgements.find((judgement) => {
-            const judgementMatchesMetavariableName = judgement.matchMetavariableName(metavariableName);
+            const judgementMatchesMetavariableNode = judgement.matchMetavariableNode(metavariableNode);
 
-            if (judgementMatchesMetavariableName) {
+            if (judgementMatchesMetavariableNode) {
               return true;
             }
           }) || null;
@@ -561,11 +528,28 @@ export default class FileContext {
   }
 
   findMetavariableByMetavariableName(metavariableName) {
-    const metavariables = this.getMetavariables(),
+    const metavariableNameB = metavariableName, ///
+          metavariableNames = this.getMetavariableNames(),
+          metavariable = metavariableNames.find((metavariableName) => {
+            const metavariableNameA = metavariableName; ///
+
+            if (metavariableNameA === metavariableNameB) {
+              return true;
+            }
+          }) || null;
+
+    return metavariable;
+  }
+
+  findMetavariableByMetavariableNode(metavariableNode, localContext) {
+    const metavariableNodeB = metavariableNode, ///
+          metavariables = this.getMetavariables(),
           metavariable = metavariables.find((metavariable) => {
-            const nameMatches = metavariable.matchMetavariableName(metavariableName);
+            const metavariableA = metavariable, ///
+                  metavariableNodeA = metavariableA.getNode(), ///
+                  metavariableUnified = metavariableUnifier.unify(metavariableNodeA, metavariableNodeB, localContext);
 
-            if (nameMatches) {
+            if (metavariableUnified) {
               return true;
             }
           }) || null;
@@ -636,18 +620,7 @@ export default class FileContext {
   }
 
   addVariable(variable) {
-    let variableAdded = false;
-
-    const variableName = variable.getName(),
-          variablePresent = this.isVariablePresentByVariableName(variableName);
-
-    if (!variablePresent) {
-      this.variables.push(variable);
-
-      variableAdded = true;
-    }
-
-    return variableAdded;
+    this.variables.push(variable);
   }
 
   addMetaLemma(metaLemma) {
@@ -671,18 +644,7 @@ export default class FileContext {
   }
 
   addMetavariable(metavariable) {
-    let metavariableAdded = false;
-
-    const metavariableName = metavariable.getName(),
-          metavariablePresent = this.isMetavariablePresentByMetavariableName(metavariableName);
-
-    if (!metavariablePresent) {
-      this.metavariables.push(metavariable);
-
-      metavariableAdded = true;
-    }
-
-    return metavariableAdded;
+    this.metavariables.push(metavariable);
   }
 
   trace(message) { this.releaseContext.trace(message, this.filePath); }

package/src/context/local.js

@@ -160,11 +160,10 @@ class LocalContext {
     return equalityAdded;
   }
 
-  addVariable(variable) {
+  addVariable(variable, nested = true) {
     let variableAdded = false;
 
-    const nested = false,
-          variableName = variable.getNode(),
+    const variableName = variable.getNode(),
           variablePresent = this.isVariablePresentByVariableName(variableName, nested);
 
     if (!variablePresent) {
@@ -200,9 +199,8 @@ class LocalContext {
     let judgementAdded = false;
 
     const metavariableNode = judgement.getMetavariableNode(),
-          metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-          metavariableDefinedByMetavariableName = this.isMetavariableDefinedByMetavariableName(metavariableName),
-          judgementPresent = metavariableDefinedByMetavariableName; ///
+          metavariableDefined = this.isMetavariableDefinedByMetavariableNode(metavariableNode),
+          judgementPresent = metavariableDefined; ///
 
     if (!judgementPresent) {
       this.judgements.push(judgement);
@@ -276,7 +274,7 @@ class LocalContext {
 
   isLabelPresentByMetavariableNode(metavariableNode) { return this.context.isLabelPresentByMetavariableNode(metavariableNode); }
 
-  isMetavariablePresentByMetavariableName(metavariableName) { return this.context.isMetavariablePresentByMetavariableName(metavariableName); }
+  isMetavariablePresentByMetavariableNode(metavariableNode, localContext) { return this.context.isMetavariablePresentByMetavariableNode(metavariableNode, localContext); }
 
   isVariablePresentByVariableName(variableName, nested = true) {
     const variable = this.findVariableByVariableName(variableName, nested),
@@ -285,25 +283,25 @@ class LocalContext {
     return variablePresent;
   }
 
-  isJudgementPresentByMetavariableName(metavariableName) {
-    const judgement = this.findJudgementByMetavariableName(metavariableName),
+  isJudgementPresentByMetavariableNode(metavariableNode) {
+    const judgement = this.findJudgementByMetavariableNode(metavariableNode),
           judgementPresent = (judgement !== null);
 
     return judgementPresent;
   }
 
-  isMetavariableDefinedByMetavariableName(metavariableName) {
-    const judgementPresent = this.isJudgementPresentByMetavariableName(metavariableName),
-          metavariableDefinedByMetavariableName = judgementPresent; ///
+  isMetavariableDefinedByMetavariableNode(metavariableNode) {
+    const judgementPresent = this.isJudgementPresentByMetavariableNode(metavariableNode),
+          metavariableDefined = judgementPresent; ///
 
-    return metavariableDefinedByMetavariableName
+    return metavariableDefined
   }
 
   findMetaTypeByMetaTypeName(metaTypeName) { return this.context.findMetaTypeByMetaTypeName(metaTypeName); }
 
   findLabelByMetavariableNode(metavariableNode) { return this.context.findLabelByMetavariableNode(metavariableNode); }
 
-  findMetavariableByMetavariableName(metavariableName) { return this.context.findMetavariableByMetavariableName(metavariableName); }
+  findMetavariableByMetavariableNode(metavariableNode, localContext) { return this.context.findMetavariableByMetavariableNode(metavariableNode, localContext); }
 
   findVariableByVariableName(variableName, nested = true) {
     const variables = this.getVariables(nested),
@@ -318,12 +316,12 @@ class LocalContext {
     return variable;
   }
 
-  findJudgementByMetavariableName(metavariableName) {
+  findJudgementByMetavariableNode(metavariableNode) {
     const judgements = this.getJudgements(),
           judgement = judgements.find((judgement) => {
-            const judgementMatchesMetavariableName = judgement.matchMetavariableName(metavariableName);
+            const judgementMatchesMetavariableNode = judgement.matchMetavariableNode(metavariableNode);
 
-            if (judgementMatchesMetavariableName) {
+            if (judgementMatchesMetavariableNode) {
               return true;
             }
           }) || null;

package/src/declaration/combinator.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import Combinator from "../combinator";
+import shim from "../shim";
 
 export default class CombinatorDeclaration {
   constructor(fileContext, combinator) {
@@ -25,9 +25,9 @@ export default class CombinatorDeclaration {
 
     this.fileContext.trace(`Verifying the '${combinatorDeclarationString}' combinator declaration...`);
 
-    const combinatorVerifiedAtTopLevel = this.combinator.verifyAtTopLevel(this.fileContext);
+    const combinatorVerifiedWhenDeclared = this.combinator.verifyWhenDeclared(this.fileContext);
 
-    if (combinatorVerifiedAtTopLevel) {
+    if (combinatorVerifiedWhenDeclared) {
       this.fileContext.addCombinator(this.combinator);
 
       verified = true;
@@ -41,7 +41,8 @@ export default class CombinatorDeclaration {
   }
 
   static fromCombinatorDeclarationNode(combinatorDeclarationNode, fileContext) {
-    const combinator = Combinator.fromCombinatorDeclarationNode(combinatorDeclarationNode, fileContext),
+    const { Combinator } = shim,
+          combinator = Combinator.fromCombinatorDeclarationNode(combinatorDeclarationNode, fileContext),
           combinatorDeclaration = new CombinatorDeclaration(fileContext, combinator);
 
     return combinatorDeclaration;

package/src/declaration/constructor.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import Constructor from "../constructor";
+import shim from "../shim";
 
 export default class ConstructorDeclaration {
   constructor(fileContext, constructor) {
@@ -25,9 +25,9 @@ export default class ConstructorDeclaration {
 
     this.fileContext.trace(`Verifying the '${constructorDeclarationString}' constructor declaration...`);
 
-    const constructorVerifiedAtTopLevel = this.constructor.verifyAtTopLevel(this.fileContext);
+    const constructorVerifiedWhenDeclared = this.constructor.verifyWhenDeclared(this.fileContext);
 
-    if (constructorVerifiedAtTopLevel) {
+    if (constructorVerifiedWhenDeclared) {
       this.fileContext.addConstructor(this.constructor);
 
       verified = true;
@@ -41,7 +41,8 @@ export default class ConstructorDeclaration {
   }
 
   static fromConstructorDeclarationNode(constructorDeclarationNode, fileContext) {
-    const constructor = Constructor.fromConstructorDeclarationNode(constructorDeclarationNode, fileContext),
+    const { Constructor } = shim,
+          constructor = Constructor.fromConstructorDeclarationNode(constructorDeclarationNode, fileContext),
           constructorDeclaration = new ConstructorDeclaration(fileContext, constructor);
 
     return constructorDeclaration;

package/src/declaration/metavariable.js

@@ -1,7 +1,6 @@
 "use strict";
 
 import shim from "../shim";
-import Metavariable from "../metavariable";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -33,9 +32,9 @@ export default class MetavariableDeclaration {
 
     this.fileContext.trace(`Verifying the '${metavariableDeclarationString}' metavariable declaration...`);
 
-    const metavariableVerifiedAtTopLevel = this.metavariable.verifyAtTopLevel(this.fileContext);
+    const metavariableVerifiedWhenDeclared = this.metavariable.verifyWhenDeclared(this.fileContext);
 
-    if (metavariableVerifiedAtTopLevel) {
+    if (metavariableVerifiedWhenDeclared) {
       this.fileContext.addMetavariable(this.metavariable);
 
       verified = true;
@@ -49,7 +48,7 @@ export default class MetavariableDeclaration {
   }
 
   static fromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext) {
-    const { MetaType } = shim,
+    const { MetaType, Metavariable } = shim,
           metaTypeNode = metaTypeNodeQuery(metavariableDeclarationNode),
           metaType = MetaType.fromMetaTypeNode(metaTypeNode, fileContext),
           metavariable = Metavariable.fromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext),

package/src/declaration/type.js

@@ -25,9 +25,9 @@ export default class TypeDeclaration {
 
     this.fileContext.trace(`Verifying the '${typeDeclarationString}' type declaration...`);
 
-    const typeVerifiedAtTopLevel = this.type.verifyAtTopLevel(this.fileContext);
+    const typeVerifiedWhenDeclared = this.type.verifyWhenDeclared(this.fileContext);
 
-    if (typeVerifiedAtTopLevel) {
+    if (typeVerifiedWhenDeclared) {
       this.fileContext.addType(this.type);
 
       verified = true;

package/src/declaration/variable.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import Variable from "../variable";
+import shim from "../shim";
 
 import { nodeQuery } from "../utilities/query";
 import { typeNameFromTypeNode } from "../utilities/name";
@@ -33,9 +33,9 @@ export default class VariableDeclaration {
 
     this.fileContext.trace(`Verifying the '${variableDeclarationString}' variable declaration...`);
 
-    const variableVerifiedAtTopLevel = this.variable.verifyAtTopLevel(this.fileContext);
+    const variableVerifiedWhenDeclared = this.variable.verifyWhenDeclared(this.fileContext);
 
-    if (variableVerifiedAtTopLevel) {
+    if (variableVerifiedWhenDeclared) {
       this.fileContext.addVariable(this.variable);
 
       verified = true;
@@ -49,7 +49,8 @@ export default class VariableDeclaration {
   }
 
   static fromVariableDeclarationNode(variableDeclarationNode, fileContext) {
-    const typeNode = typeNodeQuery(variableDeclarationNode),
+    const { Variable } = shim,
+          typeNode = typeNodeQuery(variableDeclarationNode),
           variable = Variable.fromVariableDeclarationNode(variableDeclarationNode, fileContext),
           string = stringFromVariableAndTypeNode(variable, typeNode),
           variableDeclaration = new VariableDeclaration(fileContext, string, variable);

package/src/declaration.js

@@ -9,7 +9,7 @@ import { stripBracketsFromStatementNode } from "./utilities/brackets";
 const referenceNodeQuery = nodeQuery("/declaration/reference"),
       statementNodeQuery = nodeQuery("/declaration/statement");
 
-export default class Declaration {
+class Declaration {
   constructor(string, reference, statement) {
     this.string = string;
     this.reference = reference;
@@ -141,3 +141,9 @@ export default class Declaration {
     return declaration;
   }
 }
+
+Object.assign(shim, {
+  Declaration
+});
+
+export default Declaration;

package/src/derivation.js

@@ -10,7 +10,7 @@ const { last } = arrayUtilities;
 
 const proofStepNodesQuery = nodesQuery("/derivation/proofStep|lastProofStep");
 
-export default class Derivation {
+class Derivation {
   constructor(proofSteps) {
     this.proofSteps = proofSteps;
   }
@@ -52,3 +52,9 @@ export default class Derivation {
     return derivation;
   }
 }
+
+Object.assign(shim, {
+  Derivation
+});
+
+export default Derivation;

package/src/equality.js

@@ -11,7 +11,7 @@ const variableNodeQuery = nodeQuery("/term/variable!"),
       leftTermNodeQuery = nodeQuery("/equality/term[0]"),
       rightTermNodeQuery = nodeQuery("/equality/term[1]");
 
-export default class Equality {
+class Equality {
   constructor(string,leftTerm, rightTerm) {
     this.string = string;
     this.leftTerm = leftTerm;
@@ -220,3 +220,9 @@ export default class Equality {
     return equality;
   }
 }
+
+Object.assign(shim, {
+  Equality
+});
+
+export default Equality;

package/src/frame.js

@@ -3,8 +3,6 @@
 import { arrayUtilities } from "necessary";
 
 import shim from "./shim";
-import Declaration from "./declaration";
-import Metavariable from "./metavariable";
 
 import { FRAME_META_TYPE_NAME } from "./metaTypeNames";
 import { nodeQuery, nodesQuery } from "./utilities/query";
@@ -76,16 +74,16 @@ class Frame {
     return frameNodeMatches;
   }
 
-  matchMetavariableName(metavariableName) {
-    let metavariableNameMatches = false;
+  matchMetavariableNode(metavariableNode) {
+    let metavariableNodeMatches = false;
 
     const metavariable = this.getMetavariable();
 
     if (metavariable !== null) {
-      metavariableNameMatches = metavariable.matchMetavariableName(metavariableName);
+      metavariableNodeMatches = metavariable.matchMetavariableNode(metavariableNode);
     }
 
-    return metavariableNameMatches;
+    return metavariableNodeMatches;
   }
 
   unifySubstitution(substitution, localContext) {
@@ -259,7 +257,8 @@ class Frame {
     let frame = null;
 
     if (frameNode !== null) {
-      const declarationNodes = declarationNodesQuery(frameNode),
+      const { Declaration, Metavariable } = shim,
+            declarationNodes = declarationNodesQuery(frameNode),
             metavariableNodes = metavariableNodesQuery(frameNode),
             declarations = declarationNodes.map((declarationNode) => {
               const declaration = Declaration.fromDeclarationNode(declarationNode, localContext);
@@ -289,7 +288,8 @@ class Frame {
       const metavariableNode = metavariableNodeQuery(frameNode);
 
       if (metavariableNode !== null) {
-        const metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
+        const { Metavariable } = shim,
+              metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
               declarations = [],
               metavariables = [
                 metavariable
@@ -313,7 +313,8 @@ class Frame {
       const metavariableNode = metavariableNodeQuery(frameNode);
 
       if (metavariableNode !== null) {
-        const metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
+        const { Metavariable } = shim,
+              metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
               declarations = [],
               metavariables = [
                 metavariable

package/src/index.js

@@ -6,20 +6,32 @@ import Rule from "./rule";
 import Label from "./label";
 import Axiom from "./axiom";
 import Lemma from "./lemma";
+import Frame from "./frame";
+import Proof from "./proof";
 import Premise from "./premise";
 import Theorem from "./theorem";
+import Equality from "./equality";
 import MetaType from "./metaType";
+import Subproof from "./subproof";
 import Variable from "./variable";
 import Statement from "./statement";
 import ProofStep from "./proofStep";
+import Judgement from "./judgement";
+import MetaLemma from "./metaLemma";
 import Consequent from "./consequent";
 import Conjecture from "./conjecture";
 import Combinator from "./combinator";
 import Conclusion from "./conclusion";
+import Derivation from "./derivation";
+import Declaration from "./declaration";
 import Constructor from "./constructor";
 import Supposition from "./supposition";
 import Metatheorem from "./metatheorem";
 import Metavariable from "./metavariable";
+import Substitution from "./substitution";
+import Substitutions from "./substitutions";
+import SubDerivation from "./subDerivation";
+import QualifiedStatement from "./statement/qualified";
 import UnqualifiedStatement from "./statement/unqualified";
 
 export { default as Log } from "./log";

package/src/judgement.js

@@ -1,7 +1,6 @@
 "use strict";
 
-import Frame from "./frame";
-import Declaration from "./declaration";
+import shim from "./shim";
 import JudgementAssignment from "./assignment/judgement";
 
 import { nodeQuery } from "./utilities/query";
@@ -9,7 +8,7 @@ import { nodeQuery } from "./utilities/query";
 const frameNodeQuery = nodeQuery("/judgement/frame"),
       declarationNodeQuery = nodeQuery("/judgement/declaration");
 
-export default class Judgement {
+class Judgement {
   constructor(string, frame, declaration) {
     this.string = string;
     this.frame = frame;
@@ -30,7 +29,7 @@ export default class Judgement {
 
   getMetavariableNode() { return this.frame.getMetavariableNode(); }
 
-  matchMetavariableName(metavariableName) { return this.frame.matchMetavariableName(metavariableName); }
+  matchMetavariableNode(metavariableNode) { return this.frame.matchMetavariableNode(metavariableNode); }
 
   verify(assignments, stated, localContext) {
     let verified;
@@ -117,7 +116,8 @@ export default class Judgement {
     let judgement = null;
 
     if (judgementNode !== null) {
-      const frameNode = frameNodeQuery(judgementNode),
+      const { Frame, Declaration } = shim,
+            frameNode = frameNodeQuery(judgementNode),
             declarationNode = declarationNodeQuery(judgementNode),
             node = judgementNode, ///
             string = localContext.nodeAsString(node),
@@ -130,3 +130,9 @@ export default class Judgement {
     return judgement;
   }
 }
+
+Object.assign(shim, {
+  Judgement
+});
+
+export default Judgement;

package/src/label.js

@@ -2,7 +2,6 @@
 
 import shim from "./shim";
 import LocalContext from "./context/local";
-import Metavariable from "./metavariable";
 
 import { nodeQuery } from "./utilities/query";
 import { metavariableFromJSON, metavariableToMetavariableJSON } from "./utilities/json";
@@ -22,12 +21,12 @@ class Label {
 
   matchMetavariableNode(metavariableNode) { return this.metavariable.matchMetavariableNode(metavariableNode); }
 
-  verifyAtTopLevel(fileContext) {
+  verifyWhenDeclared(fileContext) {
     let verifiedAtTopLevel = false;
 
     const labelString = this.getString(); ///
 
-    fileContext.trace(`Verifying the '${labelString}' label at top level...`);
+    fileContext.trace(`Verifying the '${labelString}' label when declared...`);
 
     const metavariableNode = this.metavariable.getNode(),
           labelPresent = fileContext.isLabelPresentByMetavariableNode(metavariableNode);
@@ -39,7 +38,7 @@ class Label {
     }
 
     if (verifiedAtTopLevel) {
-      fileContext.debug(`...verified the '${labelString}' label at top level.`);
+      fileContext.debug(`...verified the '${labelString}' label when declared.`);
     }
 
     return verifiedAtTopLevel;
@@ -63,7 +62,8 @@ class Label {
   }
 
   static fromLabelNode(labelNode, fileContext) {
-    const metavariableNode = metavariableNodeQuery(labelNode),
+    const { Metavariable } = shim,
+          metavariableNode = metavariableNodeQuery(labelNode),
           localContext = LocalContext.fromFileContext(fileContext),
           metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
           label = new Label(metavariable);