occam-verify-cli 0.0.1075 → 0.0.1078

package/src/context/local.js

@@ -250,7 +250,7 @@ class LocalContext {
     return termGrounded;
   }
 
-  isVariableDefined(variable) {
+  isVariableDefinedByVariableName(variableName) {
     const context = this,
           equivalences = this.getEquivalences(),
           groundedTerms = [],
@@ -259,9 +259,9 @@ class LocalContext {
     groundedTermsAndDefinedVariablesFromFromEquivalences(equivalences, groundedTerms, definedVariables, context);
 
     const variableMatchesDefinedVariable = definedVariables.some((definedVariable) => {
-            const variableMatchesDefinedVariable = variable.match(definedVariable);
+            const definedVariableName = definedVariable.getName();
 
-            if (variableMatchesDefinedVariable) {
+            if (definedVariableName === variableName) {
               return true;
             }
           }),

package/src/declaration.js

@@ -100,17 +100,14 @@ class Declaration {
 
     localContext.trace(`Verifying the '${declarationString}' declaration...`);
 
-    stated = true;
+    stated = true;  ///
 
-    assignments = null;
+    assignments = null; ///
 
-    const referenceVerified = this.reference.verify(localContext);
+    const referenceVerified = this.reference.verify(localContext),
+          statementVerified = this.statement.verify(assignments, stated, localContext);
 
-    if (referenceVerified) {
-      const statementVerified = this.statement.verify(assignments, stated, localContext);
-
-      verified = statementVerified; ///
-    }
+    verified = (referenceVerified && statementVerified);
 
     if (verified) {
       localContext.debug(`...verified the '${declarationString}' declaration.`);

package/src/equality.js

@@ -50,8 +50,9 @@ class Equality {
   }
 
   isReflexive() {
-    const leftTermMatchesRightTerm = this.leftTerm.match(this.rightTerm),
-          reflexive = leftTermMatchesRightTerm; ///
+    const rightTermNode = this.rightTerm.getNode(),
+          leftTermNodeMatchesRightTermNode = this.leftTerm.matchTermNode(rightTermNode),
+          reflexive = leftTermNodeMatchesRightTermNode; ///
 
     return reflexive;
   }

package/src/equivalence.js

@@ -56,30 +56,18 @@ export default class Equivalence {
     return typeMatches;
   }
 
-  matchTerm(term) {
+  equateTerm(term) {
     const termA = term, ///
-          termMatches = this.terms.some((term) => {
+          termEquates = this.terms.some((term) => {
             const termB = term, ///
-                  termAMatchesTermB = termA.match(termB);
+                  termAEqualToTermB = termA.isEqualTo(termB);
 
-            if (termAMatchesTermB) {
+            if (termAEqualToTermB) {
               return true;
             }
           });
 
-    return termMatches;
-  }
-
-  matchTerms(terms) {
-    const termsMatch = terms.every((term) => {
-      const termMatches = this.matchTerm(term);
-
-      if (termMatches) {
-        return true;
-      }
-    })
-
-    return termsMatch;
+    return termEquates;
   }
 
   matchTermNode(termNode) {
@@ -206,7 +194,7 @@ export default class Equivalence {
 
       string = (string === null) ?
                  termString :
-                    `${string} ${termString}`;
+                    `${string} = ${termString}`;
 
       return string;
     }, null);

package/src/metavariable.js

@@ -6,6 +6,7 @@ import FrameForMetavariableSubstitution from "./substitution/frameForMetavariabl
 import StatementForMetavariableSubstitution from "./substitution/statementForMetavariable";
 
 import { nodeQuery } from "./utilities/query";
+import { EMPTY_STRING } from "./constants";
 import { metavariableNodeFromMetavariableString } from "./utilities/node";
 import { metaTypeFromJSON, metaTypeToMetaTypeJSON } from "./utilities/json";
 import { typeNameFromTypeNode, metavariableNameFromMetavariableNode } from "./utilities/name";
@@ -122,11 +123,9 @@ class Metavariable {
           metavariableString = this.string, ///
           substitutionString = (substitution !== null) ?
                                   substitution.getString() :
-                                    null;
+                                    EMPTY_STRING;
 
-    (substitutionString !== null) ?
-      localContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}' metavariable given the ${substitutionString} substitution...`) :
-        localContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}' metavariable...`);
+    localContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}${substitutionString}' metavariable...`);
 
     const statementNode = statement.getNode(),
           metavariableNode = this.node, ///
@@ -147,7 +146,7 @@ class Metavariable {
             metavariable = metavariableFromMetavariableNode(metavariableNode, localContext),
             statementMetavariable = statementMetavariableFromStatementNode(statementNode, localContext);
 
-      if (metavariable === statementMetavariable) {
+      if ((metavariable !== null) && (metavariable === statementMetavariable)) {
         statementUnified = true;
       } else {
         const metavariable = this,  ///
@@ -162,9 +161,7 @@ class Metavariable {
     }
 
     if (statementUnified) {
-      (substitutionString !== null) ?
-        localContext.debug(`...unified the '${statementString}' statement with the '${metavariableString}' metavariable given the ${substitutionString} substitution.`) :
-          localContext.debug(`...unified the '${statementString}' statement with the '${metavariableString}' metavariable.`);
+      localContext.debug(`...unified the '${statementString}' statement with the '${metavariableString}${substitutionString}' metavariable.`);
     }
 
     return statementUnified;

package/src/mixins/statement/resolve.js

@@ -0,0 +1,68 @@
+"use strict";
+
+import DefinedAssertion from "../../assertion/defined";
+import ContainedAssertion from "../../assertion/contained";
+
+import { nodeQuery } from "../../utilities/query";
+
+const definedAssertionNodeQuery = nodeQuery("/statement/definedAssertion"),
+      containedAssertionNodeQuery = nodeQuery("/statement/containedAssertion");
+
+function resolveAsDefinedAssertion(statement, substitutions, localContextA, localContextB) {
+  let resolvedAsDefinedAssertion = false;
+
+  const localContext = localContextA, ///
+        statementNode = statement.getNode(),
+        definedAssertionNode = definedAssertionNodeQuery(statementNode),
+        definedAssertion = DefinedAssertion.fromDefinedAssertionNode(definedAssertionNode, localContext);
+
+  if (definedAssertion !== null) {
+    const statementString = statement.getString();
+
+    localContextB.trace(`Resolving the '${statementString}' statement as a defined assertion...`);
+
+    const localContext = localContextB, ///
+          definedAssertionVerified = definedAssertion.resolve(substitutions, localContext);
+
+    resolvedAsDefinedAssertion = definedAssertionVerified; ///
+
+    if (resolvedAsDefinedAssertion) {
+      localContextB.debug(`...resolved the '${statementString}' statement as a defined assertion.`);
+    }
+  }
+
+  return resolvedAsDefinedAssertion;
+}
+
+function resolveAsContainedAssertion(statement, substitutions, localContextA, localContextB) {
+  let resolvedAsContainedAssertion = false;
+
+  const localContext = localContextA, ///
+        statementNode = statement.getNode(),
+        containedAssertionNode = containedAssertionNodeQuery(statementNode),
+        containedAssertion = ContainedAssertion.fromContainedAssertionNode(containedAssertionNode, localContext);
+
+  if (containedAssertion !== null) {
+    const statementString = statement.getString();
+
+    localContextB.trace(`Resolving the '${statementString}' statement as a contained assertion...`);
+
+    const localContext = localContextB, ///
+          containedAssertionVerified = containedAssertion.resolve(substitutions, localContext);
+
+    resolvedAsContainedAssertion = containedAssertionVerified; ///
+
+    if (resolvedAsContainedAssertion) {
+      localContextB.debug(`...resolved the '${statementString}' statement as a contained assertion.`);
+    }
+  }
+
+  return resolvedAsContainedAssertion;
+}
+
+const resolveMixins = [
+  resolveAsDefinedAssertion,
+  resolveAsContainedAssertion
+];
+
+export default resolveMixins;

package/src/mixins/statement/unify.js

@@ -28,10 +28,10 @@ function unifyWithCombinators(statement, assignments, stated, localContext) {
 
   const combinators = localContext.getCombinators();
 
-  assignments = null; ///
-
   stated = true;  ///
 
+  assignments = null; ///
+
   unifiedWithCombinators = combinators.some((combinator) => {
     const unifiedWithCombinator = unifyStatementWithCombinator(statement, combinator, assignments, stated, localContext);
 

package/src/mixins/statement/verify.js

@@ -8,10 +8,8 @@ import ContainedAssertion from "../../assertion/contained";
 
 import { nodeQuery } from "../../utilities/query";
 
-const frameNodeQuery = nodeQuery("/statement/frame"),
-      equalityNodeQuery = nodeQuery("/statement/equality"),
+const equalityNodeQuery = nodeQuery("/statement/equality"),
       judgementNodeQuery = nodeQuery("/statement/judgement"),
-      declarationNodeQuery = nodeQuery("/statement/declaration"),
       metavariableNodeQuery = nodeQuery("/statement/metavariable!"),
       typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion"),
       definedAssertionNodeQuery = nodeQuery("/statement/definedAssertion"),
@@ -68,31 +66,6 @@ function verifyAsEquality(statement, assignments, stated, localContext) {
   return verifiedAsEquality;
 }
 
-function verifyAsFrame(statement, assignments, stated, localContext) {
-  let verifiedAsFrame = false;
-
-  const { Frame } = shim,
-        statementNode = statement.getNode(),
-        frameNode = frameNodeQuery(statementNode),
-        frame = Frame.fromFrameNode(frameNode, localContext);
-
-  if (frame !== null) {
-    const statementString = statement.getString();
-
-    localContext.trace(`Verifying the '${statementString}' statement as a frame...`);
-
-    const frameVerified = frame.verify(assignments, stated, localContext);
-
-    verifiedAsFrame = frameVerified; ///
-
-    if (verifiedAsFrame) {
-      localContext.debug(`...verified the '${statementString}' statement as a frame.`);
-    }
-  }
-
-  return verifiedAsFrame;
-}
-
 function verifyAsJudgement(statement, assignments, stated, localContext) {
   let verifiedAsJudgement = false;
 
@@ -118,31 +91,6 @@ function verifyAsJudgement(statement, assignments, stated, localContext) {
   return verifiedAsJudgement;
 }
 
-function verifyAsDeclaration(statement, assignments, stated, localContext) {
-  let verifiedAsDeclaration = false;
-
-  const { Declaration } = shim,
-        statementNode = statement.getNode(),
-        declarationNode = declarationNodeQuery(statementNode),
-        declaration = Declaration.fromDeclarationNode(declarationNode, localContext);
-
-  if (declaration !== null) {
-    const statementString = statement.getString();
-
-    localContext.trace(`Verifying the '${statementString}' statement as a declaration...`);
-
-    const declarationVerified = declaration.verify(assignments, stated, localContext);
-
-    verifiedAsDeclaration = declarationVerified; ///
-
-    if (verifiedAsDeclaration) {
-      localContext.debug(`...verified the '${statementString}' statement as a declaration.`);
-    }
-  }
-
-  return verifiedAsDeclaration;
-}
-
 function verifyAsTypeAssertion(statement, assignments, stated, localContext) {
   let verifiedAsTypeAssertion = false;
 
@@ -191,60 +139,58 @@ function verifyAsDefinedAssertion(statement, assignments, stated, localContext)
   return verifiedAsDefinedAssertion;
 }
 
-function verifyAsSubproofAssertion(statement, assignments, stated, localContext) {
-  let verifiedAsSubproofAssertion = false;
+function verifyAsContainedAssertion(statement, assignments, stated, localContext) {
+  let verifiedAsContainedAssertion = false;
 
   const statementNode = statement.getNode(),
-        subproofAssertionNode = subproofAssertionNodeQuery(statementNode),
-        subproofAssertion = SubproofAssertion.fromSubproofAssertionNode(subproofAssertionNode, localContext);
+        containedAssertionNode = containedAssertionNodeQuery(statementNode),
+        containedAssertion = ContainedAssertion.fromContainedAssertionNode(containedAssertionNode, localContext);
 
-  if (subproofAssertionNode !== null) {
+  if (containedAssertion !== null) {
     const statementString = statement.getString();
 
-    localContext.trace(`Verifying the '${statementString}' statement as a subproof assertion...`);
+    localContext.trace(`Verifying the '${statementString}' statement as a contained assertion...`);
 
-    const subproofAssertionVerified = subproofAssertion.verify(assignments, stated, localContext);
+    const containedAssertionVerified = containedAssertion.verify(assignments, stated, localContext);
 
-    verifiedAsSubproofAssertion = subproofAssertionVerified; ///
+    verifiedAsContainedAssertion = containedAssertionVerified; ///
 
-    if (verifiedAsSubproofAssertion) {
-      localContext.debug(`...verified the '${statementString}' statement as a subproof assertion.`);
+    if (verifiedAsContainedAssertion) {
+      localContext.debug(`...verified the '${statementString}' statement as a contained assertion.`);
     }
   }
 
-  return verifiedAsSubproofAssertion;
+  return verifiedAsContainedAssertion;
 }
 
-function verifyAsContainedAssertion(statement, assignments, stated, localContext) {
-  let verifiedAsContainedAssertion = false;
+function verifyAsSubproofAssertion(statement, assignments, stated, localContext) {
+  let verifiedAsSubproofAssertion = false;
 
   const statementNode = statement.getNode(),
-        containedAssertionNode = containedAssertionNodeQuery(statementNode),
-        containedAssertion = ContainedAssertion.fromContainedAssertionNode(containedAssertionNode, localContext);
+        subproofAssertionNode = subproofAssertionNodeQuery(statementNode),
+        subproofAssertion = SubproofAssertion.fromSubproofAssertionNode(subproofAssertionNode, localContext);
 
-  if (containedAssertion !== null) {
+  if (subproofAssertionNode !== null) {
     const statementString = statement.getString();
 
-    localContext.trace(`Verifying the '${statementString}' statement as a contained assertion...`);
+    localContext.trace(`Verifying the '${statementString}' statement as a subproof assertion...`);
 
-    const containedAssertionVerified = containedAssertion.verify(assignments, stated, localContext);
+    const subproofAssertionVerified = subproofAssertion.verify(assignments, stated, localContext);
 
-    verifiedAsContainedAssertion = containedAssertionVerified; ///
+    verifiedAsSubproofAssertion = subproofAssertionVerified; ///
 
-    if (verifiedAsContainedAssertion) {
-      localContext.debug(`...verified the '${statementString}' statement as a contained assertion.`);
+    if (verifiedAsSubproofAssertion) {
+      localContext.debug(`...verified the '${statementString}' statement as a subproof assertion.`);
     }
   }
 
-  return verifiedAsContainedAssertion;
+  return verifiedAsSubproofAssertion;
 }
 
 const verifyMixins = [
   verifyAsMetavariable,
   verifyAsEquality,
-  verifyAsFrame,
   verifyAsJudgement,
-  verifyAsDeclaration,
   verifyAsTypeAssertion,
   verifyAsDefinedAssertion,
   verifyAsSubproofAssertion,

package/src/premise.js

@@ -28,35 +28,28 @@ class Premise {
 
   getStatement() { return this.unqualifiedStatement.getStatement(); }
 
-  unifySubproof(subproof, substitutions, localContext) {
-    let subproofUnified = false;
+  resolveIndependently(substitutions, localContext) {
+    let resolvedIndependently;
 
-    const premise = this, ///
-          subproofString = subproof.getString(),
-          premiseStatement = premise.getStatement(),
-          premiseStatementString = premiseStatement.getString();
+    const premiseString = this.getString();
 
-    localContext.trace(`Unifying the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement...`);
+    const localContextB = localContext; ///
 
-    const statement = this.unqualifiedStatement.getStatement(),
-          statementNode = statement.getNode(),
-          statementTokens = statement.getTokens(),
-          context = this.fileContext, ///
-          tokens = statementTokens; ///
+    localContext = LocalContext.fromFileContext(this.fileContext);
 
-    localContext = LocalContext.fromContextAndTokens(context, tokens);  ///
+    const localContextA = localContext; ///
 
-    const subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, localContext);
+    localContextB.trace(`Resolving the '${premiseString}' premise independently...`);
 
-    if (subproofAssertion !== null) {
-      subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, this.fileContext, localContext);
-    }
+    const unqualifiedStatementResolvedIndependently = this.unqualifiedStatement.resolveIndependently(substitutions, localContextA, localContextB);
 
-    if (subproofUnified) {
-      localContext.debug(`...unified the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement.`);
+    resolvedIndependently = unqualifiedStatementResolvedIndependently;  ///
+
+    if (resolvedIndependently) {
+      localContextB.trace(`...resolved the '${premiseString}' premise independently.`);
     }
 
-    return subproofUnified;
+    return resolvedIndependently;
   }
 
   unifyProofStep(proofStep, substitutions, localContext) {
@@ -79,6 +72,14 @@ class Premise {
     }
 
     if (subproofUnified || statementUnified) {
+      const localContextB = localContext; ///
+
+      localContext = LocalContext.fromFileContext(this.fileContext);
+
+      const localContextA = localContext; ///
+
+      substitutions.resolve(localContextA, localContextB);
+
       proofStepUnified = true;
     }
 
@@ -112,6 +113,37 @@ class Premise {
     return statementUnified;
   }
 
+  unifySubproof(subproof, substitutions, localContext) {
+    let subproofUnified = false;
+
+    const premise = this, ///
+          subproofString = subproof.getString(),
+          premiseStatement = premise.getStatement(),
+          premiseStatementString = premiseStatement.getString();
+
+    localContext.trace(`Unifying the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement...`);
+
+    const statement = this.unqualifiedStatement.getStatement(),
+          statementNode = statement.getNode(),
+          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);
+    }
+
+    if (subproofUnified) {
+      localContext.debug(`...unified the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement.`);
+    }
+
+    return subproofUnified;
+  }
+
   verify(localContext) {
     let verified = false;
 

package/src/proofStep.js

@@ -1,10 +1,15 @@
 "use strict";
 
+import { arrayUtilities } from "necessary";
+
 import shim from "./shim";
+import metaLevelUnifier from "./unifier/metaLevel";
 
 import { nodeQuery } from "./utilities/query";
 import { assignAssignments } from "./utilities/assignments";
 
+const { match } = arrayUtilities;
+
 const subproofNodeQuery = nodeQuery("/proofStep|lastProofStep/subproof"),
       qualifiedStatementNodeQuery = nodeQuery("/proofStep|lastProofStep/qualifiedStatement"),
       unqualifiedStatementNodeQuery = nodeQuery("/proofStep|lastProofStep/unqualifiedStatement");
@@ -45,56 +50,112 @@ class ProofStep {
   unifyStatement(statement, localContext) {
     let statementUnified = false;
 
-    const { Substitutions } = shim,
-          substitutions = Substitutions.fromNothing();
+    if ((this.qualifiedStatement !== null) || (this.unqualifiedStatement !== null !== null)) {
+      const statementString = statement.getString();
 
-    if (this.qualifiedStatement !== null) {
-      const localContextA = localContext, ///
-            localContextB = localContext; ///
+      localContext.trace(`Unifying the '${statementString}' statement...`);
 
-      statementUnified = this.qualifiedStatement.unifyStatement(statement, substitutions, localContextA, localContextB);
-    }
+      const { Substitutions } = shim,
+            localContextA = localContext, ///
+            localContextB = localContext, ///
+            substitutions = Substitutions.fromNothing();
 
-    if (this.unqualifiedStatement !== null) {
-      const localContextA = localContext, ///
-            localContextB = localContext; ///
+      if (this.qualifiedStatement !== null) {
+        statementUnified = this.qualifiedStatement.unifyStatement(statement, substitutions, localContextA, localContextB);
+      }
 
-      statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, localContextA, localContextB);
-    }
+      if (this.unqualifiedStatement !== null) {
+        statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, localContextA, localContextB);
+      }
 
-    const substitutionsLength = substitutions.getLength();
+      const substitutionsLength = substitutions.getLength();
 
-    if (substitutionsLength > 0) {
-      statementUnified = false;
+      if (substitutionsLength > 0) {
+        statementUnified = false;
+      }
+
+      if (statementUnified) {
+        localContext.debug(`...unified the '${statementString}' statement.`);
+      }
     }
 
     return statementUnified;
   }
 
+  unifySubproofAssertion(subproofAssertion, localContext) {
+    let subproofAssertionUnified = false;
+
+    if (this.subproof !== null) {
+      const subproofString = this.subproof.getString(),
+            subproofAssertionString = subproofAssertion.getString();
+
+      localContext.trace(`Unifying the '${subproofAssertionString}' subproof assertion with the '${subproofString}' subproof...`);
+
+      const { Substitutions } = shim,
+            substitutions = Substitutions.fromNothing(),
+            subproofStatements = this.subproof.getStatements(),
+            subproofAssertionStatements = subproofAssertion.getStatements();
+
+      subproofAssertionUnified = match(subproofAssertionStatements, subproofStatements, (subproofAssertionStatement, subproofStatement) => {
+        const subproofAssertionStatementNode = subproofAssertionStatement.getNode(),
+              subproofStatementNode = subproofStatement.getNode(),
+              nodeA = subproofAssertionStatementNode,  ///
+              nodeB = subproofStatementNode,  ///
+              localContextA = localContext, ///
+              localContextB = localContext, ///
+              unifiedAtMetaLevel = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+
+        if (unifiedAtMetaLevel) {
+          return true;
+        }
+      });
+
+      if (subproofAssertionUnified) {
+        const substitutionsLength = substitutions.getLength();
+
+        if (substitutionsLength > 0) {
+          subproofAssertionUnified = false;
+        }
+      }
+
+      if (subproofAssertionUnified) {
+        localContext.trace(`...unified the '${subproofAssertionString}' subproof assertion with the '${subproofString}' subproof.`);
+      }
+    }
+
+    return subproofAssertionUnified;
+  }
+
   verify(substitutions, localContext) {
     let verified = false;
 
+    let stated = false;
+
+    const assignments = [];
+
+    let subproofVerified = false,
+        qualifiedStatementVerified = false,
+        unqualifiedStatementVerified = false;
+
     if (false) {
       ///
     } else if (this.subproof !== null) {
-      const subproofVerified = this.subproof.verify(substitutions, localContext);
-
-      verified = subproofVerified;  ///
+      subproofVerified = this.subproof.verify(substitutions, localContext);
     } else if (this.qualifiedStatement !== null) {
-      const qualifiedStatementVerified = this.qualifiedStatement.verify(substitutions, localContext);
+      stated = true;
 
-      verified = qualifiedStatementVerified;  ///
+      qualifiedStatementVerified = this.qualifiedStatement.verify(substitutions, assignments, stated, localContext);
     } else if (this.unqualifiedStatement !== null) {
-      const stated = false,
-            assignments = [],
-            unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, localContext);
+      stated = false;
+
+      unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, localContext);
+    }
 
-      if (unqualifiedStatementVerified) {
-        const assignmentsAssigned = assignAssignments(assignments, localContext);
+    if (subproofVerified || qualifiedStatementVerified || unqualifiedStatementVerified) {
+      const assignmentsAssigned = assignAssignments(assignments, localContext);
 
-        if (assignmentsAssigned) {
-          verified = true;
-        }
+      if (assignmentsAssigned) {
+        verified = true;
       }
     }