occam-verify-cli 0.0.1003 → 0.0.1006

package/src/metavariable.js

@@ -1,15 +1,21 @@
 "use strict";
 
-import { nodeAsString } from "./utilities/string";
+import { metaTypeFromJSON } from "./metaType";
+import { metavariableNameFromMetavariableNode } from "./utilities/name";
 
 export default class Metavariable {
-  constructor(node, name, termType, metaType) {
+  constructor(string, node, name, termType, metaType) {
+    this.string = string;
     this.node = node;
     this.name = name;
     this.termType = termType;
     this.metaType = metaType;
   }
 
+  getString() {
+    return this.string;
+  }
+
   getNode() {
     return this.node;
   }
@@ -44,18 +50,60 @@ export default class Metavariable {
     return metavariableNodeMatches;
   }
 
-  asString(tokens) {
-    const metaTypeName = this.metaType.getName();
+  toJSON() {
+    const metaTypeJSON = (this.metaType !== null) ?
+                            this.metaType.toJSON() :
+                              null,
+          string = this.string,
+          metaType = metaTypeJSON,  ///
+          json = {
+            string,
+            metaType
+          };
+
+    return json;
+  }
+
+  static fromJSON(json, fileContext) {
+    const { string } = json,
+          lexer  = fileContext.getLexer(),
+          parser = fileContext.getParser(),
+          metavariableString = string,  ///
+          metavariableNode = metavariableNodeFromMetavariableString(metavariableString, lexer, parser),
+          node = metavariableNode;  ///
+
+    let { metaType } = json;
 
-    let string = nodeAsString(this.node, tokens);
+    json = metaType;  ///
 
-    string = `${string}:${metaTypeName}`; ///
+    metaType = metaTypeFromJSON(json, fileContext);
 
-    return string;
+    const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+          name = metavariableName,  ///
+          termType = termTypeFromMetavariableNode(metavariableNode, fileContext),
+          metavariable = new Metavariable(string, node, name, termType, metaType);
+
+    return metavariable;
+  }
+
+  static fromMetavariableNode(metavariableNode, fileContext) {
+    const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+          name = metavariableName,  ///
+          node = metavariableNode,  ///
+          string = fileContext.nodeAsString(node),
+          termType = null,
+          metaType = null,
+          metavariable = new Metavariable(string, node, name, termType, metaType);
+
+    return metavariable;
   }
 
-  static fromNodeNameTermTypeAndMetaType(node, name, termType, metaType) {
-    const metavariable = new Metavariable(node, name, termType, metaType);
+  static fromMetavariableNodeNameTermTypeAndMetaType(metavariableNode, termType, metaType, fileContext) {
+    const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+          name = metavariableName,  ///
+          node = metavariableNode,  ///
+          string = fileContext.nodeAsString(node),
+          metavariable = new Metavariable(string, node, name, termType, metaType);
 
     return metavariable;
   }

package/src/mixins/statement/qualified/unify.js

@@ -0,0 +1,186 @@
+"use strict";
+
+import metavariableUnifier from "../../../unifier/metavariable";
+import StatementForMetavariableSubstitution from "../../../substitution/statementForMetavariable";
+
+import { trim } from "../../../utilities/string";
+import { metavariableNameFromMetavariableNode } from "../../../utilities/name";
+
+function unifyAWithRule(qualifiedStatement, substitutions, localContext) {
+  let unifiedWithRule = false;
+
+  const reference = qualifiedStatement.getReference(),
+        rule = localContext.findRuleByReference(reference);
+
+  if (rule !== null) {
+    const referenceString = reference.getString(),
+          qualifiedStatementString = trim(qualifiedStatement.getString());  ///
+
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${referenceString}' rule...`);
+
+    const statement = qualifiedStatement.getStatement(),
+          statementUnified = rule.unifyStatement(statement, localContext);
+
+    unifiedWithRule = statementUnified;  ///
+
+    if (unifiedWithRule) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${referenceString}' rule.`);
+    }
+  }
+
+  return unifiedWithRule;
+}
+
+function unifyAWithAxiom(qualifiedStatement, substitutions, localContext) {
+  let unifiedWithAxiom = false;
+
+  const reference = qualifiedStatement.getReference(),
+        axiom = localContext.findAxiomByReference(reference);
+
+  if (axiom !== null) {
+    const referenceString = reference.getString(),
+          qualifiedStatementString = trim(qualifiedStatement.getString());  ///
+
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${referenceString}' axiom...`);
+
+    const statement = qualifiedStatement.getStatement(),
+          statementUnified = axiom.unifyStatement(statement, localContext);
+
+    unifiedWithAxiom = statementUnified; ///
+
+    if (unifiedWithAxiom) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${referenceString}' axiom.`);
+    }
+  }
+
+  return unifiedWithAxiom;
+}
+
+function unifyAWithLemma(qualifiedStatement, substitutions, localContext) {
+  let unifiedWithLemma = false;
+
+  const reference = qualifiedStatement.getReference(),
+        lemma = localContext.findLemmaByReference(reference);
+
+  if (lemma !== null) {
+    const referenceString = reference.getString(),
+          qualifiedStatementString = trim(qualifiedStatement.getString());  ///
+
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${referenceString}' lemma...`);
+
+    const statement = qualifiedStatement.getStatement(),
+          statementUnified = lemma.unifyStatement(statement, localContext);
+
+    unifiedWithLemma = statementUnified; ///
+
+    if (unifiedWithLemma) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${referenceString}' lemma.`);
+    }
+  }
+
+  return unifiedWithLemma;
+}
+
+function unifyAWithTheorem(qualifiedStatement, substitutions, localContext) {
+  let unifiedWithTheorem = false;
+
+  const reference = qualifiedStatement.getReference(),
+        theorem = localContext.findTheoremByReference(reference);
+
+  if (theorem !== null) {
+    const referenceString = reference.getString(),
+          qualifiedStatementString = trim(qualifiedStatement.getString());  ///
+
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${referenceString}' theorem...`);
+
+    const statement = qualifiedStatement.getStatement(),
+          statementUnified = theorem.unifyStatement(statement, localContext);
+
+    unifiedWithTheorem = statementUnified; ///
+
+    if (unifiedWithTheorem) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${referenceString}' theorem.`);
+    }
+  }
+
+  return unifiedWithTheorem;
+}
+
+function unifyAWithConjecture(qualifiedStatement, substitutions, localContext) {
+  let unifiedWithConjecture = false;
+
+  const reference = qualifiedStatement.getReference(),
+        conjecture = localContext.findConjectureByReference(reference);
+
+  if (conjecture !== null) {
+    const referenceString = reference.getString(),
+          qualifiedStatementString = trim(qualifiedStatement.getString());  ///
+
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${referenceString}' conjecture...`);
+
+    const statement = qualifiedStatement.getStatement(),
+          statementUnified = conjecture.unifyStatement(statement, localContext);
+
+    unifiedWithConjecture = statementUnified; ///
+
+    if (unifiedWithConjecture) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${referenceString}' conjecture.`);
+    }
+  }
+
+  return unifiedWithConjecture;
+}
+
+function unifyAWithReference(qualifiedStatement, substitutions, localContext) {
+  let unifiedWithReference = false;
+
+  const reference = qualifiedStatement.getReference(),
+        metavariableNode = reference.getMetavariableNode(),
+        metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+        metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
+
+  if (metavariable !== null) {
+    const statement = qualifiedStatement.getStatement(),
+          statementString = statement.getString(),
+          referenceString = reference.getString();
+
+    localContext.trace(`Unifying the '${statementString}' qualified statement with the '${referenceString}' reference...`);
+
+    const metavariableNode = metavariable.getNode(),
+          referenceMetavariableNode = reference.getMetavariableNode(),
+          metavariableNodeA = referenceMetavariableNode, ///
+          metavariableNodeB = metavariableNode, ///
+          unified = metavariableUnifier.unify(metavariableNodeA, metavariableNodeB, localContext);
+
+    if (unified) {
+      const statementNode = statement.getNode(),
+            metavariableNode = metavariableNodeA, ///
+            statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementNodeAndMetavariableNode(statementNode, metavariableNode, localContextA, localContextB),
+            substitution = statementForMetavariableSubstitution, ///
+            localContextA = localContext, ///
+            localContextB = localContext; ///
+
+      substitutions.addSubstitution(substitution, localContextA, localContextB);
+
+      unifiedWithReference = true;
+    }
+
+    if (unifiedWithReference) {
+      localContext.debug(`...unified the '${statementString}' qualified statement with the '${referenceString}' reference.`);
+    }
+  }
+
+  return unifiedWithReference;
+}
+
+const unifyMixins = [
+  unifyAWithRule,
+  unifyAWithAxiom,
+  unifyAWithLemma,
+  unifyAWithTheorem,
+  unifyAWithConjecture,
+  unifyAWithReference
+];
+
+export default unifyMixins;
+

package/src/mixins/statement/unify.js

@@ -0,0 +1,70 @@
+"use strict";
+
+import BracketedCombinator from "../../ocmbinator/bracketed";
+import statementWithCombinatorUnifier from "../../unifier/statementWithCombinator";
+
+function unifyWithBracketedCombinator(statement, assignments, stated, localContext) {
+  let unifiedWithBracketedCombinator;
+
+  const statementNode = statement.getNode(),
+        statementString = statement.getString(),
+        bracketedCombinator = BracketedCombinator.fromNothing(),
+        bracketedCombinatorStatementNode = bracketedCombinator.getStatementNode(),
+        combinatorStatementNode = bracketedCombinatorStatementNode; ///
+
+  localContext.trace(`Unifying the '${statementString}' statement with the bracketed combinator...`);
+
+  unifiedWithBracketedCombinator = statementWithCombinatorUnifier.unify(statementNode, combinatorStatementNode, assignments, stated, localContext);
+
+  if (unifiedWithBracketedCombinator) {
+    localContext.debug(`...unified the '${statementString}' statement with the bracketed combinator.`);
+  }
+
+  return unifiedWithBracketedCombinator;
+}
+
+function unifyWithCombinators(statement, assignments, stated, localContext) {
+  let unifiedWithCombinators;
+
+  const combinators = localContext.getCombinators();
+
+  assignments = null; ///
+
+  stated = true;  ///
+
+  unifiedWithCombinators = combinators.some((combinator) => {
+    const unifiedWithCombinator = unifyStatementWithCombinator(statement, combinator, assignments, stated, localContext);
+
+    if (unifiedWithCombinator) {
+      return true;
+    }
+  });
+
+  return unifiedWithCombinators;
+}
+
+const unifyMixins = [
+  unifyWithBracketedCombinator,
+  unifyWithCombinators
+];
+
+export default unifyMixins;
+
+function unifyStatementWithCombinator(statement, combinator, assignments, stated, localContext) {
+  let unifiedWithCombinator;
+
+  const statementNode = statement.getNode(),
+        statementString = statement.getString(),
+        combinatorString = combinator.getString(),
+        combinatorStatementNode = combinator.getStatementNode();
+
+  localContext.trace(`Unifying the '${statementString}' statement with the '${combinatorString}' combinator...`);
+
+  unifiedWithCombinator = statementWithCombinatorUnifier.unify(statementNode, combinatorStatementNode, assignments, stated, localContext);
+
+  if (unifiedWithCombinator) {
+    localContext.debug(`...unified the '${statementString}' statement with the '${combinatorString}' combinator.`);
+  }
+
+  return unifiedWithCombinator;
+}

package/src/mixins/statement/verify.js

@@ -0,0 +1,274 @@
+"use strict";
+
+import verifyFrame from "../../verify/frame";
+import verifyEquality from "../../verify/equality";
+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";
+import verifyContainedAssertion from "../../verify/assertion/contained";
+
+import { nodeQuery } from "../../utilities/query";
+import { metavariableNameFromMetavariableNode } from "../../utilities/name";
+
+const frameNodeQuery = nodeQuery("/statement/frame!"),
+      equalityNodeQuery = nodeQuery("/statement/equality!"),
+      judgementNodeQuery = nodeQuery("/statement/judgement!"),
+      declarationNodeQuery = nodeQuery("/statement/declaration!"),
+      metavariableNodeQuery = nodeQuery("/statement/metavariable!"),
+      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!"),
+      definedAssertionNodeQuery = nodeQuery("/statement/definedAssertion!"),
+      subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
+      containedAssertionNodeQuery = nodeQuery("/statement/containedAssertion!");
+
+function verifyAsMetavariable(statement, assignments, stated, localContext) {
+  let verifiedAsMetavariable = false;
+
+  const statementNode = statement.getNode(),
+        metavariableNode = metavariableNodeQuery(statementNode);
+
+  if (metavariableNode !== null) {
+    const statementString = statement.getString();
+
+    localContext.trace(`Verifying the '${statementString}' statement as a metavariable...`);
+
+    const metavariableUnified = unifyMetavariable(metavariableNode, localContext);
+
+    verifiedAsMetavariable = metavariableUnified;  ///
+
+    if (verifiedAsMetavariable) {
+      localContext.debug(`...verified the '${statementString}' statement as a metavariable.`);
+    }
+  }
+
+  return verifiedAsMetavariable;
+}
+
+function verifyAsEquality(statement, assignments, stated, localContext) {
+  let verifiedAsEquality = false;
+
+  const statementNode = statement.getNode(),
+        equalityNode = equalityNodeQuery(statementNode);
+
+  if (equalityNode !== null) {
+    const statementString = statement.getString();
+
+    localContext.trace(`Verifying the '${statementString}' statement as an equality...`);
+
+    const equalityVerified = verifyEquality(equalityNode, assignments, stated, localContext);
+
+    verifiedAsEquality = equalityVerified; ///
+
+    if (verifiedAsEquality) {
+      localContext.debug(`...verified the '${statementString}' statement as an equality.`);
+    }
+  }
+
+  return verifiedAsEquality;
+}
+
+function verifyAsFrame(statement, assignments, stated, localContext) {
+  let verifiedAsFrame = false;
+
+  const statementNode = statement.getNode(),
+        frameNode = frameNodeQuery(statementNode);
+
+  if (frameNode !== null) {
+    const statementString = statement.getString();
+
+    localContext.trace(`Verifying the '${statementString}' statement as a frame...`);
+
+    const frameVerified = verifyFrame(frameNode, assignments, stated, localContext);
+
+    verifiedAsFrame = frameVerified; ///
+
+    if (verifiedAsFrame) {
+      localContext.debug(`...verified the '${statementString}' statement as a frame.`);
+    }
+  }
+
+  return verifiedAsFrame;
+}
+
+function verifyAsJudgement(statement, assignments, stated, localContext) {
+  let verifiedAsJudgement = false;
+
+  const statementNode = statement.getNode(),
+        judgementNode = judgementNodeQuery(statementNode);
+
+  if (judgementNode !== null) {
+    const statementString = statement.getString();
+
+    localContext.trace(`Verifying the '${statementString}' statement as a judgement...`);
+
+    const judgementVerified = verifyJudgement(judgementNode, assignments, stated, localContext);
+
+    verifiedAsJudgement = judgementVerified;  ///
+
+    if (verifiedAsJudgement) {
+      localContext.debug(`...verified the '${statementString}' statement as a judgement.`);
+    }
+  }
+
+  return verifiedAsJudgement;
+}
+
+function verifyAsDeclaration(statement, assignments, stated, localContext) {
+  let verifiedAsDeclaration = false;
+
+  const statementNode = statement.getNode(),
+        declarationNode = declarationNodeQuery(statementNode);
+
+  if (declarationNode !== null) {
+    const statementString = statement.getString();
+
+    localContext.trace(`Verifying the '${statementString}' statement as a declaration...`);
+
+    const declarationVerified = verifyDeclaration(declarationNode, assignments, stated, localContext);
+
+    verifiedAsDeclaration = declarationVerified; ///
+
+    if (verifiedAsDeclaration) {
+      localContext.debug(`...verified the '${statementString}' statement as a declaration.`);
+    }
+  }
+
+  return verifiedAsDeclaration;
+}
+
+function verifyAsTypeAssertion(statement, assignments, stated, localContext) {
+  let verifiedAsTypeAssertion = false;
+
+  const statementNode = statement.getNode(),
+        typeAssertionNode = typeAssertionNodeQuery(statementNode);
+
+  if (typeAssertionNode !== null) {
+    const statementString = statement.getString();
+
+    localContext.trace(`Verifying the '${statementString}' statement as a type assertion...`);
+
+    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, stated, localContext);
+
+    verifiedAsTypeAssertion = typeAssertionVerified; ///
+
+    if (verifiedAsTypeAssertion) {
+      localContext.debug(`...verified the '${statementString}' statement as a type assertion.`);
+    }
+  }
+
+  return verifiedAsTypeAssertion;
+}
+
+function verifyAsDefinedAssertion(statement, assignments, stated, localContext) {
+  let verifiedAsDefinedAssertion = false;
+
+  const statementNode = statement.getNode(),
+        definedAssertionNode = definedAssertionNodeQuery(statementNode);
+
+  if (definedAssertionNode !== null) {
+    const statementString = statement.getString();
+
+    localContext.trace(`Verifying the '${statementString}' statement as a defined assertion...`);
+
+    const definedAssertionVerified = verifyDefinedAssertion(definedAssertionNode, assignments, stated, localContext);
+
+    verifiedAsDefinedAssertion = definedAssertionVerified; ///
+
+    if (verifiedAsDefinedAssertion) {
+      localContext.debug(`...verified the '${statementString}' statement as a defined assertion.`);
+    }
+  }
+
+  return verifiedAsDefinedAssertion;
+}
+
+function verifyAsSubproofAssertion(statement, assignments, stated, localContext) {
+  let verifiedAsSubproofAssertion = false;
+
+  const statementNode = statement.getNode(),
+        subproofAssertionNode = subproofAssertionNodeQuery(statementNode);
+
+  if (subproofAssertionNode !== null) {
+    const statementString = statement.getString();
+
+    localContext.trace(`Verifying the '${statementString}' statement as a subproof assertion...`);
+
+    const subproofAssertionVerified = verifySubproofAssertion(subproofAssertionNode, assignments, stated, localContext);
+
+    verifiedAsSubproofAssertion = subproofAssertionVerified; ///
+
+    if (verifiedAsSubproofAssertion) {
+      localContext.debug(`...verified the '${statementString}' statement as a subproof assertion.`);
+    }
+  }
+
+  return verifiedAsSubproofAssertion;
+}
+
+function verifyAsContainedAssertion(statement, assignments, stated, localContext) {
+  let verifiedAsContainedAssertion = false;
+
+  const statementNode = statement.getNode(),
+        containedAssertionNode = containedAssertionNodeQuery(statementNode);
+
+  if (containedAssertionNode !== null) {
+    const statementString = statement.getString();
+
+    localContext.trace(`Verifying the '${statementString}' statement as a contained assertion...`);
+
+    const containedAssertionVerified = verifyContainedAssertion(containedAssertionNode, assignments, stated, localContext);
+
+    verifiedAsContainedAssertion = containedAssertionVerified; ///
+
+    if (verifiedAsContainedAssertion) {
+      localContext.debug(`...verified the '${statementString}' statement as a contained assertion.`);
+    }
+  }
+
+  return verifiedAsContainedAssertion;
+}
+
+const verifyMixins = [
+  verifyAsMetavariable,
+  verifyAsEquality,
+  verifyAsFrame,
+  verifyAsJudgement,
+  verifyAsDeclaration,
+  verifyAsTypeAssertion,
+  verifyAsDefinedAssertion,
+  verifyAsSubproofAssertion,
+  verifyAsContainedAssertion
+];
+
+export default verifyMixins;
+
+function unifyMetavariable(metavariableNode, localContext) {
+  let metavariableUnified;
+
+  const metavariableString = localContext.nodeAsString(metavariableNode);
+
+  localContext.trace(`Unifying the '${metavariableString}' metavariable...`);
+
+  const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+        metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
+
+  if (metavariable !== null) {
+    const metavariableNodeA = metavariableNode; ///
+
+    metavariableNode = metavariable.getNode();
+
+    const metavariableNodeB = metavariableNode; ///
+
+    const unified = metavariableUnifier.unify(metavariableNodeA, metavariableNodeB, localContext);
+
+    metavariableUnified = unified;  ///
+  }
+
+  if (metavariableUnified) {
+    localContext.debug(`...unified the '${metavariableString}' metavariable.`);
+  }
+
+  return metavariableUnified;
+}

package/src/node/statement/combinator/bracketed.js

@@ -1,9 +1,10 @@
 "use strict";
 
-import bracketedCombinatorStatementTokens from "../../../tokens/combinatorStatement/bracketed";
+import { STATEMENT_META_TYPE_NAME } from "../../../metaTypeNames";
+import { statementNodeFromStatementString } from "../../../utilities/node";
 
-import { statementNodeFromStatementTokens } from "../../../utilities/node";
+export const bracketedCombinatorStatementString = `(${STATEMENT_META_TYPE_NAME})`;
 
-const bracketedCombinatorStatementNode = statementNodeFromStatementTokens(bracketedCombinatorStatementTokens);
+const bracketedCombinatorStatementNode = statementNodeFromStatementString(bracketedCombinatorStatementString)
 
 export default bracketedCombinatorStatementNode;

package/src/ocmbinator/bracketed.js

@@ -1,23 +1,26 @@
 "use strict";
 
+import shim from "../shim";
 import Combinator from "../combinator";
 import bracketedCombinatorStatementNode from "../node/statement/combinator/bracketed";
-import bracketedCombinatorStatementTokens from "../tokens/combinatorStatement/bracketed";
 
-import { nodeAsString } from "../utilities/string";
+import { bracketedCombinatorStatementString } from "../node/statement/combinator/bracketed";
 
-class BracketedCombinator extends Combinator {
+const localContext = {
+  nodeAsString: (node) => {
+    const string = bracketedCombinatorStatementString;  ///
+
+    return string;
+  }
+};
+
+export default class BracketedCombinator extends Combinator {
   static fromNothing() {
-    const node = bracketedCombinatorStatementNode,  ///
-          tokens = bracketedCombinatorStatementTokens, ///
-          string = nodeAsString(node, tokens),
-          statementNode = node, ///
-          bracketedCombinator = new BracketedCombinator(statementNode, string);
+    const { Statement } = shim,
+          statementNode = bracketedCombinatorStatementNode,  ///
+          statement = Statement.fromStatementNode(statementNode, localContext),
+          bracketedCombinator = new BracketedCombinator(statement);
 
     return bracketedCombinator;
   }
 }
-
-const bracketedCombinator = BracketedCombinator.fromNothing();
-
-export default bracketedCombinator;