occam-verify-cli 0.0.1248 → 0.0.1250

package/src/dom/statement.js

@@ -105,10 +105,75 @@ export default domAssigned(class Statement {
     return frameContained;
   }
 
-  matchStatementNode(statementNode) {
-    const statementNodeMatches = this.node.match(statementNode);
+  match(statement) {
+    const statementNode = statement.getNode(),
+          statementNodeMatchesNode = this.node.match(statementNode),
+          matches = statementNodeMatchesNode;  ///
 
-    return statementNodeMatches;
+    return matches;
+  }
+
+  verify(assignments, stated, context) {
+    let verified;
+
+    const statementString = this.string;  ///
+
+    context.trace(`Verifying the '${statementString}' statement...`);
+
+    verified = verifyMixins.some((verifyMixin) => {
+      const statement = this, ///
+            verified = verifyMixin(statement, assignments, stated, context);
+
+      if (verified) {
+        return true;
+      }
+    });
+
+    if (verified) {
+      context.debug(`...verified the '${statementString}' statement.`);
+    }
+
+    return verified;
+  }
+
+  verifyWhenDeclared(fileContext) {
+    let verifiedWhenDeclared;
+
+    const statementNode = this.node,  ///
+          statementString = this.string;  ///
+
+    fileContext.trace(`Verifying the '${statementString}' statement when declared...`);
+
+    verifiedWhenDeclared = combinatorVerifier.verifyStatement(statementNode, fileContext);
+
+    if (verifiedWhenDeclared) {
+      fileContext.debug(`...verified the '${statementString}' statement when declared.`);
+    }
+
+    return verifiedWhenDeclared;
+  }
+
+  verifyGivenMetaType(metaType, assignments, stated, context) {
+    let verifiedGivenMetaType = false;
+
+    const metaTypeString = metaType.getString(),
+          statementString = this.string;  ///
+
+    context.trace(`Verifying the '${statementString}' statement given the '${metaTypeString}' meta-type...`);
+
+    const metaTypeName = metaType.getName();
+
+    if (metaTypeName === STATEMENT_META_TYPE_NAME) {
+      const verified = this.verify(assignments, stated, context)
+
+      verifiedGivenMetaType = verified; ///
+    }
+
+    if (verifiedGivenMetaType) {
+      context.debug(`...verified the '${statementString}' statement given the '${metaTypeString}' meta-type.`);
+    }
+
+    return verifiedGivenMetaType;
   }
 
   unifySubproof(subproof, substitutions, generalContext, specificContext) {
@@ -209,69 +274,6 @@ export default domAssigned(class Statement {
     return unifiedWithProofSteps;
   }
 
-  verify(assignments, stated, context) {
-    let verified;
-
-    const statementString = this.string;  ///
-
-    context.trace(`Verifying the '${statementString}' statement...`);
-
-    verified = verifyMixins.some((verifyMixin) => {
-      const statement = this, ///
-            verified = verifyMixin(statement, assignments, stated, context);
-
-      if (verified) {
-        return true;
-      }
-    });
-
-    if (verified) {
-      context.debug(`...verified the '${statementString}' statement.`);
-    }
-
-    return verified;
-  }
-
-  verifyWhenDeclared(fileContext) {
-    let verifiedWhenDeclared;
-
-    const statementNode = this.node,  ///
-          statementString = this.string;  ///
-
-    fileContext.trace(`Verifying the '${statementString}' statement when declared...`);
-
-    verifiedWhenDeclared = combinatorVerifier.verifyStatement(statementNode, fileContext);
-
-    if (verifiedWhenDeclared) {
-      fileContext.debug(`...verified the '${statementString}' statement when declared.`);
-    }
-
-    return verifiedWhenDeclared;
-  }
-
-  verifyGivenMetaType(metaType, assignments, stated, context) {
-    let verifiedGivenMetaType = false;
-
-    const metaTypeString = metaType.getString(),
-          statementString = this.string;  ///
-
-    context.trace(`Verifying the '${statementString}' statement given the '${metaTypeString}' meta-type...`);
-
-    const metaTypeName = metaType.getName();
-
-    if (metaTypeName === STATEMENT_META_TYPE_NAME) {
-      const verified = this.verify(assignments, stated, context)
-
-      verifiedGivenMetaType = verified; ///
-    }
-
-    if (verifiedGivenMetaType) {
-      context.debug(`...verified the '${statementString}' statement given the '${metaTypeString}' meta-type.`);
-    }
-
-    return verifiedGivenMetaType;
-  }
-
   toJSON() {
     const string = this.string, ///
           json = {

package/src/dom/topLevelAssertion.js

@@ -57,7 +57,7 @@ export default class TopLevelAssertion {
     return this.proof;
   }
 
-  matchStatementNode(statementNode) { return this.consequent.matchStatementNode(statementNode); }
+  getStatement() { return this.consequent.getStatement(); }
 
   matchMetavariableName(metavariableName) {
     const metavariableNameMatches = this.labels.some((label) => {
@@ -238,11 +238,10 @@ export default class TopLevelAssertion {
 
   static fromJSON(Class, json, fileContext) {
     const labels = labelsFromJSON(json, fileContext),
-          labelsString = labelsStringFromLabels(labels),
           suppositions = suppositionsFromJSON(json, fileContext),
           consequent = consequentFromJSON(json, fileContext),
           proof = null,
-          string = labelsString,  ///
+          string = stringFromLabelsAndConsequent(labels, consequent),
           topLevelAssertion = new Class(fileContext, string, labels, suppositions, consequent, proof);
 
     return topLevelAssertion;
@@ -250,11 +249,10 @@ export default class TopLevelAssertion {
 
   static fromNode(Class, node, fileContext) {
     const labels = labelsFromNode(node, fileContext),
-          labelsString = labelsStringFromLabels(labels),
           suppositions = suppositionsFromNode(node, fileContext),
           consequent = consequentFromNode(node, fileContext),
           proof = proofFromNode(node, fileContext),
-          string = labelsString,  ///
+          string = stringFromLabelsAndConsequent(labels, consequent),
           metaLemma = new Class(fileContext, string, labels, suppositions, consequent, proof);
 
     return metaLemma;
@@ -314,3 +312,11 @@ export function labelsStringFromLabels(labels) {
 
   return labelsString;
 }
+
+export function stringFromLabelsAndConsequent(labels, consequent) {
+  const consequentString = consequent.getString(),
+        labelsString = labelsStringFromLabels(labels),
+        string = `${labelsString} :: ${consequentString}`;
+
+  return string;
+}

package/src/dom/topLevelMetaAssertion.js

@@ -8,7 +8,7 @@ import Substitutions from "../substitutions";
 import TopLevelAssertion from "./topLevelAssertion";
 
 import { nodeQuery } from "../utilities/query";
-import { proofFromNode, consequentFromNode, suppositionsFromNode, labelsStringFromLabels } from "./topLevelAssertion";
+import { proofFromNode, consequentFromNode, suppositionsFromNode, stringFromLabelsAndConsequent } from "./topLevelAssertion";
 import { labelsFromJSON,
          labelsToLabelsJSON,
          consequentFromJSON,
@@ -41,6 +41,13 @@ export default class TopLevelMetaAssertion extends TopLevelAssertion {
     return label;
   }
 
+  matchReference(reference) {
+    const label = this.getLabel(),
+          referenceMatches = label.matchReference(reference);
+
+    return referenceMatches;
+  }
+
   verify() {
     let verified = false;
 
@@ -88,14 +95,6 @@ export default class TopLevelMetaAssertion extends TopLevelAssertion {
     return labelsVerified;
   }
 
-  verifyWhenStated(statement, reference, context) {
-    let verifiedWhenStated;
-
-    debugger
-
-    return verifiedWhenStated;
-  }
-
   toJSON() {
     const labelsJSON = labelsToLabelsJSON(this.labels),
           consequentJSON = consequentToConsequentJSON(this.consequent),
@@ -118,11 +117,10 @@ export default class TopLevelMetaAssertion extends TopLevelAssertion {
   static fromJSON(Class, json, fileContext) {
     const labels = labelsFromJSON(json, fileContext),
           substitutions = substitutionsFromJSON(json, fileContext),
-          labelsString = labelsStringFromLabels(labels),
           suppositions = suppositionsFromJSON(json, fileContext),
           consequent = consequentFromJSON(json, fileContext),
           proof = null,
-          string = labelsString,  ///
+          string = stringFromLabelsAndConsequent(labels, consequent),
           topLevelAssertion = new Class(fileContext, string, labels, suppositions, consequent, proof, substitutions);
 
     return topLevelAssertion;
@@ -131,11 +129,10 @@ export default class TopLevelMetaAssertion extends TopLevelAssertion {
   static fromNode(Class, node, fileContext) {
     const labels = labelsFromNode(node, fileContext),
           substitutions = Substitutions.fromNothing(),
-          labelsString = labelsStringFromLabels(labels),
           suppositions = suppositionsFromNode(node, fileContext),
           consequent = consequentFromNode(node, fileContext),
           proof = proofFromNode(node, fileContext),
-          string = labelsString,  ///
+          string = stringFromLabelsAndConsequent(labels, consequent),
           metaLemma = new Class(fileContext, string, labels, suppositions, consequent, proof, substitutions);
 
     return metaLemma;

package/src/dom/variable.js

@@ -166,13 +166,13 @@ export default domAssigned(class Variable {
     return verifiedWhenDeclared;
   }
 
-  unifyTerm(term, substitutions, generalContext, specificContext, contextsReversed = false) {
+  unifyTerm(term, substitutions, generalContext, specificContext) {
     let termUnified = false;
 
     const termString = term.getString(),
           variableString = this.string; ///
 
-    specificContext.trace(`Unifying the '${termString}' term with the '${variableString}' variable...`);
+    generalContext.trace(`Unifying the '${termString}' term with the '${variableString}' variable...`);
 
     const effectivelyEqualToTerm = this.isEffectivelyEqualToTerm(term, generalContext, specificContext);
 
@@ -190,15 +190,15 @@ export default domAssigned(class Variable {
           termUnified = true;
         }
       } else {
-        let context = contextsReversed ?
-                        generalContext :
-                          specificContext;
+        let context;
+
+        context = specificContext;  ///
 
         const variable = this,  ///
               termSubstitution = TermSubstitution.fromTernAndVariable(term, variable, context),
               substitution = termSubstitution;  ///
 
-        context = specificContext;  ///
+        context = generalContext;  ///
 
         substitutions.addSubstitution(substitution, context);
 
@@ -207,7 +207,7 @@ export default domAssigned(class Variable {
     }
 
     if (termUnified) {
-      specificContext.debug(`...unified the '${termString}' term with the '${variableString}' variable.`);
+      generalContext.debug(`...unified the '${termString}' term with the '${variableString}' variable.`);
     }
 
     return termUnified;

package/src/equivalence.js

@@ -186,7 +186,7 @@ export default class Equivalence {
     return implicitlyGroundedTerms;
   }
 
-  getString() {
+  asString() {
     let string;
 
     string = this.terms.reduce((string, term) => {

package/src/equivalences.js

@@ -43,7 +43,7 @@ export default class Equivalences {
   }
 
   addEquivalence(equivalence, context) {
-    const equivalenceString = equivalence.getString();
+    const equivalenceString = equivalence.asString();
 
     context.trace(`Added the '${equivalenceString}' equivalence.`);
 

package/src/substitution/term.js

@@ -47,6 +47,14 @@ export default class TermSubstitution extends Substitution {
 
   matchName(name) { return this.variable.matchName(name); }
 
+  matchSubstitution(substitution) {
+    const term = substitution.getTerm(),
+          variable = substitution.getVariable(),
+          termMatches = this.term.match
+
+    return substitutionMatches;
+  }
+
   unifyWithEquivalence(equivalence) {
     let unifiedWithEquivalence;
 

package/src/substitution.js

@@ -129,6 +129,13 @@ export default class Substitution {
     return resolved;
   }
 
+  match(substitution) {
+    const equalTo = this.isEqualTo(substitution),
+          matches = equalTo;  ///
+
+    return matches;
+  }
+
   matchName(name) {
     const nameMatches = false;
 
@@ -146,4 +153,10 @@ export default class Substitution {
 
     return unifiedWithEquivalence;
   }
+
+  matchSubstitution(substitution) {
+    const substitutionMatches = false;
+
+    return substitutionMatches;
+  }
 }

package/src/substitutions.js

@@ -4,7 +4,7 @@ import { arrayUtilities } from "necessary";
 
 import { EMPTY_STRING } from "./constants";
 
-const { find, first, clear, prune, filter, compress } = arrayUtilities;
+const { find, first, clear, prune, filter, compress, correlate } = arrayUtilities;
 
 export default class Substitutions {
   constructor(array, savedArray) {
@@ -200,6 +200,20 @@ export default class Substitutions {
     context.trace(`Removed the ${substitutionString} substitution.`);
   }
 
+  matchSubstitutions(substitutions) {
+    const array = substitutions.getArray(),
+          correlates = correlate(array, this.array, (substitutionA, substitutionB) => {
+            const substitutionAMatchesSubstitutionB = substitutionA.match(substitutionB);
+
+            if (substitutionAMatchesSubstitutionB) {
+              return true;
+            }
+          }),
+          match = correlates; ///
+
+    return match;
+  }
+
   clear() {
     clear(this.array);
 
@@ -278,19 +292,25 @@ export default class Substitutions {
     this.savedArray = null;
   }
 
-  getString(generalContext, specificContext) {
-    let string = this.array.reduce((string, substitution) => {
-      const substitutionString = substitution.getString(generalContext, specificContext);
+  asString() {
+    let string;
+
+    const length = this.getLength();
+
+    if (length === 0) {
+      string = EMPTY_STRING;
+    } else {
+      const substitutionsString = this.array.reduce((substitutionsString, substitution) => {
+        const substitutionString = substitution.getString();
 
-      string = (string === null) ?
-                 substitutionString :
-                   `${string}, ${substitutionString}`;
+        substitutionsString = (substitutionsString === null) ?
+                                 substitutionString :
+                                  `${substitutionsString}, ${substitutionString}`;
 
-      return string;
-    }, EMPTY_STRING);
+        return substitutionsString;
+      }, null);
 
-    if (string !== EMPTY_STRING) {
-      string = ` ${string}`;
+      string = substitutionsString; ///
     }
 
     return string;

package/src/unifier/intrinsicLevel.js

@@ -9,16 +9,14 @@ const termNodeQuery = nodeQuery("/term"),
       termVariableNodeQuery = nodeQuery("/term/variable!");
 
 class IntrinsicLevelUnifier extends Unifier {
-  unify(generalNode, specificNode, substitutions, generalContext, specificContext) {
-    let unifiedAtMetaLevel;
+  unify(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext) {
+    let unifiedAtIntrinsicLevel;
 
-    const generalNonTerminalNode = generalNode, ///
-          specificNonTerminalNode = specificNode, ///
-          nonTerminalNodeUnified = this.unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext);
+    const nonTerminalNodeUnified = this.unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext);
 
-    unifiedAtMetaLevel = nonTerminalNodeUnified; ///
+    unifiedAtIntrinsicLevel = nonTerminalNodeUnified; ///
 
-    return unifiedAtMetaLevel;
+    return unifiedAtIntrinsicLevel;
   }
 
   static maps = [

package/src/unifier/metaLevel.js

@@ -17,12 +17,10 @@ const termNodeQuery = nodeQuery("/term"),
       statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!");
 
 class MetaLevelUnifier extends Unifier {
-  unify(generalNode, specificNode, substitutions, generalContext, specificContext) {
+  unify(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext) {
     let unifiedAtMetaLevel;
 
-    const generalNonTerminalNode = generalNode, ///
-          specificNonTerminalNode = specificNode, ///
-          nonTerminalNodeUnified = this.unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext);
+    const nonTerminalNodeUnified = this.unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext);
 
     unifiedAtMetaLevel = nonTerminalNodeUnified; ///
 

package/src/utilities/unification.js

@@ -1,9 +1,7 @@
 "use string";
 
 import LocalContext from "../context/local";
-import Substitutions from "../substitutions";
 import equalityUnifier from "../unifier/equality";
-import referenceUnifier from "../unifier/reference";
 import metaLevelUnifier from "../unifier/metaLevel";
 import metavariableUnifier from "../unifier/metavariable";
 import intrinsicLevelUnifier from "../unifier/intrinsicLevel";
@@ -35,9 +33,9 @@ export function unifyStatement(generalStatement, specificStatement, substitution
 
   specificContext = contextFromTokens(specificStatementTokens, specificContext);  ///
 
-  const generalNode = generalStatementNode, ///
-        specificNode = specificStatementNode,
-        unifiedAtMetaLevel = metaLevelUnifier.unify(generalNode, specificNode, substitutions, generalContext, specificContext);
+  const generalNonTerminalNode = generalStatementNode, ///
+        specificNonTerminalNode = specificStatementNode,  ///
+        unifiedAtMetaLevel = metaLevelUnifier.unify(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext);
 
   statementUnified = unifiedAtMetaLevel; ///
 
@@ -56,9 +54,9 @@ export function unifySubstitution(generalSubstitution, specificSubstitution, sub
 
   specificContext = contextFromTokens(specificSubstitutionTokens, specificContext);  ///
 
-  const generalNode = generalSubstitutionNode, ///
-        specificNode = specificSubstitutionNode,
-        unifiedAtMetaLevel = metaLevelUnifier.unify(generalNode, specificNode, substitutions, generalContext, specificContext);
+  const generalNonTerminalNode = generalSubstitutionNode, ///
+        specificNonTerminalNode = specificSubstitutionNode,
+        unifiedAtMetaLevel = metaLevelUnifier.unify(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext);
 
   substitutionUnified = unifiedAtMetaLevel; ///
 
@@ -82,75 +80,36 @@ export function unifyMetavariable(generalMetavariable, specificMetavariable, gen
   return metavariableUnified;
 }
 
-export function unifyLabelWithReference(label, reference, context) {
-  let labelUnifiedWithReference;
-
-  let generalContext,
-      specificContext;
-
-  const fileContext = label.getFileContext(),
-        labelMetavariable = label.getMetavariable(),
-        referenceMetavariable = reference.getMetavariable(),
-        labelMetavariableNode = labelMetavariable.getNode(),
-        labelMetavariableTokens = labelMetavariable.getTokens(),
-        referenceMetavariableNode = referenceMetavariable.getNode(),
-        referenceMetavariableTokens = referenceMetavariable.getTokens();
-
-  generalContext = context; ///
-
-  specificContext = fileContext;  ///
-
-  generalContext = contextFromTokens(labelMetavariableTokens, generalContext);  ///
-
-  specificContext = contextFromTokens(referenceMetavariableTokens, specificContext);  ///
+export function unifyTermWithConstructor(term, constructor, context) {
+  let termUnifiedWithConstructor;
 
-  const substitutions = Substitutions.fromNothing(),
-        referenceUnified = referenceUnifier.unify(labelMetavariableNode, referenceMetavariableNode, substitutions, generalContext, specificContext);
+  const termNode = term.getNode(),
+        constructorTerm = constructor.getTerm(),
+        constructorTermNode = constructorTerm.getNode();
 
-  labelUnifiedWithReference = referenceUnified; ///
+  termUnifiedWithConstructor = termWithConstructorUnifier.unify(constructorTermNode, termNode, context);
 
-  return labelUnifiedWithReference;
+  return termUnifiedWithConstructor;
 }
 
-export function unifyMetavariableWithReference(metavariable, reference, context) {
-  let metavariableUnifiedWithReference;
-
-  let generalContext,
-      specificContext;
-
-  const fileContext = context.getFileContext(),
-        metavariableNode = metavariable.getNode(),
-        metavariableTokens = metavariable.getTokens(),
-        referenceMetavariable = reference.getMetavariable(),
-        referenceMetavariableNode = referenceMetavariable.getNode(),
-        referenceMetavariableTokens = referenceMetavariable.getTokens();
-
-  generalContext = context; ///
-
-  specificContext = fileContext;  ///
-
-  generalContext = contextFromTokens(metavariableTokens, generalContext);  ///
-
-  specificContext = contextFromTokens(referenceMetavariableTokens, specificContext);  ///
-
-  const substitutions = Substitutions.fromNothing(),
-        referenceUnified = referenceUnifier.unify(metavariableNode, referenceMetavariableNode, substitutions, generalContext, specificContext);
+export function unifyStatementIntrinsically(generalStatement, specificStatement, substitutions, generalContext, specificContext) {
+  let metavariableUnifiedIntrinsically;
 
-  metavariableUnifiedWithReference = referenceUnified; ///
+  const generalStatementNode = generalStatement.getNode(),
+        specificStatementNode = specificStatement.getNode(),
+        generalStatementTokens = generalStatement.getTokens(),
+        specificStatementTokens = specificStatement.getTokens();
 
-  return metavariableUnifiedWithReference;
-}
+  generalContext = contextFromTokens(generalStatementTokens, generalContext); ///
 
-export function unifyTermWithConstructor(term, constructor, context) {
-  let termUnifiedWithConstructor;
+  specificContext = contextFromTokens(specificStatementTokens, specificContext); ///
 
-  const termNode = term.getNode(),
-        constructorTerm = constructor.getTerm(),
-        constructorTermNode = constructorTerm.getNode();
+  const generalNonTerminalNode = generalStatementNode, ///
+        specificNonTerminalNode = specificStatementNode; ///
 
-  termUnifiedWithConstructor = termWithConstructorUnifier.unify(constructorTermNode, termNode, context);
+  metavariableUnifiedIntrinsically = intrinsicLevelUnifier.unify(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext);
 
-  return termUnifiedWithConstructor;
+  return metavariableUnifiedIntrinsically;
 }
 
 export function unifyStatementWithCombinator(statement, combinator, assignments, stated, context) {
@@ -186,7 +145,10 @@ export function unifyMetavariableIntrinsically(generalMetavariable, specificMeta
 
   specificContext = contextFromTokens(specificMetavariableTokens, specificContext); ///
 
-  metavariableUnifiedIntrinsically = intrinsicLevelUnifier.unify(generalMetavariableNode, specificMetavariableNode, substitutions, generalContext, specificContext);
+  const generalNonTerminalNode = generalMetavariableNode, ///
+        specificNonTerminalNode = specificMetavariableNode; ///
+
+  metavariableUnifiedIntrinsically = intrinsicLevelUnifier.unify(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext);
 
   return metavariableUnifiedIntrinsically;
 }