occam-verify-cli 1.0.357 → 1.0.359

package/src/context/local.js

@@ -162,8 +162,8 @@ class LocalContext {
   addJudgement(judgement) {
     let judgementAdded = false;
 
-    const metavariable = judgement.getMetavariable(),
-          judgementPresent = this.isJudgementPresentByMetavariable(metavariable);
+    const simpleReference = judgement.getSimpleReference(),
+          judgementPresent = this.isJudgementPresentBySimpleReference(simpleReference);
 
     if (!judgementPresent) {
       this.judgements.push(judgement);
@@ -209,16 +209,16 @@ class LocalContext {
     return variable;
   }
 
-  findJudgementByMetavariable(metavariable) {
+  findJudgementBySimpleReference(simpleReference) {
     const judgements = this.getJudgements(),
           judgement = judgements.find((judgement) => {
             const judgementSimple = judgement.isSimple();
 
             if (judgementSimple) {
-              const judgementMetavariable = judgement.getMetavariable(),
-                  judgementMetavariableEqualToMetavariable = judgementMetavariable.isEqualTo(metavariable);
+              const judgementSimpleReference = judgement.getSimpleReference(),
+                    judgementSimpleReferenceEqualToSimpleReference = judgementSimpleReference.isEqualTo(simpleReference);
 
-              if (judgementMetavariableEqualToMetavariable) {
+              if (judgementSimpleReferenceEqualToSimpleReference) {
                 return true;
               }
             }
@@ -272,8 +272,8 @@ class LocalContext {
 
   isMetavariablePresentByMetavariableName(metavariableNode) { return this.context.isMetavariablePresentByMetavariableName(metavariableNode); }
 
-  isJudgementPresentByMetavariable(metavariable) {
-    const judgement = this.findJudgementByMetavariable(metavariable),
+  isJudgementPresentBySimpleReference(simpleReference) {
+    const judgement = this.findJudgementBySimpleReference(simpleReference),
           judgementPresent = (judgement !== null);
 
     return judgementPresent;
@@ -320,11 +320,11 @@ class LocalContext {
     return variableDefined;
   }
 
-  isMetavariableDefined(metavariable) {
-    const judgementPresent = this.isJudgementPresentByMetavariable(metavariable),
-          metavariableDefined = judgementPresent; ///
+  isSimpleReferenceDefined(simpleReference) {
+    const judgementPresent = this.isJudgementPresentBySimpleReference(simpleReference),
+          simpleReferenceDefined = judgementPresent; ///
 
-    return metavariableDefined
+    return simpleReferenceDefined
   }
 
   matchTermAndPropertyRelation(term, propertyRelation) {

package/src/dom/assertion/defined.js

@@ -227,16 +227,16 @@ function verifyWhenDerived(term, frame, negated, context) {
   }
 
   if (frame!== null) {
-    const { Metavariable } = dom,
+    const { SimpleReference } = dom,
           frameNode = frame.getNode(),
-          metavariable = Metavariable.fromFrameNode(frameNode, context),
-          metavariableDefined = context.isMetavariableDefined(metavariable);
+          simpleReference = SimpleReference.fromFrameNode(frameNode, context),
+          simpleReferenceDefined = context.isSimpleReferenceDefined(simpleReference);
 
-    if (!negated && metavariableDefined) {
+    if (!negated && simpleReferenceDefined) {
       verifiesWhenDerived = true;
     }
 
-    if (negated && !metavariableDefined) {
+    if (negated && !simpleReferenceDefined) {
       verifiesWhenDerived = true;
     }
   }

package/src/dom/declaration.js

@@ -7,11 +7,11 @@ import { domAssigned } from "../dom";
 import { unifyStatementIntrinsically } from "../utilities/unification";
 
 export default domAssigned(class Declaration {
-  constructor(string, node, metavariable, statement) {
+  constructor(string, node, statement, simpleReference) {
     this.string = string;
     this.node = node;
-    this.metavariable = metavariable;
     this.statement = statement;
+    this.simpleReference = simpleReference;
   }
 
   getString() {
@@ -22,14 +22,14 @@ export default domAssigned(class Declaration {
     return this.node;
   }
 
-  getMetavariable() {
-    return this.metavariable;
-  }
-
   getStatement() {
     return this.statement;
   }
 
+  getSimpleReference() {
+    return this.simpleReference;
+  }
+
   isSimple() {
     const simple = (this.statement === null);
 
@@ -47,7 +47,7 @@ export default domAssigned(class Declaration {
     const simple = this.isSimple();
 
     if (simple) {
-      const judgement = context.findJudgementByMetavariable(this.metavariable);
+      const judgement = context.findJudgementBySimpleReference(this.simpleReference);
 
       if (judgement !== null) {
         const declaration = judgement.getDeclaration();
@@ -56,9 +56,9 @@ export default domAssigned(class Declaration {
       }
     } else {
       const statement = substitution.getStatement(),
-            metavariable = substitution.getMetavariable(),
+            simpleReference = substitution.getMetavariable(),
             statementEqualToStatement = this.statement.isEqualTo(statement),
-            metavariableEqualToMetavariable = this.metavariable.isEqualTo(metavariable);
+            metavariableEqualToMetavariable = this.simpleReference.isEqualTo(simpleReference);
 
       if (metavariableEqualToMetavariable && statementEqualToStatement) {
         substitutionMatches = true;
@@ -119,17 +119,17 @@ export default domAssigned(class Declaration {
     let metavariableVerifiesAsReference;
 
     const declarationString = this.string,
-          metavariableString = this.metavariable.getString();
+          metavariableString = this.simpleReference.getString();
 
-    context.trace(`Verifying the '${declarationString}' declaration's '${metavariableString}' metavariable as a reference...`);
+    context.trace(`Verifying the '${declarationString}' declaration's '${metavariableString}' simpleReference as a reference...`);
 
-    const reference = referenceFromMetavariable(this.metavariable, context),
+    const reference = referenceFromMetavariable(this.simpleReference, context),
           referenceVerifies = reference.verify(context);
 
     metavariableVerifiesAsReference = referenceVerifies;  ///
 
     if (metavariableVerifiesAsReference) {
-      context.debug(`...verified the '${declarationString}' declaration's '${metavariableString}' metavariable as a reference.`);
+      context.debug(`...verified the '${declarationString}' declaration's '${metavariableString}' simpleReference as a reference.`);
     }
 
     return metavariableVerifiesAsReference;
@@ -163,14 +163,14 @@ export default domAssigned(class Declaration {
     let verifiesAsMetavariable;
 
     const declarationString = this.string,  ///
-          metavariableString = this.metavariable.getString();
+          metavariableString = this.simpleReference.getString();
 
-    context.trace(`Verifying the '${declarationString}' declaration's '${metavariableString}' metavariable...`);
+    context.trace(`Verifying the '${declarationString}' declaration's '${metavariableString}' simpleReference...`);
 
-    verifiesAsMetavariable = this.metavariable.verify(context);
+    verifiesAsMetavariable = this.simpleReference.verify(context);
 
     if (verifiesAsMetavariable) {
-      context.debug(`...verified the '${declarationString}' declaration's '${metavariableString}' metavariable.`);
+      context.debug(`...verified the '${declarationString}' declaration's '${metavariableString}' simpleReference.`);
     }
 
     return verifiesAsMetavariable;
@@ -183,7 +183,7 @@ export default domAssigned(class Declaration {
 
     context.trace(`Verifying the '${declarationString}' stated declaration...`);
 
-    const reference = referenceFromMetavariable(this.metavariable, context),
+    const reference = referenceFromMetavariable(this.simpleReference, context),
           metavariablePresent = context.isMetavariablePresentByReference(reference);
 
     if (metavariablePresent) {
@@ -215,7 +215,7 @@ export default domAssigned(class Declaration {
 
     context.trace(`Verifying the '${declarationString}' derived declaration...`);
 
-    const reference = referenceFromMetavariable(this.metavariable, context),
+    const reference = referenceFromMetavariable(this.simpleReference, context),
           metaLemmaMetatheoremPresent = context.isMetaLemmaMetatheoremPresentByReference(reference);
 
     verifiesWhenDerived = metaLemmaMetatheoremPresent; ///
@@ -264,7 +264,7 @@ export default domAssigned(class Declaration {
 
     context.trace(`Unifying the '${labelString}' label with the '${declarationString}' declaration...`);
 
-    const reference = referenceFromMetavariable(this.metavariable, context),
+    const reference = referenceFromMetavariable(this.simpleReference, context),
           labelUnifies = reference.unifyLabel(label, substitutions, context);
 
     labelUnifiesWithReference = labelUnifies; ///
@@ -332,9 +332,9 @@ export default domAssigned(class Declaration {
   }
 });
 
-function referenceFromMetavariable(metavariable, context) {
+function referenceFromMetavariable(simpleReference, context) {
   const { Reference } = dom,
-        metavariableNode = metavariable.getNode(),
+        metavariableNode = simpleReference.getNode(),
         reference = Reference.fromMetavariableNode(metavariableNode, context);
 
   return reference;
@@ -344,9 +344,9 @@ function declarationFromDeclarationNode(declarationNode, context) {
   const { Metavariable, Declaration, Statement } = dom,
         node = declarationNode,  ///
         string = context.nodeAsString(node),
-        metavariable = Metavariable.fromDeclarationNode(declarationNode, context),
+        simpleReference = Metavariable.fromDeclarationNode(declarationNode, context),
         statement = Statement.fromDeclarationNode(declarationNode, context),
-        declaration = new Declaration(string, node, metavariable, statement);
+        declaration = new Declaration(string, node, statement, simpleReference);
 
   return declaration;
 }

package/src/dom/metavariable.js

@@ -494,6 +494,27 @@ export default domAssigned(class Metavariable {
     return metavariable;
   }
 
+  static fromSimpleReferenceNode(simpleReferenceNode, context) {
+    const { Metavariable } = dom;
+
+    let node;
+
+    const type = null,
+          name = simpleReferenceNode.getName();
+
+    node = simpleReferenceNode;  ///
+
+    const string = context.nodeAsString(node),
+          tokens = context.nodeAsTokens(node),
+          metaType = null;
+
+    node = null;
+
+    const metavariable = new Metavariable(string, node, tokens, name, type, metaType);
+
+    return metavariable;
+  }
+
   static fromMetavariableDeclarationNode(metavariableDeclarationNode, context) {
     const { MetaType } = dom,
           metavariableNode = metavariableDeclarationNode.getMetavariableNode(),

package/src/dom/reference.js

@@ -214,8 +214,8 @@ export default domAssigned(class Reference {
   }
 
   static fromSatisfiesAssertionNode(satisfiesAssertionNode, context) {
-    const metavariableNode = satisfiesAssertionNode.getMetavariableNode(),
-          reference = referenceFromMetavariableNode(metavariableNode, context);
+    const simpleReferenceNode = satisfiesAssertionNode.getSimpleReferenceNode(),
+          reference = referenceFromSimpleReferenceNode(simpleReferenceNode, context);
 
     return reference;
   }
@@ -234,5 +234,13 @@ function referenceFromMetavariableNode(metavariableNode, context) {
         metavariable = Metavariable.fromMetavariableNode(metavariableNode, context),
         reference = new Reference(metavariable);
 
+  return reference;
+}
+
+function referenceFromSimpleReferenceNode(simpleReferenceNode, context) {
+  const { Reference, Metavariable } = dom,
+        metavariable = Metavariable.fromSimpleReferenceNode(simpleReferenceNode, context),
+        reference = new Reference(metavariable);
+
   return reference;
 }

package/src/index.js

@@ -39,6 +39,7 @@ import Metavariable from "./dom/metavariable";
 import ProcedureCall from "./dom/procedureCall";
 import SubDerivation from "./dom/subDerivation";
 import TypeAssertion from "./dom/assertion/type";
+import SimpleReference from "./dom/simpleReference";
 import DefinedAssertion from "./dom/assertion/defined";
 import PropertyRelation from "./dom/propertyRelation";
 import TermSubstitution from "./dom/substitution/term";

package/src/node/assertion/satisfies.js

@@ -2,7 +2,7 @@
 
 import NonTerminalNode from "../../node/nonTerminal";
 
-import { SIGNATURE_RULE_NAME, METAVARIABLE_RULE_NAME } from "../../ruleNames";
+import { SIGNATURE_RULE_NAME, SIMPLE_REFERENCE_RULE_NAME } from "../../ruleNames";
 
 export default class SatisfiesAssertionNode extends NonTerminalNode {
   getSignatureNode() {
@@ -12,11 +12,11 @@ export default class SatisfiesAssertionNode extends NonTerminalNode {
     return signatureNode;
   }
 
-  getMetavariableNode() {
-    const ruleName = METAVARIABLE_RULE_NAME,
-          metavariableNode = this.getNodeByRuleName(ruleName);
+  getSimpleReferenceNode() {
+    const ruleName = SIMPLE_REFERENCE_RULE_NAME,
+          simpleReferenceNode = this.getNodeByRuleName(ruleName);
 
-    return metavariableNode;
+    return simpleReferenceNode;
   }
 
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(SatisfiesAssertionNode, ruleName, childNodes, opacity, precedence); }

package/src/node/simpleReference.js

@@ -0,0 +1,16 @@
+"use strict";
+
+import NonTerminalNode from "../node/nonTerminal";
+
+import { METAVARIABLE_RULE_NAME } from "../ruleNames";
+
+export default class SimpleReferenceNode extends NonTerminalNode {
+  getMetavariableNode() {
+    const ruleName = METAVARIABLE_RULE_NAME,
+          metavariableNode = this.getNodeByRuleName(ruleName);
+
+    return metavariableNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(SimpleReferenceNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/nonTerminalNodeMap.js

@@ -57,6 +57,7 @@ import TypeAssertionNode from "./node/assertion/type";
 import ConjectureBodyNode from "./node/body/conjecture";
 import MetatheoremBodyNode from "./node/body/metatheorem";
 import MetaLemmaHeaderNode from "./node/header/metaLemma";
+import SimpleReferenceNode from "./node/simpleReference";
 import PropertyRelationNode from "./node/propertyRelation"
 import DefinedAssertionNode from "./node/assertion/defined";
 import TermSubstitutionNode from "./node/substitution/term";
@@ -135,6 +136,7 @@ import { RULE_RULE_NAME,
          CONJECTURE_BODY_RULE_NAME,
          META_LEMMA_BODY_RULE_NAME,
          METATHEOREM_BODY_RULE_NAME,
+         SIMPLE_REFERENCE_RULE_NAME,
          CONJECTURE_HEADER_RULE_NAME,
          META_LEMMA_HEADER_RULE_NAME,
          PROPERTY_RELATION_RULE_NAME,
@@ -214,6 +216,7 @@ const NonTerminalNodeMap = {
   [THEOREM_HEADER_RULE_NAME]: TheoremHeaderNode,
   [META_LEMMA_BODY_RULE_NAME]: MetaLemmaBodyNode,
   [CONJECTURE_BODY_RULE_NAME]: ConjectureBodyNode,
+  [SIMPLE_REFERENCE_RULE_NAME]: SimpleReferenceNode,
   [METATHEOREM_BODY_RULE_NAME]: MetatheoremBodyNode,
   [META_LEMMA_HEADER_RULE_NAME]: MetaLemmaHeaderNode,
   [CONJECTURE_HEADER_RULE_NAME]: ConjectureHeaderNode,

package/src/ruleNames.js

@@ -56,6 +56,7 @@ export const THEOREM_HEADER_RULE_NAME = "theoremHeader";
 export const META_LEMMA_BODY_RULE_NAME = "metaLemmaBody";
 export const CONJECTURE_BODY_RULE_NAME = "conjectureBody";
 export const METATHEOREM_BODY_RULE_NAME = "metatheoremBody";
+export const SIMPLE_REFERENCE_RULE_NAME = "simpleReference";
 export const META_LEMMA_HEADER_RULE_NAME = "metaLemmaHeader";
 export const PROPERTY_RELATION_RULE_NAME = "propertyRelation";
 export const DEFINED_ASSERTION_RULE_NAME = "definedAssertion";