occam-verify-cli 0.0.1032 → 0.0.1035

package/src/substitution/termForVariable.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import shim from "../shim";
 import Substitution from "../substitution";
 
 import { nodeQuery } from "../utilities/query";
@@ -25,12 +26,6 @@ export default class TermForVariableSubstitution extends Substitution {
     return this.variableNode;
   }
 
-  getNode() {
-    const node = this.termNode; ///
-
-    return node;
-  }
-
   transformed(substitutions) {
     let transformedSubstitution = null;
 
@@ -88,6 +83,22 @@ export default class TermForVariableSubstitution extends Substitution {
     return unifiedWithEquivalence;
   }
 
+  static fromTernAndVariable(term, variable, localContext) {
+    let termNode = term.getNode();
+
+    termNode = stripBracketsFromTerm(termNode); ///
+
+    const { Term } = shim;
+
+    term = Term.fromTermNode(termNode, localContext)
+
+    const string = stringFromTermAndVariable(term, variable),
+          variableNode = variable.getNode(),
+          termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode);
+
+    return termForVariableSubstitution;
+  }
+
   static fromSubstitutionNode(substitutionNode) {
     let termForVariableSubstitution = null;
 
@@ -106,15 +117,6 @@ export default class TermForVariableSubstitution extends Substitution {
 
     return termForVariableSubstitution;
   }
-
-  static fromTernNodeAndVariableNode(termNode, variableNode, localContextA, localContextB) {
-    termNode = stripBracketsFromTerm(termNode); ///
-
-    const string = stringFromTermNodeAndVariableNode(termNode, variableNode, localContextA, localContextB),
-          termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode);
-
-    return termForVariableSubstitution;
-  }
 }
 
 function transformTermNode(termNode, substitutions) {
@@ -162,12 +164,10 @@ function transformVariableNode(variableNode, substitutions) {
   return transformedVariableNode;
 }
 
-function stringFromTermNodeAndVariableNode(termNode, variableNode, localContextA, localContextB) {
-  const termNodeB = termNode,  ///
-        termStringB = localContextB.nodeAsString(termNodeB),
-        variableNodeA = variableNode,  ///
-        variableStringA = localContextA.nodeAsString(variableNodeA),
-        string = `[${termStringB} for ${variableStringA}]`;
+function stringFromTermAndVariable(term, variable) {
+  const termString = term.getString(),
+        variableString = variable.getString(),
+        string = `[${termString} for ${variableString}]`;
 
   return string;
 }

package/src/supposition.js

@@ -12,8 +12,9 @@ import { assignAssignments } from "./utilities/assignments";
 const unqualifiedStatementNodeQuery = nodeQuery("/supposition/unqualifiedStatement");
 
 export default class Supposition {
-  constructor(fileContext, unqualifiedStatement) {
+  constructor(fileContext, subproofAssertion, unqualifiedStatement) {
     this.fileContext = fileContext;
+    this.subproofAssertion = subproofAssertion;
     this.unqualifiedStatement = unqualifiedStatement;
   }
 
@@ -21,6 +22,10 @@ export default class Supposition {
     return this.fileContext;
   }
 
+  getSubproofAssertion() {
+    return this.subproofAssertion;
+  }
+
   getUnqualifiedStatement() {
     return this.unqualifiedStatement;
   }
@@ -90,12 +95,8 @@ export default class Supposition {
 
     localContext.trace(`Unifying the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement...`);
 
-    const statement = this.unqualifiedStatement.getStatement(),
-          statementNode = statement.getNode(),
-          subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, this.fileContext);
-
-    if (subproofAssertion !== null) {
-      subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, localContext);
+    if (this.subproofAssertion !== null) {
+      subproofUnified = this.subproofAssertion.unifySubproof(subproof, substitutions, localContext);
     }
 
     if (subproofUnified) {
@@ -142,22 +143,33 @@ export default class Supposition {
 
   toJSON() {
     const unqualifiedStatementJSON = this.unqualifiedStatement.toJSON(),
+          subproofAssertionJSON = (this.subproofAssertion !== null) ?
+                                     this.subproofAssertion.toJSON() :
+                                       null,
           unqualifiedStatement = unqualifiedStatementJSON,  ///
+          subproofAssertion = subproofAssertionJSON,  ///
           json = {
-            unqualifiedStatement
+            unqualifiedStatement,
+            subproofAssertion
           };
 
     return json;
   }
 
   static fromJSON(json, fileContext) {
-    let { unqualifiedStatement } = json;
+    let { subproofAssertion, unqualifiedStatement } = json;
 
     json = unqualifiedStatement;  ///
 
     unqualifiedStatement = UnqualifiedStatement.fromJSON(json, fileContext);
 
-    const supposition = new Supposition(fileContext, unqualifiedStatement);
+    json = subproofAssertion; ///
+
+    subproofAssertion = (json !== null) ?
+                          SubproofAssertion.fromJSON(json, fileContext) :
+                            null;
+
+    const supposition = new Supposition(fileContext, subproofAssertion, unqualifiedStatement);
 
     return supposition;
   }
@@ -165,7 +177,8 @@ export default class Supposition {
   static fromSuppositionNode(suppositionNode, fileContext) {
     const unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
           unqualifiedStatement = UnqualifiedStatement.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
-          supposition = new Supposition(fileContext, unqualifiedStatement);
+          subproofAssertion = SubproofAssertion.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
+          supposition = new Supposition(fileContext, subproofAssertion, unqualifiedStatement);
 
     return supposition
   }

package/src/term.js

@@ -8,6 +8,7 @@ import termAsConstructorVerifier from "./verifier/termAsConstructor";
 import { filter } from "./utilities/array";
 import { nodesQuery } from "./utilities/query"
 import { termNodeFromTermString } from "./utilities/node";
+import {objectType} from "./type";
 
 const variableNodesQuery = nodesQuery("//variable");
 
@@ -136,22 +137,26 @@ class Term {
   verifyType(fileContext) {
     let typeVerified;
 
-    const typeName = this.type.getName();
+    if (this.type === objectType) {
+      typeVerified = true;
+    } else {
+      const typeName = this.type.getName();
 
-    fileContext.trace(`Verifying the '${typeName}' type...`);
+      fileContext.trace(`Verifying the '${typeName}' type...`);
 
-    const type = fileContext.findTypeByTypeName(typeName);
+      const type = fileContext.findTypeByTypeName(typeName);
 
-    if (type === null) {
-      fileContext.debug(`The '${typeName}' type is missing.`);
-    } else {
-      this.type = type; ///
+      if (type === null) {
+        fileContext.debug(`The '${typeName}' type is missing.`);
+      } else {
+        this.type = type; ///
 
-      typeVerified = true;
-    }
+        typeVerified = true;
+      }
 
-    if (typeVerified) {
-      fileContext.debug(`...verified the '${typeName}' type.`);
+      if (typeVerified) {
+        fileContext.debug(`...verified the '${typeName}' type.`);
+      }
     }
 
     return typeVerified;
@@ -160,10 +165,10 @@ class Term {
   verifyGivenType(type, localContext) {
     let verifiedGivenType;
 
-    const termString = this.getString(),
-          typeString = type.getString();
+    const typeName = type.getName(),
+          termString = this.getString();
 
-    localContext.trace(`Verifying the '${termString}' term given the '${typeString}' type...`);
+    localContext.trace(`Verifying the '${termString}' term given the '${typeName}' type...`);
 
     const verified = this.verify(localContext, () => {
       let verifiedAhead;
@@ -180,7 +185,7 @@ class Term {
     verifiedGivenType = verified; ///
 
     if (verifiedGivenType) {
-      localContext.debug(`...verified the '${termString}' term given the '${typeString}' type.`);
+      localContext.debug(`...verified the '${termString}' term given the '${typeName}' type.`);
     }
 
     return verifiedGivenType;
@@ -243,9 +248,9 @@ class Term {
     return term;
   }
 
-  static fromTermNodeAndType(termNode, type, fileContext) {
+  static fromTermNodeAndType(termNode, type, localContext) {
     const node = termNode,  ///
-          string = fileContext.nodeAsString(node),
+          string = localContext.nodeAsString(node),
           term = new Term(string, node, type);
 
     return term;

package/src/theorem.js

@@ -1,7 +1,93 @@
 "use strict";
 
+import Label from "./label";
+import Proof from "./proof";
+import Consequent from "./consequent";
+import Supposition from "./supposition";
+import LocalContext from "./context/local";
+import Substitutions from "./substitutions";
 import TopLevelAssertion from "./topLevelAssertion";
 
+import { nodeQuery, nodesQuery } from "./utilities/query";
+import { labelsStringFromLabels } from "./topLevelAssertion";
+
+const proofNodeQuery = nodeQuery("/theorem/proof"),
+      labelNodesQuery = nodesQuery("/theorem/label"),
+      consequentNodeQuery = nodeQuery("/theorem/consequent"),
+      suppositionNodesQuery = nodesQuery("/theorem/supposition");
+
 export default class Theorem extends TopLevelAssertion {
-  static fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext) { return TopLevelAssertion.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(Theorem, labels, suppositions, consequent, substitutions, fileContext); }
+  verify() {
+    let verified = false;
+
+    const labelsString = labelsStringFromLabels(this.labels);
+
+    this.fileContext.trace(`Verifying the '${labelsString}' theorem...`);
+
+    const labelsVerifiedAtTopLevel = this.labels.every((label) => {
+      const labelVVerifiedAtTopLevel = label.verifyAtTopLevel(this.fileContext);
+
+      if (labelVVerifiedAtTopLevel) {
+        return true;
+      }
+    });
+
+    if (labelsVerifiedAtTopLevel) {
+      const localContext = LocalContext.fromFileContext(this.fileContext),
+            suppositionsVerified = this.suppositions.every((supposition) => {
+              const suppositionVerified = supposition.verify(localContext);
+
+              if (suppositionVerified) {
+                return true;
+              }
+            });
+
+      if (suppositionsVerified) {
+        const consequentVerified = this.consequent.verify(localContext);
+
+        if (consequentVerified) {
+          const substitutions = Substitutions.fromNothing(),
+                proofVerified = this.proof.verify(substitutions, this.consequent, localContext);
+
+          if (proofVerified) {
+            const theorem = this;  ///
+
+            this.fileContext.addTheorem(theorem);
+
+            verified = true;
+          }
+        }
+      }
+    }
+
+    if (verified) {
+      this.fileContext.debug(`...verified the '${labelsString}' theorem.`);
+    }
+
+    return verified;
+  }
+
+  static fromJSON(json, fileContext) { return TopLevelAssertion.fromJSON(Theorem, json, fileContext); }
+
+  static fromTheoremNode(theoremNode, fileContext) {
+    const proofNode = proofNodeQuery(theoremNode),
+          labelNodes = labelNodesQuery(theoremNode),
+          consequentNode = consequentNodeQuery(theoremNode),
+          suppositionNodes = suppositionNodesQuery(theoremNode),
+          labels = labelNodes.map((labelNode) => {
+            const label = Label.fromLabelNode(labelNode, fileContext);
+
+            return label;
+          }),
+          suppositions = suppositionNodes.map((suppositionNode) => {
+            const supposition = Supposition.fromSuppositionNode(suppositionNode, fileContext);
+
+            return supposition;
+          }),
+          consequent = Consequent.fromConsequentNode(consequentNode, fileContext),
+          proof = Proof.fromProofNode(proofNode, fileContext),
+          theorem = new Theorem(fileContext, labels, suppositions, consequent, proof);
+
+    return theorem;
+  }
 }

package/src/unifier/intrinsicLevel.js

@@ -2,9 +2,9 @@
 
 import shim from "../shim";
 import Unifier from "../unifier";
-import unifyVariableWithTerm from "../unify/variableWithTerm";
 
 import { nodeQuery } from "../utilities/query";
+import { variableNameFromVariableNode } from "../utilities/name";
 
 const termNodeQuery = nodeQuery("/term!"),
       termVariableNodeQuery = nodeQuery("/term/variable!");
@@ -27,10 +27,23 @@ class IntrinsicLevelUnifier extends Unifier {
       nodeQueryA: termVariableNodeQuery,
       nodeQueryB: termNodeQuery,
       unify: (termVariableNodeA, termNodeB, substitutions, localContextA, localContextB) => {
+        let termUnified = false;
+
         const variableNodeA = termVariableNodeA, ///
-              variableUnifiedWithTerm = unifyVariableWithTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB);
+              variableNameA = variableNameFromVariableNode(variableNodeA),
+              variableA = localContextA.findVariableByVariableName(variableNameA);
+
+        if (variableA !== null) {
+          const { Term } = shim,
+                termB = Term.fromTermNode(termNodeB, localContextB),
+                localContext = localContextB, ///
+                variable = variableA, ///
+                term = termB; ///
+
+          termUnified = variable.unifyTerm(term, substitutions, localContext);
+        }
 
-        return variableUnifiedWithTerm;
+        return termUnified;
       }
     }
   ];

package/src/unifier/metaLevel.js

@@ -2,12 +2,12 @@
 
 import shim from "../shim";
 import Unifier from "../unifier";
-import unifyVariableWithTerm from "../unify/variableWithTerm";
 import unifyMetavariableWithFrame from "../unify/metavariableWithFrame";
 import unifyMetavariableWithStatement from "../unify/metavariableWithStatement";
 import unifyMetavariableWithStatementGivenSubstitution from "../unify/metavariableWithStatementGivenSubstitution";
 
 import { nodeQuery } from "../utilities/query";
+import { variableNameFromVariableNode } from "../utilities/name";
 
 const termNodeQuery = nodeQuery("/term!"),
       frameNodeQuery = nodeQuery("/frame!"),
@@ -70,6 +70,8 @@ class MetaLevelUnifier extends Unifier {
       nodeQueryA: frameMetavariableNodeQuery,
       nodeQueryB: frameNodeQuery,
       unify: (frameMetavariableNodeA, frameNodeB, substitutions, localContextA, localContextB) => {
+        debugger
+
         const metavariableNodeA = frameMetavariableNodeA, ///
               metavariableUnifiedWithFrame = unifyMetavariableWithFrame(metavariableNodeA, frameNodeB, substitutions, localContextA, localContextB);
 
@@ -80,10 +82,23 @@ class MetaLevelUnifier extends Unifier {
       nodeQueryA: termVariableNodeQuery,
       nodeQueryB: termNodeQuery,
       unify: (termVariableNodeA, termNodeB, substitutions, localContextA, localContextB) => {
+        let termUnified = false;
+
         const variableNodeA = termVariableNodeA, ///
-              variableUnifiedWithTerm = unifyVariableWithTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB);
+              variableNameA = variableNameFromVariableNode(variableNodeA),
+              variableA = localContextA.findVariableByVariableName(variableNameA);
+
+        if (variableA !== null) {
+          const { Term } = shim,
+                termB = Term.fromTermNode(termNodeB, localContextB),
+                localContext = localContextB, ///
+                variable = variableA, ///
+                term = termB; ///
+
+          termUnified = variable.unifyTerm(term, substitutions, localContext);
+        }
 
-        return variableUnifiedWithTerm;
+        return termUnified;
       }
     }
   ];

package/src/unifier/statementWithCombinator.js

@@ -55,7 +55,7 @@ class StatementWithCombinatorUnifier extends Unifier {
               metaTypeNode = metaTypeNodeB, ///
               frameNode = frameNodeA, ///
               metaType = MetaType.fromMetaTypeNode(metaTypeNode, localContext),
-              frame = Frame.fromTermNode(frameNode, localContext),
+              frame = Frame.fromFrameNode(frameNode, localContext),
               frameVerifiedGivenType = frame.verifyGivenMetaType(metaType, localContext);
 
         unified = frameVerifiedGivenType;

package/src/utilities/array.js

@@ -2,7 +2,7 @@
 
 import { arrayUtilities } from "necessary";
 
-export const { first, last, extract, tail, push, find, clear, match, prune, filter, compress, separate } = arrayUtilities;
+export const { first, last, front, tail, push, find, match, clear, prune, extract, filter, compress, separate } = arrayUtilities;
 
 export function reverse(array) {
   array = [ ///

package/src/utilities/unify.js

@@ -3,24 +3,9 @@
 import { nodeQuery } from "../utilities/query";
 import { metavariableNameFromMetavariableNode}  from "../utilities/name";
 
-const termVariableNodeQuery = nodeQuery("/term/variable"),
-      frameMetavariableNodeQuery = nodeQuery("/frame/metavariable"),
+const frameMetavariableNodeQuery = nodeQuery("/frame/metavariable"),
       statementMetavariableNodeQuery = nodeQuery("/statement/metavariable");
 
-export function variableFromTermNode(termNode, localContext) {
-  let variable = null;
-
-  const termVariableNode = termVariableNodeQuery(termNode);
-
-  if (termVariableNode !== null) {
-    const variableNode = termVariableNode;  ///
-
-    variable = localContext.findVariableByVariableNode(variableNode);
-  }
-
-  return variable;
-}
-
 export function metavariableFromFrameNode(frameNode, localContext) {
   let metavariable = null;
 

package/src/variable.js

@@ -2,6 +2,7 @@
 
 import shim from "./shim";
 import LocalContext from "./context/local";
+import TermForVariableSubstitution from "./substitution/termForVariable";
 
 import { nodeQuery } from "./utilities/query";
 import { objectType } from "./type";
@@ -9,7 +10,8 @@ import { variableNameFromVariableNode} from "./utilities/name";
 import { variableNodeFromVariableString } from "./utilities/node";
 
 const typeNodeQuery = nodeQuery("/variableDeclaration/type"),
-      variableNodeQuery = nodeQuery("/variableDeclaration/variable");
+      variableNodeQuery = nodeQuery("/variableDeclaration/variable"),
+      termVariableNodeQuery = nodeQuery("/term/variable");
 
 export default class Variable {
   constructor(string, node, name, type) {
@@ -35,6 +37,10 @@ export default class Variable {
     return this.type;
   }
 
+  setType(type) {
+    this.type = type;
+  }
+
   matchNode(node) {
     const nodeMatches = this.node.match(node);
 
@@ -78,22 +84,26 @@ export default class Variable {
   verifyType(fileContext) {
     let typeVerified;
 
-    const typeName = this.type.getName();
+    if (this.type === objectType) {
+      typeVerified = true;
+    } else {
+      const typeName = this.type.getName();
 
-    fileContext.trace(`Verifying the '${typeName}' type...`);
+      fileContext.trace(`Verifying the '${typeName}' type...`);
 
-    const type = fileContext.findTypeByTypeName(typeName);
+      const type = fileContext.findTypeByTypeName(typeName);
 
-    if (type === null) {
-      fileContext.debug(`The '${typeName}' type is missing.`);
-    } else {
-      this.type = type; ///
+      if (type === null) {
+        fileContext.debug(`The '${typeName}' type is missing.`);
+      } else {
+        this.type = type; ///
 
-      typeVerified = true;
-    }
+        typeVerified = true;
+      }
 
-    if (typeVerified) {
-      fileContext.debug(`...verified the '${typeName}' type.`);
+      if (typeVerified) {
+        fileContext.debug(`...verified the '${typeName}' type.`);
+      }
     }
 
     return typeVerified;
@@ -125,6 +135,47 @@ export default class Variable {
     return verifiedAtTopLevel;
   }
 
+  unifyTerm(term, substitutions, localContext) {
+    let termUnified = false;
+
+    const termString = term.getString(),
+          variableString = this.string; ///
+
+    localContext.trace(`Unifying the '${termString}' term with the '${variableString}' variable...`);
+
+    const termNode = term.getNode(),
+          variableNode = this.node, ///
+          substitution = substitutions.findSubstitutionByVariableNode(variableNode);
+
+    if (substitution !== null) {
+      const termNodeMatches = substitution.matchTermNode(termNode);
+
+      if (termNodeMatches) {
+        termUnified = true;
+      }
+    } else {
+      const variable = this,  ///
+            termVariable = termVariableFromTermNode(termNode, localContext);
+
+      if (termVariable === variable) {
+        termUnified = true;
+      } else {
+        const termForVariableSubstitution = TermForVariableSubstitution.fromTernAndVariable(term, variable, localContext),
+              substitution = termForVariableSubstitution;  ///
+
+        substitutions.addSubstitution(substitution, localContext);
+
+        termUnified = true;
+      }
+    }
+
+    if (termUnified) {
+      localContext.trace(`...unified the '${termString}' term with the '${variableString}' variable.`);
+    }
+
+    return termUnified;
+  }
+
   toJSON() {
     const typeJSON = this.type.toJSON(),
           string = this.string,
@@ -153,12 +204,17 @@ export default class Variable {
   }
 
   static fromVariableNode(variableNode, localContext) {
-    const node = variableNode,  ///
-          variableName = variableNameFromVariableNode(variableNode),
-          string = localContext.nodeAsString(node),
-          name = variableName,  ///
-          type = null,
-          variable = new Variable(string, node, name, type);
+    let variable = null;
+
+    if (variableNode !== null) {
+      const node = variableNode,  ///
+            variableName = variableNameFromVariableNode(variableNode),
+            string = localContext.nodeAsString(node),
+            name = variableName,  ///
+            type = null;
+
+      variable = new Variable(string, node, name, type);
+    }
 
     return variable;
   }
@@ -200,3 +256,17 @@ function typeFromJSON(json, fileContext) {
 
   return type;
 }
+
+function termVariableFromTermNode(termNode, localContext) {
+  let termVariable = null;
+
+  const termVariableNode = termVariableNodeQuery(termNode);
+
+  if (termVariableNode !== null) {
+    const termVariableName = variableNameFromVariableNode(termVariableNode);
+
+    termVariable = localContext.findVariableByVariableName(termVariableName);
+  }
+
+  return termVariable;
+}

package/src/verifier/topLevel.js

@@ -4,6 +4,7 @@ import Rule from "../rule";
 import Error from "../error";
 import Axiom from "../axiom";
 import Lemma from "../lemma";
+import Theorem from "../theorem";
 import TypeDeclaration from "../declaration/type";
 import VariableDeclaration from "../declaration/variable";
 import CombinatorDeclaration from "../declaration/combinator";
@@ -11,7 +12,6 @@ import ConstructorDeclaration from "../declaration/constructor";
 import MetavariableDeclaration from "../declaration/metavariable";
 
 import Verifier from "../verifier";
-import verifyTheorem from "../verify/theorem";
 import verifyMetaLemma from "../verify/metaLemma";
 import verifyConjecture from "../verify/conjecture";
 import verifyMetatheorem from "../verify/metatheorem";
@@ -84,7 +84,8 @@ class TopLevelVerifier extends Verifier {
     {
       nodeQuery: theoremNodeQuery,
       verify: (theoremNode, fileContext) => {
-        const theoremVerified = verifyTheorem(theoremNode, fileContext);
+        const theorem = Theorem.fromTheoremNode(theoremNode, fileContext),
+              theoremVerified = theorem.verify();
 
         return theoremVerified;
       }