occam-verify-cli 0.0.1119 → 0.0.1121

package/src/dom/metavariable.js

@@ -3,6 +3,7 @@
 import dom from "../dom";
 import LocalContext from "../context/local";
 import FrameSubstitution from "../substitution/frame";
+import ReferenceSubstitution from "../substitution/reference";
 import StatementSubstitution from "../substitution/statement";
 import MetavariableNodeAndTokens from "../nodeAndTokens/metavariable";
 
@@ -10,10 +11,11 @@ import { nodeQuery } from "../utilities/query";
 import { objectType } from "../dom/type";
 import { domAssigned } from "../dom";
 import { EMPTY_STRING } from "../constants";
-import { unifyMetavariable } from "../utilities/unification";
 import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 import { metavariableNameFromMetavariableNode } from "../utilities/name";
 import { metaTypeFromJSON, metaTypeToMetaTypeJSON } from "../utilities/json";
+import { unifyMetavariable, unifyMetavariableIntrinsically } from "../utilities/unification";
+import { metavariableFromFrame, metavariableFromReference, metavariableFromStatement } from "../utilities/verification";
 
 const termNodeQuery = nodeQuery("/metavariable/argument/term"),
       metavariableNodeQuery = nodeQuery("/metavariableDeclaration/metavariable"),
@@ -77,38 +79,28 @@ export default domAssigned(class Metavariable {
     return equalTo;
   }
 
-  isEffectivelyEqualToFrame(frame, generalContext, specificContext) {
-    let effectivelyEqualToFrame = false;
-
-    const generalContextFilePath = generalContext.getFilePath(),
-          specificContextFilePath = specificContext.getFilePath();
-
-    if (generalContextFilePath === specificContextFilePath) {
-      const frameString = frame.getString();
+  unifySubstitution(substitution, context) {
+    let substitutionUnified = false;
 
-      if (frameString === this.string) {
-        effectivelyEqualToFrame = true;
-      }
-    }
+    const metavariableString = this.string,  ///
+          substitutionString = substitution.getString();
 
-    return effectivelyEqualToFrame;
-  }
+    context.trace(`Unifying the '${substitutionString}' substitution with the '${metavariableString}' metavariable...`);
 
-  isEffectivelyEqualToStatement(statement, generalContext, specificContext) {
-    let effectivelyEqualToStatement = false;
+    const metavariable = this, ///
+          judgement = context.findJudgementByMetavariable(metavariable);
 
-    const generalContextFilePath = generalContext.getFilePath(),
-          specificContextFilePath = specificContext.getFilePath();
+    if (judgement !== null) {
+      const declaration = judgement.getDeclaration();
 
-    if (generalContextFilePath === specificContextFilePath) {
-      const statementString = statement.getString();
+      substitutionUnified = declaration.unifySubstitution(substitution, context);
+    }
 
-      if (statementString === this.string) {
-        effectivelyEqualToStatement = true;
-      }
+    if (substitutionUnified) {
+      context.debug(`...unified the '${substitutionString}' substitution with the '${metavariableString}' metavariable.`);
     }
 
-    return effectivelyEqualToStatement;
+    return substitutionUnified;
   }
 
   unifyFrame(frame, substitutions, generalContext, specificContext) {
@@ -119,9 +111,9 @@ export default domAssigned(class Metavariable {
 
     specificContext.trace(`Unifying the '${frameString}' frame with the '${metavariableString}' metavariable...`);
 
-    const effectivelyEqualToFrame = this.isEffectivelyEqualToFrame(frame, generalContext, specificContext);
+    const frameMetavariableUnified = this.unifyFrameMetavariable(frame, substitutions, generalContext, specificContext);
 
-    if (effectivelyEqualToFrame) {
+    if (frameMetavariableUnified) {
       frameUnified = true;
     } else {
       const metavariable = this, ///
@@ -154,6 +146,49 @@ export default domAssigned(class Metavariable {
     return frameUnified;
   }
 
+  unifyReference(reference, substitutions, generalContext, specificContext) {
+    let referenceUnified = false;
+
+    const referenceString = reference.getString(),
+          metavariableString = this.string; ///
+
+    specificContext.trace(`Unifying the '${referenceString}' reference with the '${metavariableString}' metavariable...`);
+
+    const referenceMetavariableUnified = this.unifyReferenceMetavariable(reference, substitutions, generalContext, specificContext);
+
+    if (referenceMetavariableUnified) {
+      referenceUnified = true;
+    } else {
+      const metavariable = this, ///
+            simpleSubstitutionPresent = substitutions.isSimpleSubstitutionPresentByMetavariable(metavariable);
+
+      if (simpleSubstitutionPresent) {
+        const simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariable(metavariable),
+              substitution = simpleSubstitution,  ///
+              substitutionReferenceEqualToReference = substitution.isReferenceEqualTo(reference);
+
+        if (substitutionReferenceEqualToReference) {
+          referenceUnified = true;
+        }
+      } else {
+        const context = specificContext,  ///
+              metavariable = this,  ///
+              referenceSubstitution = ReferenceSubstitution.fromFrameAndMetavariable(reference, metavariable, context),
+              substitution = referenceSubstitution;  ///
+
+        substitutions.addSubstitution(substitution, context);
+
+        referenceUnified = true;
+      }
+    }
+
+    if (referenceUnified) {
+      specificContext.debug(`...unified the '${referenceString}' reference with the '${metavariableString}' metavariable.`);
+    }
+
+    return referenceUnified;
+  }
+
   unifyStatement(statement, substitution, substitutions, generalContext, specificContext) {
     let statementUnified = false;
 
@@ -165,9 +200,9 @@ export default domAssigned(class Metavariable {
 
     specificContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}${substitutionString}' metavariable...`);
 
-    const effectivelyEqualToStatement = this.isEffectivelyEqualToStatement(statement, generalContext, specificContext);
+    const statementMetavariableUnified = this.unifyStatementMetavariable(statement, substitutions, generalContext, specificContext);
 
-    if (effectivelyEqualToStatement) {
+    if (statementMetavariableUnified) {
       statementUnified = true;
     } else {
       const context = specificContext,  ///
@@ -220,28 +255,118 @@ export default domAssigned(class Metavariable {
     return metavariableUnified;
   }
 
-  unifySubstitution(substitution, context) {
-    let substitutionUnified = false;
+  unifyFrameMetavariable(frame, substitutions, generalContext, specificContext) {
+    let frameMetavariableUnified = false;
 
-    const metavariableString = this.string,  ///
-          substitutionString = substitution.getString();
+    const generalContextFilePath = generalContext.getFilePath(),
+          specificContextFilePath = specificContext.getFilePath();
 
-    context.trace(`Unifying the '${substitutionString}' substitution with the '${metavariableString}' metavariable...`);
+    if (generalContextFilePath === specificContextFilePath) {
+      const frameString = frame.getString();
 
-    const metavariable = this, ///
-          judgement = context.findJudgementByMetavariable(metavariable);
+      if (frameString === this.string) {
+        frameMetavariableUnified = true;
+      } else {
+        const context = specificContext,  ///
+              metavariable = metavariableFromFrame(frame, context);
 
-    if (judgement !== null){
-      const declaration = judgement.getDeclaration();
+        if (metavariable !== null) {
+          const frameMetavariable = metavariable, ///
+                metavariableString = this.string, ///
+                frameMetavariableString = frameMetavariable.getString();
 
-      substitutionUnified = declaration.unifySubstitution(substitution, context);
+          specificContext.trace(`Unifying the frame's ${frameMetavariableString}' metavariable with the '${metavariableString}' metavariable...`);
+
+          const specificMetavariable = frameMetavariable, ///
+                generalMetavariable = this, ///
+                metavariableUnifiedIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, substitutions, generalContext, specificContext);
+
+          frameMetavariableUnified = metavariableUnifiedIntrinsically; ///
+
+          if (frameMetavariableUnified) {
+            specificContext.debug(`...unified the frame's '${frameMetavariableString}' metavariable with the '${metavariableString}' metavariable.`);
+          }
+        }
+      }
     }
 
-    if (substitutionUnified) {
-      context.debug(`...unified the '${substitutionString}' substitution with the '${metavariableString}' metavariable.`);
+    return frameMetavariableUnified;
+  }
+
+  unifyReferenceMetavariable(reference, substitutions, generalContext, specificContext) {
+    let referenceMetavariableUnified = false;
+
+    const generalContextFilePath = generalContext.getFilePath(),
+          specificContextFilePath = specificContext.getFilePath();
+
+    if (generalContextFilePath === specificContextFilePath) {
+      const referenceString = reference.getString();
+
+      if (referenceString === this.string) {
+        referenceMetavariableUnified = true;
+      } else {
+        const context = specificContext,  ///
+              metavariable = metavariableFromReference(reference, context);
+
+        if (metavariable !== null) {
+          const referenceMetavariable = metavariable, ///
+            metavariableString = this.string, ///
+            referenceMetavariableString = referenceMetavariable.getString();
+
+          specificContext.trace(`Unifying the reference's ${referenceMetavariableString}' metavariable with the '${metavariableString}' metavariable...`);
+
+          const specificMetavariable = referenceMetavariable, ///
+            generalMetavariable = this, ///
+            metavariableUnifiedIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, substitutions, generalContext, specificContext);
+
+          referenceMetavariableUnified = metavariableUnifiedIntrinsically; ///
+
+          if (referenceMetavariableUnified) {
+            specificContext.debug(`...unified the reference's '${referenceMetavariableString}' metavariable with the '${metavariableString}' metavariable.`);
+          }
+        }
+      }
     }
 
-    return substitutionUnified;
+    return referenceMetavariableUnified;
+  }
+
+  unifyStatementMetavariable(statement, substitutions, generalContext, specificContext) {
+    let statementMetavariableUnified = false;
+
+    const generalContextFilePath = generalContext.getFilePath(),
+          specificContextFilePath = specificContext.getFilePath();
+
+    if (generalContextFilePath === specificContextFilePath) {
+      const statementString = statement.getString();
+
+      if (statementString === this.string) {
+        statementMetavariableUnified = true;
+      } else {
+        const context = specificContext,  ///
+              metavariable = metavariableFromStatement(statement, context);
+
+        if (metavariable !== null) {
+          const statementMetavariable = metavariable, ///
+                metavariableString = this.string, ///
+                statementMetavariableString = statementMetavariable.getString();
+
+          specificContext.trace(`Unifying the statement's ${statementMetavariableString}' metavariable with the '${metavariableString}' metavariable...`);
+
+          const specificMetavariable = statementMetavariable, ///
+                generalMetavariable = this, ///
+                metavariableUnifiedIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, substitutions, generalContext, specificContext);
+
+          statementMetavariableUnified = metavariableUnifiedIntrinsically; ///
+
+          if (statementMetavariableUnified) {
+            specificContext.debug(`...unified the statement's '${statementMetavariableString}' metavariable with the '${metavariableString}' metavariable.`);
+          }
+        }
+      }
+    }
+
+    return statementMetavariableUnified;
   }
 
   verify(context) {

package/src/dom/reference.js

@@ -120,6 +120,16 @@ export default domAssigned(class Reference {
     return reference;
   }
 
+  static fromReferenceNode(referenceNode, fileContext) {
+    const { Metavariable } = dom,
+          localContext = LocalContext.fromFileContext(fileContext),
+          context = localContext, ///
+          metavariable = Metavariable.fromReferenceNode(referenceNode, context),
+          reference = new Reference(metavariable);
+
+    return reference;
+  }
+
   static fromProofStepNode(proofStepNode, fileContext) {
     let reference = null;
 

package/src/dom/statement.js

@@ -210,6 +210,10 @@ export default domAssigned(class Statement {
   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);
@@ -219,6 +223,10 @@ export default domAssigned(class Statement {
       }
     });
 
+    if (verified) {
+      context.debug(`...verified the '${statementString}' statement.`);
+    }
+
     return verified;
   }
 

package/src/dom/term.js

@@ -127,13 +127,13 @@ export default domAssigned(class Term {
   verify(context, verifyAhead) {
     let verified;
 
-    const term = this, ///
-          termString = this.string;  ///
+    const termString = this.string;  ///
 
     context.trace(`Verifying the '${termString}' term...`);
 
     verified = verifyMixins.some((verifyMixin) => {
-      const verified = verifyMixin(term, context, verifyAhead);
+      const term = this, ///
+            verified = verifyMixin(term, context, verifyAhead);
 
       if (verified) {
         return true;

package/src/mixins/proofStep/unify.js

@@ -2,27 +2,7 @@
 
 import StatementSubstitution from "../../substitution/statement";
 
-import { equalityFromStatement } from "../../utilities/verification";
-
-function unifyAsEquality(statement, reference, substitutions, context) {
-  let unifiedAsEquality = false;
-
-  if (reference === null) {
-    const equality = equalityFromStatement(statement, context);
-
-    if (equality !== null) {
-      const statementString = statement.getString();
-
-      context.trace(`Unifying the '${statementString}' statement as an equality...`);
-
-      unifiedAsEquality = true;
-
-      context.debug(`...unified the '${statementString}' statement as an equality.`);
-    }
-  }
-
-  return unifiedAsEquality;
-}
+import { equalityFromStatement, judgementFromStatement, typeAssertionFromStatement } from "../../utilities/verification";
 
 function unifyAWithRule(statement, reference, substitutions, context) {
   let unifiedWithRule = false;
@@ -113,6 +93,66 @@ function unifyAWithAxiomLemmaTheoremOrConjecture(statement, reference, substitut
   return unifiedWithAxiomLemmaTheoremOrConjecture;
 }
 
+function unifyAsEquality(statement, reference, substitutions, context) {
+  let unifiedAsEquality = false;
+
+  if (reference === null) {
+    const equality = equalityFromStatement(statement, context);
+
+    if (equality !== null) {
+      const statementString = statement.getString();
+
+      context.trace(`Unifying the '${statementString}' statement as an equality...`);
+
+      unifiedAsEquality = true;
+
+      context.debug(`...unified the '${statementString}' statement as an equality.`);
+    }
+  }
+
+  return unifiedAsEquality;
+}
+
+function unifyAsJudgement(statement, reference, substitutions, context) {
+  let unifiedAsJudgement = false;
+
+  if (reference === null) {
+    const judgement = judgementFromStatement(statement, context);
+
+    if (judgement !== null) {
+      const statementString = statement.getString();
+
+      context.trace(`Unifying the '${statementString}' statement as a judgement...`);
+
+      unifiedAsJudgement = true;
+
+      context.debug(`...unified the '${statementString}' statement as a judgement.`);
+    }
+  }
+
+  return unifiedAsJudgement;
+}
+
+function unifyAsTypeAssertion(statement, reference, substitutions, context) {
+  let unifiedAsTypeAssertion = false;
+
+  if (reference === null) {
+    const typeAssertion = typeAssertionFromStatement(statement, context);
+
+    if (typeAssertion !== null) {
+      const statementString = statement.getString();
+
+      context.trace(`Unifying the '${statementString}' statement as a type assertion...`);
+
+      unifiedAsTypeAssertion = true;
+
+      context.debug(`...unified the '${statementString}' statement as a type assertion.`);
+    }
+  }
+
+  return unifiedAsTypeAssertion;
+}
+
 function unifyWithProofSteps(statement, reference, substitutions, context) {
   let unifiedWithProofSteps = false;
 
@@ -127,10 +167,12 @@ function unifyWithProofSteps(statement, reference, substitutions, context) {
 }
 
 const unifyMixins = [
-  unifyAsEquality,
   unifyAWithRule,
   unifyAWithReference,
   unifyAWithAxiomLemmaTheoremOrConjecture,
+  unifyAsEquality,
+  unifyAsJudgement,
+  unifyAsTypeAssertion,
   unifyWithProofSteps
 ];
 

package/src/nodeAndTokens/substitution/reference.js

@@ -0,0 +1,18 @@
+"use strict";
+
+import NodeAndTokens from "../../nodeAndTokens";
+
+import { ruleFromBNF } from "../../nodeAndTokens";
+
+const bnf = `
+
+            _ ::= referenceSubstitution... <END_OF_LINE> ;
+            
+      `,
+      rule = ruleFromBNF(bnf);
+
+export default class ReferenceSubstitutionNodeAndTokens extends NodeAndTokens {
+  static rule = rule;
+
+  static fromString(string, context) { return NodeAndTokens.fromString(ReferenceSubstitutionNodeAndTokens, string, context); }
+}

package/src/substitution/reference.js

@@ -0,0 +1,74 @@
+"use strict";
+
+import dom from "../dom";
+import Substitution from "../substitution";
+import ReferenceSubstitutionNodeAndTokens from "../nodeAndTokens/substitution/reference";
+
+import { nodeQuery } from "../utilities/query";
+
+const referenceNodeQuery = nodeQuery("/referenceSubstitution/reference[0]"),
+      metavariableNodeQuery = nodeQuery("/referenceSubstitution/reference[1]/metavariable!"),
+      referenceSubstitutionNodeQuery = nodeQuery("/statement/referenceSubstitution");
+
+export default class ReferenceSubstitution extends Substitution {
+  constructor(string, node, tokens, reference, metavariable) {
+    super(string, node, tokens);
+
+    this.reference = reference;
+    this.metavariable = metavariable;
+  }
+
+  getReference() {
+    return this.reference;
+  }
+
+  getMetavariable() {
+    return this.metavariable;
+  }
+
+  isReferenceEqualTo(reference) { return this.reference.isEqualTo(reference); }
+
+  isMetavariableEqualTo(metavariable) { return this.metavariable.isEqualTo(metavariable); }
+
+  static fromStatementNode(statementNode, context) {
+    let referenceSubstitution = null;
+
+    const referenceSubstitutionNode = referenceSubstitutionNodeQuery(statementNode);
+
+    if (referenceSubstitutionNode !== null) {
+      const referenceNode = referenceNodeQuery(referenceSubstitutionNode),
+            metavariableNode = metavariableNodeQuery(referenceSubstitutionNode);
+
+      if ((referenceNode !== null) && (metavariableNode !== null)) {
+        const { Reference, Metavariable } = dom,
+              reference = Reference.fromReferenceNode(referenceNode, context),
+              metavariable = Metavariable.fromMetavariableNode(metavariableNode, context),
+              node = referenceSubstitutionNode,  ///
+              tokens = context.nodeAsTokens(node),
+              string = stringFromReferenceAndMetavariable(reference, metavariable);
+
+        referenceSubstitution = new ReferenceSubstitution(string, node, tokens, reference, metavariable);
+      }
+    }
+
+    return referenceSubstitution;
+  }
+
+  static fromReferenceAndMetavariable(reference, metavariable, context) {
+    const string = stringFromReferenceAndMetavariable(reference, metavariable),
+          referenceSubstitutionNodeAndTokens = ReferenceSubstitutionNodeAndTokens.fromString(string, context),
+          node = referenceSubstitutionNodeAndTokens.getNode(),
+          tokens = referenceSubstitutionNodeAndTokens.getTokens(),
+          referenceSubstitution = new ReferenceSubstitution(string, node, tokens, reference, metavariable);
+
+    return referenceSubstitution;
+  }
+}
+
+function stringFromReferenceAndMetavariable(reference, metavariable) {
+  const referenceString = reference.getString(),
+        metavariableString = metavariable.getString(),
+        string = `[${referenceString} for [${metavariableString}]]`;
+
+  return string;
+}

package/src/substitution/statement.js

@@ -5,7 +5,7 @@ import Substitutions from "../substitutions";
 import StatementSubstitutionNodeAndTokens from "../nodeAndTokens/substitution/statement";
 
 import { unifySubstitution } from "../utilities/unification";
-import { stripBracketsFromStatement } from "../utilities/verification";
+import { stripBracketsFromStatement } from "../utilities/brackets";
 import { statementFromJSON, statementToStatementJSON, metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
 
 export default class StatementSubstitution extends Substitution {

package/src/substitution/term.js

@@ -5,7 +5,7 @@ import Substitution from "../substitution";
 import TermSubstitutionNodeAndTokens from "../nodeAndTokens/substitution/term";
 
 import { nodeQuery } from "../utilities/query";
-import { stripBracketsFromTerm } from "../utilities/verification";
+import { stripBracketsFromTerm } from "../utilities/brackets";
 import { stripBracketsFromTermNode } from "../utilities/brackets";
 
 const termNodeQuery = nodeQuery("/termSubstitution/term[0]"),

package/src/substitution.js

@@ -37,6 +37,12 @@ export default class Substitution {
     return variable;
   }
 
+  getReference() {
+    const reference = null;
+
+    return reference;
+  }
+
   getStatement() {
     const statement = null;
 
@@ -93,6 +99,12 @@ export default class Substitution {
     return variableEqualTo;
   }
 
+  isReferenceEqualTo(reference) {
+    const referenceEqualTo = false;
+
+    return referenceEqualTo;
+  }
+
   isStatementEqualTo(statement) {
     const statementEqualTo = false;
 

package/src/unifier/intrinsicLevel.js

@@ -0,0 +1,55 @@
+"use strict";
+
+import dom from "../dom";
+import Unifier from "../unifier";
+
+import { nodeQuery } from "../utilities/query";
+
+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: (generalTermVariableNode, specificTermNode, substitutions, generalContext, specificContext) => {
+        let termUnified;
+
+        const { Term, Variable } = dom,
+              termNode = specificTermNode, ///
+              variableNode = generalTermVariableNode; ///
+
+        let context;
+
+        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;