occam-verify-cli 0.0.1059 → 0.0.1063

package/src/assertion/defined.js

@@ -0,0 +1,188 @@
+"use strict";
+
+import shim from "../shim";
+
+import { isAssertionNegated } from "../utilities/assertion";
+import { variableNameFromVariableNode, metavariableNameFromMetavariableNode } from "../utilities/name";
+
+export default class DefinedAssertion {
+  constructor(string, node, term, frame) {
+    this.string = string;
+    this.node = node;
+    this.term = term;
+    this.frame= frame
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getNode() {
+    return this.node;
+  }
+
+  getTerm() {
+    return this.term;
+  }
+
+  getStatement() {
+    return this.frame;
+  }
+
+  verify(assignments, stated, localContext) {
+    let verified = false;
+
+    const definedAssertionString = this.string; ///
+
+    localContext.trace(`Verifying the '${definedAssertionString}' defined assertion...`);
+
+    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...`);
+
+    debugger
+
+    if (this.term !== null) {
+
+    }
+
+    if (this.frame!== null) {
+
+    }
+
+    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;
+  }
+}
+
+function verifyDerivedDefinedAssertion(definedAssertionNode, assignments, stated, localContext) {
+  let derivedDefinedAssertionVerified = false;
+
+  if (!stated) {
+    const definedAssertionString = localContext.nodeAsString(definedAssertionNode);
+
+    localContext.trace(`Verifying the '${definedAssertionString}' derived defined assertion...`, definedAssertionNode);
+
+    const assertionNegated = isAssertionNegated(definedAssertionNode),
+      metavariableNode = metavariableNodeQuery(definedAssertionNode),
+      variableNode = variableNodeQuery(definedAssertionNode);
+
+    if (false) {
+      ///
+    } else if (metavariableNode !== null) {
+      const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+        metavariableDefinedByMetavariableName = localContext.isMetavariableDefinedByMetavariableName(metavariableName);
+
+      if (!assertionNegated) {
+        if (metavariableDefinedByMetavariableName) {
+          derivedDefinedAssertionVerified = true;
+        }
+      }
+
+      if (assertionNegated) {
+        if (!metavariableDefinedByMetavariableName) {
+          derivedDefinedAssertionVerified = true;
+        }
+      }
+    } else if (variableNode !== null) {
+      const variableName = variableNameFromVariableNode(variableNode),
+        variable = localContext.findVariableByVariableName(variableName),
+        variableDefined = localContext.isVariableDefined(variable);
+
+      if (!assertionNegated) {
+        if (variableDefined) {
+          derivedDefinedAssertionVerified = true;
+        }
+      }
+
+      if (assertionNegated) {
+        if (!variableDefined) {
+          derivedDefinedAssertionVerified = true;
+        }
+      }
+    }
+
+    if (derivedDefinedAssertionVerified) {
+      localContext.debug(`...verified the '${definedAssertionString}' derived defined assertion.`, definedAssertionNode);
+    }
+  }
+
+  return derivedDefinedAssertionVerified;
+}

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) {

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/context/release.js

@@ -81,11 +81,7 @@ export default class ReleaseContext {
     return released;
   }
 
-  findFile(filePath) {
-    const file = this.entries.getFile(filePath);
-
-    return file;
-  }
+  findFile(filePath) { return this.entries.findFile(filePath); }
 
   findFileContext(filePath) {
     const fileContext = this.fileContexts.find((fileContext) => {
@@ -457,7 +453,7 @@ function fileContextsFromJSONAndEntries(json, entries, fileContexts, releaseCont
 
   fileContextsJSON.forEach((fileContextJSON) => {
     const { filePath } = fileContextJSON,
-          file = entries.getFile(filePath),
+          file = entries.findFile(filePath),
           fileContext = FileContext.fromFile(file, releaseContext);
 
     fileContext.initialise(fileContextJSON);
@@ -516,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;  ///