occam-verify-cli 0.0.1067 → 0.0.1069

package/src/context/file.js

@@ -2,22 +2,29 @@
 
 import { arrayUtilities } from "necessary";
 
-import shim from "../shim";
-import Rule from "../rule";
-import Axiom from "../axiom";
-import Lemma from "../lemma";
-import Theorem from "../theorem";
-import Variable from "../variable";
-import metaTypes from "../metaTypes";
-import MetaLemma from "../metaLemma";
-import Conjecture from "../conjecture";
-import Combinator from "../combinator";
-import Constructor from "../constructor";
-import Metatheorem from "../metatheorem";
-import Metavariable from "../metavariable";
-
 import { objectType } from "../type";
+import { frameMetaType, referenceMetaType, statementMetaType } from "../metaType";
 import { nodeAsTokens, nodeAsString, nodesAsString, tokensAsString } from "../utilities/string";
+import { typesFromJSON,
+         rulesFromJSON,
+         axiomsFromJSON,
+         theoremsFromJSON,
+         variablesFromJSON,
+         conjecturesFromJSON,
+         combinatorsFromJSON,
+         constructorsFromJSON,
+         metatheoremsFromJSON,
+         metavariablesFromJSON,
+         typesToTypesJSON,
+         rulesToRulesJSON,
+         axiomsToAxiomsJSON,
+         theoremsToTheoremsJSON,
+         variablesToVariablesJSON,
+         conjecturesToConjecturesJSON,
+         combinatorsToCombinatorsJSON,
+         constructorsToConstructorsJSON,
+         metatheoremsToMetatheoremsJSON,
+         metavariablesToMetavariablesJSON } from "../utilities/json";
 
 const { push } = arrayUtilities;
 
@@ -224,6 +231,12 @@ export default class FileContext {
   }
 
   getMetaTypes(includeRelease = true) {
+    const metaTypes = [
+      frameMetaType,
+      referenceMetaType,
+      statementMetaType
+    ];
+
     return metaTypes;
   }
 
@@ -686,6 +699,30 @@ export default class FileContext {
 
   error(message) { this.releaseContext.error(message, this.filePath); }
 
+  initialise(json) {
+    const fileContext = this;
+
+    this.types - typesFromJSON(json, fileContext);
+
+    this.rules = rulesFromJSON(json, fileContext);
+
+    this.axioms = axiomsFromJSON(json, fileContext);
+
+    this.theorems = theoremsFromJSON(json, fileContext);
+
+    this.variables = variablesFromJSON(json, fileContext);
+
+    this.conjectures = conjecturesFromJSON(json, fileContext);
+
+    this.combinators = combinatorsFromJSON(json, fileContext);
+
+    this.constructors = constructorsFromJSON(json, fileContext);
+
+    this.metatheorems = metatheoremsFromJSON(json, fileContext);
+
+    this.metavariables = metavariablesFromJSON(json, fileContext);
+  }
+
   reset() {
     this.types = [];
     this.rules = [];
@@ -703,99 +740,33 @@ export default class FileContext {
 
   toJSON() {
     const filePath =  this.filePath,
-          types = this.types.map((type) => {
-            const typeJSON = type.toJSON();
-
-            type = typeJSON; ///
-
-            return type;
-          }),
-          rules = this.rules.map((rule) => {
-            const ruleJSON = rule.toJSON();
-
-            rule = ruleJSON; ///
-
-            return rule;
-          }),
-          axioms = this.axioms.map((axiom) => {
-            const axiomJSON = axiom.toJSON();
-
-            axiom = axiomJSON; ///
-
-            return axiom;
-          }),
-          lemmas = this.lemmas.map((lemma) => {
-            const lemmaJSON = lemma.toJSON();
-
-            lemma = lemmaJSON; ///
-
-            return lemma;
-          }),
-          theorems = this.theorems.map((theorem) => {
-            const theoremJSON = theorem.toJSON();
-
-            theorem = theoremJSON; ///
-
-            return theorem;
-          }),
-          variables = this.variables.map((variable) => {
-            const variableJSON = variable.toJSON();
-
-            variable = variableJSON;  ///
-
-            return variable;
-          }),
-          metaLemmas = this.metaLemmas.map((metaLemma) => {
-            const metaLemmaJSON = metaLemma.toJSON();
-
-            metaLemma = metaLemmaJSON; ///
-
-            return metaLemma;
-          }),
-          conjectures = this.conjectures.map((conjecture) => {
-            const conjectureJSON = conjecture.toJSON();
-
-            conjecture = conjectureJSON; ///
-
-            return conjecture;
-          }),
-          combinators = this.combinators.map((combinator) => {
-            const combinatorJSON = combinator.toJSON();
-
-            combinator = combinatorJSON; ///
-
-            return combinator;
-          }),
-          constructors = this.constructors.map((constructor) => {
-            const constructorJSON = constructor.toJSON();
-
-            constructor = constructorJSON;  ///
-
-            return constructor;
-          }),
-          metatheorems = this.metatheorems.map((metatheorem) => {
-            const metatheoremJSON = metatheorem.toJSON();
-
-            metatheorem = metatheoremJSON; ///
-
-            return metatheorem;
-          }),
-          metavariables = this.metavariables.map((metavariable) => {
-            const metavariableJSON = metavariable.toJSON();
-
-            metavariable = metavariableJSON;  ///
-
-            return metavariable;
-          }),
+          typesJSON = typesToTypesJSON(this.types),
+          rulesJSON = rulesToRulesJSON(this.rules),
+          axiomsJSON = axiomsToAxiomsJSON(this.axioms),
+          theoremsJSON = theoremsToTheoremsJSON(this.theorems),
+          variablesJSON = variablesToVariablesJSON(this.variables),
+          conjecturesJSON = conjecturesToConjecturesJSON(this.conjectures),
+          combinatorsJSON = combinatorsToCombinatorsJSON(this.combinators),
+          constructorsJSON = constructorsToConstructorsJSON(this.constructors),
+          metatheoremsJSON = metatheoremsToMetatheoremsJSON(this.metatheorems),
+          metavariablesJSON = metavariablesToMetavariablesJSON(this.metavariables),
+          types = typesJSON,  ///
+          rules = rulesJSON,  ///
+          axioms = axiomsJSON,  ///
+          theorems = theoremsJSON,  ///
+          variables = variablesJSON,  ///
+          conjectures = conjecturesJSON,  ///
+          combinators = combinatorsJSON,  ///
+          constructors = constructorsJSON,  ///
+          metatheorems = metatheoremsJSON,  ///
+          metavariables = metavariablesJSON,  ///
           json = {
             filePath,
             types,
             rules,
             axioms,
-            lemmas,
             theorems,
             variables,
-            metaLemmas,
             conjectures,
             combinators,
             constructors,
@@ -806,108 +777,6 @@ export default class FileContext {
     return json;
   }
 
-  initialise(fileContextJSON) {
-    const { types, rules, axioms, lemmas, theorems, metaLemmas, variables, conjectures, combinators, constructors, metatheorems, metavariables } = fileContextJSON,
-          fileContext = this, ///
-          typesJSON = types,  ///
-          rulesJSON = rules,  ///
-          axiomsJSON = axioms,  ///
-          lemmasJSON = lemmas,  ///
-          theoremsJSON = theorems,  ///
-          variablesJSON = variables,  ///
-          metaLemmasJSON = metaLemmas,  ///
-          conjecturesJSON = conjectures,  ///
-          combinatorsJSON = combinators,  ///
-          constructorsJSON = constructors,  ///
-          metatheoremsJSON = metatheorems,  ///
-          metavariablesJSON = metavariables;  ///
-
-    typesJSON.forEach((typeJSON) => {
-      const { Type } = shim,
-            json = typeJSON,  ///
-            type = Type.fromJSON(json, fileContext);
-
-      this.types.push(type);
-    });
-
-    rulesJSON.forEach((ruleJSON) => {
-      const json = ruleJSON,  ///
-            rule = Rule.fromJSON(json, fileContext);
-
-      this.rules.push(rule);
-    });
-
-    axiomsJSON.forEach((axiomJSON) => {
-      const json = axiomJSON,  ///
-            axiom = Axiom.fromJSON(json, fileContext);
-
-      this.axioms.push(axiom);
-    });
-
-    lemmasJSON.forEach((lemmaJSON) => {
-      const json = lemmaJSON,  ///
-            lemma = Lemma.fromJSON(json, fileContext);
-
-      this.lemmas.push(lemma);
-    });
-
-    theoremsJSON.forEach((theoremJSON) => {
-      const json = theoremJSON,  ///
-            theorem = Theorem.fromJSON(json, fileContext);
-
-      this.theorems.push(theorem);
-    });
-
-    variablesJSON.forEach((variableJSON) => {
-      const json = variableJSON,  ///
-            variable = Variable.fromJSON(json, fileContext);
-
-      this.variables.push(variable);
-    });
-
-    metaLemmasJSON.forEach((metaLemmaJSON) => {
-      const json = metaLemmaJSON,  ///
-            metaLemma = MetaLemma.fromJSON(json, fileContext);
-
-      this.metaLemmas.push(metaLemma);
-    });
-
-    conjecturesJSON.forEach((conjectureJSON) => {
-      const json = conjectureJSON,  ///
-            conjecture = Conjecture.fromJSON(json, fileContext);
-
-      this.conjectures.push(conjecture);
-    });
-
-    combinatorsJSON.forEach((combinatorJSON) => {
-      const json = combinatorJSON,  ///
-            combinator = Combinator.fromJSON(json, fileContext);
-
-      this.combinators.push(combinator);
-    });
-
-    constructorsJSON.forEach((constructorJSON) => {
-      const json = constructorJSON,  ///
-            constructor = Constructor.fromJSON(json, fileContext);
-
-      this.constructors.push(constructor);
-    });
-
-    metatheoremsJSON.forEach((metatheoremJSON) => {
-      const json = metatheoremJSON,  ///
-            metatheorem = Metatheorem.fromJSON(json, fileContext);
-
-      this.metatheorems.push(metatheorem);
-    });
-
-    metavariablesJSON.forEach((metavariableJSON) => {
-      const json = metavariableJSON,  ///
-            metavariable = Metavariable.fromJSON(json, fileContext);
-
-      this.metavariables.push(metavariable);
-    });
-  }
-
   static fromFile(file, releaseContext) {
     const lexer = releaseContext.getLexer(),
           parser = releaseContext.getParser(),
@@ -932,4 +801,27 @@ export default class FileContext {
 
     return fileContext;
   }
+
+  static fromFileAndJSON(file, json, releaseContext) {
+    const filePath = file.getPath(),
+          tokens = null,
+          node = null,
+          types = null,
+          rules = null,
+          axioms = null,
+          lemmas = [],
+          theorems = null,
+          variables = null,
+          metaLemmas = [],
+          conjectures = null,
+          combinators = null,
+          constructors = null,
+          metatheorems = null,
+          metavariables = null,
+          fileContext = new FileContext(releaseContext, filePath, tokens, node, types, rules, axioms, lemmas, variables, metaLemmas, theorems, conjectures, combinators, constructors, metatheorems, metavariables);
+
+    fileContext.initialise(json);
+
+    return fileContext;
+  }
 }

package/src/context/local.js

@@ -96,6 +96,10 @@ class LocalContext {
     return lastProofStep;
   }
 
+  getLexer() { return this.context.getLexer(); }
+
+  getParser() { return this.context.getParser(); }
+
   getAxioms() { return this.context.getAxioms(); }
 
   getLemmas() { return this.context.getLemmas(); }
@@ -456,15 +460,13 @@ class LocalContext {
     return localContext;
   }
 
-  static fromLocalContextAndTokens(localContext, tokens) {
-    const context = localContext,  ///
-          variables = [],
+  static fromContextAndTokens(context, tokens) {
+    const variables = [],
           proofSteps = [],
           judgements = [],
           equivalences = [],
-          metavariables = [];
-
-    localContext = new LocalContext(context, tokens, variables, proofSteps, judgements, equivalences, metavariables);  ///
+          metavariables = [],
+          localContext = new LocalContext(context, tokens, variables, proofSteps, judgements, equivalences, metavariables);  ///
 
     return localContext;
   }

package/src/context/release.js

@@ -454,9 +454,8 @@ function fileContextsFromJSONAndEntries(json, entries, fileContexts, releaseCont
   fileContextsJSON.forEach((fileContextJSON) => {
     const { filePath } = fileContextJSON,
           file = entries.findFile(filePath),
-          fileContext = FileContext.fromFile(file, releaseContext);
-
-    fileContext.initialise(fileContextJSON);
+          json = fileContextJSON, ///
+          fileContext = FileContext.fromFileAndJSON(file, json, releaseContext);
 
     fileContexts.push(fileContext);
   });

package/src/declaration.js

@@ -1,13 +1,25 @@
 "use strict";
 
-import { stripBracketsFromStatement } from "./utilities/brackets";
+import shim from "./shim";
+import Reference from "./reference";
+
+import { nodeQuery } from "./utilities/query";
+import { stripBracketsFromStatementNode } from "./utilities/brackets";
+
+const referenceNodeQuery = nodeQuery("/declaration/reference"),
+      statementNodeQuery = nodeQuery("/declaration/statement");
 
 export default class Declaration {
-  constructor(reference, statement) {
+  constructor(string, reference, statement) {
+    this.string = string;
     this.reference = reference;
     this.statement = statement;
   }
 
+  getString() {
+    return this.string;
+  }
+
   getReference() {
     return this.reference;
   }
@@ -16,47 +28,116 @@ export default class Declaration {
     return this.statement;
   }
 
-  // getMetavariableNode() { return this.reference.getMetavariableNode(); }
-  //
-  // unifyStatement(statementNode) {
-  //   statementNode = stripBracketsFromStatement(statementNode); ///
-  //
-  //   const statementNodeMatches = this.statementNode.match(statementNode),
-  //         statementUnified = statementNodeMatches;  ///
-  //
-  //   return statementUnified;
-  // }
-  //
-  // unifySubstitution(substitution) {
-  //   const statementNode = substitution.getStatementNode(),
-  //         metavariableNode = substitution.getMetavariableNode(),
-  //         statementUnified = this.unifyStatement(statementNode),
-  //         metavariableUnified = this.unifyMetavariable(metavariableNode),
-  //         substitutionUnified = (metavariableUnified && statementUnified);
-  //
-  //   return substitutionUnified;
-  // }
-  //
-  // unifyMetavariable(metavariable) {
-  //   const metavariableNodeMatches = this.reference.matchMetavariableNode(metavariable);
-  //
-  //   return metavariableNodeMatches;
-  // }
-  //
-  // unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem) {
-  //   const consequent = metaLemmaMetatheorem.getConsequent(),
-  //         statementNode = consequent.getStatementNode(),
-  //         statementNodeMatches = this.statementNode.match(statementNode),
-  //         metaLemmaOrMetaTheoremUnified = statementNodeMatches;  ///
-  //
-  //   return metaLemmaOrMetaTheoremUnified;
-  // }
-  //
-  // static fromReferenceAndStatementNode(reference, statementNode) {
-  //   statementNode = stripBracketsFromStatement(statementNode); ///
-  //
-  //   const declaration = new Declaration(reference, statementNode);
-  //
-  //   return declaration;
-  // }
+  unifyStatement(statement, localContext) {
+    let statementUnified;
+
+    const statementString = statement.getString(),
+          declarationStatementString = this.statement.getString(); ///
+
+    localContext.trace(`Unifying the '${statementString}' statement with the '${declarationStatementString}' statement...`);
+
+    let statementNode = statement.getNode();
+
+    statementNode = stripBracketsFromStatementNode(statementNode); ///
+
+    const statementNodeMatches = this.statement.matchStatementNode(statementNode);
+
+    statementUnified = statementNodeMatches;  ///
+
+    if (statementUnified) {
+      localContext.debug(`...unified the '${statementString}' statement with the '${declarationStatementString}' statement.`);
+    }
+
+    return statementUnified;
+  }
+
+  unifyMetavariable(metavariable, localContext) {
+    let metavariableUnified;
+
+    const referenceString = this.reference.getString(),
+          metavariableString = metavariable.getString();
+
+    localContext.trace(`Unifying the '${metavariableString}' metavariable with the '${referenceString}' reference...`);
+
+    const metavariableNode = metavariable.getNode(),
+          metavariableNodeMatches = this.reference.matchMetavariableNode(metavariableNode);
+
+    metavariableUnified = metavariableNodeMatches;  ///
+
+    if (metavariableUnified) {
+      localContext.debug(`...unified the '${metavariableString}' metavariable with the '${referenceString}' reference.`);
+    }
+
+    return metavariableUnified;
+  }
+
+  unifySubstitution(substitution, localContext) {
+    let substitutionUnified;
+
+    const declarationString = this.string,  ///
+          substitutionString = substitution.getString();
+
+    localContext.trace(`Unifying the '${substitutionString}' substitution with the '${declarationString}' declaration...`);
+
+    const statement = substitution.getStatement(),
+          metavariable = substitution.getMetavariable(),
+          statementUnified = this.unifyStatement(statement, localContext),
+          metavariableUnified = this.unifyMetavariable(metavariable, localContext);
+
+    substitutionUnified = (metavariableUnified && statementUnified);
+
+    if (substitutionUnified) {
+      localContext.debug(`...unified the '${declarationString}' substitution with the '${substitutionString}' declaration.`);
+    }
+
+    return substitutionUnified;
+  }
+
+  verify(assignments, stated, localContext) {
+    let verified;
+
+    const declarationString = this.string;  ///
+
+    localContext.trace(`Verifying the '${declarationString}' declaration...`);
+
+    stated = true;
+
+    assignments = null;
+
+    const referenceVerified = this.reference.verify(localContext);
+
+    if (referenceVerified) {
+      const statementVerified = this.statement.verify(assignments, stated, localContext);
+
+      verified = statementVerified; ///
+    }
+
+    if (verified) {
+      localContext.debug(`...verified the '${declarationString}' declaration.`);
+    }
+
+    return verified;
+  }
+
+  static fromDeclarationNode(declarationNode, localContext) {
+    let declaration = null;
+
+    if (declarationNode !== null) {
+      const { Statement } = shim,
+            referenceNode = referenceNodeQuery(declarationNode);
+
+      let statementNode = statementNodeQuery(declarationNode);
+
+      statementNode = stripBracketsFromStatementNode(statementNode);  ///
+
+      const reference = Reference.fromReferenceNode(referenceNode, localContext),
+            statement = Statement.fromStatementNode(statementNode, localContext),
+            node = declarationNode,  ///
+            string = localContext.nodeAsString(node);
+
+      declaration = new Declaration(string, reference, statement);
+    }
+
+    return declaration;
+  }
 }

package/src/equivalence.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import { nodeQuery } from "./utilities/query";
-import { stripBracketsFromTerm } from "./utilities/brackets";
+import { stripBracketsFromTermNode } from "./utilities/brackets";
 import { variableNameFromVariableNode } from "./utilities/name";
 
 const variableNodeQuery = nodeQuery("/term/variable!");
@@ -83,7 +83,7 @@ export default class Equivalence {
   }
 
   matchTermNode(termNode) {
-    termNode = stripBracketsFromTerm(termNode); ///
+    termNode = stripBracketsFromTermNode(termNode); ///
 
     const termNodeMatches = this.terms.some((term) => {
       const termNodeMatches = term.matchTermNode(termNode);