occam-verify-cli 1.0.609 → 1.0.612

package/src/context/scoped.js

@@ -159,7 +159,8 @@ class ScopedContext extends Context {
     let judgementAdded = false;
 
     const metavariable = judgement.getMetavariable(),
-          judgementPresent = this.isJudgementPresentByMetavariable(metavariable);
+          metavariableName = metavariable.getMetavariableName(),
+          judgementPresent = this.isJudgementPresentByMetavariableName(metavariableName);
 
     if (!judgementPresent) {
       this.judgements.push(judgement);
@@ -183,10 +184,10 @@ class ScopedContext extends Context {
 
   findEquivalenceByTerm(term) { return this.equivalences.findEquivalenceByTerm(term); }
 
-  findJudgementByMetavariable(metavariable) {
+  findJudgementByMetavariableName(metavariableName) {
     const judgements = this.getJudgements(),
           judgement = judgements.find((judgement) => {
-            const judgementMetavariableComparesToMetavariable = judgement.compareMetavariable(metavariable);
+            const judgementMetavariableComparesToMetavariable = judgement.matchMetavariableName(metavariableName);
 
             if (judgementMetavariableComparesToMetavariable) {
               return true;
@@ -230,8 +231,8 @@ class ScopedContext extends Context {
     return termGrounded;
   }
 
-  isJudgementPresentByMetavariable(metavariable) {
-    const judgement = this.findJudgementByMetavariable(metavariable),
+  isJudgementPresentByMetavariableName(metavariableName) {
+    const judgement = this.findJudgementByMetavariableName(metavariableName),
           judgementPresent = (judgement !== null);
 
     return judgementPresent;

package/src/context.js

@@ -33,11 +33,25 @@ export default class Context extends ContextBase {
 
   getFrames() {
     const context = this.getContext(),
-      frames = context.getFrames();
+          frames = context.getFrames();
 
     return frames;
   }
 
+  getStatements() {
+    const context = this.getContext(),
+          statements = context.getStatements();
+
+    return statements;
+  }
+
+  getReferences() {
+    const context = this.getContext(),
+          references = context.getReferences();
+
+    return references;
+  }
+
   getSubstitutions() {
     const context = this.getContext(),
           substitutions = context.getSubstitutions();
@@ -47,7 +61,7 @@ export default class Context extends ContextBase {
 
   getVariables(includeRelease) {
     const context = this.getContext(),
-      variables = context.getVariables(includeRelease);
+          variables = context.getVariables(includeRelease);
 
     return variables;
   }
@@ -59,6 +73,13 @@ export default class Context extends ContextBase {
     return combinators;
   }
 
+  getConstrustors(includeRelease) {
+    const context = this.getContext(),
+          constructors = context.getConstrustors(includeRelease);
+
+    return constructors;
+  }
+
   getMetavariables(includeRelease) {
     const context = this.getContext(),
           metavariables = context.getMetavariables(includeRelease);
@@ -88,13 +109,6 @@ export default class Context extends ContextBase {
     return procedure;
   }
 
-  findRuleByReference(reference) {
-    const context = this.getContext(),
-          rule = context.findRuleByReference(reference);
-
-    return rule;
-  }
-
   findFrameByFrameNode(frameNode) {
     const context = this.getContext(),
           frame = context.findFrameByFrameNode(frameNode);
@@ -116,56 +130,70 @@ export default class Context extends ContextBase {
     return reference;
   }
 
-  findTopLevelAssertionByReference(reference) {
+  findVariableByVariableIdentifier(variableIdentifier) {
     const context = this.getContext(),
-      topLevelAssertion = context.findTopLevelAssertionByReference(reference);
+          variable = context.findVariableByVariableIdentifier(variableIdentifier);
 
-    return topLevelAssertion;
+    return variable;
   }
 
-  findSubstitutionByVariable(variable, generalContext, specificContext) {
+  findSubstitutionByMetavariableName(metavariableName) {
     const context = this.getContext(),
-          substitution = context.findSubstitutionByVariable(variable, generalContext, specificContext);
+          substitution = context.findSubstitutionByMetavariableName(metavariableName);
 
     return substitution;
   }
 
-  findSubstitutionByMetavariable(metavariable, generalContet, specificContext) {
+  findMetavariableByMetavariableName(metavariableName) {
     const context = this.getContext(),
-          substitution = context.findSubstitutionByMetavariable(metavariable, generalContet, specificContext);
+          metavariable = context.findMetavariableByMetavariableName(metavariableName);
 
-    return substitution;
+    return metavariable;
   }
 
-  findVariableByVariableIdentifier(variableIdentifier) {
+  findSubstitutionByVariableIdentifier(variableIdentifier) {
     const context = this.getContext(),
-          variable = context.findVariableByVariableIdentifier(variableIdentifier);
+          substitution = context.findSubstitutionByVariableIdentifier(variableIdentifier);
 
-    return variable;
+    return substitution;
   }
 
-  findMetavariableByMetavariableName(metavariableName) {
+  findSimpleSubstitutionByMetavariableName(metavariableName) {
     const context = this.getContext(),
-          metavariable = context.findMetavariableByMetavariableName(metavariableName);
+          simpleSubstitution = context.findSimpleSubstitutionByMetavariableName(metavariableName);
 
-    return metavariable;
+    return simpleSubstitution;
   }
 
-  findSimpleSubstitutionByMetavariable(metavariable) {
+  findComplexSubstitutionsByMetavariableName(metavariableName) {
     const context = this.getContext(),
-          simpleSubstitution = context.findSimpleSubstitutionByMetavariable(metavariable);
+          complexSubstitution = context.findComplexSubstitutionsByMetavariableName(metavariableName);
 
-    return simpleSubstitution;
+    return complexSubstitution;
   }
 
-  findSubstitutionByMetavariableAndSubstitution(metavariable, substitution, generalContet, specificContext) {
+  findSubstitutionByMetavariableNameAndSubstitution(metavariableName, substitution) {
     const context = this.getContext();
 
-    substitution = context.findSubstitutionByMetavariableAndSubstitution(metavariable, substitution, generalContet, specificContext); ///
+    substitution = context.findSubstitutionByMetavariableNameAndSubstitution(metavariableName, substitution); ///
 
     return substitution;
   }
 
+  findRuleByReference(reference) {
+    const context = this.getContext(),
+          rule = context.findRuleByReference(reference);
+
+    return rule;
+  }
+
+  findTopLevelAssertionByReference(reference) {
+    const context = this.getContext(),
+          topLevelAssertion = context.findTopLevelAssertionByReference(reference);
+
+    return topLevelAssertion;
+  }
+
   isTermPresentByTermNode(termNode) {
     const context = this.getContext(),
           termPresent = context.isTermPresentByTermNode(termNode);
@@ -173,18 +201,18 @@ export default class Context extends ContextBase {
     return termPresent;
   }
 
-  isFramePresentByFrameNode(frameNode) {
+  isProcedurePresentByName(name) {
     const context = this.getContext(),
-          framePresent = context.isFramePresentByFrameNode(frameNode);
+          procedurePresent = context.isProcedurePresentByName(name);
 
-    return framePresent;
+    return procedurePresent;
   }
 
-  isJudgementPresentByMetavariable(metavariable) {
+  isFramePresentByFrameNode(frameNode) {
     const context = this.getContext(),
-          judgementPresent = context.isJudgementPresentByMetavariable(metavariable);
+          framePresent = context.isFramePresentByFrameNode(frameNode);
 
-    return judgementPresent;
+    return framePresent;
   }
 
   isStatementPresentByStatementNode(statementNode) {
@@ -208,18 +236,18 @@ export default class Context extends ContextBase {
     return referencePresent;
   }
 
-  isSubstitutionPresentBySubstitutionNode(substitutionNode) {
+  isJudgementPresentByMetavariableName(metavariableName) {
     const context = this.getContext(),
-          substitutionPresent = context.isSubstitutionPresentBySubstitutionNode(substitutionNode);
+          judgementPresent = context.isJudgementPresentByMetavariableName(metavariableName);
 
-    return substitutionPresent;
+    return judgementPresent;
   }
 
-  isProcedurePresentByName(name) {
+  isSubstitutionPresentBySubstitutionNode(substitutionNode) {
     const context = this.getContext(),
-          procedurePresent = context.isProcedurePresentByName(name);
+          substitutionPresent = context.isSubstitutionPresentBySubstitutionNode(substitutionNode);
 
-    return procedurePresent;
+    return substitutionPresent;
   }
 
   isLabelPresentByReference(reference) {

package/src/element/assertion/contained.js

@@ -31,6 +31,13 @@ export default define(class ContainedAssertion extends Assertion {
     return this.statement;
   }
 
+  getContainedAssertionNode() {
+    const node = this.getNode(),
+          containedAssertionNode = node;  ///
+
+    return containedAssertionNode;
+  }
+
   validate(assignments, stated, context) {
     let validates = false;
 

package/src/element/assertion/defined.js

@@ -26,6 +26,13 @@ export default define(class DefinedAssertion extends Assertion {
     return this.negated;
   }
 
+  getDefinedAssertionNode() {
+    const node = this.getNode(),
+          definedAssertionNode = node;  ///
+
+    return definedAssertionNode;
+  }
+
   validate(assignments, stated, context) {
     let validates = false;
 
@@ -189,7 +196,8 @@ function validateWhenDerived(term, frame, negated, generalContext, specificConte
   const context = specificContext;  ///
 
   if (term !== null) {
-    const variable = term.getVariable(generalContext, specificContext),
+    const variableIdentifier = term.getVariableIdentifier(),
+          variable = context.findVariableByVariableIdentifier(variableIdentifier),
           variableDefined = isVariableDefined(variable, context);
 
     if (!negated && variableDefined) {
@@ -202,7 +210,8 @@ function validateWhenDerived(term, frame, negated, generalContext, specificConte
   }
 
   if (frame!== null) {
-    const metavariable = frame.getMetavariable(generalContext, specificContext),
+    const metavariableName = frame.getMetavariableName(),
+          metavariable = context.findMetavariableByMetavariableName(metavariableName),
           metavariableDefined = isMetavariableDefined(metavariable, context);
 
     if (!negated && metavariableDefined) {
@@ -237,7 +246,8 @@ function isVariableDefined(variable, context) {
 }
 
 function isMetavariableDefined(metavariable, context) {
-  const judgementPresent = context.isJudgementPresentByMetavariable(metavariable),
+  const metavariableName = metavariable.getNode(),
+        judgementPresent = context.isJudgementPresentByMetavariableName(metavariableName),
         metavariableDefined = judgementPresent; ///
 
   return metavariableDefined

package/src/element/assertion/property.js

@@ -22,6 +22,13 @@ export default define(class PropertyAssertion extends Assertion {
     return this.propertyRelation;
   }
 
+  getPropertyAssertionNode() {
+    const node = this.getNode(),
+          propertyAssertionNode = node; ///
+
+    return propertyAssertionNode;
+  }
+
   compareTermAndPropertyRelation(term, propertyRelation, context) {
     let comparesToTermAndPropertyRelation = false;
 

package/src/element/assertion/satisfies.js

@@ -20,6 +20,13 @@ export default define(class SatisfiesAssertion extends Assertion {
     return this.reference;
   }
 
+  getSatisfiesAssertionNode() {
+    const node = this.getNode(),
+          satisfiesAssertionNode = node;  ///
+
+    return satisfiesAssertionNode;
+  }
+
   compareSubstitutions(substitutions, context) { return this.signature.compareSubstitutions(substitutions, context); }
 
   correlateSubstitutions(substitutions, context) { return this.signature.correlateSubstitutions(substitutions, context); }

package/src/element/assertion/subproof.js

@@ -20,6 +20,13 @@ export default define(class SubproofAssertion extends Assertion {
     return this.statements;
   }
 
+  getSubproofAssertionNode() {
+    const node = this.getNode(),
+          subproofAssertionNode = node; ///
+
+    return subproofAssertionNode;
+  }
+
   validate(assignments, stated, context) {
     let validates = false;
 

package/src/element/assertion/type.js

@@ -22,6 +22,13 @@ export default define(class TypeAssertion extends Assertion {
     return this.type;
   }
 
+  getTypeAssertionNBode() {
+    const node = this.getNode(),
+          typeAssertionNode = node; ///
+
+    return typeAssertionNode;
+  }
+
   verify(assignments, stated, context) {
     let verifies = false;
 

package/src/element/assumption.js

@@ -33,9 +33,9 @@ export default define(class Assumption extends Element {
     context.trace(`Comparing the '${assumptionString}' assumption to the '${substitutionString}' substitution...`);
 
     const statement = substitution.getStatement(),
-          metavariable = substitution.getMetavariable(generalContext, specificContext),
+          metavariableName = substitution.getMetavariableName(),
           statementEqualToStatement = this.statement.isEqualTo(statement),
-          referenceMetavariableComparesToMetavariable = this.reference.compareMetavariable(metavariable);
+          referenceMetavariableComparesToMetavariable = this.reference.compareMetavariableName(metavariableName);
 
     if (statementEqualToStatement && referenceMetavariableComparesToMetavariable) {
       comparesToSubstituion = true;

package/src/element/combinator/bracketed.js

@@ -5,6 +5,13 @@ import Combinator from "../combinator";
 import { define } from "../../elements";
 
 export default define(class BracketedCombinator extends Combinator {
+  getBracketedCombinatorNode() {
+    const node = this.getNode(),
+          bracketedCombinatorNode = node; ///
+
+    return bracketedCombinatorNode;
+  }
+
   unifyStatement(statement, assignments, stated, context) {
     let statementUnifies;
 

package/src/element/constructor/bracketed.js

@@ -6,6 +6,13 @@ import Constructor from "../constructor";
 import { define } from "../../elements";
 
 export default define(class BracketedConstructor extends Constructor {
+  getBracketedConstructorNode() {
+    const node = this.getNode(),
+          bracketedConstructorNode = node;  ///
+
+    return bracketedConstructorNode;
+  }
+
   unifyTerm(term, context, verifyForwards) {
     let termUnifies;
 

package/src/element/declaration/combinator.js

@@ -15,6 +15,13 @@ export default define(class CombinatorDeclaration extends Declaration {
     return this.combinator;
   }
 
+  getCombinatorDeclarationNode() {
+    const node = this.getNode(),
+          combinatorDeclarationNode = node; ///
+
+    return combinatorDeclarationNode;
+  }
+
   async verify() {
     let verifies = false;
 

package/src/element/declaration/complexType.js

@@ -20,6 +20,13 @@ export default define(class ComplexTypeDeclaration extends Declaration {
     return this.prefixed;
   }
 
+  getComplexTypeDeclarationNode() {
+    const node = this.getNode(),
+          complexTypeDeclarationNode = node;  ///
+
+    return complexTypeDeclarationNode;
+  }
+
   verifyType() {
     let typeVerifies = false;
 

package/src/element/declaration/constructor.js

@@ -16,31 +16,11 @@ export default define(class ConstructorDeclaration extends Declaration {
     return this.constructor;
   }
 
-  async verify() {
-    let verifies;
-
-    const context = this.getContext(),
-          constructorDeclarationString = this.getString(); ///
-
-    context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration...`);
-
-    const constructorTypeVerifies = this.verifyConstructorType();
-
-    if (constructorTypeVerifies) {
-      const constructorValidates = this.verifyConstructor();
-
-      if (constructorValidates) {
-        context.addConstructor(this.constructor);
+  getConstructorDeclarationNode() {
+    const node = this.getNode(),
+          constructorDeclarationNode = node;  ///
 
-        verifies = true;
-      }
-    }
-
-    if (verifies) {
-      context.debug(`...verified the '${constructorDeclarationString}' constructor declaration.`);
-    }
-
-    return verifies;
+    return constructorDeclarationNode;
   }
 
   verifyConstructor() {
@@ -110,5 +90,32 @@ export default define(class ConstructorDeclaration extends Declaration {
     return constructorTypeVerifies;
   }
 
+  async verify() {
+    let verifies;
+
+    const context = this.getContext(),
+          constructorDeclarationString = this.getString(); ///
+
+    context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration...`);
+
+    const constructorTypeVerifies = this.verifyConstructorType();
+
+    if (constructorTypeVerifies) {
+      const constructorValidates = this.verifyConstructor();
+
+      if (constructorValidates) {
+        context.addConstructor(this.constructor);
+
+        verifies = true;
+      }
+    }
+
+    if (verifies) {
+      context.debug(`...verified the '${constructorDeclarationString}' constructor declaration.`);
+    }
+
+    return verifies;
+  }
+
   static name = "ConstructorDeclaration";
 });

package/src/element/declaration/metavariable.js

@@ -5,21 +5,21 @@ import Declaration from "../declaration";
 import { define } from "../../elements";
 
 export default define(class MetavariableDeclaration extends Declaration {
-  constructor(context, string, node, metavariable, metaType) {
+  constructor(context, string, node, metaType, metavariable) {
     super(context, string, node);
 
-    this.metavariable = metavariable;
     this.metaType = metaType;
-  }
-
-  getMetavariable() {
-    return this.metavariable;
+    this.metavariable = metavariable;
   }
 
   getMetaType() {
     return this.metaType;
   }
 
+  getMetavariable() {
+    return this.metavariable;
+  }
+
   verifyMetavariable() {
     let metavariableVerifies = false;
 

package/src/element/declaration/simpleType.js

@@ -16,6 +16,13 @@ export default define(class SimpleTypeDeclaration extends Declaration {
     return this.type;
   }
 
+  getSimpleTypeDeclarationNode() {
+    const node = this.getNode(),
+          simpleTypeDeclarationNode = node; ///
+
+    return simpleTypeDeclarationNode;
+  }
+
   isPrefixed() {
     return this.prefixed;
   }

package/src/element/declaration/typePrefix.js

@@ -15,6 +15,13 @@ export default define(class TypePrefixDeclaration extends Declaration {
     return this.typePrefix;
   }
 
+  getTypePrefixDeclarationNode() {
+    const node = this.getNode(),
+          typePrefixDeclarationNode = node; ///
+
+    return typePrefixDeclarationNode;
+  }
+
   verifyTypePrefix() {
     let typePrefixVerifies = false;
 

package/src/element/declaration/variable.js

@@ -5,26 +5,33 @@ import Declaration from "../declaration";
 import { define } from "../../elements";
 
 export default define(class VariableDeclaration extends Declaration {
-  constructor(context, string, node, variable, type, provisional) {
+  constructor(context, string, node, type, variable, provisional) {
     super(context, string, node);
 
-    this.variable = variable;
     this.type = type;
+    this.variable = variable;
     this.provisional = provisional;
   }
 
-  getVariable() {
-    return this.variable;
-  }
-
   getType() {
     return this.type;
   }
 
+  getVariable() {
+    return this.variable;
+  }
+
   isProvisional() {
     return this.provisional;
   }
 
+  getVariableDeclarationNode() {
+    const node = this.getNode(),
+          typePrefixDeclarationNode = node; ///
+
+    return typePrefixDeclarationNode;
+  }
+
   verifyType() {
     let typeVerifies = false;
 

package/src/element/frame.js

@@ -23,13 +23,6 @@ export default define(class Frame extends Element {
     return this.metavariable;
   }
 
-  getMetavariableName() {
-    const node = this.getNode(),
-          metavariableName = node.getMetavariableName();
-
-    return metavariableName;
-  }
-
   getFrameNode() {
     const node = this.getNode(),
           frameNode = node; ///
@@ -37,26 +30,18 @@ export default define(class Frame extends Element {
     return frameNode;
   }
 
-  compareMetavariable(metavariable) {
-    let metavaraibleComparseTo = false;
-
-    const singular = this.isSingular();
-
-    if (singular) {
-      let metavariableName;
-
-      metavariableName = this.metavariable.getName();
-
-      const metavariableNameA = metavariableName ///
-
-      metavariableName = metavariable.getName();
+  getMetavariableName() {
+    const frameNode = this.getFrameNode(),
+          metavariableName = frameNode.getMetavariableName();
 
-      const metavariableNameB = metavariableName; ///
+    return metavariableName;
+  }
 
-      metavaraibleComparseTo = (metavariableNameA === metavariableNameB);
-    }
+  getMetavariableNode() {
+    const frameNode = this.getFrameNode(),
+          metavariableNode = frameNode.getMetavariableNode();
 
-    return metavaraibleComparseTo;
+    return metavariableNode;
   }
 
   matchFrameNode(frameNode) {
@@ -88,13 +73,30 @@ export default define(class Frame extends Element {
   }
 
   isSingular() {
-    const node = this.getNode(),
-          frameNode = node, ///
+    const frameNode = this.getFrameNode(),
           singular = frameNode.isSingular();
 
     return singular;
   }
 
+  matchMetavariableName(metavariableName) {
+    let metavariableNameMatches = false;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      const metavariableNameA = metavariableName ///
+
+      metavariableName = this.getMetavariableName();
+
+      const metavariableNameB = metavariableName; ///
+
+      metavariableNameMatches = (metavariableNameA === metavariableNameB);
+    }
+
+    return metavariableNameMatches;
+  }
+
   compareParameter(parameter) {
     let comparesToParamter = false;