occam-verify-cli 0.0.1061 → 0.0.1065

package/src/assertion/defined.js

@@ -0,0 +1,161 @@
+"use strict";
+
+import shim from "../shim";
+
+import { isAssertionNegated } from "../utilities/assertion";
+
+export default class DefinedAssertion {
+  constructor(string, node, term, frame, negated) {
+    this.string = string;
+    this.node = node;
+    this.term = term;
+    this.frame= frame;
+    this.negated = negated;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getNode() {
+    return this.node;
+  }
+
+  getTerm() {
+    return this.term;
+  }
+
+  getFrame() {
+    return this.frame;
+  }
+
+  isNegated() {
+    return this.negated;
+  }
+
+  verify(assignments, stated, localContext) {
+    let verified = false;
+
+    const definedAssertionString = this.string; ///
+
+    localContext.trace(`Verifying the '${definedAssertionString}' defined assertion...`);
+
+    assignments = null; ///
+
+    let termVerified = true,  ///
+        frameVerified = true; ///
+
+    if (this.term !== null) {
+      termVerified = this.term.verify(localContext, () => {
+        const verifiedAhead = true;
+
+        return verifiedAhead;
+      });
+    }
+
+    if (this.frame!== null) {
+      frameVerified = this.frame.verify(localContext);
+    }
+
+    if (termVerified && frameVerified) {
+      let verifiedWhenStated = false,
+          verifiedWhenDerived = false;
+
+      if (stated) {
+        verifiedWhenStated = this.verifyWhenStated(localContext);
+      } else {
+        verifiedWhenDerived = this.verifyWhenDerived(localContext);
+      }
+
+      if (verifiedWhenStated || verifiedWhenDerived) {
+        verified = true;
+      }
+    }
+
+    if (verified) {
+      localContext.debug(`...verified the '${definedAssertionString}' defined assertion.`);
+    }
+
+    return verified;
+  }
+
+  verifyWhenStated(localContext) {
+    let verifiedWhenStated;
+
+    const definedAssertionString = this.string; ///
+
+    localContext.trace(`Verifying the '${definedAssertionString}' stated defined assertion...`);
+
+    verifiedWhenStated = true;
+
+    if (verifiedWhenStated) {
+      localContext.debug(`...verified the '${definedAssertionString}' stated defined assertion.`);
+    }
+
+    return verifiedWhenStated;
+  }
+
+  verifyWhenDerived(localContext) {
+    let verifiedWhenDerived = false;
+
+    const definedAssertionString = this.string; ///
+
+    localContext.trace(`Verifying the '${definedAssertionString}' derived defined assertion...`);
+
+    if (this.term !== null) {
+      const { Variable } = shim,
+            termNode = this.term.getNode(),
+            variable = Variable.fromTermNode(termNode, localContext),
+            variableDefined = localContext.isVariableDefined(variable);
+
+      if (!this.negated && variableDefined) {
+        verifiedWhenDerived = true;
+      }
+
+      if (this.negated && !variableDefined) {
+        verifiedWhenDerived = true;
+      }
+    }
+
+    if (this.frame!== null) {
+      debugger
+
+      const { Metavariable } = shim,
+            frameNode = this.frame.getNode(),
+            metavariable = Metavariable.fromTermNode(frameNode, localContext),
+            metavariableDefined = localContext.isMetametavariableDefined(metavariable);
+
+      if (!this.negated && metavariableDefined) {
+        verifiedWhenDerived = true;
+      }
+
+      if (this.negated && !metavariableDefined) {
+        verifiedWhenDerived = true;
+      }
+    }
+
+    if (verifiedWhenDerived) {
+      localContext.debug(`...verified the '${definedAssertionString}' derived defined assertion.`);
+    }
+
+    return verifiedWhenDerived;
+  }
+
+  static fromDefinedAssertionNode(definedAssertionNode, localContext) {
+    let definedAssertion = null;
+
+    if (definedAssertionNode !== null) {
+      const { Term, Frame } = shim,
+            node = definedAssertionNode,  ///
+            string = localContext.nodeAsString(node),
+            term = Term.fromDefinedAssertionNode(definedAssertionNode, localContext),
+            frame = Frame.fromDefinedAssertionNode(definedAssertionNode, localContext),
+            definedAssertionNegated = isAssertionNegated(definedAssertionNode),
+            negated = definedAssertionNegated;  ///
+
+      definedAssertion = new DefinedAssertion(string, node, term, frame, negated);
+    }
+
+    return definedAssertion;
+  }
+}

package/src/assertion/subproof.js

@@ -54,9 +54,10 @@ export default class SubproofAssertion {
 
       stated = true;  ///
 
-      const subproofAssertionNode = this.node;  ///
+      const subproofAssertionNode = this.node,  ///
+            verifiedAtMetaLevel = metaLevelVerifier.verify(subproofAssertionNode, assignments, stated, localContext);
 
-      verified = metaLevelVerifier.verify(subproofAssertionNode, assignments, stated, localContext);
+      verified = verifiedAtMetaLevel; ///
     }
 
     if (verified) {
@@ -113,9 +114,9 @@ export default class SubproofAssertion {
             fileContextA = fileContext,  ///
             localContextA = LocalContext.fromFileContext(fileContextA),
             localContextB = localContext, ///
-            unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+            unifiedAtMetaLevel = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
 
-      if (unified) {
+      if (unifiedAtMetaLevel) {
         return true;
       }
     });

package/src/assertion/type.js

@@ -5,7 +5,7 @@ import Variable from "../variable";
 import VariableAssignment from "../assignment/variable";
 
 import { nodeQuery } from "../utilities/query";
-import {objectType} from "../type";
+import { objectType } from "../type";
 
 const termNodeQuery = nodeQuery("/typeAssertion/term"),
       typeNodeQuery = nodeQuery("/typeAssertion/type"),
@@ -36,16 +36,27 @@ export default class TypeAssertion {
   }
 
   verify(assignments, stated, localContext) {
-    let verified;
+    let verified = false;
 
-    if (stated) {
-      const verifiedWhenStated = this.verifyWhenStated(assignments, localContext);
+    let typeAssertionString = this.string;  ///
+
+    localContext.trace(`Verifying the '$${typeAssertionString}' type assertion...`);
 
-      verified = verifiedWhenStated;  ///
+    let verifiedWhenStated = false,
+        verifiedWhenDerived = false;
+
+    if (stated) {
+      verifiedWhenStated = this.verifyWhenStated(assignments, localContext);
     } else {
-      const verifiedWhenDerived = this.verifyWhenDerived(localContext);
+      verifiedWhenDerived = this.verifyWhenDerived(localContext);
+    }
+
+    if (verifiedWhenStated || verifiedWhenDerived) {
+      verified = true;
+    }
 
-      verified = verifiedWhenDerived; ///
+    if (verified) {
+      localContext.debug(`...verified the '$${typeAssertionString}' type assertion.`);
     }
 
     return verified;

package/src/conclusion.js

@@ -1,7 +1,5 @@
 "use strict";
 
-import LocalContext from "./context/local";
-import metaLevelUnifier from "./unifier/metaLevel";
 import UnqualifiedStatement from "./statement/unqualified";
 
 import { nodeQuery } from "./utilities/query";
@@ -29,26 +27,15 @@ export default class Conclusion {
   unifyStatement(statement, substitutions, localContext) {
     let statementUnified;
 
-    const conclusion = this, ///
-          statementString = statement.getString(),
-          conclusionStatement = conclusion.getStatement(),
-          conclusionStatementString = conclusionStatement.getString();
+    const statementString = statement.getString(),
+          conclusionString = this.getString();
 
-    localContext.trace(`Unifying the '${statementString}' statement with the conclusion's '${conclusionStatementString}' statement...`);
+    localContext.trace(`Unifying the '${statementString}' statement with the '${conclusionString}' conclusion...`);
 
-    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; ///
+    statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, this.fileContext, localContext);
 
     if (statementUnified) {
-      localContext.debug(`...unified the '${statementString}' statement with the conclusion's '${conclusionStatementString}' statement.`);
+      localContext.debug(`...unified the '${statementString}' statement with the '${conclusionString}' conclusion.`);
     }
 
     return statementUnified;

package/src/consequent.js

@@ -1,7 +1,5 @@
 "use strict";
 
-import LocalContext from "./context/local";
-import metaLevelUnifier from "./unifier/metaLevel";
 import UnqualifiedStatement from "./statement/unqualified";
 
 import { nodeQuery } from "./utilities/query";
@@ -29,26 +27,15 @@ export default class Consequent {
   unifyStatement(statement, substitutions, localContext) {
     let statementUnified;
 
-    const consequent = this, ///
-          statementString = statement.getString(),
-          consequentStatement = consequent.getStatement(),
-          consequentStatementString = consequentStatement.getString();
+    const statementString = statement.getString(),
+          consequentString = this.getString();
 
-    localContext.trace(`Unifying the '${statementString}' statement with the consequent's '${consequentStatementString}' statement...`);
+    localContext.trace(`Unifying the '${statementString}' statement with the '${consequentString}' consequent...`);
 
-    const statementNode = statement.getNode(),
-          consequentStatementNode = consequentStatement.getNode(),
-          nodeA = consequentStatementNode,  ///
-          nodeB = statementNode,  ///
-          fileContextA = this.fileContext,  ///
-          localContextA = LocalContext.fromFileContext(fileContextA),
-          localContextB = localContext, ///
-          unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
-
-    statementUnified = unified; ///
+    statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, this.fileContext, localContext);
 
     if (statementUnified) {
-      localContext.debug(`...unified the '${statementString}' statement with the consequent's '${consequentStatementString}' statement.`);
+      localContext.debug(`...unified the '${statementString}' statement with the '${consequentString}' consequent.`);
     }
 
     return statementUnified;

package/src/context/release.js

@@ -512,7 +512,9 @@ function verifyFileContext(fileContext) {
   if (node !== null) {
     fileContext.reset();
 
-    fileContextVerified = topLevelVerifier.verify(node, fileContext);
+    const verifiedAtTopLevel = topLevelVerifier.verify(node, fileContext);
+
+    fileContextVerified = verifiedAtTopLevel; ///
   }
 
   return fileContextVerified;

package/src/declaration.js

@@ -3,60 +3,60 @@
 import { stripBracketsFromStatement } from "./utilities/brackets";
 
 export default class Declaration {
-  constructor(reference, statementNode) {
+  constructor(reference, statement) {
     this.reference = reference;
-    this.statementNode = statementNode;
+    this.statement = statement;
   }
 
   getReference() {
     return this.reference;
   }
 
-  getStatementNode() {
-    return this.statementNode;
-  }
-
-  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;
-  }
+  getStatement() {
+    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;
+  // }
 }

package/src/equality.js

@@ -45,23 +45,22 @@ export default class Equality {
   }
 
   verify(assignments, stated, localContext) {
-    let verified;
+    let verified = false;
 
     const equalityString = this.string; ///
 
     localContext.trace(`Verifying the '${equalityString}' equality...`);
 
-    if (stated) {
-      const verifiedWhenStated = this.verifyWhenStated(localContext);
+    let verifiedWhenStated = false,
+        verifiedWhenDerived = false;
 
-      verified = verifiedWhenStated;  ///
+    if (stated) {
+      verifiedWhenStated = this.verifyWhenStated(localContext);
     } else {
-      const verifiedWhenDerived = this.verifyWhenDerived(localContext);
-
-      verified = verifiedWhenDerived; ///
+      verifiedWhenDerived = this.verifyWhenDerived(localContext);
     }
 
-    if (verified) {
+    if (verifiedWhenStated || verifiedWhenDerived) {
       if (assignments !== null) {
         const equality = this,  //
               equalityAssignment = EqualityAssignment.fromEquality(equality),

package/src/equivalence.js

@@ -2,6 +2,7 @@
 
 import { nodeQuery } from "./utilities/query";
 import { stripBracketsFromTerm } from "./utilities/brackets";
+import { variableNameFromVariableNode } from "./utilities/name";
 
 const variableNodeQuery = nodeQuery("/term/variable!");
 
@@ -227,7 +228,8 @@ function termTypeFromTerm(term, localContext) {
         variableNode = variableNodeQuery(termNode);
 
   if (variableNode !== null) {
-    const variable = localContext.findVariableByVariableNode(variableNode),
+    const variableName = variableNameFromVariableNode(variableNode),
+          variable = localContext.findVariableByVariableName(variableName),
           variableType = variable.getType();
 
     termType = variableType;  ///