occam-verify-cli 0.0.1032 → 0.0.1035

package/src/assertion/subproof.js

@@ -4,10 +4,11 @@ import shim from "../shim";
 import LocalContext from "../context/local";
 import metaLevelUnifier from "../unifier/metaLevel";
 
-import { match } from "../utilities/array";
+import { front, last, match } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const statementNodesQuery = nodesQuery("/subproofAssertion/statement"),
+const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement"),
+      statementNodesQuery = nodesQuery("/subproofAssertion/statement"),
       subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion");
 
 export default class SubproofAssertion {
@@ -60,26 +61,84 @@ export default class SubproofAssertion {
     return subproofUnified;
   }
 
-  static fromStatementNode(statementNode, fileContext) {
+  toJSON() {
+    const statementStings = this.statements.map((statement) => {
+            const statementString = statement.getString();
+
+            return statementString;
+          }),
+          statements = statementStings, ///
+          json = {
+            statements
+          };
+
+    return json;
+  }
+
+  static fromJSON(json, fileContext) {
+    let { statements } = json;
+
+    const statementsJSON = statements;  ///
+
+    statements = statementsJSON.map((statementJSON) => {
+      const json = statementJSON,
+            statement = Statement.fromJSON(json, fileContext);
+
+      return statement;
+    });
+
+    const string = stringFromStatements(statements),
+          subproofAssertion = new SubproofAssertion(fileContext, string, statements);
+
+    return subproofAssertion;
+  }
+
+  static fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext) {
     let subproofAssertion = null;
 
-    const subproofAssertionNode = subproofAssertionNodeQuery(statementNode);
+    if (unqualifiedStatementNode !== null) {
+      const statementNode = statementNodeQuery(unqualifiedStatementNode),
+            subproofAssertionNode = subproofAssertionNodeQuery(statementNode);
 
-    if (subproofAssertionNode !== null) {
-      const { Statement } = shim,
-            node = subproofAssertionNode, ///
-            string = fileContext.nodeAsString(node),
-            localContext = LocalContext.fromFileContext(fileContext),
-            statementNodes = statementNodesQuery(subproofAssertionNode),
-            statements = statementNodes.map((statementNode) => {
-              const statement = Statement.fromStatementNode(statementNode, localContext);
+      if (subproofAssertionNode !== null) {
+        const { Statement } = shim,
+              localContext = LocalContext.fromFileContext(fileContext),
+              statementNodes = statementNodesQuery(subproofAssertionNode),
+              statements = statementNodes.map((statementNode) => {
+                const statement = Statement.fromStatementNode(statementNode, localContext);
 
-              return statement;
-            });
+                return statement;
+              }),
+              string = stringFromStatements(statements);
 
-      subproofAssertion = new SubproofAssertion(fileContext, string, statements);
+        subproofAssertion = new SubproofAssertion(fileContext, string, statements);
+      }
     }
 
     return subproofAssertion;
   }
+}
+
+function stringFromStatements(statements) {
+  const frontStatements = front(statements),
+        lastStatement = last(statements),
+        frontStatementsString = statementsStringtatements(frontStatements),
+        lastStatementString = lastStatement.getString(),
+        string = `[${frontStatementsString}] ... ${lastStatementString}`;
+
+  return string;
+}
+
+function statementsStringtatements(statements) {
+  const statementsString = statements.reduce((statementsString, statement) => {
+    const statementString = statement.getString();
+
+    statementsString = (statementsString !== null) ?
+                        `${statementsString}, ${statementString}` :
+                           statementString;  ///
+
+    return statementsString;
+  }, null);
+
+  return statementsString
 }

package/src/assertion/type.js

@@ -0,0 +1,176 @@
+"use strict";
+
+import shim from "../shim";
+import Variable from "../variable";
+import VariableAssignment from "../assignment/variable";
+
+import { nodeQuery } from "../utilities/query";
+import {objectType} from "../type";
+
+const termNodeQuery = nodeQuery("/typeAssertion/term"),
+      typeNodeQuery = nodeQuery("/typeAssertion/type"),
+      variableNodeQuery = nodeQuery("/term/variable");
+
+export default class TypeAssertion {
+  constructor(string, term, type, variable) {
+    this.string = string;
+    this.term = term;
+    this.type = type;
+    this.variable = variable;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getTerm() {
+    return this.term;
+  }
+
+  getType() {
+    return this.type;
+  }
+
+  getVariable() {
+    return this.variable;
+  }
+
+  verify(assignments, stated, localContext) {
+    let verified;
+
+    if (stated) {
+      const verifiedWhenStated = this.verifyWhenStated(assignments, localContext);
+
+      verified = verifiedWhenStated;  ///
+    } else {
+      const verifiedWhenDerived = this.verifyWhenDerived(localContext);
+
+      verified = verifiedWhenDerived; ///
+    }
+
+    return verified;
+  }
+
+  verifyType(localContext) {
+    let typeVerified;
+
+    if (this.type === objectType) {
+      typeVerified = true;
+    } else {
+      const typeName = this.type.getName();
+
+      localContext.trace(`Verifying the '${typeName}' type...`);
+
+      const type = localContext.findTypeByTypeName(typeName);
+
+      if (type === null) {
+        localContext.debug(`The '${typeName}' type is missing.`);
+      } else {
+        this.type = type; ///
+
+        typeVerified = true;
+      }
+
+      if (typeVerified) {
+        localContext.debug(`...verified the '${typeName}' type.`);
+      }
+    }
+
+    return typeVerified;
+  }
+
+  verifyWhenStated(assignments, localContext) {
+    let verifiedWhenStated = false;
+
+    const typeAssertionString = this.string; ///
+
+    localContext.trace(`Verifying the stated '${typeAssertionString}' type assertion...`);
+
+    const typeVerified = this.verifyType(localContext);
+
+    if (typeVerified) {
+      const termVerified = this.term.verify(localContext, () => {
+        let verifiedAhead;
+
+        const termType = this.term.getType(),
+              typeEqualToOrSuperTypeOfTermType = this.type.isEqualToOrSubTypeOf(termType);
+
+        if (typeEqualToOrSuperTypeOfTermType) {
+          if (this.variable !== null) {
+            this.variable.setType(this.type);
+
+            const variableAssignment = VariableAssignment.fromVariable(this.variable),
+                  assignment = variableAssignment;  ///
+
+            assignments.push(assignment);
+          }
+
+          verifiedAhead = true;
+        }
+
+        return verifiedAhead;
+      });
+
+      verifiedWhenStated = termVerified; ///
+    }
+
+    if (verifiedWhenStated) {
+      localContext.debug(`...verified the stated '${typeAssertionString}' type assertion.`);
+    }
+
+    return verifiedWhenStated;
+  }
+
+  verifyWhenDerived(localContext) {
+    let verifiedWhenDerived = false;
+
+    const typeAssertionString = this.string; ///
+
+    localContext.trace(`Verifying the derived '${typeAssertionString}' type assertion...`);
+
+    const typeVerified = this.verifyType(localContext);
+
+    if (typeVerified) {
+      const termVerified = this.term.verify(localContext, () => {
+        let verifiedAhead;
+
+        const termType = this.term.getType(),
+              typeEqualToOrSuperTypeOfTermType = this.type.isEqualToOrSuperTypeOf(termType);
+
+        verifiedAhead = typeEqualToOrSuperTypeOfTermType; ///
+
+        return verifiedAhead;
+      });
+
+      verifiedWhenDerived = termVerified; ///
+    }
+
+    if (verifiedWhenDerived) {
+      localContext.debug(`...verified the derived '${typeAssertionString}' type assertion.`);
+    }
+
+    return verifiedWhenDerived;
+  }
+
+  static fromTypeAssertionNode(typeAssertionNode, localContext) {
+    const { Term, Type } = shim,
+          termNode = termNodeQuery(typeAssertionNode),
+          typeNode = typeNodeQuery(typeAssertionNode),
+          variableNode = variableNodeQuery(termNode),
+          term = Term.fromTermNode(termNode, localContext),
+          type = Type.fromTypeNode(typeNode, localContext),
+          variable = Variable.fromVariableNode(variableNode, localContext),
+          string = stringFromTermAndType(term, type),
+          typeAssertion = new TypeAssertion(string, term, type, variable);
+
+    return typeAssertion;
+  }
+}
+
+function stringFromTermAndType(term, type) {
+  const termString = term.getString(),
+        typeName = type.getName(),
+        string = `${termString}:${typeName}`;
+
+  return string;
+}

package/src/constructor.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import shim from "./shim";
+import LocalContext from "./context/local";
 
 import { nodeQuery } from "./utilities/query";
 import { objectType } from "./type";
@@ -79,7 +80,8 @@ export default class Constructor {
           type = (typeNode === null) ?
                    objectType :
                      Type.fromTypeNode(typeNode),
-          term = Term.fromTermNodeAndType(termNode, type, fileContext),
+          localContext = LocalContext.fromFileContext(fileContext),
+          term = Term.fromTermNodeAndType(termNode, type, localContext),
           string = stringFromTermAndType(term, type),
           constructor = new Constructor(string, term);
 

package/src/context/file.js

@@ -390,20 +390,6 @@ export default class FileContext {
     return label;
   }
 
-  findMetavariableByMetavariableName(metavariableName) {
-    const name = metavariableName,  ///
-          metavariables = this.getMetavariables(),
-          metavariable = metavariables.find((metavariable) => {
-            const nameMatches = metavariable.matchName(name);
-
-            if (nameMatches) {
-              return true;
-            }
-          }) || null;
-
-    return metavariable;
-  }
-
   isTypePresentByTypeName(typeName) {
     const type = this.findTypeByTypeName(typeName),
           typePresent = (type !== null);
@@ -544,6 +530,33 @@ export default class FileContext {
     return variable;
   }
 
+  findJudgementByMetavariableName(metavariableName) {
+    const judgements = this.getJudgements(),
+          judgement = judgements.find((judgement) => {
+            const judgementMatchesMetavariableName = judgement.matchMetavariableName(metavariableName);
+
+            if (judgementMatchesMetavariableName) {
+              return true;
+            }
+          }) || null;
+
+    return judgement;
+  }
+
+  findMetavariableByMetavariableName(metavariableName) {
+    const name = metavariableName,  ///
+          metavariables = this.getMetavariables(),
+          metavariable = metavariables.find((metavariable) => {
+            const nameMatches = metavariable.matchName(name);
+
+            if (nameMatches) {
+              return true;
+            }
+          }) || null;
+
+    return metavariable;
+  }
+
   nodeAsString(node) {
     const string = nodeAsString(node, this.tokens);
 
@@ -864,6 +877,27 @@ export default class FileContext {
     });
   }
 
+  static fromJSONAndReleaseContext(json, releaseContext) {
+    const { filePath } = json,
+          tokens = null,
+          node = null,
+          types = [],
+          rules = [],
+          axioms = [],
+          lemmas = [],
+          theorems = [],
+          variables = [],
+          metaLemmas = [],
+          conjectures = [],
+          combinators = [],
+          constructors = [],
+          metatheorems = [],
+          metavariables = [],
+          fileContext = new FileContext(releaseContext, filePath, tokens, node, types, rules, axioms, lemmas, variables, metaLemmas, theorems, conjectures, combinators, constructors, metatheorems, metavariables);
+
+    return fileContext;
+  }
+
   static fromFileAndReleaseContext(file, releaseContext) {
     const lexer = releaseContext.getLexer(),
           parser = releaseContext.getParser(),

package/src/context/local.js

@@ -332,11 +332,21 @@ class LocalContext {
 
   findMetaTypeByMetaTypeName(metaTypeName) { return this.context.findMetaTypeByMetaTypeName(metaTypeName); }
 
-  findVariableByVariableName(variableName) { return this.context.findVariableByVariableName(variableName); }
-
   findLabelByMetavariableNode(metavariableNode) { return this.context.findLabelByMetavariableNode(metavariableNode); }
 
-  findMetavariableByMetavariableName(metavariableName) { return this.context.findMetavariableByMetavariableName(metavariableName); }
+  findVariableByVariableName(variableName) {
+    const name = variableName,  ///
+          variables = this.getVariables(),
+          variable = variables.find((variable) => {
+            const nameMatches = variable.matchName(name);
+
+            if (nameMatches) {
+              return true;
+            }
+          }) || null;
+
+    return variable;
+  }
 
   findJudgementByMetavariableName(metavariableName) {
     const judgements = this.getJudgements(),
@@ -351,13 +361,13 @@ class LocalContext {
     return judgement;
   }
 
-  findMetavariableByMetavariableNode(metavariableNode) {
-    const localContext = this,  ///
+  findMetavariableByMetavariableName(metavariableName) {
+    const name = metavariableName,  ///
           metavariables = this.getMetavariables(),
           metavariable = metavariables.find((metavariable) => {
-            const metavariableNodeMatches = metavariable.matchMetavariableNode(metavariableNode, localContext);
+            const nameMatches = metavariable.matchName(name);
 
-            if (metavariableNodeMatches) {
+            if (nameMatches) {
               return true;
             }
           }) || null;

package/src/context/release.js

@@ -438,9 +438,9 @@ export default class ReleaseContext {
 
     this.parser = nominalParser; ///
 
-    this.fileContexts = released ?
-                          fileContextsFromJSONEntriesAndReleaseContext(this.json, this.entries, releaseContext) :
-                            fileContextsFromEntriesAndReleaseContext(this.entries, releaseContext);
+    released ?
+       fileContextsFromJSONAndReleaseContext(this.json, this.fileContexts, releaseContext) :
+         fileContextsFromEntriesAndReleaseContext(this.entries, this.fileContexts, releaseContext);
 
     this.initialised = true;
   }
@@ -487,31 +487,20 @@ export default class ReleaseContext {
   }
 }
 
-function fileContextsFromJSONEntriesAndReleaseContext(json, entries, releaseContext) {
-  const fileContexts = [];
+function fileContextsFromJSONAndReleaseContext(json, fileContexts, releaseContext) {
+  const fileContextsJSON = json;  ///
 
-  entries.forEachFile((file) => {
-    const filePath = file.getPath(),
-          filePathNominalFilePath = isFilePathNominalFilePath(filePath);
-
-    if (filePathNominalFilePath) {
-      const fileContext = FileContext.fromFileAndReleaseContext(file, releaseContext),
-            filePath = fileContext.getFilePath();
-
-      fileContexts.push(fileContext);
+  fileContextsJSON.forEach((fileContextJSON) => {
+    const json = fileContextJSON,
+          fileContext = FileContext.fromJSONAndReleaseContext(json, releaseContext);
 
-      const fileContextJSON = findFileContextJSON(json, filePath);
+    fileContext.initialise(fileContextJSON);
 
-      fileContext.initialise(fileContextJSON);
-    }
+    fileContexts.push(fileContext);
   });
-
-  return fileContexts;
 }
 
-function fileContextsFromEntriesAndReleaseContext(entries, releaseContext) {
-  const fileContexts = [];
-
+function fileContextsFromEntriesAndReleaseContext(entries, fileContexts, releaseContext) {
   entries.forEachFile((file) => {
     const filePath = file.getPath(),
           filePathNominalFilePath = isFilePathNominalFilePath(filePath);
@@ -526,19 +515,6 @@ function fileContextsFromEntriesAndReleaseContext(entries, releaseContext) {
   return fileContexts;
 }
 
-function findFileContextJSON(json, filePath) {
-  const fileContextsJSON = json,  ///
-        fileContextJSON = fileContextsJSON.find((fileContextJSON) => {
-          const { filePath: fileContextFilePath } = fileContextJSON;
-
-          if (fileContextFilePath === filePath) {
-            return true;
-          }
-        });
-
-  return fileContextJSON;
-}
-
 function verifyFileContexts(fileContexts, verifiedFileContexts) {
   let fileContextsVerified;
 

package/src/equality.js

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

package/src/mixins/statement/verify.js

@@ -1,11 +1,11 @@
 "use strict";
 
 import Equality from "../../equality";
+import TypeAssertion from "../../assertion/type";
 
 import verifyFrame from "../../verify/frame";
 import verifyJudgement from "../../verify/judgement";
 import verifyDeclaration from "../../verify/declaration";
-import verifyTypeAssertion from "../../verify/assertion/type";
 import metavariableUnifier from "../../unifier/metavariable";
 import verifyDefinedAssertion from "../../verify/assertion/defined";
 import verifySubproofAssertion from "../../verify/assertion/subproof";
@@ -151,7 +151,8 @@ function verifyAsTypeAssertion(statement, assignments, stated, localContext) {
 
     localContext.trace(`Verifying the '${statementString}' statement as a type assertion...`);
 
-    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, stated, localContext);
+    const typeAssertion = TypeAssertion.fromTypeAssertionNode(typeAssertionNode, localContext),
+          typeAssertionVerified = typeAssertion.verify(assignments, stated, localContext);
 
     verifiedAsTypeAssertion = typeAssertionVerified; ///
 

package/src/premise.js

@@ -12,8 +12,9 @@ import { assignAssignments } from "./utilities/assignments";
 const unqualifiedStatementNodeQuery = nodeQuery("/premise/unqualifiedStatement");
 
 export default class Premise {
-  constructor(fileContext, unqualifiedStatement) {
+  constructor(fileContext, subproofAssertion, unqualifiedStatement) {
     this.fileContext = fileContext;
+    this.subproofAssertion = subproofAssertion;
     this.unqualifiedStatement = unqualifiedStatement;
   }
 
@@ -21,6 +22,10 @@ export default class Premise {
     return this.fileContext;
   }
 
+  getSubproofAssertion() {
+    return this.subproofAssertion;
+  }
+
   getUnqualifiedStatement() {
     return this.unqualifiedStatement;
   }
@@ -90,12 +95,8 @@ export default class Premise {
 
     localContext.trace(`Unifying the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement...`);
 
-    const statement = this.unqualifiedStatement.getStatement(),
-          statementNode = statement.getNode(),
-          subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, this.fileContext);
-
-    if (subproofAssertion !== null) {
-      subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, localContext);
+    if (this.subproofAssertion !== null) {
+      subproofUnified = this.subproofAssertion.unifySubproof(subproof, substitutions, localContext);
     }
 
     if (subproofUnified) {
@@ -142,30 +143,42 @@ export default class Premise {
 
   toJSON() {
     const unqualifiedStatementJSON = this.unqualifiedStatement.toJSON(),
-          unqualifiedStatement = unqualifiedStatementJSON,  ///
-          json = {
-            unqualifiedStatement
-          };
+      subproofAssertionJSON = (this.subproofAssertion !== null) ?
+        this.subproofAssertion.toJSON() :
+        null,
+      unqualifiedStatement = unqualifiedStatementJSON,  ///
+      subproofAssertion = subproofAssertionJSON,  ///
+      json = {
+        unqualifiedStatement,
+        subproofAssertion
+      };
 
     return json;
   }
 
   static fromJSON(json, fileContext) {
-    let { unqualifiedStatement } = json;
+    let { subproofAssertion, unqualifiedStatement } = json;
 
     json = unqualifiedStatement;  ///
 
     unqualifiedStatement = UnqualifiedStatement.fromJSON(json, fileContext);
 
-    const premise = new Premise(fileContext, unqualifiedStatement);
+    json = subproofAssertion; ///
+
+    subproofAssertion = (json !== null) ?
+                          SubproofAssertion.fromJSON(json, fileContext) :
+                            null;
+
+    const premise = new Premise(fileContext, subproofAssertion, unqualifiedStatement);
 
     return premise;
   }
 
-  static fromPremiseNode(premiseNode, fileContext) {
-    const unqualifiedStatementNode = unqualifiedStatementNodeQuery(premiseNode),
+  static fromSuppositionNode(suppositionNode, fileContext) {
+    const unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
           unqualifiedStatement = UnqualifiedStatement.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
-          premise = new Premise(fileContext, unqualifiedStatement);
+          subproofAssertion = SubproofAssertion.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
+          premise = new Premise(fileContext, subproofAssertion, unqualifiedStatement);
 
     return premise
   }