occam-verify-cli 1.0.304 → 1.0.306

package/src/dom/declaration.js

@@ -7,10 +7,10 @@ import { domAssigned } from "../dom";
 import { unifyStatementIntrinsically } from "../utilities/unification";
 
 export default domAssigned(class Declaration {
-  constructor(string, node, reference, statement) {
+  constructor(string, node, metavariable, statement) {
     this.string = string;
     this.node = node;
-    this.reference = reference;
+    this.metavariable = metavariable;
     this.statement = statement;
   }
 
@@ -22,26 +22,18 @@ export default domAssigned(class Declaration {
     return this.node;
   }
 
-  getReference() {
-    return this.reference;
+  getMetavariable() {
+    return this.metavariable;
   }
 
   getStatement() {
     return this.statement;
   }
 
-  isSimple() { return this.node.isSimple(); }
-
-  getMetavariable() {
-    let metavariable = null;
-
-    const simple = this.isSimple();
-
-    if (simple) {
-      metavariable = this.reference.getMetavariable();
-    }
+  isSimple() {
+    const simple = (this.statement === null);
 
-    return metavariable;
+    return simple;
   }
 
   matchSubstitution(substitution, context) {
@@ -55,8 +47,7 @@ export default domAssigned(class Declaration {
     const simple = this.isSimple();
 
     if (simple) {
-      const metavariable = this.reference.getMetavariable(),
-            judgement = context.findJudgementByMetavariable(metavariable);
+      const judgement = context.findJudgementByMetavariable(this.metavariable);
 
       if (judgement !== null) {
         const declaration = judgement.getDeclaration();
@@ -67,9 +58,9 @@ export default domAssigned(class Declaration {
       const statement = substitution.getStatement(),
             metavariable = substitution.getMetavariable(),
             statementEqualToStatement = this.statement.isEqualTo(statement),
-            referenceMetavariableEqualToMetavariable = this.reference.isMetavariableEqualTo(metavariable);
+            metavariableEqualToMetavariable = this.metavariable.isEqualTo(metavariable);
 
-      if (referenceMetavariableEqualToMetavariable && statementEqualToStatement) {
+      if (metavariableEqualToMetavariable && statementEqualToStatement) {
         substitutionMatches = true;
       }
     }
@@ -91,13 +82,13 @@ export default domAssigned(class Declaration {
     const simple = this.isSimple();
 
     if (simple) {
-      const referenceVerifiesAsMetavariable = this.verifyReferenceAsMetavariable(assignments, stated, context);
+      const verifiesAsMetavariable = this.verifyAsMetavariable(assignments, stated, context);
 
-      verifies = referenceVerifiesAsMetavariable; ///
+      verifies = verifiesAsMetavariable; ///
     } else {
-      const referenceVerifies = this.verifyReference(assignments, stated, context);
+      const metavariableVerifiesAsReference = this.verifyMetavariableAsReference(assignments, stated, context);
 
-      if (referenceVerifies) {
+      if (metavariableVerifiesAsReference) {
         const statementVerifies = this.verifyStatement(assignments, stated, context);
 
         if (statementVerifies) {
@@ -124,20 +115,24 @@ export default domAssigned(class Declaration {
     return verifies;
   }
 
-  verifyReference(assignments, stated, context) {
-    let referenceVerifies;
+  verifyMetavariableAsReference(assignments, stated, context) {
+    let metavariableVerifiesAsReference;
 
-    const referenceString = this.reference.getString();
+    const declarationString = this.string,
+          metavariableString = this.metavariable.getString();
 
-    context.trace(`Verifying the '${referenceString}' reference...`);
+    context.trace(`Verifying the '${declarationString}' declaration's '${metavariableString}' metavariable as a reference...`);
 
-    referenceVerifies = this.reference.verify(context);
+    const reference = referenceFromMetavariable(this.metavariable, context),
+          referenceVerifies = reference.verify(context);
 
-    if (referenceVerifies) {
-      context.debug(`...verified the '${referenceString}' reference.`);
+    metavariableVerifiesAsReference = referenceVerifies;  ///
+
+    if (metavariableVerifiesAsReference) {
+      context.debug(`...verified the '${declarationString}' declaration's '${metavariableString}' metavariable as a reference.`);
     }
 
-    return referenceVerifies;
+    return metavariableVerifiesAsReference;
   }
 
   verifyStatement(assignments, stated, context) {
@@ -164,23 +159,21 @@ export default domAssigned(class Declaration {
     return statementVerifies;
   }
 
-  verifyReferenceAsMetavariable(assignments, stated, context) {
-    let referenceVerifiesAsMetavariable;
-
-    const referenceString = this.reference.getString();
+  verifyAsMetavariable(assignments, stated, context) {
+    let verifiesAsMetavariable;
 
-    context.trace(`Verifying the '${referenceString}' reference as a metavariable...`);
+    const declarationString = this.string,  ///
+          metavariableString = this.metavariable.getString();
 
-    const metavariable = this.reference.getMetavariable(),
-          metavariableVerifies = metavariable.verify(context);
+    context.trace(`Verifying the '${declarationString}' declaration's '${metavariableString}' metavariable...`);
 
-    referenceVerifiesAsMetavariable = metavariableVerifies; ///
+    verifiesAsMetavariable = this.metavariable.verify(context);
 
-    if (referenceVerifiesAsMetavariable) {
-      context.debug(`...verified the '${referenceString}' reference as a metavariable.`);
+    if (verifiesAsMetavariable) {
+      context.debug(`...verified the '${declarationString}' declaration's '${metavariableString}' metavariable.`);
     }
 
-    return referenceVerifiesAsMetavariable;
+    return verifiesAsMetavariable;
   }
 
   verifyWhenStated(assignments, context) {
@@ -190,12 +183,13 @@ export default domAssigned(class Declaration {
 
     context.trace(`Verifying the '${declarationString}' stated declaration...`);
 
-    const metavariablePresent = context.isMetavariablePresentByReference(this.reference);
+    const reference = referenceFromMetavariable(this.metavariable, context),
+          metavariablePresent = context.isMetavariablePresentByReference(reference);
 
     if (metavariablePresent) {
       verifiesWhenStated = true;
     } else {
-      const metaLemmaMetatheorems = context.findMetaLemmaMetatheoremsByReference(this.reference),
+      const metaLemmaMetatheorems = context.findMetaLemmaMetatheoremsByReference(reference),
             metaLemmaMetatheoremsUnify = metaLemmaMetatheorems.every((metaLemmaMetatheorem) => {
               const metaLemmaMetatheoremUnifies = this.unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context);
 
@@ -221,7 +215,8 @@ export default domAssigned(class Declaration {
 
     context.trace(`Verifying the '${declarationString}' derived declaration...`);
 
-    const metaLemmaMetatheoremPresent = context.isMetaLemmaMetatheoremPresentByReference(this.reference);
+    const reference = referenceFromMetavariable(this.metavariable, context),
+          metaLemmaMetatheoremPresent = context.isMetaLemmaMetatheoremPresentByReference(reference);
 
     verifiesWhenDerived = metaLemmaMetatheoremPresent; ///
 
@@ -235,7 +230,9 @@ export default domAssigned(class Declaration {
   unifyStatement(statement, substitutions, generalContext, specificContext) {
     let statementUnifies;
 
-    if (this.statement === null) {
+    const simple = this.isSimple();
+
+    if (simple) {
       statementUnifies = false;
     } else {
       const context = generalContext,  ///
@@ -258,21 +255,22 @@ export default domAssigned(class Declaration {
     return statementUnifies;
   }
 
-  unifyLabelWithReference(label, substitutions, generalContext, specificContext) {
+  unifyLabel(label, substitutions, generalContext, specificContext) {
     let labelUnifiesWithReference;
 
     const context = generalContext, ///
           labelString = label.getString(),
-          referenceString = this.reference.getString();
+          declarationString = this.string;  //;/
 
-    context.trace(`Unifying the '${labelString}' label with the '${referenceString}' reference...`);
+    context.trace(`Unifying the '${labelString}' label with the '${declarationString}' declaration...`);
 
-    const labelUnifies = this.reference.unifyLabel(label, substitutions, context);
+    const reference = referenceFromMetavariable(this.metavariable, context),
+          labelUnifies = reference.unifyLabel(label, substitutions, context);
 
     labelUnifiesWithReference = labelUnifies; ///
 
     if (labelUnifiesWithReference) {
-      context.debug(`...unified the '${labelString}' label with the '${referenceString}' reference.`);
+      context.debug(`...unified the '${labelString}' label with the '${declarationString}' declaration.`);
     }
 
     return labelUnifiesWithReference;
@@ -294,9 +292,9 @@ export default domAssigned(class Declaration {
           labelSubstitutions = Substitutions.fromNothing(),
           label = metaLemmaMetatheorem.getLabel(),
           substitutions = labelSubstitutions, ///
-          labelUnifiesWithReference = this.unifyLabelWithReference(label, substitutions, generalContext, specificContext);
+          labelUnifies = this.unifyLabel(label, substitutions, generalContext, specificContext);
 
-    if (labelUnifiesWithReference) {
+    if (labelUnifies) {
       const statementSubstitutions = Substitutions.fromNothing(),
             statement = metaLemmaMetatheorem.getStatement(),
             substitutions = statementSubstitutions, ///
@@ -334,13 +332,21 @@ export default domAssigned(class Declaration {
   }
 });
 
+function referenceFromMetavariable(metavariable, context) {
+  const { Reference } = dom,
+        metavariableNode = metavariable.getNode(),
+        reference = Reference.fromMetavariableNode(metavariableNode, context);
+
+  return reference;
+}
+
 function declarationFromDeclarationNode(declarationNode, context) {
-  const { Declaration, Reference, Statement } = dom,
+  const { Metavariable, Declaration, Statement } = dom,
         node = declarationNode,  ///
         string = context.nodeAsString(node),
-        reference = Reference.fromDeclarationNode(declarationNode, context),
+        metavariable = Metavariable.fromDeclarationNode(declarationNode, context),
         statement = Statement.fromDeclarationNode(declarationNode, context),
-        declaration = new Declaration(string, node, reference, statement);
+        declaration = new Declaration(string, node, metavariable, statement);
 
   return declaration;
 }

package/src/dom/metavariable.js

@@ -398,6 +398,13 @@ export default domAssigned(class Metavariable {
     return metavariable;
   }
 
+  static fromDeclarationNode(declarationNode, context) {
+    const metavariableNode = declarationNode.getMetavariableNode(),
+          metavariable = metavariableFromMetavariableNode(metavariableNode, context);
+
+    return metavariable;
+  }
+
   static fromMetavariableNode(metavariableNode, context) {
     let metavariable = null;
 

package/src/dom/procedureCall.js

@@ -71,7 +71,7 @@ export default domAssigned(class ProcedureCall {
   }
 
   unifyIndependently(substitutions, context) {
-    let unifiesIndependently;
+    let unifiesIndependently = false;
 
     const procedureCallString = this.string; ///
 

package/src/dom/reference.js

@@ -195,13 +195,6 @@ export default domAssigned(class Reference {
     return reference;
   }
 
-  static fromDeclarationNode(declarationNode, context) {
-    const metavariableNode = declarationNode.getMetavariableNode(),
-          reference = referenceFromMetavariableNode(metavariableNode, context);
-
-    return reference;
-  }
-
   static fromMetavariableNode(metavariableNode, context) {
     const reference = referenceFromMetavariableNode(metavariableNode, context);
 

package/src/node/declaration.js

@@ -5,13 +5,6 @@ import NonTerminalNode from "../node/nonTerminal";
 import { STATEMENT_RULE_NAME, METAVARIABLE_RULE_NAME } from "../ruleNames";
 
 export default class DeclarationNode extends NonTerminalNode {
-  isSimple() {
-    const statementNode = this.getStatementNode(),
-          simple = (statementNode === null);
-
-    return simple;
-  }
-
   getStatementNode() {
     const ruleName = STATEMENT_RULE_NAME,
           statementNode = this.getNodeByRuleName(ruleName);

package/src/node/frame.js

@@ -19,9 +19,23 @@ export default class FrameNode extends NonTerminalNode {
     return metavariableNodes;
   }
 
+  getSingularDeclarationNode() {
+    const ruleName = DECLARATION_RULE_NAME,
+          singularDeclarationNode = this.getSingularTNodeByRuleName(ruleName);
+
+    return singularDeclarationNode;
+  }
+
   getSingularMetavariableNode() {
-    const ruleName = METAVARIABLE_RULE_NAME,
-          singularMetavariableNode = this.getSingularTNodeByRuleName(ruleName);
+    let singularMetavariableNode = null;
+
+    const singularDeclarationNode = this.getSingularDeclarationNode();
+
+    if (singularDeclarationNode !== null) {
+      const metavariableNode = singularDeclarationNode.getMetavariableNode();
+
+      singularMetavariableNode = metavariableNode;  ///
+    }
 
     return singularMetavariableNode;
   }

package/src/node/statement.js

@@ -122,13 +122,6 @@ export default class StatementNode extends NonTerminalNode {
     return satisfiedAssertionNode;
   }
 
-  getSingularMetavariableNode() {
-    const ruleName = METAVARIABLE_RULE_NAME,
-          singularMetavariableNode = this.getSingularTNodeByRuleName(ruleName);
-
-    return singularMetavariableNode;
-  }
-
   getSingularMetaArgumentNode() {
     const ruleName = META_ARGUMENT_RULE_NAME,
           singularMetaArgumentNode = this.getNodeByRuleName(ruleName);

package/src/unifier/metaLevel.js

@@ -9,8 +9,8 @@ const termNodeQuery = nodeQuery("/term"),
       frameNodeQuery = nodeQuery("/frame"),
       statementNodeQuery = nodeQuery("/statement"),
       termVariableNodeQuery = nodeQuery("/term/variable!"),
-      frameMetavariableNodeQuery = nodeQuery("/frame/metavariable!"),
-      declarationMetavariableNodeQuery = nodeQuery("/declaration/metavariable!");
+      statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!"),
+      frameDeclarationMetavariableNodeQuery = nodeQuery("/frame/declaration!/metavariable!");
 
 class MetaLevelUnifier extends Unifier {
   unify(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext) {
@@ -25,83 +25,50 @@ class MetaLevelUnifier extends Unifier {
 
   static maps = [
     {
-      generalNodeQuery: statementNodeQuery,
+      generalNodeQuery: statementMetavariableNodeQuery,
       specificNodeQuery: statementNodeQuery,
-      unify: (generalStatementNode, specificStatementNode, substitutions, generalContext, specificContext) => {
+      unify: (generalStatementMetavariableNode, specificStatementNode, substitutions, generalContext, specificContext) => {
         let statementUnifies;
 
-        const statementNode = generalStatementNode, ///
-              singularMetavariableNode = statementNode.getSingularMetavariableNode();
+        const { Metavariable, Statement } = dom; ///
 
-        if (singularMetavariableNode !== null) {
-          const { Metavariable, Statement } = dom; ///
+        let context,
+            statementNode;
 
-          let context,
-              statementNode;
+        context = generalContext; ///
 
-          context = generalContext; ///
+        const metavariableNode = generalStatementMetavariableNode,  ///
+              metavariable = Metavariable.fromMetavariableNode(metavariableNode, context);
 
-          statementNode = generalStatementNode; ///
+        const metavariableNodeParentNode = metavariableNode.getParentNode();
 
-          const { TermSubstitution, FrameSubstitution } = dom,
-                frameSubstitution = FrameSubstitution.fromStatementNode(statementNode, context),
-                termSubstitution = TermSubstitution.fromStatementNode(statementNode, context),
-                metavariable = Metavariable.fromStatementNode(statementNode, context),
-                substitution = (frameSubstitution || termSubstitution);
+        statementNode = metavariableNodeParentNode; ///
 
-          context = specificContext; ///
+        const { TermSubstitution, FrameSubstitution } = dom,
+              frameSubstitution = FrameSubstitution.fromStatementNode(statementNode, context),
+              termSubstitution = TermSubstitution.fromStatementNode(statementNode, context),
+              substitution = (frameSubstitution || termSubstitution);
 
-          statementNode = specificStatementNode;  ///
+        context = specificContext; ///
 
-          const statement = Statement.fromStatementNode(statementNode, context);
+        statementNode = specificStatementNode;  ///
 
-          statementUnifies = metavariable.unifyStatement(statement, substitution, substitutions, generalContext, specificContext);
-        } else {
-          const childNodesUnify = unifyChildNodes(generalStatementNode, specificStatementNode, substitutions, generalContext, specificContext);
+        const statement = Statement.fromStatementNode(statementNode, context);
 
-          statementUnifies = childNodesUnify; ///
-        }
+        statementUnifies = metavariable.unifyStatement(statement, substitution, substitutions, generalContext, specificContext);
 
         return statementUnifies;
       }
     },
     {
-      generalNodeQuery: declarationMetavariableNodeQuery,
-      specificNodeQuery: declarationMetavariableNodeQuery,
-      unify: (generalDeclarationMetavariableNode, specificDeclarationMetavariableNode, substitutions, generalContext, specificContext) => {
-        let referenceUnifies;
-
-        const { Frame, Metavariable } = dom;
-
-        let context,
-            metavariableNode;
-
-        context = generalContext; ///
-
-        metavariableNode = generalDeclarationMetavariableNode;  ///
-
-        const metavariable = Metavariable.fromMetavariableNode(metavariableNode, context);
-
-        context = specificContext;  ///
-
-        metavariableNode = specificDeclarationMetavariableNode; ///
-
-        const frame = Frame.fromMetavariableNode(metavariableNode, context);
-
-        referenceUnifies = metavariable.unifyFrame(frame, substitutions, generalContext, specificContext);
-
-        return referenceUnifies;
-      }
-    },
-    {
-      generalNodeQuery: frameMetavariableNodeQuery,
+      generalNodeQuery: frameDeclarationMetavariableNodeQuery,
       specificNodeQuery: frameNodeQuery,
-      unify: (generalFrameMetavariableNode, specificFrameNode, substitutions, generalContext, specificContext) => {
+      unify: (generalFrameDeclarationMetavariableNode, specificFrameNode, substitutions, generalContext, specificContext) => {
         let frameUnifies;
 
         const { Frame, Metavariable } = dom,
               frameNode = specificFrameNode, ///
-              metavariableNode = generalFrameMetavariableNode;  ///
+              metavariableNode = generalFrameDeclarationMetavariableNode;  ///
 
         let context;
 
@@ -149,15 +116,3 @@ class MetaLevelUnifier extends Unifier {
 const metaLevelUnifier = new MetaLevelUnifier();
 
 export default metaLevelUnifier;
-
-function unifyChildNodes(generalStatementNode, specificStatementNode, substitutions, generalContext, specificContext) {
-  const generalNonTerminalNode = generalStatementNode, ///
-        specificNonTerminalNode = specificStatementNode, ///
-        generalNonTerminalNodeChildNodes = generalNonTerminalNode.getChildNodes(),
-        specificNonTerminalNodeChildNodes = specificNonTerminalNode.getChildNodes(),
-        generalChildNodes = generalNonTerminalNodeChildNodes, ///
-        specificChildNodes = specificNonTerminalNodeChildNodes, ///
-        childNodesUnify = metaLevelUnifier.unifyChildNodes(generalChildNodes, specificChildNodes, substitutions, generalContext, specificContext);
-
-  return childNodesUnify;
-}