occam-verify-cli 0.0.1036 → 0.0.1038

package/src/context/release.js

@@ -15,7 +15,7 @@ const { isFilePathNominalFilePath } = filePathUtilities,
       { nominalParserFromCombinedCustomGrammar } = parsersUtilities;
 
 export default class ReleaseContext {
-  constructor(log, name, json, entries, lexer, parser, verified, initialised, fileContexts, customGrammar, verifiedFileContexts, dependencyReleaseContexts) {
+  constructor(log, name, json, entries, lexer, parser, verified, initialised, fileContexts, customGrammar, dependencyReleaseContexts) {
     this.log = log;
     this.name = name;
     this.json = json;
@@ -26,7 +26,6 @@ export default class ReleaseContext {
     this.initialised = initialised;
     this.fileContexts = fileContexts;
     this.customGrammar = customGrammar;
-    this.verifiedFileContexts = verifiedFileContexts;
     this.dependencyReleaseContexts = dependencyReleaseContexts;
   }
 
@@ -70,52 +69,20 @@ export default class ReleaseContext {
     return this.customGrammar;
   }
 
-  getVerifiedFileContexts() {
-    return this.verifiedFileContexts;
-  }
-
   getDependencyReleaseContexts() {
     return this.dependencyReleaseContexts;
   }
 
-  setLog(log) {
-    this.log = log;
-  }
-
-  setName(name) {
-    this.name = name;
-  }
-
-  setEntries(entries) {
-    this.entries = entries;
-  }
-
-  setLexer(lexer) {
-    this.lexer = lexer;
-  }
-
-  setParser(parser) {
-    this.parser = parser;
-  }
-
-  setVerified(verified) {
-    this.verified = verified;
-  }
-
-  setInitialised(initialised) {
-    return this.initialised = initialised;
-  }
+  isReleased() {
+    const released = (this.json !== null);
 
-  setFileContexts(fileContexts) {
-    this.fileContexts = fileContexts;
+    return released;
   }
 
-  setCustomGrammar(customGrammar) {
-    this.customGrammar = customGrammar;
-  }
+  findFile(filePath) {
+    const file = this.entries.getFile(filePath);
 
-  setDependencyReleaseContexts(dependencyReleaseContexts) {
-    this.dependencyReleaseContexts = dependencyReleaseContexts;
+    return file;
   }
 
   findFileContext(filePath) {
@@ -130,12 +97,6 @@ export default class ReleaseContext {
     return fileContext;
   }
 
-  isReleased() {
-    const released = (this.json !== null);
-
-    return released;
-  }
-
   getLabels(includeDependencies = true) {
     const labels = [];
 
@@ -438,9 +399,11 @@ export default class ReleaseContext {
 
     this.parser = nominalParser; ///
 
+    clear(this.fileContexts);
+
     released ?
-       fileContextsFromJSONAndReleaseContext(this.json, this.fileContexts, releaseContext) :
-         fileContextsFromEntriesAndReleaseContext(this.entries, this.fileContexts, releaseContext);
+      fileContextsFromJSONAndEntries(this.json, this.entries, this.fileContexts, releaseContext) :
+        fileContextsFromEntries(this.entries, this.fileContexts, releaseContext);
 
     this.initialised = true;
   }
@@ -448,11 +411,12 @@ export default class ReleaseContext {
   verify() {
     let verified = false;
 
-    clear(this.verifiedFileContexts);
-
-    const fileContextsVerified = verifyFileContexts(this.fileContexts, this.verifiedFileContexts);
+    const verifiedFileContexts = [],
+          fileContextsVerified = verifyFileContexts(this.fileContexts, verifiedFileContexts);
 
     if (fileContextsVerified) {
+      this.fileContexts = verifiedFileContexts; ///
+
       this.verified = true;
 
       verified = true;
@@ -462,12 +426,12 @@ export default class ReleaseContext {
   }
 
   toJSON() {
-    const verifiedFileContextsJSON = this.verifiedFileContexts.map((verifiedFileContext) => {
-            const verifiedFileContextJSON = verifiedFileContext.toJSON();
+    const fileContextsJSON = this.fileContexts.map((fileContext) => {
+            const fileContextJSON = fileContext.toJSON();
 
-            return verifiedFileContextJSON;
+            return fileContextJSON;
           }),
-          json = verifiedFileContextsJSON;  ///
+          json = fileContextsJSON;  ///
 
     return json;
   }
@@ -479,20 +443,20 @@ export default class ReleaseContext {
           initialised = false,
           fileContexts = [],
           customGrammar = customGrammarFromNameAndEntries(name, entries),
-          verifiedFileContexts = [],
           dependencyReleaseContexts = null,
-          releaseContext = new ReleaseContext(log, name, json, entries, lexer, parser, verified, initialised, fileContexts, customGrammar, verifiedFileContexts, dependencyReleaseContexts);
+          releaseContext = new ReleaseContext(log, name, json, entries, lexer, parser, verified, initialised, fileContexts, customGrammar, dependencyReleaseContexts);
 
     return releaseContext;
   }
 }
 
-function fileContextsFromJSONAndReleaseContext(json, fileContexts, releaseContext) {
+function fileContextsFromJSONAndEntries(json, entries, fileContexts, releaseContext) {
   const fileContextsJSON = json;  ///
 
   fileContextsJSON.forEach((fileContextJSON) => {
-    const json = fileContextJSON,
-          fileContext = FileContext.fromJSONAndReleaseContext(json, releaseContext);
+    const { filePath } = fileContextJSON,
+          file = entries.getFile(filePath),
+          fileContext = FileContext.fromFile(file, releaseContext);
 
     fileContext.initialise(fileContextJSON);
 
@@ -500,19 +464,17 @@ function fileContextsFromJSONAndReleaseContext(json, fileContexts, releaseContex
   });
 }
 
-function fileContextsFromEntriesAndReleaseContext(entries, fileContexts, releaseContext) {
+function fileContextsFromEntries(entries, fileContexts, releaseContext) {
   entries.forEachFile((file) => {
     const filePath = file.getPath(),
           filePathNominalFilePath = isFilePathNominalFilePath(filePath);
 
     if (filePathNominalFilePath) {
-      const fileContext = FileContext.fromFileAndReleaseContext(file, releaseContext);
+      const fileContext = FileContext.fromFile(file, releaseContext);
 
       fileContexts.push(fileContext);
     }
   });
-
-  return fileContexts;
 }
 
 function verifyFileContexts(fileContexts, verifiedFileContexts) {
@@ -562,7 +524,7 @@ function verifyFileContext(fileContext) {
 
   if (tokens === null) {
     const filePath = fileContext.getFilePath(),
-          file = fileContext.getFile(filePath),
+          file = fileContext.findFile(filePath),
           lexer = fileContext.getLexer(),
           parser = fileContext.getParser(),
           content = file.getContent(),

package/src/equality.js

@@ -121,14 +121,14 @@ export default class Equality {
 
     const equalityString = this.string; ///
 
-    localContext.trace(`Verifying the stated '${equalityString}' equality...`);
+    localContext.trace(`Verifying the '${equalityString}' stated equality...`);
 
     const termsVerified = this.verifyTerms(localContext);
 
     verifiedWhenStated = termsVerified; ///
 
     if (verifiedWhenStated) {
-      localContext.debug(`...verified the stated '${equalityString}' equality.`);
+      localContext.debug(`...verified the '${equalityString}' stated equality.`);
     }
 
     return verifiedWhenStated;
@@ -139,7 +139,7 @@ export default class Equality {
 
     const equalityString = this.string; ///
 
-    localContext.trace(`Verifying the derived '${equalityString}' equality...`);
+    localContext.trace(`Verifying the '${equalityString}' derived equality...`);
 
     const termsVerified = this.verifyTerms(localContext);
 
@@ -150,7 +150,7 @@ export default class Equality {
     }
 
     if (verifiedWhenDerived) {
-      localContext.debug(`...verified the derived '${equalityString}' equality.`);
+      localContext.debug(`...verified the '${equalityString}' derived equality.`);
     }
 
     return verifiedWhenDerived;

package/src/metavariable.js

@@ -3,6 +3,7 @@
 import shim from "./shim";
 import Argument from "./argument";
 import LocalContext from "./context/local";
+import StatementForMetavariableSubstitution from "./substitution/statementForMetavariable";
 
 import { nodeQuery } from "./utilities/query";
 import { metavariableNameFromMetavariableNode } from "./utilities/name";
@@ -10,16 +11,22 @@ import { metavariableNodeFromMetavariableString } from "./utilities/node";
 
 const argumentNodeQuery = nodeQuery("/metavariable/argument"),
       metaTypeNodeQuery = nodeQuery("/metavariableDeclaration/metaType"),
-      metavariableNodeQuery = nodeQuery("/metavariableDeclaration/metavariable");
+      metavariableNodeQuery = nodeQuery("/metavariableDeclaration/metavariable"),
+      statementMetavariableNodeQuery = nodeQuery("/statement/metavariable");
 
 export default class Metavariable {
-  constructor(string, node, name, metaType) {
+  constructor(fileContext, string, node, name, metaType) {
+    this.fileContext = fileContext;
     this.string = string;
     this.node = node;
     this.name = name;
     this.metaType = metaType;
   }
 
+  getFileContext() {
+    return this.fileContext;
+  }
+
   getString() {
     return this.string;
   }
@@ -105,6 +112,94 @@ export default class Metavariable {
     return verifiedAtTopLevel;
   }
 
+  unifyStatement(statement, substitutions, localContext) {
+    let statementUnified = false;
+
+    const statementString = statement.getString(),
+          metavariableString = this.string;
+
+    localContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}' metavariable...`);
+
+    const statementNode = statement.getNode(),
+          metavariableNode = this.node, ///
+          simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariableNode(metavariableNode),
+          substitution = simpleSubstitution;  ///
+
+    if (substitution !== null) {
+      const statementNodeMatches = substitution.matchStatementNode(statementNode);
+
+      if (statementNodeMatches) {
+        statementUnified = true;
+      }
+    } else {
+      const metavariable = this, ///
+            statementMetavariable = statementMetavariableFromStatementNode(statementNode, localContext);
+
+      if (metavariable === statementMetavariable) {
+        statementUnified = true;
+      } else {
+        const statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementAndMetavariable(statement, metavariable, localContext),
+              substitution = statementForMetavariableSubstitution;  ///
+
+        substitutions.addSubstitution(substitution, localContext);
+
+        statementUnified = true;
+      }
+    }
+
+    if (statementUnified) {
+      localContext.debug(`...unified the '${statementString}' statement with the '${metavariableString}' metavariable.`);
+    }
+
+    return statementUnified;
+  }
+
+  unifyStatementGivenSubstitution(statement, substitution, substitutions, localContext) {
+    let statementUnifiedGivenSubstitution = false;
+
+    const statementString = statement.getString(),
+          substitutionString = substitution.getString(),
+          metavariableString = this.string;
+
+    localContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}' metavariable givne the '${substitutionString}' substitution...`);
+
+    // let metavariableUnifiedWithStatementGivenSubstitution = false;
+    //
+    // const metavariableNode = metavariable.getNode(),
+    //   substitutionNode = substitution.getNode(),
+    //   complexSubstitution = substitutions.findComplexSubstitutionByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode);
+    //
+    // if (complexSubstitution !== null) {
+    //   const statementNode = statement.getNode(),
+    //     statementNodeMatches = complexSubstitution.matchStatementNode(statementNode);
+    //
+    //   if (statementNodeMatches) {
+    //     metavariableUnifiedWithStatementGivenSubstitution = true;
+    //   }
+    // } else {
+    //   const metavariableNameA = metavariableNameFromMetavariableNode(metavariableNode),
+    //     metavariableA = localContextA.findMetavariableByMetavariableName(metavariableNameA),
+    //     metavariableB = metavariableFromStatementNode(statement, localContextB);
+    //
+    //   if (metavariableA === metavariableB) {
+    //     metavariableUnifiedWithStatementGivenSubstitution = false;  ///
+    //   } else {
+    //     const statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContextA, localContextB),
+    //       substitution = statementForMetavariableSubstitution;  ///
+    //
+    //     substitutions.addSubstitution(substitution, localContextA, localContextB);
+    //
+    //     metavariableUnifiedWithStatementGivenSubstitution = true;
+    //   }
+    // }
+
+    if (statementUnifiedGivenSubstitution) {
+      localContext.trace(`...unified the '${statementString}' statement with the '${metavariableString}' metavariable givne the '${substitutionString}' substitution.`);
+    }
+
+    return statementUnifiedGivenSubstitution;
+  }
+
   toJSON() {
     const metaTypeJSON = (this.metaType !== null) ?
                             this.metaType.toJSON() :
@@ -129,7 +224,7 @@ export default class Metavariable {
           node = metavariableNode,  ///
           name = metavariableName,  ///
           metaType = metaTypeFromJSON(json, fileContext),
-          metavariable = new Metavariable(string, node, name, metaType);
+          metavariable = new Metavariable(fileContext, string, node, name, metaType);
 
     return metavariable;
   }
@@ -140,7 +235,7 @@ export default class Metavariable {
           name = metavariableName,  ///
           string = fileContext.nodeAsString(node),
           metaType = null,
-          metavariable = new Metavariable(string, node, name, metaType);
+          metavariable = new Metavariable(fileContext, string, node, name, metaType);
 
     return metavariable;
   }
@@ -156,7 +251,7 @@ export default class Metavariable {
           node = metavariableNode,  ///
           name = metavariableName,  ///
           metaType = MetaType.fromMetaTypeNode(metaTypeNode, localContext),
-          metavariable = new Metavariable(string, node, name, metaType);
+          metavariable = new Metavariable(fileContext, string, node, name, metaType);
 
     return metavariable;
   }
@@ -173,4 +268,18 @@ function metaTypeFromJSON(json, fileContext) {
   }
 
   return metaType;
-}
+}
+
+function statementMetavariableFromStatementNode(statementNode, localContext) {
+  let statementMetavariable = null;
+
+  const statementMetavariableNode = statementMetavariableNodeQuery(statementNode);
+
+  if (statementMetavariableNode !== null) {
+    const statementMetavariableName = metavariableNameFromMetavariableNode(statementMetavariableNode);
+
+    statementMetavariable = localContext.findMetavariableByMetavariableName(statementMetavariableName);
+  }
+
+  return statementMetavariable;
+}

package/src/mixins/statement/verify.js

@@ -8,11 +8,11 @@ import verifyJudgement from "../../verify/judgement";
 import verifyDeclaration from "../../verify/declaration";
 import metavariableUnifier from "../../unifier/metavariable";
 import verifyDefinedAssertion from "../../verify/assertion/defined";
-import verifySubproofAssertion from "../../verify/assertion/subproof";
 import verifyContainedAssertion from "../../verify/assertion/contained";
 
 import { nodeQuery } from "../../utilities/query";
 import { metavariableNameFromMetavariableNode } from "../../utilities/name";
+import SubproofAssertion from "../../assertion/subproof";
 
 const frameNodeQuery = nodeQuery("/statement/frame!"),
       equalityNodeQuery = nodeQuery("/statement/equality!"),
@@ -198,7 +198,8 @@ function verifyAsSubproofAssertion(statement, assignments, stated, localContext)
 
     localContext.trace(`Verifying the '${statementString}' statement as a subproof assertion...`);
 
-    const subproofAssertionVerified = verifySubproofAssertion(subproofAssertionNode, assignments, stated, localContext);
+    const subproofAssertion = SubproofAssertion.fromSubproofAssertionNode(subproofAssertionNode, localContext),
+          subproofAssertionVerified = subproofAssertion.verify(assignments, stated, localContext);
 
     verifiedAsSubproofAssertion = subproofAssertionVerified; ///
 

package/src/premise.js

@@ -12,9 +12,8 @@ import { assignAssignments } from "./utilities/assignments";
 const unqualifiedStatementNodeQuery = nodeQuery("/premise/unqualifiedStatement");
 
 export default class Premise {
-  constructor(fileContext, subproofAssertion, unqualifiedStatement) {
+  constructor(fileContext, unqualifiedStatement) {
     this.fileContext = fileContext;
-    this.subproofAssertion = subproofAssertion;
     this.unqualifiedStatement = unqualifiedStatement;
   }
 
@@ -22,10 +21,6 @@ export default class Premise {
     return this.fileContext;
   }
 
-  getSubproofAssertion() {
-    return this.subproofAssertion;
-  }
-
   getUnqualifiedStatement() {
     return this.unqualifiedStatement;
   }
@@ -34,6 +29,30 @@ export default class Premise {
 
   getStatement() { return this.unqualifiedStatement.getStatement(); }
 
+  unifySubproof(subproof, substitutions, localContext) {
+    let subproofUnified = false;
+
+    const premise = this, ///
+          subproofString = subproof.getString(),
+          premiseStatement = premise.getStatement(),
+          premiseStatementString = premiseStatement.getString();
+
+    localContext.trace(`Unifying the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement...`);
+
+    const statement = this.unqualifiedStatement.getStatement(),
+          subproofAssertion = SubproofAssertion.fromStatement(statement, this.fileContext);
+
+    if (subproofAssertion !== null) {
+      subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, this.fileContext, localContext);
+    }
+
+    if (subproofUnified) {
+      localContext.debug(`...unified the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement.`);
+    }
+
+    return subproofUnified;
+  }
+
   unifyProofStep(proofStep, substitutions, localContext) {
     let proofStepUnified = false;
 
@@ -85,27 +104,6 @@ export default class Premise {
     return statementUnified;
   }
 
-  unifySubproof(subproof, substitutions, localContext) {
-    let subproofUnified = false;
-
-    const premise = this, ///
-          subproofString = subproof.getString(),
-          premiseStatement = premise.getStatement(),
-          premiseStatementString = premiseStatement.getString();
-
-    localContext.trace(`Unifying the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement...`);
-
-    if (this.subproofAssertion !== null) {
-      subproofUnified = this.subproofAssertion.unifySubproof(subproof, substitutions, localContext);
-    }
-
-    if (subproofUnified) {
-      localContext.debug(`...unified the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement.`);
-    }
-
-    return subproofUnified;
-  }
-
   verify(localContext) {
     let verified = false;
 
@@ -143,42 +141,30 @@ export default class Premise {
 
   toJSON() {
     const unqualifiedStatementJSON = this.unqualifiedStatement.toJSON(),
-      subproofAssertionJSON = (this.subproofAssertion !== null) ?
-        this.subproofAssertion.toJSON() :
-        null,
-      unqualifiedStatement = unqualifiedStatementJSON,  ///
-      subproofAssertion = subproofAssertionJSON,  ///
-      json = {
-        unqualifiedStatement,
-        subproofAssertion
-      };
+          unqualifiedStatement = unqualifiedStatementJSON,  ///
+          json = {
+            unqualifiedStatement
+          };
 
     return json;
   }
 
   static fromJSON(json, fileContext) {
-    let { subproofAssertion, unqualifiedStatement } = json;
+    let { unqualifiedStatement } = json;
 
     json = unqualifiedStatement;  ///
 
     unqualifiedStatement = UnqualifiedStatement.fromJSON(json, fileContext);
 
-    json = subproofAssertion; ///
-
-    subproofAssertion = (json !== null) ?
-                          SubproofAssertion.fromJSON(json, fileContext) :
-                            null;
-
-    const premise = new Premise(fileContext, subproofAssertion, unqualifiedStatement);
+    const premise = new Premise(fileContext, unqualifiedStatement);
 
     return premise;
   }
 
-  static fromSuppositionNode(suppositionNode, fileContext) {
+  static fromPremiseNode(suppositionNode, fileContext) {
     const unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
           unqualifiedStatement = UnqualifiedStatement.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
-          subproofAssertion = SubproofAssertion.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
-          premise = new Premise(fileContext, subproofAssertion, unqualifiedStatement);
+          premise = new Premise(fileContext, unqualifiedStatement);
 
     return premise
   }

package/src/ruleNames.js

@@ -2,5 +2,6 @@
 
 export const VARIABLE_RULE_NAME = "variable";
 export const METAVARIABLE_RULE_NAME = "metavariable";
+export const SUBSTITUTION_RULE_NAME = "substitution";
 export const UNQUALIFIED_STATEMENT_RULE_NAME = "unqualifiedStatement";
 export const CONSTRUCTOR_DECLARATION_RULE_NAME = "constructorDeclaration";

package/src/statement.js

@@ -3,15 +3,17 @@
 import shim from "./shim";
 import unifyMixins from "./mixins/statement/unify";
 import verifyMixins from "./mixins/statement/verify";
+import StatementSubstitution from "./substitution/statement";
 import statementAsCombinatorVerifier from "./verifier/statementAsCombinator";
 
 import { STATEMENT_META_TYPE_NAME } from "./metaTypeNames";
 import { statementNodeFromStatementString } from "./utilities/node";
 
 class Statement {
-  constructor(string, node) {
+  constructor(string, node, substitution) {
     this.string = string;
     this.node = node;
+    this.substitution = substitution;
   }
 
   getString() {
@@ -22,6 +24,10 @@ class Statement {
     return this.node;
   }
 
+  getSubstitution() {
+    return this.substitution;
+  }
+
   isEqualTo(statement) {
     const node = statement.getNode(),
           matches = this.node.match(node),
@@ -122,8 +128,17 @@ class Statement {
           lexer = fileContext.getLexer(),
           parser = fileContext.getParser(),
           statementNode = statementNodeFromStatementString(statementString, lexer, parser),
-          node = statementNode,  ///
-          statement = new Statement(string, node);
+          node = statementNode;  ///
+
+    let { substitution } = json;
+
+    json = substitution;  ///
+
+    const statementSubstitution = StatementSubstitution.fromJSON(json, fileContext);
+
+    substitution = statementSubstitution; ///
+
+    const statement = new Statement(string, node, substitution);
 
     return statement;
   }
@@ -131,7 +146,9 @@ class Statement {
   static fromStatementNode(statementNode, localContext) {
     const node = statementNode, ///
           string = localContext.nodeAsString(node),
-          statement = new Statement(string, node);
+          statementSubstitution = StatementSubstitution.fromStatementNode(statementNode, localContext),
+          substitution = statementSubstitution, ///
+          statement = new Statement(string, node, substitution);
 
     return statement;
   }

package/src/substitution/frameForMetavariable.js

@@ -69,10 +69,11 @@ export default class FrameForMetavariableSubstitution extends Substitution {
     return metavariableNodeMatches;
   }
 
-  static fromSubstitutionNode(substitutionNode, localContextA, localContextB) {
+  static fromSubstitution(substitution, localContextA, localContextB) {
     let frameForMetavariableSubstitution = null;
 
-    const substitutionFrameNode = substitutionFrameNodeQuery(substitutionNode);
+    const substitutionNode = substitution.getNode(),
+          substitutionFrameNode = substitutionFrameNodeQuery(substitutionNode);
 
     if (substitutionFrameNode !== null) {
       const substitutionMetavariableNode = substitutionMetavariableNodeQuery(substitutionNode),