occam-verify-cli 0.0.1089 → 0.0.1091

package/src/supposition.js

@@ -28,33 +28,36 @@ class Supposition {
 
   getStatement() { return this.unqualifiedStatement.getStatement(); }
 
-  resolveIndependently(substitutions, localContext) {
+  resolveIndependently(substitutions, context) {
     let resolvedIndependently;
 
-    const suppositionString = this.getString();
+    const localContext = LocalContext.fromFileContext(this.fileContext),
+          generalContext = localContext,  ///
+          specificContext = context; ///
 
-    const localContextB = localContext; ///
-
-    localContext = LocalContext.fromFileContext(this.fileContext);
-
-    const localContextA = localContext; ///
+    const supposition = this, ///
+          suppositionString = supposition.getString();
 
-    localContextB.trace(`Resolving the '${suppositionString}' supposition independently...`);
+    specificContext.trace(`Resolving the '${suppositionString}' supposition independently...`);
 
-    const unqualifiedStatementResolvedIndependently = this.unqualifiedStatement.resolveIndependently(substitutions, localContextA, localContextB);
+    const unqualifiedStatementResolvedIndependently = this.unqualifiedStatement.resolveIndependently(substitutions, generalContext, specificContext);
 
     resolvedIndependently = unqualifiedStatementResolvedIndependently;  ///
 
     if (resolvedIndependently) {
-      localContextB.trace(`...resolved the '${suppositionString}' supposition independently.`);
+      specificContext.trace(`...resolved the '${suppositionString}' supposition independently.`);
     }
 
     return resolvedIndependently;
   }
 
-  unifyProofStep(proofStep, substitutions, localContext) {
+  unifyProofStep(proofStep, substitutions, context) {
     let proofStepUnified = false;
 
+    const localContext = LocalContext.fromFileContext(this.fileContext),
+          generalContext = localContext,  ///
+          specificContext = context; ///
+
     const subproof = proofStep.getSubproof(),
           statement = proofStep.getStatement();
 
@@ -66,54 +69,47 @@ class Supposition {
     if (false) {
       ///
     } else if (subproof !== null) {
-      subproofUnified = this.unifySubproof(subproof, substitutions, localContext);
+      subproofUnified = this.unifySubproof(subproof, substitutions, generalContext, specificContext);
     } else if (statement !== null) {
-      statementUnified = this.unifyStatement(statement, substitutions, localContext);
+      statementUnified = this.unifyStatement(statement, substitutions, generalContext, specificContext);
     }
 
     if (subproofUnified || statementUnified) {
-      const localContextB = localContext; ///
+      const localContext = LocalContext.fromFileContext(this.fileContext),
+            generalContext = localContext,  ///
+            specificContext = context; ///
 
-      localContext = LocalContext.fromFileContext(this.fileContext);
-
-      const localContextA = localContext; ///
-
-      substitutions.resolve(localContextA, localContextB);
+      substitutions.resolve(generalContext, specificContext);
 
       proofStepUnified = true;
     }
 
     proofStepUnified ?
       substitutions.continue() :
-        substitutions.rollback(localContext);
+        substitutions.rollback(context);
 
     return proofStepUnified;
   }
 
-  unifyStatement(statement, substitutions, localContext) {
+  unifyStatement(statement, substitutions, generalContext, specificContext) {
     let statementUnified;
 
-    const statementString = statement.getString(),
-          suppositionString = this.getString();
-
-    const localContextB = localContext; ///
-
-    localContext = LocalContext.fromFileContext(this.fileContext);
-
-    const localContextA = localContext; ///
+    const supposition = this, ///
+          suppositionString = supposition.getString(),
+          statementString = statement.getString();
 
-    localContextB.trace(`Unifying the '${statementString}' statement with the '${suppositionString}' supposition...`);
+    specificContext.trace(`Unifying the '${statementString}' statement with the '${suppositionString}' supposition...`);
 
-    statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, localContextA, localContextB);
+    statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, generalContext, specificContext);
 
     if (statementUnified) {
-      localContextB.debug(`...unified the '${statementString}' statement with the '${suppositionString}' supposition.`);
+      specificContext.debug(`...unified the '${statementString}' statement with the '${suppositionString}' supposition.`);
     }
 
     return statementUnified;
   }
 
-  unifySubproof(subproof, substitutions, localContext) {
+  unifySubproof(subproof, substitutions, generalContext, specificContext) {
     let subproofUnified = false;
 
     const supposition = this, ///
@@ -121,59 +117,51 @@ class Supposition {
           suppositionStatement = supposition.getStatement(),
           suppositionStatementString = suppositionStatement.getString();
 
-    const localContextB = localContext; ///
-
     const statement = this.unqualifiedStatement.getStatement(),
-          statementTokens = statement.getTokens(),
-          context = this.fileContext, ///
-          tokens = statementTokens; ///
-
-    localContext = LocalContext.fromContextAndTokens(context, tokens);  ///
-
-    const localContextA = localContext; ///
+          statementNode = statement.getNode();
 
-    localContextB.trace(`Unifying the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement...`);
+    specificContext.trace(`Unifying the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement...`);
 
-    const statementNode = statement.getNode(),
-          subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, localContext);
+    const context = specificContext,  ///
+          subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, context);
 
     if (subproofAssertion !== null) {
-      subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, localContextA, localContextB);
+      subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);
     }
 
     if (subproofUnified) {
-      localContextB.debug(`...unified the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement.`);
+      specificContext.debug(`...unified the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement.`);
     }
 
     return subproofUnified;
   }
 
-  verify(localContext) {
+  verify(context) {
     let verified = false;
 
     const suppositionString = this.getString(); ///
 
-    localContext.trace(`Verifying the '${suppositionString}' supposition...`);
+    context.trace(`Verifying the '${suppositionString}' supposition...`);
 
     const stated = true,
           assignments = [],
-          unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, localContext);
+          unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, context);
 
     if (unqualifiedStatementVerified) {
-      const assignmentsAssigned = assignAssignments(assignments, localContext);
+      const assignmentsAssigned = assignAssignments(assignments, context);
 
       if (assignmentsAssigned) {
         const { ProofStep } = shim,
               proofStep = ProofStep.fromUnqualifiedStatement(this.unqualifiedStatement);
 
-        localContext.addProofStep(proofStep);
+        context.addProofStep(proofStep);
 
         verified = true;
       }
     }
 
     if (verified) {
-      localContext.debug(`...verified the '${suppositionString}' supposition.`);
+      context.debug(`...verified the '${suppositionString}' supposition.`);
     }
 
     return verified;

package/src/term.js

@@ -42,7 +42,7 @@ class Term {
     this.type = type;
   }
 
-  getVariable(localContext) {
+  getVariable(context) {
     let variable = null;
 
     const variableNode = variableNodeQuery(this.node);
@@ -50,19 +50,19 @@ class Term {
     if (variableNode !== null) {
       const variableName = variableNameFromVariableNode(variableNode);
 
-      variable = localContext.findVariableByVariableName(variableName);
+      variable = context.findVariableByVariableName(variableName);
     }
 
     return variable;
   }
 
-  getVariables(localContext) {
+  getVariables(context) {
     const variables = [],
           variableNodes = variableNodesQuery(this.node);
 
     variableNodes.forEach((variableNode) => {
       const variableName = variableNameFromVariableNode(variableNode),
-            variable = localContext.findVariableByVariableName(variableName),
+            variable = context.findVariableByVariableName(variableName),
             variablesIncludesVariable = variables.includes(variable);
 
       if (!variablesIncludesVariable) {
@@ -73,8 +73,8 @@ class Term {
     return variables;
   }
 
-  isGrounded(definedVariables, localContext) {
-    const variables = this.getVariables(localContext);
+  isGrounded(definedVariables, context) {
+    const variables = this.getVariables(context);
 
     filter(variables, (variable) => {
       const definedVariablesIncludesVariable = definedVariables.includes(variable);
@@ -114,32 +114,32 @@ class Term {
     return termNodeMatches;
   }
 
-  isInitiallyGrounded(localContext) {
-    const variables = this.getVariables(localContext),
+  isInitiallyGrounded(context) {
+    const variables = this.getVariables(context),
           variablesLength = variables.length,
           initiallyGrounded = (variablesLength === 0);
 
     return initiallyGrounded;
   }
 
-  isImplicitlyGrounded(definedVariables, localContext) {
-    const grounded = this.isGrounded(definedVariables, localContext),
+  isImplicitlyGrounded(definedVariables, context) {
+    const grounded = this.isGrounded(definedVariables, context),
           implicitlyGrounded = grounded;  ///
 
     return implicitlyGrounded;
   }
 
-  verify(localContext, verifyAhead) {
+  verify(context, verifyAhead) {
     let verified = false;
 
     const term = this, ///
           termString = this.string;  ///
 
-    localContext.trace(`Verifying the '${termString}' term...`);
+    context.trace(`Verifying the '${termString}' term...`);
 
     if (!verified) {
       verified = verifyMixins.some((verifyMixin) => {
-        const verified = verifyMixin(term, localContext, verifyAhead);
+        const verified = verifyMixin(term, context, verifyAhead);
 
         if (verified) {
           return true;
@@ -149,7 +149,7 @@ class Term {
 
     if (!verified) {
       const unified = unifyMixins.some((unifyMixin) => { ///
-        const unified = unifyMixin(term, localContext, verifyAhead);
+        const unified = unifyMixin(term, context, verifyAhead);
 
         if (unified) {
           return true;
@@ -160,7 +160,7 @@ class Term {
     }
 
     if (verified) {
-      localContext.debug(`...verified the '${termString}' term.`);
+      context.debug(`...verified the '${termString}' term.`);
     }
 
     return verified;
@@ -194,15 +194,15 @@ class Term {
     return typeVerified;
   }
 
-  verifyGivenType(type, localContext) {
+  verifyGivenType(type, context) {
     let verifiedGivenType;
 
     const typeName = type.getName(),
           termString = this.getString();
 
-    localContext.trace(`Verifying the '${termString}' term given the '${typeName}' type...`);
+    context.trace(`Verifying the '${termString}' term given the '${typeName}' type...`);
 
-    const verified = this.verify(localContext, () => {
+    const verified = this.verify(context, () => {
       let verifiedAhead;
 
       const typeEqualToOrSubTypeOfGivenTypeType = this.type.isEqualToOrSubTypeOf(type);
@@ -217,7 +217,7 @@ class Term {
     verifiedGivenType = verified; ///
 
     if (verifiedGivenType) {
-      localContext.debug(`...verified the '${termString}' term given the '${typeName}' type.`);
+      context.debug(`...verified the '${termString}' term given the '${typeName}' type.`);
     }
 
     return verifiedGivenType;
@@ -271,12 +271,12 @@ class Term {
     return term;
   }
 
-  static fromTermNode(termNode, localContext) {
+  static fromTermNode(termNode, context) {
     let term = null;
 
     if (termNode !== null) {
       const node = termNode,  ///
-            string = localContext.nodeAsString(node),
+            string = context.nodeAsString(node),
             type = null;
 
       term = new Term(string, node, type);
@@ -285,15 +285,15 @@ class Term {
     return term;
   }
 
-  static fromTermNodeAndType(termNode, type, localContext) {
+  static fromTermNodeAndType(termNode, type, context) {
     const node = termNode,  ///
-          string = localContext.nodeAsString(node),
+          string = context.nodeAsString(node),
           term = new Term(string, node, type);
 
     return term;
   }
 
-  static fromDefinedAssertionNode(definedAssertionNode, localContext) {
+  static fromDefinedAssertionNode(definedAssertionNode, context) {
     let term = null;
 
     const termNode = termNodeQuery(definedAssertionNode);
@@ -303,7 +303,7 @@ class Term {
 
       if (variableNode !== null) {
         const node = termNode,  ///
-              string = localContext.nodeAsString(node),
+              string = context.nodeAsString(node),
               type = null;
 
         term = new Term(string, node, type);
@@ -313,7 +313,7 @@ class Term {
     return term;
   }
 
-  static fromContainedAssertionNode(containedAssertionNode, localContext) {
+  static fromContainedAssertionNode(containedAssertionNode, context) {
     let term = null;
 
     const termNode = termNodeQuery(containedAssertionNode);
@@ -323,7 +323,7 @@ class Term {
 
       if (variableNode !== null) {
         const node = termNode,  ///
-              string = localContext.nodeAsString(node),
+              string = context.nodeAsString(node),
               type = null;
 
         term = new Term(string, node, type);

package/src/topLevelAssertion.js

@@ -76,15 +76,27 @@ export default class TopLevelAssertion {
     return metavariableNodeMatches;
   }
 
-  unifyStatement(statement, localContext) {
+  unifyReference(reference, generalContext, specificContext) {
+    const referenceUnified = this.labels.some((label) => {
+      const referenceUnified = label.unifyReference(reference, generalContext, specificContext);
+
+      if (referenceUnified) {
+        return true;
+      }
+    });
+
+    return referenceUnified;
+  }
+
+  unifyStatement(statement, context) {
     let statementUnified;
 
     const { Substitutions } = shim,
       substitutions = Substitutions.fromNothing(),
-      consequentUnified = this.unifyConsequent(statement, substitutions, localContext);
+      consequentUnified = this.unifyConsequent(statement, substitutions, context);
 
     if (consequentUnified) {
-      const suppositionsUnified = this.unifySupposition(substitutions, localContext);
+      const suppositionsUnified = this.unifySupposition(substitutions, context);
 
       if (suppositionsUnified) {
         const substitutionsResolved = substitutions.areResolved();
@@ -96,31 +108,31 @@ export default class TopLevelAssertion {
     return statementUnified;
   }
 
-  unifyConsequent(statement, substitutions, localContext) {
+  unifyConsequent(statement, substitutions, context) {
     let consequentUnified;
 
     const consequentString = this.consequent.getString();
 
-    localContext.trace(`Unifying the '${consequentString}' consequent...`);
+    context.trace(`Unifying the '${consequentString}' consequent...`);
 
-    const statementUnified = this.consequent.unifyStatement(statement, substitutions, localContext);  ///
+    const statementUnified = this.consequent.unifyStatement(statement, substitutions, context);  ///
 
     consequentUnified = statementUnified; ///
 
     if (consequentUnified) {
-      localContext.debug(`...unified the '${consequentString}' consequent`);
+      context.debug(`...unified the '${consequentString}' consequent`);
     }
 
     return consequentUnified;
   }
 
-  unifySupposition(substitutions, localContext) {
-    let proofSteps = localContext.getProofSteps();
+  unifySupposition(substitutions, context) {
+    let proofSteps = context.getProofSteps();
 
     proofSteps = reverse(proofSteps); ///
 
     const suppositionsUnified = backwardsEvery(this.suppositions, (supposition) => {
-      const suppositionUnified = this.unifyPremise(supposition, proofSteps, substitutions, localContext);
+      const suppositionUnified = this.unifyPremise(supposition, proofSteps, substitutions, context);
 
       if (suppositionUnified) {
         return true;
@@ -130,25 +142,25 @@ export default class TopLevelAssertion {
     return suppositionsUnified;
   }
 
-  unifyPremise(supposition, proofSteps, substitutions, localContext) {
+  unifyPremise(supposition, proofSteps, substitutions, context) {
     let suppositionUnified  =false;
 
     const suppositionString = supposition.getString();
 
-    localContext.trace(`Unifying the '${suppositionString}' supposition...`);
+    context.trace(`Unifying the '${suppositionString}' supposition...`);
 
-    const suppositionResolvedIndependently = supposition.resolveIndependently(substitutions, localContext);
+    const suppositionResolvedIndependently = supposition.resolveIndependently(substitutions, context);
 
     if (suppositionResolvedIndependently) {
       suppositionUnified = true;
     } else {
       const proofStep = extract(proofSteps, (proofStep) => {
-        const proofStepUnified = supposition.unifyProofStep(proofStep, substitutions, localContext);
+        const proofStepUnified = supposition.unifyProofStep(proofStep, substitutions, context);
 
         if (proofStepUnified) {
           return true;
         }
-      });
+      }) || null;
 
       if (proofStep !== null) {
         suppositionUnified = true;
@@ -156,7 +168,7 @@ export default class TopLevelAssertion {
     }
 
     if (suppositionUnified) {
-      localContext.debug(`...unified the '${suppositionString}' supposition.`);
+      context.debug(`...unified the '${suppositionString}' supposition.`);
     }
 
     return suppositionUnified;
@@ -175,8 +187,9 @@ export default class TopLevelAssertion {
 
     if (labelsVerifiedWhenDeclared) {
       const localContext = LocalContext.fromFileContext(this.fileContext),
+            context = localContext, ///
             suppositionsVerified = this.suppositions.every((supposition) => {
-              const suppositionVerified = supposition.verify(localContext);
+              const suppositionVerified = supposition.verify(context);
 
               if (suppositionVerified) {
                 return true;
@@ -184,13 +197,13 @@ export default class TopLevelAssertion {
             });
 
       if (suppositionsVerified) {
-        const consequentVerified = this.consequent.verify(localContext);
+        const consequentVerified = this.consequent.verify(context);
 
         if (consequentVerified) {
           if (this.proof === null) {
             verified = true;
           } else {
-            const proofVerified = this.proof.verify(this.substitutions, this.consequent, localContext);
+            const proofVerified = this.proof.verify(this.substitutions, this.consequent, context);
 
             verified = proofVerified; ///
           }

package/src/unifier/equality.js

@@ -8,12 +8,12 @@ import { findEquivalenceByTermNodes } from "../utilities/equivalences";
 const termNodeQuery = nodeQuery("/term");
 
 class EqualityUnifier extends Unifier {
-  unify(leftTermNode, rightTermNode, localContext) {
+  unify(leftTermNode, rightTermNode, context) {
     let equalityUnified;
 
     const nonTerminalNodeA = leftTermNode, ///
           nonTerminalNodeB = rightTermNode, ///
-          nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext);
+          nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context);
 
     equalityUnified = nonTerminalNodeUnified; ///
 
@@ -22,9 +22,9 @@ class EqualityUnifier extends Unifier {
 
   static maps = [
     {
-      nodeQueryA: termNodeQuery,
-      nodeQueryB: termNodeQuery,
-      unify: (termNodeA, termNodeB, localContext) => {
+      generalNodeQuery: termNodeQuery,
+      specificNodeQuery: termNodeQuery,
+      unify: (termNodeA, termNodeB, context) => {
         let termUnifiedWithTerm;
 
         const leftTermNode = termNodeA, ///
@@ -34,7 +34,7 @@ class EqualityUnifier extends Unifier {
         if (leftTermNodeMatchesRightTermNode) {
           termUnifiedWithTerm = true;
         } else {
-          const equivalences = localContext.getEquivalences(),
+          const equivalences = context.getEquivalences(),
                 termNodes = [
                   leftTermNode,
                   rightTermNode
@@ -51,7 +51,7 @@ class EqualityUnifier extends Unifier {
                 nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
                 childNodesA = nonTerminalNodeAChildNodes, ///
                 childNodesB = nonTerminalNodeBChildNodes, ///
-                childNodesVerified = equalityUnifier.unifyChildNodes(childNodesA, childNodesB, localContext);
+                childNodesVerified = equalityUnifier.unifyChildNodes(childNodesA, childNodesB, context);
 
           termUnifiedWithTerm = childNodesVerified; ///
         }

package/src/unifier/intrinsicLevel.js

@@ -0,0 +1,61 @@
+"use strict";
+
+import shim from "../shim";
+import Unifier from "../unifier";
+
+import { nodeQuery } from "../utilities/query";
+import { variableNameFromVariableNode } from "../utilities/name";
+
+const termNodeQuery = nodeQuery("/term"),
+      termVariableNodeQuery = nodeQuery("/term/variable!");
+
+class IntrinsicLevelUnifier extends Unifier {
+  unify(generalNode, specificNode, substitutions, generalContext, specificContext) {
+    let unifiedAtMetaLevel;
+
+    const generalNonTerminalNode = generalNode, ///
+          specificNonTerminalNode = specificNode, ///
+          nonTerminalNodeUnified = this.unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext);
+
+    unifiedAtMetaLevel = nonTerminalNodeUnified; ///
+
+    return unifiedAtMetaLevel;
+  }
+
+  static maps = [
+    {
+      generalNodeQuery: termVariableNodeQuery,
+      specificNodeQuery: termNodeQuery,
+      unify: (generalVermVariableNode, specificTermNode, substitutions, generalContext, specificContext) => {
+        let termUnified = false;
+
+        const variableNode = generalVermVariableNode, ///
+              variableName = variableNameFromVariableNode(variableNode),
+              variablePresent = generalContext.isVariablePresentByVariableName(variableName);
+
+        if (variablePresent) {
+          let context;
+
+          const { Term, Variable } = shim,
+                termNode = specificTermNode; ///
+
+          context = generalContext; ///
+
+          const variable = Variable.fromVariableNode(variableNode, context);
+
+          context = specificContext;  ///
+
+          const term = Term.fromTermNode(termNode, context);
+
+          termUnified = variable.unifyTerm(term, substitutions, generalContext, specificContext);
+        }
+
+        return termUnified;
+      }
+    }
+  ];
+}
+
+const intrinsicLevelUnifier = new IntrinsicLevelUnifier();
+
+export default intrinsicLevelUnifier;