occam-verify-cli 0.0.1016 → 0.0.1020

package/src/equality.js

@@ -1,15 +1,25 @@
 "use strict";
 
+import shim from "./shim";
 import equalityUnifier from "./unifier/equality";
+import EqualityAssignment from "./assignment/equality";
 
-import { first, second } from "./utilities/array";
+import { nodeQuery } from "./utilities/query";
+
+const leftTermNodeQuery = nodeQuery("/equality/term[0]"),
+      rightTermNodeQuery = nodeQuery("/equality/term[1]");
 
 export default class Equality {
-  constructor(leftTerm, rightTerm) {
+  constructor(string,leftTerm, rightTerm) {
+    this.string = string;
     this.leftTerm = leftTerm;
     this.rightTerm = rightTerm;
   }
 
+  getString() {
+    return this.string;
+  }
+
   getLeftTerm() {
     return this.leftTerm;
   }
@@ -34,37 +44,128 @@ export default class Equality {
     return equal;
   }
 
-  static fromTermsAndEqualityNode(terms, equalityNode) {
-    let equality = null;
+  verify(assignments, stated, localContext) {
+    let verified;
 
-    const firstTerm = first(terms),
-          secondTerm = second(terms),
-          leftTerm = firstTerm, ///
-          rightTerm = secondTerm, ///
-          leftTermType = leftTerm.getType(),
-          rightTermType = rightTerm.getType(),
-          leftTermTypeComparableToRightTermType = leftTermType.isComparableTo(rightTermType);
+    const equalityString = this.string; ///
 
-    if (leftTermTypeComparableToRightTermType) {
-      const node = equalityNode;  ///
+    localContext.trace(`Verifying the '${equalityString}' equality...`);
 
-      equality = new Equality(node, leftTerm, rightTerm);
+    if (stated) {
+      const verifiedWhenStated = this.verifyWhenStated(localContext);
+
+      verified = verifiedWhenStated;  ///
+    } else {
+      const verifiedWhenDerived = this.verifyWhenDerived(localContext);
+
+      verified = verifiedWhenDerived; ///
     }
 
-    return equality;
+    if (verified) {
+      if (assignments !== null) {
+        const equality = this,  //
+              equalityAssignment = EqualityAssignment.fromEquality(equality),
+              assignment = equalityAssignment; ///
+
+        assignments.push(assignment);
+      }
+
+      verified = true;
+    }
+
+    if (verified) {
+      localContext.debug(`...verified the '${equalityString}' equality.`);
+    }
+
+    return verified;
+  }
+
+  verifyTerms(localContext) {
+    let termsVerified;
+
+    const equalityString = this.string; ///
+
+    localContext.trace(`Verifying the '${equalityString}' equality's terms...`);
+
+    const leftTermVerified = this.leftTerm.verify(localContext, () => {
+      let verifiedAhead;
+
+      const rightTermVerified = this.rightTerm.verify(localContext, () => {
+        let verifiedAhead;
+
+        const leftTermType = this.leftTerm.getType(),
+              rightTermType = this.rightTerm.getType(),
+              leftTermTypeComparableToRightTermType = leftTermType.isComparableTo(rightTermType);
+
+        verifiedAhead = leftTermTypeComparableToRightTermType;  ///
+
+        return verifiedAhead;
+      });
+
+      verifiedAhead = rightTermVerified; ///
+
+      return verifiedAhead;
+    });
+
+    termsVerified = leftTermVerified; ///
+
+    if (termsVerified) {
+      localContext.debug(`...verified the '${equalityString}' equality's terms.`);
+    }
+
+    return termsVerified;
+  }
+
+  verifyWhenStated(localContext) {
+    let verifiedWhenStated;
+
+    const equalityString = this.string; ///
+
+    localContext.trace(`Verifying the '${equalityString}' equality when stated...`);
+
+    const termsVerified = this.verifyTerms(localContext);
+
+    verifiedWhenStated = termsVerified; ///
+
+    if (verifiedWhenStated) {
+      localContext.debug(`...verified the '${equalityString}' equality when stated.`);
+    }
+
+    return verifiedWhenStated;
   }
 
-  static fromLeftTermRightTermAndEqualityNode(leftTerm, rightTerm, equalityNode) {
-    let equality = null;
+  verifyWhenDerived(localContext) {
+    let verifiedWhenDerived = false;
+
+    const equalityString = this.string; ///
+
+    localContext.trace(`Verifying the '${equalityString}' equality when derived...`);
+
+    const termsVerified = this.verifyTerms(localContext);
 
-    const leftTermType = leftTerm.getType(),
-          rightTermType = rightTerm.getType(),
-          leftTermTypeComparableToRightTermType = leftTermType.isComparableTo(rightTermType);
+    if (termsVerified) {
+      const equal = this.isEqual(localContext);
 
-    if (leftTermTypeComparableToRightTermType) {
-      equality = new Equality(leftTerm, rightTerm);
+      verifiedWhenDerived = equal;  ///
     }
 
+    if (verifiedWhenDerived) {
+      localContext.debug(`...verified the '${equalityString}' equality when derived.`);
+    }
+
+    return verifiedWhenDerived;
+  }
+
+  static fromEqualityNode(equalityNode, localContext) {
+    const { Term } = shim,
+          leftTermNode = leftTermNodeQuery(equalityNode),
+          rightTermNode = rightTermNodeQuery(equalityNode),
+          leftTerm = Term.fromTermNode(leftTermNode, localContext),
+          rightTerm = Term.fromTermNode(rightTermNode, localContext),
+          node = equalityNode,  ///
+          string = localContext.nodeAsString(node),
+          equality = new Equality(string, leftTerm, rightTerm);
+
     return equality;
   }
 }

package/src/index.js

@@ -1,5 +1,11 @@
 "use strict";
 
+import Type from "./type";
+import Term from "./term";
+import MetaType from "./metaType";
+import Statement from "./statement";
+import ProofStep from "./proofStep";
+
 export { default as Log } from "./log";
 export { default as verifyRelease } from "./verify/release";
 export { default as ReleaseContext } from "./context/release";

package/src/label.js

@@ -19,12 +19,12 @@ export default class Label {
 
   matchMetavariableNode(metavariableNode) { return this.metavariable.matchMetavariableNode(metavariableNode); }
 
-  verify(fileContext) {
-    let verified = false;
+  verifyAtTopLevel(fileContext) {
+    let verifiedAtTopLevel = false;
 
     const labelString = this.getString(); ///
 
-    fileContext.trace(`Verifying the '${labelString}' label...`);
+    fileContext.trace(`Verifying the '${labelString}' label at top level...`);
 
     const metavariableNode = this.metavariable.getNode(),
           labelPresent = fileContext.isLabelPresentByMetavariableNode(metavariableNode);
@@ -32,14 +32,14 @@ export default class Label {
     if (labelPresent) {
       fileContext.debug(`The '${labelString}' label is already present.`);
     } else {
-      verified = true;
+      verifiedAtTopLevel = true;
     }
 
-    if (verified) {
-      fileContext.debug(`...verified the '${labelString}' label.`);
+    if (verifiedAtTopLevel) {
+      fileContext.debug(`...verified the '${labelString}' label at top level.`);
     }
 
-    return verified;
+    return verifiedAtTopLevel;
   }
 
   toJSON() {

package/src/lemma.js

@@ -1,7 +1,97 @@
 "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("/lemma/proof"),
+      labelNodesQuery = nodesQuery("/lemma/label"),
+      consequentNodeQuery = nodeQuery("/lemma/consequent"),
+      suppositionNodesQuery = nodesQuery("/lemma/supposition");
+
 export default class Lemma extends TopLevelAssertion {
-  static fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext) { return TopLevelAssertion.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(Lemma, labels, suppositions, consequent, substitutions, fileContext); }
+  verify() {
+    let verified = false;
+
+    const labelsString = labelsStringFromLabels(this.labels);
+
+    (labelsString === null) ?
+      this.fileContext.trace(`Verifying a lemma...`) :
+        this.fileContext.trace(`Verifying the '${labelsString}' lemma...`);
+
+    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 lemma = this;  ///
+
+            this.fileContext.addLemma(lemma);
+
+            verified = true;
+          }
+        }
+      }
+    }
+
+    if (verified) {
+      (labelsString === null) ?
+        this.fileContext.debug(`...verified a lemma.`) :
+          this.fileContext.debug(`...verified the '${labelsString}' lemma.`);
+    }
+
+    return verified;
+  }
+
+  static fromJSON(json, fileContext) { return TopLevelAssertion.fromJSON(Lemma, json, fileContext); }
+
+  static fromLemmaNode(lemmaNode, fileContext) {
+    const proofNode = proofNodeQuery(lemmaNode),
+          labelNodes = labelNodesQuery(lemmaNode),
+          consequentNode = consequentNodeQuery(lemmaNode),
+          suppositionNodes = suppositionNodesQuery(lemmaNode),
+          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),
+          lemma = new Lemma(fileContext, labels, suppositions, consequent, proof);
+
+    return lemma;
+  }
 }

package/src/metavariable.js

@@ -54,31 +54,32 @@ export default class Metavariable {
     return metavariableNodeMatches;
   }
 
-  verify(fileContext) {
+  verify(localContext) {
     let verified = false;
 
     const metavariableString = this.string; ///
 
-    fileContext.trace(`Verifying the '${metavariableString}' metavariable...`);
+    localContext.trace(`Verifying the '${metavariableString}' metavariable...`);
 
     debugger
 
     if (verified) {
-      fileContext.debug(`...verified the '${metavariableString}' metavariable.`);
+      localContext.debug(`...verified the '${metavariableString}' metavariable.`);
     }
 
     return verified;
   }
 
-  verifyWhenDeclared(fileContext) {
-    let verifiedWhenDeclared = false;
+  verifyAtTopLevel(fileContext) {
+    let verifiedAtTopLevel = false;
 
     const metavariableString = this.string; ///
 
-    fileContext.trace(`Verifying the '${metavariableString}' metavariable when declared...`);
+    fileContext.trace(`Verifying the '${metavariableString}' metavariable at top level...`);
 
     const metavariableNode = this.node, ///
-          metavariablePresent = fileContext.isMetavariablePresentByMetavariableNode(metavariableNode);
+          metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+          metavariablePresent = fileContext.isMetavariablePresentByMetavariableName(metavariableName);
 
     if (metavariablePresent) {
       fileContext.debug(`The metavariable '${metavariableString}' is already present.`);
@@ -87,21 +88,21 @@ export default class Metavariable {
             argument = Argument.fromArgumentNode(argumentNode, fileContext);
 
       if (argument === null) {
-        verifiedWhenDeclared = true;
+        verifiedAtTopLevel = true;
       } else {
         const argumentVerified = argument.verify(fileContext);
 
         if (argumentVerified) {
-          verifiedWhenDeclared = true;
+          verifiedAtTopLevel = true;
         }
       }
     }
 
-    if (verifiedWhenDeclared) {
-      fileContext.debug(`...verified the '${metavariableString}' metavariable when declared.`);
+    if (verifiedAtTopLevel) {
+      fileContext.debug(`...verified the '${metavariableString}' metavariable at top level.`);
     }
 
-    return verifiedWhenDeclared;
+    return verifiedAtTopLevel;
   }
 
   toJSON() {
@@ -152,16 +153,6 @@ export default class Metavariable {
     return metavariable;
   }
 
-  static fromMetavariableNodeAndMetaType(metavariableNode, metaType, fileContext) {
-    const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-          node = metavariableNode,  ///
-          name = metavariableName,  ///
-          string = fileContext.nodeAsString(node),
-          metavariable = new Metavariable(string, node, name, metaType);
-
-    return metavariable;
-  }
-
   static fromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext) {
     const metaTypeNode = metaTypeNodeQuery(metavariableDeclarationNode),
           metavariableNode = metavariableNodeQuery(metavariableDeclarationNode),

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

@@ -150,9 +150,9 @@ function unifyAWithReference(qualifiedStatement, substitutions, localContext) {
           referenceMetavariableNode = reference.getMetavariableNode(),
           metavariableNodeA = referenceMetavariableNode, ///
           metavariableNodeB = metavariableNode, ///
-          unified = metavariableUnifier.unify(metavariableNodeA, metavariableNodeB, localContext);
+          metavariableUnified = metavariableUnifier.unify(metavariableNodeA, metavariableNodeB, localContext);
 
-    if (unified) {
+    if (metavariableUnified) {
       const statementNode = statement.getNode(),
             metavariableNode = metavariableNodeA, ///
             statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementNodeAndMetavariableNode(statementNode, metavariableNode, localContextA, localContextB),

package/src/mixins/statement/verify.js

@@ -1,7 +1,8 @@
 "use strict";
 
+import Equality from "../../equality";
+
 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";
@@ -57,7 +58,8 @@ function verifyAsEquality(statement, assignments, stated, localContext) {
 
     localContext.trace(`Verifying the '${statementString}' statement as an equality...`);
 
-    const equalityVerified = verifyEquality(equalityNode, assignments, stated, localContext);
+    const equality = Equality.fromEqualityNode(equalityNode, localContext),
+          equalityVerified = equality.verify(assignments, stated, localContext);
 
     verifiedAsEquality = equalityVerified; ///
 
@@ -261,9 +263,7 @@ function unifyMetavariable(metavariableNode, localContext) {
 
     const metavariableNodeB = metavariableNode; ///
 
-    const unified = metavariableUnifier.unify(metavariableNodeA, metavariableNodeB, localContext);
-
-    metavariableUnified = unified;  ///
+    metavariableUnified = metavariableUnifier.unify(metavariableNodeA, metavariableNodeB, localContext);
   }
 
   if (metavariableUnified) {

package/src/mixins/term/unify.js

@@ -0,0 +1,110 @@
+"use strict";
+
+import shim from "../../shim";
+import BracketedConstructor from "../../constructor/bracketed";
+import termWithConstructorUnifier from "../../unifier/termWithConstructor";
+
+import { nodeQuery } from "../../utilities/query";
+
+const termNodeQuery = nodeQuery("/term/argument/term");
+
+function unifyTermWithBracketedConstructor(term, localContext, verifyAhead) {
+  let termUnifiedWithBracketedConstructor;
+
+  const termString = term.getString();
+
+  localContext.trace(`Unifying the '${termString}' term with the bracketed constructor...`, term);
+
+  const bracketedConstructor = BracketedConstructor.fromNothing();
+
+  termUnifiedWithBracketedConstructor = unifyTermWithConstructor(term, bracketedConstructor, localContext, () => {
+    let verifiedAhead = false;
+
+    const bracketedTerm = term, ///
+          bracketedTermNode = bracketedTerm.getNode(),
+          termNode = termNodeQuery(bracketedTermNode); ///
+
+    if (termNode !== null) {
+      const { Term } = shim;
+
+      term = Term.fromTermNode(termNode, localContext);
+
+      const termVVerified = term.verify(localContext, () => {
+        let verifiedAhead;
+
+        const type = term.getType();
+
+        bracketedTerm.setType(type);
+
+        verifiedAhead = verifyAhead();
+
+        return verifiedAhead;
+      });
+
+      verifiedAhead = termVVerified;  ///
+    }
+
+    return verifiedAhead;
+  });
+
+  if (termUnifiedWithBracketedConstructor) {
+    localContext.debug(`...unified the '${termString}' term with the bracketed constructor.`, term);
+  }
+
+  return termUnifiedWithBracketedConstructor;
+}
+
+function unifyTermWithConstructors(term, localContext, verifyAhead) {
+  let termUnifiedWithConstructors = false;
+
+  const constructors = localContext.getConstructors();
+
+  termUnifiedWithConstructors = constructors.some((constructor) => {
+    const termUnifiedWithConstructor = unifyTermWithConstructor(term, constructor, localContext, verifyAhead);
+
+    if (termUnifiedWithConstructor) {
+      return true;
+    }
+  });
+
+  return termUnifiedWithConstructors;
+}
+
+const unifyMixins = [
+  unifyTermWithBracketedConstructor,
+  unifyTermWithConstructors
+];
+
+export default unifyMixins;
+
+function unifyTermWithConstructor(term, constructor, localContext, verifyAhead) {
+  let termUnifiedWithConstructor = false;
+
+  const termString = term.getString(),
+        constructorString = constructor.getString();
+
+  localContext.trace(`Unifying the '${termString}' term with the '${constructorString}' constructor...`, term);
+
+  const termNode = term.getNode(),
+        constructorTerm = constructor.getTerm(),
+        constructorTermNode = constructorTerm.getNode(),
+        unified = termWithConstructorUnifier.unify(termNode, constructorTermNode, localContext);
+
+  if (unified) {
+    let verifiedAhead;
+
+    const type = constructor.getType();
+
+    term.setType(type);
+
+    verifiedAhead = verifyAhead();
+
+    termUnifiedWithConstructor = verifiedAhead;  ///
+  }
+
+  if (termUnifiedWithConstructor) {
+    localContext.debug(`...unified the '${termString}' term with the '${constructorString}' constructor.`, term);
+  }
+
+  return termUnifiedWithConstructor;
+}

package/src/mixins/term/verify.js

@@ -0,0 +1,47 @@
+"use strict";
+
+import Variable from "../../variable";
+
+import { nodeQuery } from "../../utilities/query";
+
+const variableNodeQuery = nodeQuery("/term/variable");
+
+function verifyTermAsVariable(term, localContext, verifyAhead) {
+  let termVerifiedAsVariable = false;
+
+  const termNode = term.getNode(),
+        variableNode = variableNodeQuery(termNode);
+
+  if (variableNode !== null) {
+    const termString = localContext.nodeAsString(termNode);
+
+    localContext.trace(`Verifying the '${termString}' term as a variable...`, termNode);
+
+    const variable = Variable.fromVariableNode(variableNode, localContext),
+          variableVerified = variable.verify(localContext);
+
+    if (variableVerified) {
+      let verifiedAhead;
+
+      const type = variable.getType();
+
+      term.setType(type);
+
+      verifiedAhead = verifyAhead();
+
+      termVerifiedAsVariable = verifiedAhead; ///
+    }
+
+    if (termVerifiedAsVariable) {
+      localContext.debug(`...verified the '${termString}' term as a variable.`, termNode);
+    }
+  }
+
+  return termVerifiedAsVariable;
+}
+
+const verifyMixins = [
+  verifyTermAsVariable
+];
+
+export default verifyMixins;

package/src/node/term/constructor/bracketed.js

@@ -1,9 +1,10 @@
 "use strict";
 
-import bracketedConstructorTermTokens from "../../../tokens/constructorTerm/bracketed";
+import { OBJECT_TYPE_NAME } from "../../../typeNames";
+import { termNodeFromTermString } from "../../../utilities/node";
 
-import { termNodeFromTermTokens } from "../../../utilities/node";
+export const bracketedConstructorTermString = `(${OBJECT_TYPE_NAME})`;
 
-const bracketedConstructorTermNode = termNodeFromTermTokens(bracketedConstructorTermTokens);
+const bracketedConstructorTermNode = termNodeFromTermString(bracketedConstructorTermString)
 
 export default bracketedConstructorTermNode;

package/src/premise.js

@@ -6,10 +6,8 @@ import metaLevelUnifier from "./unifier/metaLevel";
 import SubproofAssertion from "./assertion/subproof";
 import UnqualifiedStatement from "./statement/unqualified";
 
-import { trim } from "./utilities/string";
 import { nodeQuery } from "./utilities/query";
 import { assignAssignments } from "./utilities/assignments";
-import { unqualifiedStatementNodeFromUnqualifiedStatementString } from "./utilities/node";
 
 const unqualifiedStatementNodeQuery = nodeQuery("/premise/unqualifiedStatement");
 
@@ -108,10 +106,9 @@ export default class Premise {
   }
 
   verify(localContext) {
-    let verified = false,
-        premiseString = this.getString(); ///
+    let verified = false;
 
-    premiseString = trim(premiseString);  ///
+    const premiseString = this.getString(); ///
 
     if (this.unqualifiedStatement !== null) {
       localContext.trace(`Verifying the '${premiseString}' premise...`);

package/src/proofStep.js

@@ -73,7 +73,7 @@ class ProofStep {
     } else if (this.unqualifiedStatement !== null) {
       const stated = true,
             assignments = [],
-            unqualifiedStatementVerified = this.unqualifiedStatement.verify(stated, assignments, localContext);
+            unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, localContext);
 
       verified = unqualifiedStatementVerified;  ///
     }