occam-verify-cli 0.0.1016 → 0.0.1020

package/src/topLevelAssertion.js

@@ -1,17 +1,23 @@
 "use strict";
 
+import Label from "./label";
+import Consequent from "./consequent";
+import Supposition from "./supposition";
 import Substitutions from "./substitutions";
-import resolveSubstitutions from "./resolve/substitutions";
-import unifyConsequentWithStatement from "./unify/consequentWithStatement";
-import unifySuppositionsWithProofSteps from "./unify/suppositionsWithProofSteps";
+
+import { reverse, correlate } from "./utilities/array";
 
 export default class TopLevelAssertion {
-  constructor(labels, suppositions, consequent, substitutions, fileContext) {
+  constructor(fileContext, labels, suppositions, consequent, proof) {
+    this.fileContext = fileContext;
     this.labels = labels;
     this.suppositions = suppositions;
     this.consequent = consequent;
-    this.substitutions = substitutions;
-    this.fileContext = fileContext;
+    this.proof = proof;
+  }
+
+  getFileContext() {
+    return this.fileContext;
   }
 
   getLabels() {
@@ -26,50 +32,131 @@ export default class TopLevelAssertion {
     return this.consequent;
   }
 
-  getSubstitutions() {
-    return this.substitutions;
+  getProof() {
+    return this.proof;
   }
 
-  getFileContext() {
-    return this.fileContext;
-  }
+  matchMetavariableNode(metavariableNode) {
+    const metavariableNodeMatches = this.labels.some((label) => {
+      const metavariableNodeMatches = label.matchMetavariableNode(metavariableNode);
 
-  unifyStatement(statementNode, localContext) {
-    let statementUnified = false;
+      if (metavariableNodeMatches) {
+        return true;
+      }
+    });
 
-    const substitutions = Substitutions.fromNothing(),
-          proofSteps = localContext.getProofSteps(),
-          proofStepsB = proofSteps, ///
-          fileContextA = this.fileContext,  ///
-          suppositionsA = this.suppositions,  ///
-          localContextB = localContext, ///
-          suppositionsUnified = unifySuppositionsWithProofSteps(suppositionsA, proofStepsB, substitutions, fileContextA, localContextB);
+    return metavariableNodeMatches;
+  }
 
-    if (suppositionsUnified) {
-      const consequentA = this.consequent,  ///
-            consequentUnified = unifyConsequentWithStatement(consequentA, statementNode, substitutions, fileContextA, localContext);
+  unifyStatement(statement, localContext) {
+    let statementUnified = false;
 
-      if (consequentUnified) {
-        const substitutionsResolved = resolveSubstitutions(substitutions, fileContextA, localContextB);
+    const proofSteps = localContext.getProofSteps(),
+          substitutions = Substitutions.fromNothing(),
+          proofStepsUnified = this.unifyProofSteps(proofSteps, substitutions, localContext);
 
-        statementUnified = substitutionsResolved; ///
-      }
+    if (proofStepsUnified) {
+      statementUnified = this.consequent.unifyStatement(statement, substitutions, localContext);
     }
 
     return statementUnified;
   }
 
-  matchMetavariableNode(metavariableNode) {
-    const metavariableNodeMatches = this.labels.some((label) => {
-      const metavariableNodeMatches = label.matchMetavariableNode(metavariableNode);
+  unifyProofSteps(proofSteps, substitutions, localContext) {
+    let proofStepsUnified;
 
-      if (metavariableNodeMatches) {
+    let suppositions = this.suppositions;
+
+    suppositions = reverse(suppositions); ///
+
+    proofSteps = reverse(proofSteps); ///
+
+    proofStepsUnified = correlate(suppositions, proofSteps, (supposition, proofStep) => {
+      const proofStepUnified = supposition.unifyProofStep(proofStep, substitutions, localContext);
+
+      if (proofStepUnified) {
         return true;
       }
     });
 
-    return metavariableNodeMatches;
+    return proofStepsUnified;
   }
 
-  static fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(Class, labels, suppositions, consequent, substitutions, fileContext) { return new Class(labels, suppositions, consequent, substitutions, fileContext); }
+  toJSON() {
+    const labelsJSON = this.labels.map((label) => {
+            const labelJSON = label.toJSON();
+
+            return labelJSON;
+          }),
+          suppositionsJSON = this.suppositions.map((supposition) => {
+            const suppositionJSON = supposition.toJSON();
+
+            return suppositionJSON;
+          }),
+          consequentJSON = this.consequent.toJSON(),
+          labels = labelsJSON,  ///
+          suppositions = suppositionsJSON,  ///
+          consequent = consequentJSON,  ///
+          json = {
+            labels,
+            suppositions,
+            consequent
+          };
+
+    return json;
+  }
+
+  static fromJSON(Class, json, fileContext) {
+    let rule;
+
+    let { labels } = json;
+
+    const labelsJSON = labels;  ///
+
+    labels = labelsJSON.map((labelJSON) => {
+      const json = labelJSON, ///
+            label = Label.fromJSON(json, fileContext);
+
+      return label;
+    });
+
+    let { suppositions } = json;
+
+    const suppositionsJSON = suppositions;  ///
+
+    suppositions = suppositionsJSON.map((suppositionJSON) => {
+      const json = suppositionJSON, ///
+            supposition = Supposition.fromJSON(json, fileContext);
+
+      return supposition;
+    });
+
+    let { consequent } = json;
+
+    const consequentJSON = consequent;  ///
+
+    json = consequentJSON;  ///
+
+    consequent = Consequent.fromJSON(json, fileContext);
+
+    const proof = null;
+
+    rule = new Class(fileContext, labels, suppositions, consequent, proof);
+
+    return rule;
+  }
 }
+
+export function labelsStringFromLabels(labels) {
+  const labelsString = labels.reduce((labelsString, label) => {
+    const labelString = label.getString();
+
+    labelsString = (labelsString === null) ?
+                     labelString: ///
+                       `${labelString}, ${labelString}`;
+
+    return labelsString;
+  }, null);
+
+  return labelsString;
+}

package/src/type.js

@@ -74,7 +74,7 @@ class Type {
     const equalTo = this.isEqualTo(type),
           subTypeOf = this.isSubTypeOf(type),
           superTypeOf = this.isSuperTypeOf(type),
-          comparableTo = equalTo || subTypeOf || superTypeOf;
+          comparableTo = (equalTo || subTypeOf || superTypeOf);
 
     return comparableTo;
   }
@@ -82,7 +82,7 @@ class Type {
   isEqualToOrSubTypeOf(type) {
     const equalTo = this.isEqualTo(type),
           subTypeOf = this.isSubTypeOf(type),
-          equalToOrSubTypeOf = equalTo || subTypeOf;
+          equalToOrSubTypeOf = (equalTo || subTypeOf);
 
     return equalToOrSubTypeOf;
   }
@@ -90,7 +90,7 @@ class Type {
   isEqualToOrSuperTypeOf(type) {
     const equalTo = this.isEqualTo(type),
           superTypeOf = this.isSuperTypeOf(type),
-          equalToOrSuperTypeOf = equalTo || superTypeOf;
+          equalToOrSuperTypeOf = (equalTo || superTypeOf);
 
     return equalToOrSuperTypeOf;
   }
@@ -124,37 +124,31 @@ class Type {
   verify(fileContext) {
     let verified = false;
 
-    const nameObjectTypeName = (this.name === OBJECT_TYPE_NAME);
-
-    if (nameObjectTypeName) {
-      verified = true;
-    } else {
-      const typeString = this.string; ///
+    const typeString = this.string; ///
 
-      fileContext.trace(`Verifying the '${typeString}' type...`);
+    fileContext.trace(`Verifying the '${typeString}' type...`);
 
-      const typePresent = fileContext.isTypePresentByTypeName(this.name);
+    const typePresent = fileContext.isTypePresentByTypeName(this.name);
 
-      if (typePresent) {
-        verified = true;
-      } else {
-        fileContext.debug(`The type '${typeString}' is not present.`);
-      }
+    if (typePresent) {
+      verified = true;
+    } else {
+      fileContext.debug(`The type '${typeString}' is not present.`);
+    }
 
-      if (verified) {
-        fileContext.debug(`...verified the '${typeString}' type.`);
-      }
+    if (verified) {
+      fileContext.debug(`...verified the '${typeString}' type.`);
     }
 
     return verified;
   }
 
-  verifyWhenDeclared(fileContext) {
-    let verifiedWhenDeclared = false;
+  verifyAtTopLevel(fileContext) {
+    let verifiedAtTopLevel = false;
 
     const typeString = this.string; ///
 
-    fileContext.trace(`Verifying the '${typeString}' type when declared...`);
+    fileContext.trace(`Verifying the '${typeString}' type at top level...`);
 
     const typePresent = fileContext.isTypePresentByTypeName(this.name);
 
@@ -162,13 +156,13 @@ class Type {
       fileContext.debug(`The type '${typeString}' is already present.`);
     } else {
       if (this.superType === null) {
-        verifiedWhenDeclared = true;
+        verifiedAtTopLevel = true;
       } else {
         const name = this.superType.getName(),
-          superTypePresent = fileContext.isTypePresentByTypeName(name);
+              superTypePresent = fileContext.isTypePresentByTypeName(name);
 
         if (superTypePresent) {
-          verifiedWhenDeclared = true;
+          verifiedAtTopLevel = true;
         } else {
           const superTypeString = this.superType.getString();
 
@@ -177,11 +171,11 @@ class Type {
       }
     }
 
-    if (verifiedWhenDeclared) {
-      fileContext.debug(`...verifiedWhenDeclared the '${typeString}' type when declared.`);
+    if (verifiedAtTopLevel) {
+      fileContext.debug(`...verified the '${typeString}' type at top level.`);
     }
 
-    return verifiedWhenDeclared;
+    return verifiedAtTopLevel;
   }
 
   toJSON() {
@@ -213,22 +207,23 @@ class Type {
 
     const typeName = name,  ///
           string = stringFromTypeNameAndSuperType(typeName, superType),
-          type = new Type(string, name, superType);
+          typeNameObjectTypeName = (typeName === OBJECT_TYPE_NAME),
+          type = typeNameObjectTypeName ?
+                   objectType :
+                     new Type(string, name, superType);
 
     return type;
   }
 
   static fromTypeNode(typeNode) {
-    let type = null;
-
-    if (typeNode !== null) {
-      const typeName = typeNameFromTypeNode(typeNode),
-            name = typeName,  ///
-            string = name,  ///
-            superType = null;
-
-      type = new Type(string, name, superType);
-    }
+    const typeName = typeNameFromTypeNode(typeNode),
+          name = typeName,  ///
+          string = name,  ///
+          superType = null,
+          typeNameObjectTypeName = (typeName === OBJECT_TYPE_NAME),
+          type = typeNameObjectTypeName ?
+                   objectType :
+                     new Type(string, name, superType);
 
     return type;
   }
@@ -237,7 +232,9 @@ class Type {
     const typeNode = typeNodeQuery(typeDeclarationNode),
           superTypeNode = superTypeNodeQuery(typeDeclarationNode),
           typeName = typeNameFromTypeNode(typeNode),
-          superType = Type.fromTypeNode(superTypeNode),
+          superType = (superTypeNode === null) ?
+                        objectType :
+                          Type.fromTypeNode(superTypeNode),
           string = stringFromTypeNameAndSuperType(typeName, superType),
           name = typeName,  ///
           type = new Type(string, name, superType);
@@ -268,8 +265,9 @@ export default Type;
 class ObjectType extends Type {
   static fromNothing() {
     const name = OBJECT_TYPE_NAME,
+          string = name,  //
           superType = null,
-          objectType = new ObjectType(name, superType);
+          objectType = new ObjectType(string, name, superType);
 
     return objectType;
   }

package/src/unifier/equality.js

@@ -1,9 +1,9 @@
 "use strict";
 
 import Unifier from "../unifier";
-import unifyTermWithTerm from "../unify/termWithTerm";
 
 import { nodeQuery } from "../utilities/query";
+import { findEquivalenceByTermNodes } from "../utilities/equivalences";
 
 const termNodeQuery = nodeQuery("/term!");
 
@@ -28,9 +28,21 @@ class EqualityUnifier extends Unifier {
         let termUnifiedWithTerm;
 
         const leftTermNode = termNodeA, ///
-              rightTermNode = termNodeB;  ///
+              rightTermNode = termNodeB,  ///
+              leftTermNodeMatchesRightTermNode = leftTermNode.match(rightTermNode);
 
-        termUnifiedWithTerm = unifyTermWithTerm(leftTermNode, rightTermNode, localContext);
+        if (leftTermNodeMatchesRightTermNode) {
+          termUnifiedWithTerm = true;
+        } else {
+          const equivalences = localContext.getEquivalences(),
+                termNodes = [
+                  leftTermNode,
+                  rightTermNode
+                ],
+                equivalence = findEquivalenceByTermNodes(equivalences, termNodes);
+
+          termUnifiedWithTerm = (equivalence !== null);
+        }
 
         if (!termUnifiedWithTerm) {
           const nonTerminalNodeA = termNodeA, ///

package/src/unifier/intrinsicLevel.js

@@ -38,8 +38,4 @@ class IntrinsicLevelUnifier extends Unifier {
 
 const intrinsicLevelUnifier = new IntrinsicLevelUnifier();
 
-Object.assign(shim, {
-  intrinsicLevelUnifier
-});
-
 export default intrinsicLevelUnifier;

package/src/unifier/metaLevel.js

@@ -91,10 +91,6 @@ class MetaLevelUnifier extends Unifier {
 
 const metaLevelUnifier = new MetaLevelUnifier();
 
-Object.assign(shim, {
-  metaLevelUnifier
-});
-
 export default metaLevelUnifier;
 
 function unifyStatementWithStatement(statementNodeA, statementNodeB, substitutions, localContextA, localContextB) {

package/src/unifier/metavariable.js

@@ -4,7 +4,6 @@ import shim from "../shim";
 import Unifier from "../unifier";
 
 import { nodeQuery } from "../utilities/query";
-import unifyTermWithType from "../unify/termWithType";
 
 const typeNodeQuery = nodeQuery("/type!"),
       termNodeQuery = nodeQuery("/term!");
@@ -27,11 +26,24 @@ class MetavariableUnifier extends Unifier {
       nodeQueryA: termNodeQuery,
       nodeQueryB: typeNodeQuery,
       unify: (termNodeA, typeNodeB, localContext) => {
-        const termNode = termNodeA, ///
+        let unified = false;
+
+        const { Term, Type } = shim,
               typeNode = typeNodeB, ///
-              termUnifiedWithType = unifyTermWithType(termNode, typeNode, localContext);
+              type = Type.fromTypeNode(typeNode, localContext),
+              typeVerified = type.verify(localContext);
+
+        if (typeVerified) {
+          const termNode = termNodeA, ///
+                term = Term.fromTermNode(termNode, localContext),
+                termVerifiedGivenType = term.verifyGivenType(type, localContext);
 
-        return termUnifiedWithType;
+          if (termVerifiedGivenType) {
+            unified = true;
+          }
+        }
+
+        return unified;
       }
     }
   ];
@@ -39,8 +51,4 @@ class MetavariableUnifier extends Unifier {
 
 const metavariableUnifier = new MetavariableUnifier();
 
-Object.assign(shim, {
-  metavariableUnifier
-});
-
 export default metavariableUnifier;

package/src/unifier/statementWithCombinator.js

@@ -2,8 +2,6 @@
 
 import shim from "../shim";
 import Unifier from "../unifier";
-import unifyTermWithType from "../unify/termWithType";
-import unifyFrameWithMetaType from "../unify/frameWithMetaType";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -31,36 +29,60 @@ class StatementWithCombinatorUnifier extends Unifier {
       nodeQueryA: statementNodeQuery,
       nodeQueryB: metaTypeNodeQuery,
       unify: (statementNodeA, metaTypeNodeB, assignments, stated, localContext) => {
-        const { MetaType, Statement } = shim,
+        let unified;
+
+        const { Statement, MetaType } = shim,
               metaTypeNode = metaTypeNodeB, ///
               statementNode = statementNodeA, ///
               metaType = MetaType.fromMetaTypeNode(metaTypeNode, localContext),
               statement = Statement.fromStatementNode(statementNode, localContext),
-              statementUnifiedWithMetaType = statement.unifyWithMetaType(metaType, assignments, stated, localContext);
+              statementVerifiedGivenType = statement.verifyGivenMetaType(metaType, assignments, stated, localContext);
+
+        unified = statementVerifiedGivenType;
 
-        return statementUnifiedWithMetaType;
+        return unified;
       }
     },
     {
       nodeQueryA: frameNodeQuery,
       nodeQueryB: metaTypeNodeQuery,
       unify: (frameNodeA, metaTypeNodeB, assignments, stated, localContext) => {
-        const metaTypeNode = metaTypeNodeB, ///
+        let unified;
+
+        const { Frame, MetaType } = shim,
+              metaTypeNode = metaTypeNodeB, ///
               frameNode = frameNodeA, ///
-              frameUnifiedWithMetaType = unifyFrameWithMetaType(frameNode, metaTypeNode, assignments, stated, localContext);
+              metaType = MetaType.fromMetaTypeNode(metaTypeNode, localContext),
+              frame = Frame.fromTermNode(frameNode, localContext),
+              frameVerifiedGivenType = frame.verifyGivenMetaType(metaType, localContext);
 
-        return frameUnifiedWithMetaType;
+        unified = frameVerifiedGivenType;
+
+        return unified;
       }
     },
     {
       nodeQueryA: termNodeQuery,
       nodeQueryB: typeNodeQuery,
       unify: (termNodeA, typeNodeB, assignments, stated, localContext) => {
-        const termNode = termNodeA, ///
+        let unified = false;
+
+        const { Term, Type } = shim,
               typeNode = typeNodeB, ///
-              termUnifiedWithType = unifyTermWithType(termNode, typeNode, localContext);
+              type = Type.fromTypeNode(typeNode, localContext),
+              typeVerified = type.verify(localContext);
+
+        if (typeVerified) {
+          const termNode = termNodeA, ///
+                term = Term.fromTermNode(termNode, localContext),
+                termVerifiedGivenType = term.verifyGivenType(type, localContext);
+
+          if (termVerifiedGivenType) {
+            unified = true;
+          }
+        }
 
-        return termUnifiedWithType;
+        return unified;
       }
     }
   ];

package/src/unifier/termWithConstructor.js

@@ -1,7 +1,7 @@
 "use strict";
 
+import shim from "../shim";
 import Unifier from "../unifier";
-import unifyTermWithType from "../unify/termWithType";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -26,11 +26,24 @@ class TermWithConstructorUnifier extends Unifier {
       nodeQueryA: termNodeQuery,
       nodeQueryB: typeNodeQuery,
       unify: (termNodeA, typeNodeB, localContext) => {
-        const termNode = termNodeA, ///
+        let unified = false;
+
+        const { Term, Type } = shim,
               typeNode = typeNodeB, ///
-              termUnifiedWithType = unifyTermWithType(termNode, typeNode, localContext);
+              type = Type.fromTypeNode(typeNode, localContext),
+              typeVerified = type.verify(localContext);
+
+        if (typeVerified) {
+          const termNode = termNodeA, ///
+                term = Term.fromTermNode(termNode, localContext),
+                termVerifiedGivenType = term.verifyGivenType(type, localContext);
+
+          if (termVerifiedGivenType) {
+            unified = true;
+          }
+        }
 
-        return termUnifiedWithType;
+        return unified;
       }
     }
   ];

package/src/unify/frameWithMetaType.js

@@ -5,7 +5,7 @@ import verifyFrameGivenMetaType from "../verify/frameGivenMetaType";
 export default function unifyFrameWithMetaType(frameNode, metaTypeNode, assignments, stated, localContext) {
   let frameUnifiedWithMetaType;
 
-  const metaType = localContext.findMetaTypeByMetaTypeNode(metaTypeNode),
+  const metaType = localContext.findMetaTypeByMetaTypeName(metaTypeNode),
         frameVerifiedGivenMetaType = verifyFrameGivenMetaType(frameNode, metaType, assignments, stated, localContext);
 
   frameUnifiedWithMetaType = frameVerifiedGivenMetaType;  ///

package/src/utilities/name.js

@@ -3,7 +3,7 @@
 import { nodeQuery } from "../utilities/query";
 
 const typeTerminalNodeQuery = nodeQuery("/type/@type"),
-      nameTerminalNodeQuery = nodeQuery("/metavariable/@name"),
+      nameTerminalNodeQuery = nodeQuery("/variable|metavariable/@name"),
       metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type");
 
 export function typeNameFromTypeNode(typeNode) {
@@ -14,6 +14,14 @@ export function typeNameFromTypeNode(typeNode) {
   return typeName;
 }
 
+export function variableNameFromVariableNode(variableNode) {
+  const nameTerminalNode = nameTerminalNodeQuery(variableNode),
+        nameTerminalNodeContent = nameTerminalNode.getContent(),
+        variableName = nameTerminalNodeContent; ///
+
+  return variableName;
+}
+
 export function metaTypeNameFromMetaTypeNode(metaTypeNode) {
     const metaTypeTerminalNode = metaTypeTerminalNodeQuery(metaTypeNode),
           metaTypeTerminalNodeContent = metaTypeTerminalNode.getContent(),

package/src/utilities/node.js

@@ -4,11 +4,12 @@ import { parsersUtilities } from "occam-custom-grammars";
 
 import { nodeQuery } from "../utilities/query";
 import { combinedCustomGrammarFromNothing } from "./customGrammar";
-import { TERM_RULE_NAME,
+import { VARIABLE_RULE_NAME,
          METAVARIABLE_RULE_NAME,
          UNQUALIFIED_STATEMENT_RULE_NAME,
          CONSTRUCTOR_DECLARATION_RULE_NAME } from "../ruleNames";
-import { metavariableTokensFromMetavariableString,
+import { variableTokensFromVariableString,
+         metavariableTokensFromMetavariableString,
          unqualifiedStatementTokensFromUnqualifiedStatementString,
          constructorDeclarationTokensFromConstructorDeclarationString } from "../utilities/tokens";
 
@@ -30,6 +31,13 @@ export function termNodeFromTermString(termString, lexer, parser) {
   return termNode;
 }
 
+export function variableNodeFromVariableString(variableString, lexer, parser) {
+  const variableTokens = variableTokensFromVariableString(variableString, lexer),
+        variableNode = variableNodeFromVariableTokens(variableTokens, parser);
+
+  return variableNode;
+}
+
 export function statementNodeFromStatementString(statementString, lexer, parser) {
   const unqualifiedStatementString = `${statementString}
 `,
@@ -47,19 +55,11 @@ export function metavariableNodeFromMetavariableString(metavariableString, lexer
   return metavariableNode;
 }
 
-export function unqualifiedStatementNodeFromUnqualifiedStatementString(unqualifiedStatementString, lexer, parser) {
-  const unqualifiedStatementTokens = unqualifiedStatementTokensFromUnqualifiedStatementString(unqualifiedStatementString, lexer),
-        unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser);
-
-  return unqualifiedStatementNode;
-}
-
-export function termNodeFromTermTokens(termTokens, parser) {
-  const tokens = termTokens,  ///
-        ruleName = TERM_RULE_NAME,
-        termNode = nodeFromTokensRuleNameAndParser(tokens, ruleName, parser);
+export function variableNodeFromVariableTokens(variableTokens, parser) {
+  const ruleName = VARIABLE_RULE_NAME,
+        variableNode = nodeFromTokensRuleNameAndParser(variableTokens, ruleName, parser);
 
-  return termNode;
+  return variableNode;
 }
 
 export function metavariableNodeFromMetavariableTokens(metavariableTokens, parser) {

package/src/utilities/tokens.js

@@ -9,11 +9,11 @@ const { nominalLexerFromCombinedCustomGrammar } = lexersUtilities;
 const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
       nominalLexer = nominalLexerFromCombinedCustomGrammar(combinedCustomGrammar);
 
-export function termTokensFromTermString(termString, lexer) {
-  const content = termString, ///
-        termTokens = tokensFromContentAndLexer(content, lexer);
+export function variableTokensFromVariableString(variableString, lexer) {
+  const variableContent = `${variableString}`,
+        variableTokens = tokensFromContentAndLexer(variableContent, lexer);
 
-  return termTokens;
+  return variableTokens;
 }
 
 export function metavariableTokensFromMetavariableString(metavariableString, lexer) {