occam-verify-cli 1.0.612 → 1.0.617

package/src/context/scoped.js

@@ -109,77 +109,93 @@ class ScopedContext extends Context {
   }
 
   addEquality(equality) {
-    let equalityAdded;
+    let equalityAdded = false;
 
-    const equalityReflexive = equality.isReflexive();
+    const context = this, ///
+          equalityString = equality.getString();
+
+    context.trace(`Adding the '${equalityString}' equality to the scoped context...`);
+
+    const equalityRelfexive = equality.isReflexive();
 
-    if (!equalityReflexive) {
+    if (equalityRelfexive) {
+      context.trace(`The '${equalityString}' equality is reflexive and will not added to the scoped context.`);
+    } else {
       const { Equivalence } = elements,
             equivalence = Equivalence.fromEquality(equality),
             context = this; ///
 
       this.equivalences = this.equivalences.mergedWithEquivalence(equivalence, context);
-    }
-
-    equalityAdded = true;
 
-    if (equalityAdded) {
-      const context = this, ///
-            equalityString = equality.getString();
+      equalityAdded = true;
 
-      context.trace(`Added the '${equalityString}' equality.`)
+      context.debug(`...added the '${equalityString}' equality to the scoped context.`);
     }
 
     return equalityAdded;
   }
 
-  addVariable(variable, nested = true) {
-    let variableAdded = false;
+  addVariable(variable) {
+    const context = this, ///
+          variableA = variable, ///
+          variableString = variable.getString();
 
-    const variableIdentifier = variable.getIdentifier(),
-          variablePresent = this.isVariablePresentByVariableIdentifier(variableIdentifier, nested);
+    context.trace(`Adding the '${variableString}' variable to the scoped context...`);
 
-    if (!variablePresent) {
-      this.variables.push(variable);
+    const variableB = this.variables.find((variable) => {
+      const variableB = variable, ///
+            variableAComparesToVariableB = variableA.compare(variableB);
 
-      variableAdded = true;
-    }
+      if (variableAComparesToVariableB) {
+        return true;
+      }
+    }) || null;
 
-    if (variableAdded) {
-      const context = this,
-            variableString = variable.getString();
+    if (variableB !== null) {
+      context.trace(`The '${variableString}' variable has already been added to the scoped context.`);
+    } else {
+      this.variables.push(variable);
 
-      context.trace(`Added the '${variableString}' variable.`)
+      context.debug(`...added the '${variableString}' variable to the scoped context.`);
     }
-
-    return variableAdded;
   }
 
   addJudgement(judgement) {
     let judgementAdded = false;
 
+    const context = this, ///
+          judgementString = judgement.getString();
+
+    context.trace(`Adding the '${judgementString}' judgement to the scoped context...`);
+
     const metavariable = judgement.getMetavariable(),
           metavariableName = metavariable.getMetavariableName(),
           judgementPresent = this.isJudgementPresentByMetavariableName(metavariableName);
 
-    if (!judgementPresent) {
+    if (judgementPresent) {
+      const metavariableString = metavariable.getString();
+
+      context.trace(`A '${judgementString}' judgement for the '${metavariableString}' metavariable is already present.`);
+    } else {
       this.judgements.push(judgement);
 
       judgementAdded = true;
-    }
 
-    if (judgementAdded) {
-      const context = this, ///
-            judgementString = judgement.getString();
-
-      context.trace(`Added the '${judgementString}' judgement.`)
+      context.debug(`...added the '${judgementString}' judgement to the scoped context.`);
     }
 
     return judgementAdded;
   }
 
   addSubproofOrProofAssertion(subproofOrProofAssertion) {
+    const context = this, ///
+          subproofOrProofAssertionString = subproofOrProofAssertion.getString();
+
+    context.trace(`Adding the '${subproofOrProofAssertionString}' subproof or proof assertion to the scoped context...`);
+
     this.subproofOrProofAssertions.push(subproofOrProofAssertion);
+
+    context.debug(`...added the '${subproofOrProofAssertionString}' subproof or proof assertion to the scoped context.`);
   }
 
   findEquivalenceByTerm(term) { return this.equivalences.findEquivalenceByTerm(term); }

package/src/context.js

@@ -102,9 +102,9 @@ export default class Context extends ContextBase {
     return metavariable;
   }
 
-  findProcedureByName(name) {
+  findProcedureByProcedureName(procedureName) {
     const context = this.getContext(),
-          procedure = context.findProcedureByName(name);
+          procedure = context.findProcedureByProcedureName(procedureName);
 
     return procedure;
   }
@@ -201,9 +201,9 @@ export default class Context extends ContextBase {
     return termPresent;
   }
 
-  isProcedurePresentByName(name) {
+  isProcedurePresentByProcedureName(procedureName) {
     const context = this.getContext(),
-          procedurePresent = context.isProcedurePresentByName(name);
+          procedurePresent = context.isProcedurePresentByProcedureName(procedureName);
 
     return procedurePresent;
   }

package/src/element/assertion.js

@@ -3,10 +3,6 @@
 import { Element } from "occam-languages";
 
 export default class Assertion extends Element {
-  constructor(context, string, node) {
-    super(context, string, node);
-  }
-
   getAssertionNode() {
     const node = this.getNode(),
           assertionNode = node; ///
@@ -21,9 +17,9 @@ export default class Assertion extends Element {
 
     const assertionNodeB = assertionNode, ///
           assertionNodeAAMatchesAssertionBNodeB = assertionNodeA.match(assertionNodeB),
-          equalTo = assertionNodeAAMatchesAssertionBNodeB; ///
+          assertionNodeMatches = assertionNodeAAMatchesAssertionBNodeB; ///
 
-    return equalTo;
+    return assertionNodeMatches;
   }
 
   isValid(context) {
@@ -36,8 +32,8 @@ export default class Assertion extends Element {
 
   isEqualTo(assertion) {
     const assertionNode = assertion.getNode(),
-      assertionNodeMatches = this.matchAssertionNode(assertionNode),
-      equalTo = assertionNodeMatches;  ///
+          assertionNodeMatches = this.matchAssertionNode(assertionNode),
+          equalTo = assertionNodeMatches;  ///
 
     return equalTo;
   }

package/src/element/assumption.js

@@ -14,12 +14,19 @@ export default define(class Assumption extends Element {
     this.reference = reference;
   }
 
+  getReference() {
+    return this.reference;
+  }
+
   getStatement() {
     return this.statement;
   }
 
-  getReference() {
-    return this.reference;
+  getAssumptionNode() {
+    const node = this.getNode(),
+          assumptionNode = node;  ///
+
+    return assumptionNode;
   }
 
   getMetavariable() { return this.reference.getMetavariable(); }

package/src/element/combinator.js

@@ -18,6 +18,13 @@ export default define(class Combinator extends Element {
     return this.statement;
   }
 
+  getConbinatorNode() {
+    const node = this.getNode(),
+          combinatorNode = node;  ///
+
+    return combinatorNode;
+  }
+
   verify() {
     let verifies;
 

package/src/element/conclusion.js

@@ -17,6 +17,13 @@ export  default define(class Conclusion extends Element {
     return this.statement;
   }
 
+  getConclusionNode() {
+    const node = this.getNode(),
+          conclusionNode = node;  ///
+
+    return conclusionNode;
+  }
+
   verify(context) {
     let verifies = false;
 

package/src/element/constructor.js

@@ -17,6 +17,13 @@ export default define(class Constructor extends Element {
     return this.term;
   }
 
+  getConclusionNode() {
+    const node = this.getNode(),
+          constructorNode = node;  ///
+
+    return constructorNode;
+  }
+
   isProvisional() { return this.term.isProvisional(); }
 
   getType() { return this.term.getType(); }

package/src/element/declaration.js

@@ -3,7 +3,5 @@
 import { Element } from "occam-languages";
 
 export default class Declaration extends Element {
-  constructor(context, string, node) {
-    super(context, string, node);
-  }
+  ///
 }

package/src/element/deduction.js

@@ -17,6 +17,13 @@ export default define(class Deduction extends Element {
     return this.statement;
   }
 
+  getDeductionNode() {
+    const node = this.getNode(),
+          deductionNode = node; ///
+
+    return deductionNode;
+  }
+
   verify(context) {
     let verifies = false;
 

package/src/element/derivation.js

@@ -21,6 +21,13 @@ export default define(class Derivation extends Element {
     return this.subproofOrProofAssertions;
   }
 
+  getDerivationNode() {
+    const node = this.getNode(),
+          derivationNode = node;  ///
+
+    return derivationNode;
+  }
+
   getLastProofAssertion() {
     const lastSubproofOrProofAssertion = last(this.subproofOrProofAssertions),
           lastProofAssertion = lastSubproofOrProofAssertion;  ///

package/src/element/equality.js

@@ -22,6 +22,13 @@ export default define(class Equality extends Element {
     return this.rightTerm;
   }
 
+  getEqualityNode() {
+    const node = this.getNode(),
+          equalityNde = node; ///
+
+    return equalityNde;
+  }
+
   getType() {
     let type;
 

package/src/element/equivalence.js

@@ -15,6 +15,7 @@ const { compress } = arrayUtilities;
 export default define(class Equivalence extends Element {
   constructor(context, string, node, terms) {
     super(context, string, node);
+
     this.terms = terms;
   }
 
@@ -22,6 +23,13 @@ export default define(class Equivalence extends Element {
     return this.terms;
   }
 
+  getEquivalenceNode() {
+    const node = this.getNode(),
+          equivalenceNode = node; ///
+
+    return equivalenceNode;
+  }
+
   getType() {
     const type = this.terms.reduce((type, term) => {
       const termType = term.getType();

package/src/element/equivalences.js

@@ -20,6 +20,13 @@ export default define(class Equivalences extends Element {
     return this.array;
   }
 
+  getEquivalencesNode() {
+    const node = this.getNode(),
+          equivalencesNode = node;  ///
+
+    return equivalencesNode;
+  }
+
   getLength() { return this.array.length; }
 
   getTypes() {

package/src/element/error.js

@@ -5,8 +5,11 @@ import { Element } from "occam-languages";
 import { define } from "../elements";
 
 export default define(class Error extends Element {
-  constructor(context, string, node) {
-    super(context, string, node);
+  getErrorNode() {
+    const node = this.getNode(),
+          errorNode = node; ///
+
+    return errorNode;
   }
 
   async verify() {

package/src/element/hypothesis.js

@@ -18,6 +18,13 @@ export default define(class Hypothesis extends Element {
     return this.statement;
   }
 
+  getHypothesisNode() {
+    const node = this.getNode(),
+          hypothesisNode = node;  ///
+
+    return hypothesisNode;
+  }
+
   verify(context) {
     let verifies = false;
 

package/src/element/judgement.js

@@ -21,9 +21,15 @@ export default define(class Judgement extends Element {
     return this.assumption;
   }
 
-  isSingular() {
+  getJudgementNode() {
     const node = this.getNode(),
-          judgementNode = node, ///
+          judgementNode = node; ///
+
+    return judgementNode;
+  }
+
+  isSingular() {
+    const judgementNode = this.getJudgementNode(),
           singular = judgementNode.isSingular();
 
     return singular;

package/src/element/label.js

@@ -16,6 +16,13 @@ export default define(class Label extends Element {
     return this.metavariable;
   }
 
+  getLabelNode() {
+    const node = this.getNode(),
+          labelNode = node; ///
+
+    return labelNode;
+  }
+
   getMetavariableName() { return this.metavariable.getName(); }
 
   getMetavariableNode() { return this.metavariable.getNode(); }

package/src/element/metaType.js

@@ -15,6 +15,13 @@ export default define(class MetaType extends Element {
     return this.name;
   }
 
+  getMetaTypeNode() {
+    const node = this.getNode(),
+          metaTypeNode = node;  ///
+
+    return metaTypeNode;
+  }
+
   isEqualTo(metaType) {
     const equalTo = (this === metaType);
 

package/src/element/metavariable.js

@@ -148,10 +148,6 @@ export default define(class Metavariable extends Element {
               framesubstitutionValidates = frameSubstitution.validate(generalContext, specificContext);
 
         if (framesubstitutionValidates) {
-          const substitution = frameSubstitution; ///
-
-          context.addSubstitution(substitution);
-
           frameUnifies = true;
         }
       }
@@ -212,10 +208,6 @@ export default define(class Metavariable extends Element {
         const statementSubstitutionValidates = statementSubstitution.validate(generalContext, specificContext);
 
         if (statementSubstitutionValidates) {
-          const substitution = statementSubstitution; ///
-
-          context.addSubstitution(substitution);
-
           statementUnifies = true;
         }
       }
@@ -257,11 +249,12 @@ export default define(class Metavariable extends Element {
         const { ReferenceSubstitution } = elements,
               metavariable = this, ///
               referenceSubstitution = ReferenceSubstitution.fromReferenceAndMetavariable(reference, metavariable, context),
-              substitution = referenceSubstitution; ///
+              referenceSubstitutionValidates = referenceSubstitution.validate(generalContext, specificContext);
 
-        context.addSubstitution(substitution);
+        if (referenceSubstitutionValidates) {
+          referenceUnifies = true;
 
-        referenceUnifies = true;
+        }
       }
     }
 

package/src/element/parameter.js

@@ -20,6 +20,13 @@ export default define(class Parameter extends Element {
     return this.identifier;
   }
 
+  getParameterNode() {
+    const node = this.getNode(),
+          parameterNode = node; ///
+
+    return parameterNode;
+  }
+
   findPrimitive(substitutions) {
     let primitive = null;
 

package/src/element/procedureCall.js

@@ -24,7 +24,14 @@ export default define(class ProcedureCall extends Element {
     return this.procedureReference;
   }
 
-  getName() { return this.procedureReference.getName(); }
+  getProcedureCallNode() {
+    const node = this.getNode(),
+          procedureCallNode = node;
+
+    return procedureCallNode;
+  }
+
+  getProcedureName() { return this.procedureReference.getProcedureName(); }
 
   findPrimitives(context) {
     const substitutions = context.getSubstitutions(),
@@ -44,8 +51,8 @@ export default define(class ProcedureCall extends Element {
 
     context.trace(`Validating the '${procedureCallString}' procedure call...`);
 
-    const name = this.getName(),
-          procedure = context.findProcedureByName(name);
+    const procedureName = this.getProcedureName(),
+          procedure = context.findProcedureByProcedureName(procedureName);
 
     if (procedure !== null) {
       const procedureBoolean = procedure.isBoolean();
@@ -73,13 +80,13 @@ export default define(class ProcedureCall extends Element {
 
     context.trace(`Unifying the '${procedureCallString}' procedure call independently...`);
 
-    const name = this.getName(),
-          primitives = this.findPrimitives(context),
-          terms = termsFromPrimitives(primitives),
-          procedure = context.findProcedureByName(name);
+    const procedureName = this.getProcedureName(),
+          procedure = context.findProcedureByProcedureName(procedureName);
 
-    try {
-      const term = await procedure.call(terms, context),
+    // try {
+      const primitives = this.findPrimitives(context),
+            terms = termsFromPrimitives(primitives),
+            term = await procedure.call(terms, context),
             boolean = term.isBoolean();
 
       if (!boolean) {
@@ -91,11 +98,11 @@ export default define(class ProcedureCall extends Element {
           unifiesIndependently = true;
         }
       }
-    } catch (exception) {
-      const message = exception.getMessage();
-
-      context.info(message);
-    }
+    // } catch (exception) {
+    //   const message = exception.getMessage();
+    //
+    //   context.info(message);
+    // }
 
     if (unifiesIndependently) {
       context.debug(`...unified the '${procedureCallString}' procedure call independently.`);

package/src/element/procedureReference.js

@@ -14,6 +14,19 @@ export default define(class ProcedureReference extends Element {
     return this.name;
   }
 
+  getProcedureReferenceNode() {
+    const node = this.getNode(),
+          procedureReferenceNode = node;  ///
+
+    return procedureReferenceNode;
+  }
+
+  getProcedureName() {
+    const procedureName = this.name;  ///
+
+    return procedureName;
+  }
+
   toJSON() {
     const name = this.name,
           json = {

package/src/element/proof.js

@@ -16,6 +16,13 @@ export default define(class Proof extends Element {
     return this.derivation;
   }
 
+  getProofNode() {
+    const node = this.getNode(),
+          proofNode = node; ///
+
+    return proofNode;
+  }
+
   getLastProofAssertion() { return this.derivation.getLastProofAssertion(); }
 
   getStatement() {

package/src/element/proofAssertion.js

@@ -15,6 +15,13 @@ export default class ProofAssertion extends Element {
     return this.statement;
   }
 
+  getProofAssertionNode() {
+    const node = this.getNode(),
+          proofAssertionNode = node;  ///
+
+    return proofAssertionNode;
+  }
+
   isProofAssertion() {
     const proofAssertion = true;
 

package/src/element/property.js

@@ -20,6 +20,13 @@ export default define(class Property extends Element {
     return this.nominalTypeName;
   }
 
+  getPropertyNode() {
+    const node = this.getNode(),
+          properetyNode = node; ///
+
+    return properetyNode;
+  }
+
   comparePropertyName(propertyName) {
     const comparesToPropertyName = (this.name === propertyName);
 

package/src/element/propertyRelation.js

@@ -20,6 +20,13 @@ export default define(class PropertyRelation extends Element {
     return this.term;
   }
 
+  getPropertyRelationNode() {
+    const node = this.getNode(),
+          propertyRelationNode = node;  ///
+
+    return propertyRelationNode;
+  }
+
   verify(context) {
     let verifies = false;
 

package/src/element/reference.js

@@ -20,6 +20,14 @@ export default define(class Reference extends Element {
     return this.metavariable;
   }
 
+  getReferenceNode() {
+    const node = this.getNode(),
+          referenceNode = node; ///
+
+    return referenceNode;
+  }
+
+
   getName() { return this.metavariable.getName(); }
 
   getMetavariableName() {
@@ -34,13 +42,6 @@ export default define(class Reference extends Element {
     return metavariableNode;
   }
 
-  getReferenceNode() {
-    const node = this.getNode(),
-          assertionNode = node; ///
-
-    return assertionNode;
-  }
-
   matchReferenceNode(assertionNode) {
     const assertionNodeA = assertionNode; ///