occam-verify-cli 1.0.617 → 1.0.632

package/src/context/scoped.js

@@ -17,21 +17,17 @@ class ScopedContext extends Context {
     this.subproofOrProofAssertions = subproofOrProofAssertions;
   }
 
-  getVariables(nested = true) {
+  getVariables() {
     let variables;
 
-    if (nested) {
-      const context = this.getContext();
+    const context = this.getContext();
 
-      variables = context.getVariables();
+    variables = context.getVariables();
 
-      variables = [
-        ...this.variables,
-        ...variables
-      ];
-    } else {
-      variables = this.variables;
-    }
+    variables = [
+      ...this.variables,
+      ...variables
+    ];
 
     return variables;
   }
@@ -67,6 +63,21 @@ class ScopedContext extends Context {
     return equivalences;
   }
 
+  getSubproofOrProofAssertions() {
+    let subproofOrProofAssertions;
+
+    const context = this.getContext();
+
+    subproofOrProofAssertions = context.getSubproofOrProofAssertions();
+
+    subproofOrProofAssertions = [  ///
+      ...subproofOrProofAssertions,
+      ...this.subproofOrProofAssertions
+    ];
+
+    return subproofOrProofAssertions;
+  }
+
   getProofAssertions() {
     const subproofOrProofAssertions = this.getSubproofOrProofAssertions(),
           proofAssertions = subproofOrProofAssertions.filter((subproofOrProofAssertion) => {
@@ -93,24 +104,7 @@ class ScopedContext extends Context {
     return lastProofAssertion;
   }
 
-  getSubproofOrProofAssertions() {
-    let subproofOrProofAssertions;
-
-    const context = this.getContext();
-
-    subproofOrProofAssertions = context.getSubproofOrProofAssertions();
-
-    subproofOrProofAssertions = [  ///
-      ...subproofOrProofAssertions,
-      ...this.subproofOrProofAssertions
-    ];
-
-    return subproofOrProofAssertions;
-  }
-
   addEquality(equality) {
-    let equalityAdded = false;
-
     const context = this, ///
           equalityString = equality.getString();
 
@@ -122,69 +116,34 @@ class ScopedContext extends Context {
       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; ///
+            equivalence = Equivalence.fromEquality(equality, context);
 
       this.equivalences = this.equivalences.mergedWithEquivalence(equivalence, context);
 
-      equalityAdded = true;
-
       context.debug(`...added the '${equalityString}' equality to the scoped context.`);
     }
-
-    return equalityAdded;
   }
 
   addVariable(variable) {
     const context = this, ///
-          variableA = variable, ///
           variableString = variable.getString();
 
     context.trace(`Adding the '${variableString}' variable to the scoped context...`);
 
-    const variableB = this.variables.find((variable) => {
-      const variableB = variable, ///
-            variableAComparesToVariableB = variableA.compare(variableB);
-
-      if (variableAComparesToVariableB) {
-        return true;
-      }
-    }) || null;
-
-    if (variableB !== null) {
-      context.trace(`The '${variableString}' variable has already been added to the scoped context.`);
-    } else {
-      this.variables.push(variable);
+    this.variables.push(variable);
 
-      context.debug(`...added the '${variableString}' variable to the scoped context.`);
-    }
+    context.debug(`...added the '${variableString}' variable to the scoped context.`);
   }
 
   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) {
-      const metavariableString = metavariable.getString();
-
-      context.trace(`A '${judgementString}' judgement for the '${metavariableString}' metavariable is already present.`);
-    } else {
-      this.judgements.push(judgement);
-
-      judgementAdded = true;
-
-      context.debug(`...added the '${judgementString}' judgement to the scoped context.`);
-    }
+    this.judgements.push(judgement);
 
-    return judgementAdded;
+    context.debug(`...added the '${judgementString}' judgement to the scoped context.`);
   }
 
   addSubproofOrProofAssertion(subproofOrProofAssertion) {
@@ -203,7 +162,7 @@ class ScopedContext extends Context {
   findJudgementByMetavariableName(metavariableName) {
     const judgements = this.getJudgements(),
           judgement = judgements.find((judgement) => {
-            const judgementMetavariableComparesToMetavariable = judgement.matchMetavariableName(metavariableName);
+            const judgementMetavariableComparesToMetavariable = judgement.compareMetavariableName(metavariableName);
 
             if (judgementMetavariableComparesToMetavariable) {
               return true;
@@ -213,8 +172,8 @@ class ScopedContext extends Context {
     return judgement;
   }
 
-  findVariableByVariableIdentifier(variableIdentifier, nested = true) {
-    const variables = this.getVariables(nested),
+  findVariableByVariableIdentifier(variableIdentifier) {
+    const variables = this.getVariables(),
           variable = variables.find((variable) => {
             const variableComparesToVariableIdentifier = variable.compareVariableIdentifier(variableIdentifier);
 
@@ -236,7 +195,7 @@ class ScopedContext extends Context {
 
     const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
         const groundedTermNode = groundedTerm.getNode(),
-              groundedTermNodeMatches = term.matchNode(groundedTermNode);
+              groundedTermNodeMatches = term.matchTermNode(groundedTermNode);
 
             if (groundedTermNodeMatches) {
               return true;
@@ -254,8 +213,8 @@ class ScopedContext extends Context {
     return judgementPresent;
   }
 
-  isVariablePresentByVariableIdentifier(variableIdentifier, nested = true) {
-    const variable = this.findVariableByVariableIdentifier(variableIdentifier, nested),
+  isVariablePresentByVariableIdentifier(variableIdentifier) {
+    const variable = this.findVariableByVariableIdentifier(variableIdentifier),
           variablePresent = (variable !== null);
 
     return variablePresent;

package/src/context.js

@@ -33,11 +33,18 @@ export default class Context extends ContextBase {
 
   getFrames() {
     const context = this.getContext(),
-          frames = context.getFrames();
+      frames = context.getFrames();
 
     return frames;
   }
 
+  getEqualities() {
+    const context = this.getContext(),
+          equalities = context.getEqualities();
+
+    return equalities;
+  }
+
   getStatements() {
     const context = this.getContext(),
           statements = context.getStatements();
@@ -52,6 +59,13 @@ export default class Context extends ContextBase {
     return references;
   }
 
+  getEquivalences() {
+    const context = this.getContext(),
+          equivalences = context.getEquivalences();
+
+    return equivalences;
+  }
+
   getSubstitutions() {
     const context = this.getContext(),
           substitutions = context.getSubstitutions();
@@ -102,20 +116,55 @@ export default class Context extends ContextBase {
     return metavariable;
   }
 
-  findProcedureByProcedureName(procedureName) {
+  findRuleByReference(reference) {
     const context = this.getContext(),
-          procedure = context.findProcedureByProcedureName(procedureName);
+      rule = context.findRuleByReference(reference);
 
-    return procedure;
+    return rule;
+  }
+
+  findTopLevelAssertionByReference(reference) {
+    const context = this.getContext(),
+          topLevelAssertion = context.findTopLevelAssertionByReference(reference);
+
+    return topLevelAssertion;
+  }
+
+  findMetaTypeByMetaTypeName(metaTypeName) {
+    const context = this.getContext(),
+          metaType = context.findMetaTypeByMetaTypeName(metaTypeName);
+
+    return metaType;
+  }
+
+  findTermByTermNode(termNode) {
+    const context = this.getContext(),
+          term = context.findTermByTermNode(termNode);
+
+    return term;
   }
 
   findFrameByFrameNode(frameNode) {
     const context = this.getContext(),
-          frame = context.findFrameByFrameNode(frameNode);
+      frame = context.findFrameByFrameNode(frameNode);
 
     return frame;
   }
 
+  findEqualityByEqualityNode(equalityNode) {
+    const context = this.getContext(),
+      equality = context.findEqualityByEqualityNode(equalityNode);
+
+    return equality;
+  }
+
+  findJudgementByJudgementNode(judgementNode) {
+    const context = this.getContext(),
+          judgement = context.findJudgementByJudgementNode(judgementNode);
+
+    return judgement;
+  }
+
   findStatementByStatementNode(statementNode) {
     const context = this.getContext(),
           statement = context.findStatementByStatementNode(statementNode);
@@ -180,32 +229,40 @@ export default class Context extends ContextBase {
     return substitution;
   }
 
-  findRuleByReference(reference) {
+  findProcedureByProcedureName(procedureName) {
     const context = this.getContext(),
-          rule = context.findRuleByReference(reference);
+      procedure = context.findProcedureByProcedureName(procedureName);
 
-    return rule;
+    return procedure;
   }
 
-  findTopLevelAssertionByReference(reference) {
+  isMetavariablePresent(metavariable) {
+    metavariable = this.findMetavariable(metavariable); ///
+
+    const metavariablePresent = (metavariable !== null);
+
+    return metavariablePresent;
+  }
+
+  isLabelPresentByReference(reference) {
     const context = this.getContext(),
-          topLevelAssertion = context.findTopLevelAssertionByReference(reference);
+          labelPresent = context.isLabelPresentByReference(reference);
 
-    return topLevelAssertion;
+    return labelPresent;
   }
 
-  isTermPresentByTermNode(termNode) {
+  isMetavariablePresentByReference(reference) {
     const context = this.getContext(),
-          termPresent = context.isTermPresentByTermNode(termNode);
+          metavariablePresent = context.isMetavariablePresentByReference(reference);
 
-    return termPresent;
+    return metavariablePresent;
   }
 
-  isProcedurePresentByProcedureName(procedureName) {
+  isTermPresentByTermNode(termNode) {
     const context = this.getContext(),
-          procedurePresent = context.isProcedurePresentByProcedureName(procedureName);
+          termPresent = context.isTermPresentByTermNode(termNode);
 
-    return procedurePresent;
+    return termPresent;
   }
 
   isFramePresentByFrameNode(frameNode) {
@@ -215,6 +272,20 @@ export default class Context extends ContextBase {
     return framePresent;
   }
 
+  isJudgementPresentByJudgementNode(judgementNode) {
+    const context = this.getContext(),
+          judgementPresent = context.isJudgementPresentByJudgementNode(judgementNode);
+
+    return judgementPresent;
+  }
+
+  isEqualityPresentByEqualityNode(equalityNode) {
+    const context = this.getContext(),
+          equalityPresent = context.isEqualityPresentByEqualityNode(equalityNode);
+
+    return equalityPresent;
+  }
+
   isStatementPresentByStatementNode(statementNode) {
     const context = this.getContext(),
       statementPresent = context.isStatementPresentByStatementNode(statementNode);
@@ -229,9 +300,9 @@ export default class Context extends ContextBase {
     return assertionPresent;
   }
 
-  isReferencePresentByReferenceNode(referenceNode) {
+  isReferencePresentByMetavariableNode(metvvariableNode) {
     const context = this.getContext(),
-          referencePresent = context.isReferencePresentByReferenceNode(referenceNode);
+          referencePresent = context.isReferencePresentByMetavariableNode(metvvariableNode);
 
     return referencePresent;
   }
@@ -250,30 +321,17 @@ export default class Context extends ContextBase {
     return substitutionPresent;
   }
 
-  isLabelPresentByReference(reference) {
-    const context = this.getContext(),
-          labelPresent = context.isLabelPresentByReference(reference);
-
-    return labelPresent;
-  }
-
-  isMetavariablePresentByReference(reference) {
+  isProcedurePresentByProcedureName(procedureName) {
     const context = this.getContext(),
-          metavariablePresent = context.isMetavariablePresentByReference(reference);
-
-    return metavariablePresent;
-  }
-
-  addRule(rule) {
-    const context = this.getContext();
+          procedurePresent = context.isProcedurePresentByProcedureName(procedureName);
 
-    context.addRule(rule);
+    return procedurePresent;
   }
 
-  adTerm(term) {
+  addTerm(term) {
     const context = this.getContext();
 
-    context.adTerm(term);
+    context.addTerm(term);
   }
 
   addFrame(frame) {
@@ -295,10 +353,9 @@ export default class Context extends ContextBase {
   }
 
   addJudgement(judgement) {
-    const context = this.getContext(),
-          judgementAdded = context.addJudgement(judgement);
+    const context = this.getContext();
 
-    return judgementAdded;
+    context.addJudgement(judgement);
   }
 
   addSubstitution(substitution) {
@@ -307,12 +364,6 @@ export default class Context extends ContextBase {
     context.addSubstitution(substitution);
   }
 
-  removeSubstitution(substitution) {
-    const context = this.getContext();
-
-    context.removeSubstitution(substitution);
-  }
-
   addSubproofOrProofAssertion(subproofOrProofAssertion) {
     const context = this.getContext();
 

package/src/element/assertion/contained.js

@@ -72,6 +72,10 @@ export default define(class ContainedAssertion extends Assertion {
       }
 
       if (validates) {
+        const assertion = this; ///
+
+        context.addAssertion(assertion);
+
         context.debug(`...validated the '${containedAssertionString}' contained assertion.`);
       }
     }

package/src/element/assertion/defined.js

@@ -66,6 +66,10 @@ export default define(class DefinedAssertion extends Assertion {
       }
 
       if (validates) {
+        const assertion = this; ///
+
+        context.addAssertion(assertion);
+
         context.debug(`...validates the '${definedAssertionString}' defined assertion.`);
       }
     }
@@ -88,9 +92,9 @@ export default define(class DefinedAssertion extends Assertion {
         context.debug(`The '${termString}' term is not singular.`);
       } else {
         termValidates = this.term.validate(context, () => {
-          const verifiesForwards = true;
+          const validatesForwards = true;
 
-          return verifiesForwards;
+          return validatesForwards;
         });
 
         if (termValidates) {

package/src/element/assertion/property.js

@@ -1,10 +1,9 @@
 "use strict";
 
-import elements from "../../elements";
 import Assertion from "../assertion";
 
 import { define } from "../../elements";
-import { variableAssignmentFromVariable } from "../../process/assign";
+import { variableAssignmentFromPrepertyAssertion } from "../../process/assign";
 
 export default define(class PropertyAssertion extends Assertion {
   constructor(context, string, node, term, propertyRelation) {
@@ -76,7 +75,7 @@ export default define(class PropertyAssertion extends Assertion {
 
         if (propertyRelationVerifies) {
           let validatesWhenStated = false,
-            validatesWhenDerived = false;
+              validatesWhenDerived = false;
 
           if (stated) {
             validatesWhenStated = this.validateWhenStated(assignments, context);
@@ -91,12 +90,12 @@ export default define(class PropertyAssertion extends Assertion {
       }
 
       if (validates) {
-        if (stated) {
-          this.assign(assignments, context);
-        }
-      }
+        const assertion = this; ///
+
+        context.addAssertion(assertion);
+
+        this.assign(assignments, stated, context);
 
-      if (validates) {
         context.debug(`...validated the '${propertyAssertionString}' property assertion.`);
       }
     }
@@ -172,30 +171,20 @@ export default define(class PropertyAssertion extends Assertion {
     return validatesWhenDerived;
   }
 
-  assign(assignments, context) {
+  assign(assignments, stated, context) {
     if (assignments === null) {
       return;
     }
 
-    let variable;
-
-    const { Variable } = elements,
-          termNode = this.term.getNode();
-
-    variable = Variable.fromTermNode(termNode, context);
-
-    if (variable !== null) {
-      const variableIdentifier = variable.getIdentifier();
-
-      variable = context.findVariableByVariableIdentifier(variableIdentifier);
-
-      variable = Variable.fromVariableAndPropertyRelation(variable, this.propertyRelation);
+    if (!stated) {
+      return;
+    }
 
-      const variableAssignment = variableAssignmentFromVariable(variable),
-            assignment = variableAssignment;  ///
+    const propertyAssertion = this, ///
+          variableAssigment = variableAssignmentFromPrepertyAssertion(propertyAssertion, context),
+          assignment = variableAssigment; ///
 
-      assignments.push(assignment);
-    }
+    assignments.push(assignment);
   }
 
   static name = "PropertyAssertion";

package/src/element/assertion/satisfies.js

@@ -54,6 +54,10 @@ export default define(class SatisfiesAssertion extends Assertion {
       }
 
       if (validates) {
+        const assertion = this; ///
+
+        context.addAssertion(assertion);
+
         context.debug(`...validated the '${satisfiesAssertionString}' satisfies assertion.`);
       }
     }

package/src/element/assertion/subproof.js

@@ -48,6 +48,10 @@ export default define(class SubproofAssertion extends Assertion {
       }
 
       if (validates) {
+        const assertion = this; ///
+
+        context.addAssertion(assertion);
+
         context.debug(`...validated the '${subproofAssertionString}' subproof assertion.`);
       }
     }