occam-verify-cli 0.0.1067 → 0.0.1069

package/src/substitutions.js

@@ -34,28 +34,28 @@ export default class Substitutions {
     return firstSubstitution;
   }
 
-  getMetavariableNodes() {
-    const metavariableNodes = [];
+  getMetavariableNames() {
+    const metavariableNames = [];
 
     this.forEachSubstitution((substitution) => {
-      const metavariableNode = substitution.getMetavariableNode();
+      const metavariableName = substitution.getMetavariableName();
 
-      if (metavariableNode !== null) {
-        metavariableNodes.push(metavariableNode);
+      if (metavariableName !== null) {
+        metavariableNames.push(metavariableName);
       }
     });
 
-    compress(metavariableNodes, (metavariableNodeA, metavariableNodeB) => {
-      const metavariableNodeAMatchesMetavariableNodeB = metavariableNodeA.match(metavariableNodeB);
-
-      if (metavariableNodeAMatchesMetavariableNodeB) {
+    compress(metavariableNames, (metavariableNameA, metavariableNameB) => {
+      if (metavariableNameA === metavariableNameB) {
         return true;
       }
     });
 
-    return metavariableNodes;
+    return metavariableNames;
   }
 
+  mapSubstitution(callback) { return this.array.map(callback); }
+
   findSubstitution(callback) { return this.array.find(callback) || null; }  ///
 
   someSubstitution(callback) { return this.array.some(callback); }
@@ -90,11 +90,11 @@ export default class Substitutions {
     return simpleSubstitution;
   }
 
-  findSubstitutionByVariableNode(variableNode) {
+  findSubstitutionByVariableName(variableName) {
     const substitution = this.findSubstitution((substitution) => {
-      const variableNodeMatches = substitution.matchVariableNode(variableNode);
+      const variableNameMatches = substitution.matchVariableName(variableName);
 
-      if (variableNodeMatches) {
+      if (variableNameMatches) {
         return true;
       }
     });
@@ -102,11 +102,11 @@ export default class Substitutions {
     return substitution;
   }
 
-  findSubstitutionByMetavariableNode(metavariableNode) {
+  findSubstitutionByMetavariableName(metavariableName) {
     const substitution = this.findSubstitution((substitution) => {
-      const metavariableNodeMatches = substitution.matchMetavariableNode(metavariableNode);
+      const metavariableNameMatches = substitution.matchMetavariableName(metavariableName);
 
-      if (metavariableNodeMatches) {
+      if (metavariableNameMatches) {
         return true;
       }
     });
@@ -114,11 +114,11 @@ export default class Substitutions {
     return substitution;
   }
 
-  findSubstitutionsByMetavariableNode(metavariableNode) {
+  findSubstitutionsByMetavariableName(metavariableName) {
     const substitutions = this.findSubstitutions((substitution) => {
-      const metavariableNodeMatches = substitution.matchMetavariableNode(metavariableNode);
+      const metavariableNameMatches = substitution.matchMetavariableName(metavariableName);
 
-      if (metavariableNodeMatches) {
+      if (metavariableNameMatches) {
         return true;
       }
     });
@@ -126,8 +126,8 @@ export default class Substitutions {
     return substitutions;
   }
 
-  findSimpleSubstitutionByMetavariableNode(metavariableNode) {
-    const substitutions = this.findSubstitutionsByMetavariableNode(metavariableNode),
+  findSimpleSubstitutionByMetavariableName(metavariableName) {
+    const substitutions = this.findSubstitutionsByMetavariableName(metavariableName),
           simpleSubstitutions = substitutions.filterSubstitution((substitution) => {
             const substitutionSimple = substitution.isSimple();
 
@@ -141,8 +141,8 @@ export default class Substitutions {
     return simpleSubstitution;
   }
 
-  findComplexSubstitutionsByMetavariableNode(metavariableNode) {
-    const substitutions = this.findSubstitutionsByMetavariableNode(metavariableNode),
+  findComplexSubstitutionsByMetavariableName(metavariableName) {
+    const substitutions = this.findSubstitutionsByMetavariableName(metavariableName),
           complexSubstitutions = substitutions.filterSubstitution((substitution) => {
             const substitutionComplex = substitution.isComplex();
 
@@ -154,11 +154,11 @@ export default class Substitutions {
     return complexSubstitutions;
   }
 
-  findSubstitutionByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
+  findSubstitutionByMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode) {
     const substitutions = this.findSubstitutions((substitution) => {
-            const metavariableNodeAndSubstitutionNodeMatch = substitution.matchMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode);
+            const metavariableNameAndSubstitutionNodeMatch = substitution.matchMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode);
 
-            if (metavariableNodeAndSubstitutionNodeMatch) {
+            if (metavariableNameAndSubstitutionNodeMatch) {
               return true;
             }
           }),
@@ -168,8 +168,15 @@ export default class Substitutions {
     return substitution;
   }
 
-  isSubstitutionPresentByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
-    const substitution = this.findSubstitutionByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode),
+  isSimpleSubstitutionPresentByMetavariableName(metavariableName) {
+    const simpleSubstitution = this.findSimpleSubstitutionByMetavariableName(metavariableName),
+          simpleSubstitutionPresent = (simpleSubstitution !== null);
+
+    return simpleSubstitutionPresent;
+  }
+
+  isSubstitutionPresentByMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode) {
+    const substitution = this.findSubstitutionByMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode),
           substitutionPresent = (substitution !== null);
 
     return substitutionPresent;
@@ -213,24 +220,24 @@ export default class Substitutions {
     return unifiedWithEquivalences;
   }
 
-  resolve(localContext) {
-    const metavariableNodes = this.getMetavariableNodes(),
-          resolved = metavariableNodes.every((metavariableNode) => {
-            const complexSubstitutions = this.findComplexSubstitutionsByMetavariableNode(metavariableNode),
-                  complexSubstitutionsResolved = complexSubstitutions.everySubstitution((complexSubstitution) => {
-                    const substitution = complexSubstitution, ///
-                          substitutions = this, ///
-                          substitutionResolved = substitution.resolve(substitutions, localContext);
-
-                    if (substitutionResolved) {
-                      return true;
-                    }
-                  });
-
-            if (complexSubstitutionsResolved) {
-              return true;
-            }
-          });
+  resolve(localContextA, localContextB) {
+    const metavariableNames = this.getMetavariableNames(),
+          resolved = metavariableNames.every((metavariableName) => {
+                        const complexSubstitutions = this.findComplexSubstitutionsByMetavariableName(metavariableName),
+                              complexSubstitutionsResolved = complexSubstitutions.everySubstitution((complexSubstitution) => {
+                                const substitution = complexSubstitution, ///
+                                      substitutions = this, ///
+                                      substitutionResolved = substitution.resolve(substitutions, localContextA, localContextB);
+
+                                if (substitutionResolved) {
+                                  return true;
+                                }
+                              });
+
+                        if (complexSubstitutionsResolved) {
+                          return true;
+                        }
+                      });
 
     return resolved;
   }

package/src/supposition.js

@@ -7,10 +7,11 @@ import UnqualifiedStatement from "./statement/unqualified";
 
 import { nodeQuery } from "./utilities/query";
 import { assignAssignments } from "./utilities/assignments";
+import { unqualifiedStatementFromJSON, unqualifiedStatementToUnqualifiedStatementJSON } from "./utilities/json";
 
 const unqualifiedStatementNodeQuery = nodeQuery("/supposition/unqualifiedStatement");
 
-export default class Supposition {
+class Supposition {
   constructor(fileContext, unqualifiedStatement) {
     this.fileContext = fileContext;
     this.unqualifiedStatement = unqualifiedStatement;
@@ -71,7 +72,13 @@ export default class Supposition {
 
     const statement = this.unqualifiedStatement.getStatement(),
           statementNode = statement.getNode(),
-          subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, this.fileContext);
+          statementTokens = statement.getTokens(),
+          context = this.fileContext, ///
+          tokens = statementTokens; ///
+
+    localContext = LocalContext.fromContextAndTokens(context, tokens);  ///
+
+    const subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, localContext);
 
     if (subproofAssertion !== null) {
       subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, this.fileContext, localContext);
@@ -113,25 +120,25 @@ export default class Supposition {
     const statementString = statement.getString(),
           suppositionString = this.getString();
 
-    localContext.trace(`Unifying the '${statementString}' statement with the '${suppositionString}' supposition...`);
-
-    const localContextB = localContext;
+    const localContextB = localContext; ///
 
     localContext = LocalContext.fromFileContext(this.fileContext);
 
     const localContextA = localContext; ///
 
+    localContextB.trace(`Unifying the '${statementString}' statement with the '${suppositionString}' supposition...`);
+
     statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, localContextA, localContextB);
 
     if (statementUnified) {
-      localContext.debug(`...unified the '${statementString}' statement with the '${suppositionString}' supposition.`);
+      localContextB.debug(`...unified the '${statementString}' statement with the '${suppositionString}' supposition.`);
     }
 
     return statementUnified;
   }
 
   toJSON() {
-    const unqualifiedStatementJSON = this.unqualifiedStatement.toJSON(),
+    const unqualifiedStatementJSON = unqualifiedStatementToUnqualifiedStatementJSON(this.unqualifiedStatement),
           unqualifiedStatement = unqualifiedStatementJSON,  ///
           json = {
             unqualifiedStatement
@@ -141,13 +148,8 @@ export default class Supposition {
   }
 
   static fromJSON(json, fileContext) {
-    let { unqualifiedStatement } = json;
-
-    json = unqualifiedStatement;  ///
-
-    unqualifiedStatement = UnqualifiedStatement.fromJSON(json, fileContext);
-
-    const supposition = new Supposition(fileContext, unqualifiedStatement);
+    const unqualifiedStatement = unqualifiedStatementFromJSON(json, fileContext),
+          supposition = new Supposition(fileContext, unqualifiedStatement);
 
     return supposition;
   }
@@ -160,3 +162,9 @@ export default class Supposition {
     return supposition
   }
 }
+
+Object.assign(shim, {
+  Supposition
+});
+
+export default Supposition;

package/src/term.js

@@ -11,6 +11,7 @@ import { objectType } from "./type";
 import { nodeQuery, nodesQuery } from "./utilities/query"
 import { termNodeFromTermString } from "./utilities/node";
 import { variableNameFromVariableNode } from "./utilities/name";
+import { typeFromJSON, typeToTypeJSON } from "./utilities/json";
 
 const { filter } = arrayUtilities;
 
@@ -236,12 +237,12 @@ class Term {
   }
 
   toJSON() {
-    const typeJSON = this.type.toJSON(),
+    const typeJSON = typeToTypeJSON(this.type),
           string = this.string,
           type = typeJSON,  ///
           json = {
-            string,
-            type
+            type,
+            string
           };
 
     return json;
@@ -249,9 +250,9 @@ class Term {
 
   static fromJSON(json, fileContext) {
     const { string } = json,
-          termString = string,  ///
           lexer = fileContext.getLexer(),
           parser = fileContext.getParser(),
+          termString = string,  ///
           termNode = termNodeFromTermString(termString, lexer, parser),
           node = termNode,  ///
           type = typeFromJSON(json, fileContext),
@@ -328,14 +329,3 @@ Object.assign(shim, {
 });
 
 export default Term;
-
-function typeFromJSON(json, fileContext) {
-  let { type } = json;
-
-  const { name } = type,
-        typeName = name;  ///
-
-  type = fileContext.findTypeByTypeName(typeName);
-
-  return type;
-}

package/src/theorem.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import shim from "./shim";
 import Label from "./label";
 import Proof from "./proof";
 import Consequent from "./consequent";
@@ -8,21 +9,21 @@ import LocalContext from "./context/local";
 import Substitutions from "./substitutions";
 import TopLevelAssertion from "./topLevelAssertion";
 
+import { stringFromLabels } 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 {
+class Theorem extends TopLevelAssertion {
   verify() {
     let verified = false;
 
-    const labelsString = labelsStringFromLabels(this.labels);
+    const theoremString = this.string;  ///
 
-    this.fileContext.trace(`Verifying the '${labelsString}' theorem...`);
+    this.fileContext.trace(`Verifying the '${theoremString}' theorem...`);
 
     const labelsVerifiedAtTopLevel = this.labels.every((label) => {
       const labelVVerifiedAtTopLevel = label.verifyAtTopLevel(this.fileContext);
@@ -61,7 +62,7 @@ export default class Theorem extends TopLevelAssertion {
     }
 
     if (verified) {
-      this.fileContext.debug(`...verified the '${labelsString}' theorem.`);
+      this.fileContext.debug(`...verified the '${theoremString}' theorem.`);
     }
 
     return verified;
@@ -85,9 +86,16 @@ export default class Theorem extends TopLevelAssertion {
             return supposition;
           }),
           consequent = Consequent.fromConsequentNode(consequentNode, fileContext),
+          string = stringFromLabels(labels),
           proof = Proof.fromProofNode(proofNode, fileContext),
-          theorem = new Theorem(fileContext, labels, suppositions, consequent, proof);
+          theorem = new Theorem(fileContext, string, labels, suppositions, consequent, proof);
 
     return theorem;
   }
 }
+
+Object.assign(shim, {
+  Theorem
+});
+
+export default Theorem;

package/src/topLevelAssertion.js

@@ -2,16 +2,22 @@
 
 import { arrayUtilities } from "necessary";
 
-import Label from "./label";
-import Consequent from "./consequent";
-import Supposition from "./supposition";
 import Substitutions from "./substitutions";
 
+import { EMPTY_STRING } from "./constants";
+import { labelsFromJSON,
+         labelsToLabelsJSON,
+         consequentFromJSON,
+         suppositionsFromJSON,
+         consequentToConsequentJSON,
+         suppositionsToSuppositionsJSON } from "./utilities/json";
+
 const { reverse, correlate } = arrayUtilities;
 
 export default class TopLevelAssertion {
-  constructor(fileContext, labels, suppositions, consequent, proof) {
+  constructor(fileContext, string, labels, suppositions, consequent, proof) {
     this.fileContext = fileContext;
+    this.string = string;
     this.labels = labels;
     this.suppositions = suppositions;
     this.consequent = consequent;
@@ -22,6 +28,10 @@ export default class TopLevelAssertion {
     return this.fileContext;
   }
 
+  getString() {
+    return this.string;
+  }
+
   getLabels() {
     return this.labels;
   }
@@ -85,80 +95,44 @@ export default class TopLevelAssertion {
   }
 
   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(),
+    const labelsJSON = labelsToLabelsJSON(this.labels),
+          consequentJSON = consequentToConsequentJSON(this.consequent),
+          suppositionsJSON = suppositionsToSuppositionsJSON(this.suppositions),
           labels = labelsJSON,  ///
-          suppositions = suppositionsJSON,  ///
           consequent = consequentJSON,  ///
+          suppositions = suppositionsJSON,  ///
           json = {
             labels,
-            suppositions,
-            consequent
+            consequent,
+            suppositions
           };
 
     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;
+    const labels = labelsFromJSON(json, fileContext),
+          consequent = consequentFromJSON(json, fileContext),
+          suppositions = suppositionsFromJSON(json, fileContext),
+          string = stringFromLabels(labels),
+          proof = null,
+          topLevelAssertion = new Class(fileContext, string, labels, suppositions, consequent, proof);
+
+    return topLevelAssertion;
   }
 }
 
-export function labelsStringFromLabels(labels) {
-  const labelsString = labels.reduce((labelsString, label) => {
+export function stringFromLabels(labels) {
+  const string = labels.reduce((string, label) => {
     const labelString = label.getString();
 
-    labelsString = (labelsString === null) ?
-                     labelString: ///
-                       `${labelString}, ${labelString}`;
+    string = (string === EMPTY_STRING) ?
+               labelString: ///
+                 `${labelString}, ${labelString}`;
+
+    return string;
+  }, EMPTY_STRING);
 
-    return labelsString;
-  }, null);
+  return string;
+}
 
-  return labelsString;
-}

package/src/type.js

@@ -5,6 +5,7 @@ import shim from "./shim";
 import { nodeQuery } from "./utilities/query";
 import { OBJECT_TYPE_NAME } from "./typeNames";
 import { typeNameFromTypeNode } from "./utilities/name";
+import { superTypeFromJSON, superTypeToSuperTypeJSON } from "./utilities/json";
 
 const typeNodeQuery = nodeQuery("/typeDeclaration/type[0]"),
       superTypeNodeQuery = nodeQuery("/typeDeclaration/type[1]");
@@ -155,9 +156,9 @@ class Type {
   }
 
   toJSON() {
-    const superTypeJSON = this.superType.toJSON(),
-          name = this.name,
+    const superTypeJSON = superTypeToSuperTypeJSON(this.superType),
           superType = superTypeJSON,  ///
+          name = this.name,
           json = {
             name,
             superType
@@ -229,8 +230,8 @@ export default Type;
 
 class ObjectType extends Type {
   toJSON() {
-    const name = this.name,
-          superType = null,
+    const superType = null,
+          name = this.name,
           json = {
             name,
             superType
@@ -250,19 +251,3 @@ class ObjectType extends Type {
 }
 
 export const objectType = ObjectType.fromNothing();
-
-function superTypeFromJSON(json, fileContext) {
-  let { superType } = json;
-
-  const superTypeJSON = superType;  ///
-
-  json = superTypeJSON; ///
-
-  const { name } = json,
-        typeName = name,  ///
-        type = fileContext.findTypeByTypeName(typeName);
-
-  superType = type; ///
-
-  return superType;
-}

package/src/unifier/intrinsicLevel.js

@@ -31,12 +31,13 @@ class IntrinsicLevelUnifier extends Unifier {
 
         const variableNode = termVariableNodeA, ///
               variableName = variableNameFromVariableNode(variableNode),
-              variable = localContextA.findVariableByVariableName(variableName);
+              variablePresent = localContextA.isVariablePresentByVariableName(variableName);
 
-        if (variable !== null) {
-          const { Term } = shim,
+        if (variablePresent !== null) {
+          const { Term, Variable } = shim,
                 localContext = localContextB, ///
                 termNode = termNodeB, ///
+                variable = Variable.fromVariableNode(variableNode, localContextA),
                 term = Term.fromTermNode(termNode, localContextB);
 
           termUnified = variable.unifyTerm(term, substitutions, localContext);

package/src/unifier/metaLevel.js

@@ -78,12 +78,23 @@ class MetaLevelUnifier extends Unifier {
       nodeQueryA: frameMetavariableNodeQuery,
       nodeQueryB: frameNodeQuery,
       unify: (frameMetavariableNodeA, frameNodeB, substitutions, localContextA, localContextB) => {
-        debugger
+        let frameUnified = false;
 
-        const metavariableNodeA = frameMetavariableNodeA, ///
-              metavariableUnifiedWithFrame = unifyMetavariableWithFrame(metavariableNodeA, frameNodeB, substitutions, localContextA, localContextB);
+        const metavariableNode = frameMetavariableNodeA,  ///
+              metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+              metavariablePresent = localContextA.isMetavariablePresentByMetavariableName(metavariableName);
 
-        return metavariableUnifiedWithFrame;
+        if (metavariablePresent) {
+          const { Frame, Metavariable } = shim,
+                localContext = localContextB, ///
+                frameNode = frameNodeB, ///
+                metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContextA),
+                frame = Frame.fromFrameNode(frameNode, localContextB);
+
+          frameUnified = metavariable.unifyFrame(frame, substitutions, localContext);
+        }
+
+        return frameUnified;
       }
     },
     {
@@ -94,12 +105,13 @@ class MetaLevelUnifier extends Unifier {
 
         const variableNode = termVariableNodeA, ///
               variableName = variableNameFromVariableNode(variableNode),
-              variable = localContextA.findVariableByVariableName(variableName);
+              variablePresent = localContextA.isVariablePresentByVariableName(variableName);
 
-        if (variable !== null) {
-          const { Term } = shim,
+        if (variablePresent) {
+          const { Term, Variable } = shim,
                 localContext = localContextB, ///
                 termNode = termNodeB, ///
+                variable = Variable.fromVariableNode(variableNode, localContextA),
                 term = Term.fromTermNode(termNode, localContextB);
 
           termUnified = variable.unifyTerm(term, substitutions, localContext);

package/src/unifier/metavariable.js

@@ -24,18 +24,18 @@ class MetavariableUnifier extends Unifier {
 
   static maps = [
     {
-      nodeQueryA: termNodeQuery,
-      nodeQueryB: typeNodeQuery,
-      unify: (termNodeA, typeNodeB, localContext) => {
+      nodeQueryA: typeNodeQuery,
+      nodeQueryB: termNodeQuery,
+      unify: (typeNodeA, termNodeB, localContext) => {
         let unified = false;
 
         const { Term } = shim,
-              typeNode = typeNodeB, ///
+              typeNode = typeNodeA, ///
               typeName = typeNameFromTypeNode(typeNode),
               type = localContext.findTypeByTypeName(typeName);
 
         if (type !== null) {
-          const termNode = termNodeA, ///
+          const termNode = termNodeB, ///
                 term = Term.fromTermNode(termNode, localContext),
                 termVerifiedGivenType = term.verifyGivenType(type, localContext);