occam-verify-cli 0.0.1003 → 0.0.1006

package/lib/verify/theorem.js

@@ -9,12 +9,9 @@ Object.defineProperty(exports, "default", {
     }
 });
 var _theorem = /*#__PURE__*/ _interop_require_default(require("../theorem"));
-var _proof = /*#__PURE__*/ _interop_require_default(require("../verify/proof"));
-var _labels = /*#__PURE__*/ _interop_require_default(require("../verify/labels"));
 var _local = /*#__PURE__*/ _interop_require_default(require("../context/local"));
 var _substitutions = /*#__PURE__*/ _interop_require_default(require("../substitutions"));
 var _consequent = /*#__PURE__*/ _interop_require_default(require("../verify/consequent"));
-var _suppositions = /*#__PURE__*/ _interop_require_default(require("../verify/suppositions"));
 var _array = require("../utilities/array");
 var _query = require("../utilities/query");
 function _interop_require_default(obj) {
@@ -27,13 +24,13 @@ function verifyTheorem(theoremNode, fileContext) {
     var theoremVerified = false;
     var labelNodes = labelNodesQuery(theoremNode), labelsString = fileContext.nodesAsString(labelNodes);
     fileContext.trace("Verifying the '".concat(labelsString, "' theorem..."), theoremNode);
-    var labels = [], labelsVerified = (0, _labels.default)(labelNodes, labels, fileContext);
+    var labels = [], labelsVerified = verifyLabels(labelNodes, labels, fileContext);
     if (labelsVerified) {
-        var localContext = _local.default.fromFileContext(fileContext), suppositions = [], suppositionNodes = suppositionsNodeQuery(theoremNode), suppositionsVerified = (0, _suppositions.default)(suppositionNodes, suppositions, localContext);
+        var localContext = _local.default.fromFileContext(fileContext), suppositions = [], suppositionNodes = suppositionsNodeQuery(theoremNode), suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
         if (suppositionsVerified) {
             var consequents = [], consequentNode = consequentNodeQuery(theoremNode), consequentVerified = (0, _consequent.default)(consequentNode, consequents, localContext);
             if (consequentVerified) {
-                var proofNode = proofNodeQuery(theoremNode), firstConsequent = (0, _array.first)(consequents), consequent = firstConsequent, statementNode = consequent.getStatementNode(), substitutions = _substitutions.default.fromNothing(), proofVerified = (0, _proof.default)(proofNode, statementNode, substitutions, localContext);
+                var proofNode = proofNodeQuery(theoremNode), firstConsequent = (0, _array.first)(consequents), consequent = firstConsequent, statementNode = consequent.getStatementNode(), substitutions = _substitutions.default.fromNothing(), proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);
                 if (proofVerified) {
                     var substitutions1 = _substitutions.default.fromNothing(), theorem = _theorem.default.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions1, fileContext);
                     fileContext.addTheorem(theorem);
@@ -48,4 +45,4 @@ function verifyTheorem(theoremNode, fileContext) {
     return theoremVerified;
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "0.0.1003",
+  "version": "0.0.1006",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",

package/src/assertion/subproof.js

@@ -0,0 +1,84 @@
+"use strict";
+
+import Statement from "../statement";
+import LocalContext from "../context/local";
+import metaLevelUnifier from "../unifier/metaLevel";
+
+import { match } from "../utilities/array";
+import { nodeQuery, nodesQuery } from "../utilities/query";
+
+const statementNodesQuery = nodesQuery("/subproofAssertion/statement"),
+      subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion");
+
+export default class SubproofAssertion {
+  constructor(fileContext, string, statements) {
+    this.fileContext = fileContext;
+    this.string = string;
+    this.statements = statements;
+  }
+
+  getFileContext() {
+    return this.fileContext;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getStatements() {
+    return this.statements;
+  }
+
+  unifySubproof(subproof, substitutions, localContext) {
+    let subproofUnified;
+
+    const subproofString = subproof.getString(),
+          subproofStatements = subproof.getStatements(),
+          subproofAssertionString = this.string;  ///
+
+    localContext.trace(`Unifying the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion...`);
+
+    subproofUnified = match(this.statements, subproofStatements, (statement, subproofStatement) => {
+      const statementNode = statement.getNode(),
+            subproofStatementNode = subproofStatement.getNode(),
+            nodeA = statementNode,  ///
+            nodeB = subproofStatementNode,  ///
+            fileContextA = this.fileContext,  ///
+            localContextA = LocalContext.fromFileContext(fileContextA),
+            localContextB = localContext, ///
+            unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+
+      if (unified) {
+        return true;
+      }
+    });
+
+    if (subproofUnified) {
+      localContext.debug(`...unified the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion.`);
+    }
+
+    return subproofUnified;
+  }
+
+  static fromStatementNode(statementNode, fileContext) {
+    let subproofAssertion = null;
+
+    const subproofAssertionNode = subproofAssertionNodeQuery(statementNode);
+
+    if (subproofAssertionNode !== null) {
+      const node = subproofAssertionNode, ///
+            string = fileContext.nodeAsString(node),
+            localContext = LocalContext.fromFileContext(fileContext),
+            statementNodes = statementNodesQuery(subproofAssertionNode),
+            statements = statementNodes.map((statementNode) => {
+              const statement = Statement.fromStatementNode(statementNode, localContext);
+
+              return statement;
+            });
+
+      subproofAssertion = new SubproofAssertion(fileContext, string, statements);
+    }
+
+    return subproofAssertion;
+  }
+}

package/src/assignment/metavariable.js

@@ -16,8 +16,8 @@ export default class MetavariableAssignment {
           metavariableAssigned = metavariableAdded; ///
 
     metavariableAssigned ?
-      fileContext.trace(`Assigned the '${metavariableString}' metavariable.`, metavariableNode) :
-        fileContext.debug(`Unable to assign the '${metavariableString}' metavariable.`, metavariableNode);
+      fileContext.trace(`Assigned the '${metavariableString}' metavariable.`) :
+        fileContext.debug(`Unable to assign the '${metavariableString}' metavariable.`);
 
     return metavariableAssigned;
   }

package/src/combinator.js

@@ -1,32 +1,62 @@
 "use strict";
 
-import { nodeAsString } from "./utilities/string";
+import shim from "./shim";
+import LocalContext from "./context/local";
+
+import { nodeQuery } from "./utilities/query";
+
+const statementNodeQuery = nodeQuery("/combinatorDeclaration/statement");
 
 export default class Combinator {
-  constructor(statementNode, string) {
-    this.statementNode = statementNode;
-    this.string = string;
+  constructor(statement) {
+    this.statement = statement;
+  }
+
+  getStatement() {
+    return this.statement;
   }
 
+  getString() { return this.statement.getString(); }
+
   getStatementNode() {
-    return this.statementNode;
+    const statementNode = this.statement.getNode();
+
+    return statementNode;
+  }
+
+  verify(fileContext) {
+    const localContext = LocalContext.fromFileContext(fileContext),
+          statementVerifiedAsCombinator = this.statement.verifyAsCombinator(localContext),
+          verified = statementVerifiedAsCombinator; ///
+
+    return verified;
   }
 
-  getString() {
-    return this.string;
+  toJSON() {
+    const statementString = this.statement.getString(),
+          statement = statementString,  ///
+          json = {
+            statement
+          };
+
+    return json;
   }
 
-  static fromStatementNodeAndTokens(statementNode, tokens) {
-    const string = stringFromStatementNodeAndTokens(statementNode, tokens),
-          combinator = new Combinator(statementNode, string);
+  static fromJSON(json, fileContext) {
+    let combinator = null;
+
+    debugger
 
     return combinator;
   }
-}
 
-function stringFromStatementNodeAndTokens(statementNode, tokens) {
-  const statementString = nodeAsString(statementNode, tokens),
-        string = statementString; ///
+  static fromCombinatorDeclarationNode(combinatorDeclarationNode, fileContext) {
+    const { Statement } = shim,
+          statementNode = statementNodeQuery(combinatorDeclarationNode),
+          localContext = LocalContext.fromFileContext(fileContext),
+          statement = Statement.fromStatementNode(statementNode, localContext),
+          combinator = new Combinator(statement);
 
-  return string;
+    return combinator;
+  }
 }

package/src/conclusion.js

@@ -1,32 +1,104 @@
 "use strict";
 
+import LocalContext from "./context/local";
 import metaLevelUnifier from "./unifier/metaLevel";
+import UnqualifiedStatement from "./statement/unqualified";
+
+import { trim } from "./utilities/string";
+import { nodeQuery } from "./utilities/query";
+
+const unqualifiedStatementNodeQuery = nodeQuery("/conclusion/unqualifiedStatement");
 
 export default class Conclusion {
-  constructor(statementNode) {
-    this.statementNode = statementNode;
+  constructor(fileContext, unqualifiedStatement) {
+    this.fileContext = fileContext;
+    this.unqualifiedStatement = unqualifiedStatement;
+  }
+
+  getFileContext() {
+    return this.fileContext;
   }
 
-  getStatementNode() {
-    return this.statementNode;
+  getUnqualifiedStatement() {
+    return this.unqualifiedStatement;
   }
 
-  unifyStatement(statementNodeB, substitutions, localContextA, localContextB) {
-    let statementUnified = false;
+  getString() { return this.unqualifiedStatement.getString(); }
+
+  getStatement() { return this.unqualifiedStatement.getStatement(); }
+
+  unifyStatement(statement, substitutions, localContext) {
+    let statementUnified;
+
+    const conclusion = this, ///
+          statementString = statement.getString(),
+          conclusionStatement = conclusion.getStatement(),
+          conclusionStatementString = conclusionStatement.getString();
 
-    if (this.statementNode !== null) {
-      const nodeA = this.statementNode,  ///
-            nodeB = statementNodeB,  ///
-            unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+    localContext.trace(`Unifying the '${statementString}' statement with the conclusion's '${conclusionStatementString}' statement...`);
 
-      statementUnified = unified; ///
+    const statementNode = statement.getNode(),
+          conclusionStatementNode = conclusionStatement.getNode(),
+          nodeA = conclusionStatementNode,  ///
+          nodeB = statementNode,  ///
+          fileContextA = this.fileContext,  ///
+          localContextA = LocalContext.fromFileContext(fileContextA),
+          localContextB = localContext, ///
+          unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+
+    statementUnified = unified; ///
+
+    if (statementUnified) {
+      localContext.debug(`...unified the '${statementString}' statement with the conclusion's '${conclusionStatementString}' statement.`);
     }
 
     return statementUnified;
   }
 
-  static fromStatementNode(statementNode) {
-    const conclusion = new Conclusion(statementNode);
+  verify(localContext) {
+    let verified = false,
+        conclusionString = this.getString();  ///
+
+    conclusionString = trim(conclusionString);  ///
+
+    localContext.trace(`Verifying the '${conclusionString}' conclusion...`);
+
+    const stated = true,
+          assignments = [],
+          unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, localContext);
+
+    if (unqualifiedStatementVerified) {
+      verified = true;
+    }
+
+    if (verified) {
+      localContext.debug(`...verified the '${conclusionString}' conclusion.`);
+    }
+
+    return verified;
+  }
+
+  toJSON() {
+    const unqualifiedStatementString = this.unqualifiedStatement.getString(),
+          unqualifiedStatement = unqualifiedStatementString,  ///
+          json = {
+            unqualifiedStatement
+          };
+
+    return json;
+  }
+
+  static fromJSON(json, fileContext) {
+    let conclusion = null;
+
+    debugger
+
+    return conclusion;
+  }
+  static fromConclusionNode(conclusionNode, fileContext) {
+    const unqualifiedStatementNode = unqualifiedStatementNodeQuery(conclusionNode),
+          unqualifiedStatement = UnqualifiedStatement.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
+          conclusion = new Conclusion(fileContext, unqualifiedStatement);
 
     return conclusion;
   }

package/src/context/file.js

@@ -1,6 +1,18 @@
 "use strict";
 
+import Type from "../type";
+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 topLevelVerifier from "../verifier/topLevel";
 
 import { push } from "../utilities/array";
@@ -348,8 +360,9 @@ export default class FileContext {
     return label;
   }
 
-  findRuleByMetavariableNode(metavariableNode) {
+  findRuleByReference(reference) {
     const rules = this.getRules(),
+          metavariableNode = reference.getMetavariableNode(),
           rule = rules.find((rule) => {
             const metavariableNodeMatches = rule.matchMetavariableNode(metavariableNode);
 
@@ -361,8 +374,9 @@ export default class FileContext {
     return rule;
   }
 
-  findAxiomByMetavariableNode(metavariableNode) {
+  findAxiomByReference(reference) {
     const axioms = this.getAxioms(),
+          metavariableNode = reference.getMetavariableNode(),
           axiom = axioms.find((axiom) => {
             const metavariableNodeMatches = axiom.matchMetavariableNode(metavariableNode);
 
@@ -374,8 +388,9 @@ export default class FileContext {
     return axiom;
   }
 
-  findLemmaByMetavariableNode(metavariableNode) {
+  findLemmaByReference(reference) {
     const lemmas = this.getLemmas(),
+          metavariableNode = reference.getMetavariableNode(),
           lemma = lemmas.find((lemma) => {
             const metavariableNodeMatches = lemma.matchMetavariableNode(metavariableNode);
 
@@ -387,8 +402,9 @@ export default class FileContext {
     return lemma;
   }
 
-  findTheoremByMetavariableNode(metavariableNode) {
+  findTheoremByReference(reference) {
     const theorems = this.getTheorems(),
+          metavariableNode = reference.getMetavariableNode(),
           theorem = theorems.find((theorem) => {
             const metavariableNodeMatches = theorem.matchMetavariableNode(metavariableNode);
 
@@ -400,8 +416,9 @@ export default class FileContext {
     return theorem;
   }
 
-  findMetaLemmaByMetavariableNode(metavariableNode) {
+  findMetaLemmaByReference(reference) {
     const metaLemmas = this.getMetaLemmas(),
+          metavariableNode = reference.getMetavariableNode(),
           metaLemma = metaLemmas.find((metaLemma) => {
             const metavariableNodeMatches = metaLemma.matchMetavariableNode(metavariableNode);
 
@@ -413,8 +430,9 @@ export default class FileContext {
     return metaLemma;
   }
 
-  findConjectureByMetavariableNode(metavariableNode) {
+  findConjectureByReference(reference) {
     const conjectures = this.getConjectures(),
+          metavariableNode = reference.getMetavariableNode(),
           conjecture = conjectures.find((conjecture) => {
             const metavariableNodeMatches = conjecture.matchMetavariableNode(metavariableNode);
 
@@ -426,8 +444,9 @@ export default class FileContext {
     return conjecture;
   }
 
-  findMetatheoremByMetavariableNode(metavariableNode) {
+  findMetatheoremByReference(reference) {
     const metatheorems = this.getMetatheorems(),
+          metavariableNode = reference.getMetavariableNode(),
           metatheorem = metatheorems.find((metatheorem) => {
             const metavariableNodeMatches = metatheorem.matchMetavariableNode(metavariableNode);
 
@@ -606,8 +625,6 @@ export default class FileContext {
 
   error(message, node) { this.releaseContext.error(message, node, this.tokens, this.filePath); }
 
-  fatal(message, node) { this.releaseContext.fatal(message, node, this.tokens, this.filePath); }
-
   reset() {
     this.types = [];
     this.rules = [];
@@ -649,15 +666,210 @@ export default class FileContext {
 
   toJSON() {
     const filePath =  this.filePath,
-          fileContent = this.fileContent,
+          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;
+          }),
           json = {
             filePath,
-            fileContent
+            types,
+            rules,
+            axioms,
+            lemmas,
+            theorems,
+            variables,
+            metaLemmas,
+            conjectures,
+            combinators,
+            constructors,
+            metatheorems,
+            metavariables
           };
 
     return json;
   }
 
+  static fromJSON(json) {
+    const { types, rules, axioms, lemmas, theorems, metaLemmas, variables, conjectures, combinators, constructors, metatheorems, metavariables } = json,
+          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 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 fromFileAndReleaseContext(file, releaseContext) {
     const fileContent = file.getContent(),
           filePath = file.getPath(),