occam-verify-cli 1.0.617 → 1.0.631

package/src/element/equivalence.js

@@ -5,9 +5,9 @@ import { arrayUtilities } from "necessary";
 
 import { define } from "../elements";
 import { literally } from "../utilities/context";
-import { termsStringFromTerms } from "../utilities/string";
 import { instantiateEquivalence } from "../process/instantiate";
 import { stripBracketsFromTermNode } from "../utilities/brackets";
+import { equivalenceStringFromTerms } from "../utilities/string";
 import { equivalenceFromEquivalenceNode } from "../utilities/element";
 
 const { compress } = arrayUtilities;
@@ -57,7 +57,7 @@ export default define(class Equivalence extends Element {
       if (termGrounded) {
         const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
           const groundedTermNode = groundedTerm.getNode(),
-                groundedTermNodeMatches = term.matchNode(groundedTermNode);
+                groundedTermNodeMatches = term.matchTermNode(groundedTermNode);
 
           if (groundedTermNodeMatches) {
             return true;
@@ -151,7 +151,7 @@ export default define(class Equivalence extends Element {
     termNode = stripBracketsFromTermNode(termNode); ///
 
     const termNodeMatches = this.someTerm((term) => {
-      const termNodeMatches = term.matchNode(termNode);
+      const termNodeMatches = term.matchTermNode(termNode);
 
       if (termNodeMatches) {
         return true;
@@ -234,8 +234,8 @@ export default define(class Equivalence extends Element {
 
     return literally((context) => {
       const terms = combinedTerms,  ///
-            termsString = termsStringFromTerms(terms),
-            string = termsString,  ///
+            equivalenceString = equivalenceStringFromTerms(terms),
+            string = equivalenceString,  ///
             equivalenceNode = instantiateEquivalence(string, context),
             equivalence = equivalenceFromEquivalenceNode(equivalenceNode, context);
 
@@ -248,8 +248,8 @@ export default define(class Equivalence extends Element {
   static fromEquality(equality, context) {
     return literally((context) => {
       const terms = equality.getTerms(),
-            termsString = termsStringFromTerms(terms),
-            string = termsString,  ///
+            equivalenceString = equivalenceStringFromTerms(terms),
+            string = equivalenceString,  ///
             equivalenceNode = instantiateEquivalence(string, context),
             equivalence = equivalenceFromEquivalenceNode(equivalenceNode, context);
 

package/src/element/equivalences.js

@@ -80,7 +80,7 @@ export default define(class Equivalences extends Element {
   }
 
   mergedWith(equivalences, context) {
-    let  mergedEquivalences = this.clone(); ///
+    let  mergedEquivalences = this.clone(context); ///
 
     equivalences.forEachEquivalence((equivalence) => {
       mergedEquivalences = mergedEquivalences.mergedWithEquivalence(equivalence, context);
@@ -139,7 +139,7 @@ export default define(class Equivalences extends Element {
   }
 
   separateGroundedTermsAndDefinedVariables(groundedTerms, definedVariables, context) {
-    let equivalences = this,
+    let equivalences = this,  ///
         groundedEquivalences,
         remainingEquivalences,
         initiallyGroundedEquivalences,
@@ -187,11 +187,13 @@ export default define(class Equivalences extends Element {
     }
   }
 
-  clone() {
-    const array = [
+  clone(context) {
+    const string = EMPTY_STRING,
+          node = null,
+          array = [
             ...this.array
           ],
-          equivalences = new Equivalences(array);
+          equivalences = new Equivalences(context, string, node, array);
 
     return equivalences;
   }

package/src/element/frame.js

@@ -51,9 +51,9 @@ export default define(class Frame extends Element {
 
     const frameNodeB = frameNode, ///
           frameNodeAAMatchesFrameBNodeB = frameNodeA.match(frameNodeB),
-          equalTo = frameNodeAAMatchesFrameBNodeB; ///
+          frameNodeMatches = frameNodeAAMatchesFrameBNodeB; ///
 
-    return equalTo;
+    return frameNodeMatches;
   }
 
   isValid(context) {
@@ -79,24 +79,6 @@ export default define(class Frame extends Element {
     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;
 
@@ -165,6 +147,24 @@ export default define(class Frame extends Element {
     return comparesToSubstitutions;
   }
 
+  compareMetavariableName(metavariableName) {
+    let comparesToMetavariableName = false;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      const metavariableNameA = metavariableName ///
+
+      metavariableName = this.getMetavariableName();
+
+      const metavariableNameB = metavariableName; ///
+
+      comparesToMetavariableName = (metavariableNameA === metavariableNameB);
+    }
+
+    return comparesToMetavariableName;
+  }
+
   validate(assignments, stated, context) {
     let validates = false;
 
@@ -184,7 +184,7 @@ export default define(class Frame extends Element {
 
       if (assumptionsValidate && metavariablevalidates) {
         let validatesWhenStated = false,
-              validatesWhenDerived = false;
+            validatesWhenDerived = false;
 
         if (stated) {
           validatesWhenStated = this.validateWhenStated(assignments, context);
@@ -289,12 +289,12 @@ export default define(class Frame extends Element {
 
       context.trace(`Validating the '${frameString}' frame's '${metavraibleString}' metavariable...`);
 
-      const metavariable = context.findMetavariable(this.metavariable);
+      const metavariablePresent = context.isMetavariablePresent(this.metavariable);
 
-      if (metavariable !== null) {
+      if (metavariablePresent) {
         const metaTypeName = FRAME_META_TYPE_NAME,
-              frameMetaType = findMetaTypeByMetaTypeName(metaTypeName),
-              metavariableValidateGivenMetaType = metavariable.validateGivenMetaType(frameMetaType, context);
+              frameMetaType = context.findMetaTypeByMetaTypeName(metaTypeName),
+              metavariableValidateGivenMetaType = this.metavariable.validateGivenMetaType(frameMetaType, context);
 
         if (metavariableValidateGivenMetaType) {
           metavariableValidates = true;

package/src/element/hypothesis.js

@@ -40,15 +40,13 @@ export default define(class Hypothesis extends Element {
             statementValidates = this.statement.validate(assignments, stated, context);
 
       if (statementValidates) {
-        const assignmentsAssigned = assignAssignments(assignments, context);
+        assignAssignments(assignments, context);
 
-        if (assignmentsAssigned) {
-          const subproofOrProofAssertion = this;  ///
+        const subproofOrProofAssertion = this;  ///
 
-          context.addSubproofOrProofAssertion(subproofOrProofAssertion);
+        context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
-          verifies = true;
-        }
+        verifies = true;
       }
     } else {
       context.debug(`Unable to verify the '${hypothesisString}' hypothesis because it is nonsense.`);

package/src/element/judgement.js

@@ -37,7 +37,27 @@ export default define(class Judgement extends Element {
 
   getMetavariable() { return this.frame.getMetavariable(); }
 
-  matchMetavariableName(metavariableName) { return this.frame.matchMetavariableName(metavariableName); }
+  compareMetavariableName(metavariableName) { return this.frame.compareMetavariableName(metavariableName); }
+
+  matchJudgementNode(judgementNode) {
+    const judgementNodeA = judgementNode; ///
+
+    judgementNode = this.getJudgementNode();
+
+    const judgementNodeB = judgementNode, ///
+          judgementNodeAAMatchesJudgementBNodeB = judgementNodeA.match(judgementNodeB),
+          judgementNodeMatches = judgementNodeAAMatchesJudgementBNodeB; ///
+
+    return judgementNodeMatches;
+  }
+
+  isValid(context) {
+    const judgementNode = this.getJudgementNode(),
+          judgementPresent = context.isJudgementPresentByJudgementNode(judgementNode),
+          valid = judgementPresent;  ///
+
+    return valid;
+  }
 
   validate(assignments, stated, context) {
     let validates = false;
@@ -46,35 +66,41 @@ export default define(class Judgement extends Element {
 
     context.trace(`Validating the '${judgementString}' judgement...`);
 
-    const frameValidates = this.frame.validate(assignments, stated, context);
+    const valid = this.isValid(context);
 
-    if (frameValidates) {
-      const assumptionValidates = this.assumption.validate(assignments, stated, context);
+    if (valid) {
+      validates = true;
 
-      if (assumptionValidates) {
-        let validatesWhenStated = false,
-            validatesWhenDerived = false;
+      context.debug(`...the '${judgementString}' judgement is already valid.`);
+    } else {
+      const frameValidates = this.frame.validate(assignments, stated, context);
 
-        if (stated) {
-          validatesWhenStated = this.validateWhenStated(assignments, context);
-        } else {
-          validatesWhenDerived = this.validateWhenDerived(context);
-        }
+      if (frameValidates) {
+        const assumptionValidates = this.assumption.validate(assignments, stated, context);
 
-        if (validatesWhenStated || validatesWhenDerived) {
-          validates = true;
+        if (assumptionValidates) {
+          let validatesWhenStated = false,
+              validatesWhenDerived = false;
+
+          if (stated) {
+            validatesWhenStated = this.validateWhenStated(assignments, context);
+          } else {
+            validatesWhenDerived = this.validateWhenDerived(context);
+          }
+
+          if (validatesWhenStated || validatesWhenDerived) {
+            validates = true;
+          }
         }
       }
-    }
 
-    if (validates) {
-      if (stated) {
-        this.assign(assignments, context);
-      }
-    }
+      if (validates) {
+        const judgement = this; ///
 
-    if (validates) {
-      context.debug(`...validated the '${judgementString}' judgement.`);
+        context.addJudgement(judgement)
+
+        context.debug(`...validated the '${judgementString}' judgement.`);
+      }
     }
 
     return validates;
@@ -120,13 +146,17 @@ export default define(class Judgement extends Element {
     return validatesWhenDerived;
   }
 
-  assign(assignments, context) {
+  assign(assignments, stated, context) {
     if (assignments === null) {
       return;
     }
 
+    if (!stated) {
+      return;
+    }
+
     const judgement = this, ///
-          judgementAssignment = judgementAssignmentFromJudgement(judgement),
+          judgementAssignment = judgementAssignmentFromJudgement(judgement, context),
           assignment = judgementAssignment; ///
 
     assignments.push(assignment);

package/src/element/metaType.js

@@ -48,7 +48,7 @@ export default define(class MetaType extends Element {
   static fromJSON(json, context) {
     const { name } = json,
           metaTypeName = name,  ///
-          metaType = findMetaTypeByMetaTypeName(metaTypeName);
+          metaType = context.findMetaTypeByMetaTypeName(metaTypeName);
 
     return metaType;
   }

package/src/element/metavariable.js

@@ -54,8 +54,9 @@ export default define(class Metavariable extends Element {
   }
 
   compare(metavariable) {
-    const name = metavariable.getName(),
-          comparesToMetavariable = (this.name === name);
+    const metavariableName = metavariable.getName(),
+          comparesToMetavariableName = this.compareMetavariableName(metavariableName),
+          comparesToMetavariable = comparesToMetavariableName;  ///
 
     return comparesToMetavariable;
   }
@@ -69,6 +70,18 @@ export default define(class Metavariable extends Element {
     return comparesToMetavariableName;
   }
 
+  matchMetavariableNode(metavariableNode) {
+    const metavariableNodeA = metavariableNode; ///
+
+    metavariableNode = this.getMetavariableNode();  ///
+
+    const metavariableNodeB = metavariableNode, ///
+          metavariableNodeAMatchesMetavariableNodeB = metavariableNodeA.match(metavariableNodeB),
+          metavariableNodeMatches = metavariableNodeAMatchesMetavariableNodeB;  ///
+
+    return metavariableNodeMatches;
+  }
+
   validate(context) {
     let validates = false;
 
@@ -306,7 +319,7 @@ export default define(class Metavariable extends Element {
 
     if (generalContextFilePath === specificContextFilePath) {
       const metavariableName = this.getMetavariableName(),  ///
-            frameMetavariableComparesToMetvariable = frame.matchMetavariableName(metavariableName);
+            frameMetavariableComparesToMetvariable = frame.compareMetavariableName(metavariableName);
 
       if (frameMetavariableComparesToMetvariable) {
         frameMetavariableUnifies = true;

package/src/element/reference.js

@@ -54,32 +54,18 @@ export default define(class Reference extends Element {
     return equalTo;
   }
 
-  matchMetavariableName(metavariableName) {
-    let metavariableNameMatches = false;
-
-    const metavariableNameA = metavariableName ///
-
-    metavariableName = this.getMetavariableName();
-
-    const metavariableNameB = metavariableName; ///
-
-    metavariableNameMatches = (metavariableNameA === metavariableNameB);
-
-    return metavariableNameMatches;
-  }
-
   isValid(context) {
-    const assertionNode = this.getReferenceNode(),
-          assertionPresent = context.isReferencePresentByReferenceNode(assertionNode),
-          valid = assertionPresent;  ///
+    const metavariableNode = this.getMetavariableNode(),
+          referencePresent = context.isReferencePresentByMetavariableNode(metavariableNode),
+          valid = referencePresent;  ///
 
     return valid;
   }
 
-  isEqualTo(assertion) {
-    const assertionNode = assertion.getNode(),
-          assertionNodeMatches = this.matchReferenceNode(assertionNode),
-          equalTo = assertionNodeMatches;  ///
+  isEqualTo(reference) {
+    const referenceNode = reference.getNode(),
+          referenceNodeMatches = this.matchReferenceNode(referenceNode),
+          equalTo = referenceNodeMatches;  ///
 
     return equalTo;
   }
@@ -101,7 +87,7 @@ export default define(class Reference extends Element {
   }
 
   compareMetavariable(metavariable) {
-    let metavaraibleComparseTo = false;
+    let comparesToMetavariable = false;
 
     let metavariableName;
 
@@ -114,15 +100,15 @@ export default define(class Reference extends Element {
     const metavariableNameB = metavariableName; ///
 
     if (metavariableNameA === metavariableNameB) {
-      metavaraibleComparseTo = true;
+      comparesToMetavariable = true;
     }
 
-    return metavaraibleComparseTo;
+    return comparesToMetavariable;
   }
 
   compareMetavariableName(metavariableName) { return this.metavariable.compareMetavariableName(metavariableName); }
 
-  matchMetavariableNode(metavariableNode) { return this.metavariable.matchNode(metavariableNode); }
+  matchMetavariableNode(metavariableNode) { return this.metavariable.matchMetavariableNode(metavariableNode); }
 
   validate(context) {
     let validates = false;
@@ -168,7 +154,7 @@ export default define(class Reference extends Element {
     context.trace(`Validating the '${referenceString}' reference's '${metavariableString}' metavariable....'`);
 
     const metaTypeName = REFERENCE_META_TYPE_NAME,
-          referenceMetaType = findMetaTypeByMetaTypeName(metaTypeName),
+          referenceMetaType = context.findMetaTypeByMetaTypeName(metaTypeName),
           metaType = referenceMetaType, ///
           metavariable = context.findMetavariable(this.metavariable);
 

package/src/element/rule.js

@@ -132,10 +132,6 @@ export default define(class Rule extends Element {
             const proofVerifies = await this.verifyProof(context);
 
             if (proofVerifies) {
-              const rule = this;  ///
-
-              context.addRule(rule);
-
               verifies = true;
             }
           }
@@ -144,6 +140,10 @@ export default define(class Rule extends Element {
     }, context);
 
     if (verifies) {
+      const rule = this;
+
+      context.addRule(rule);
+
       context.debug(`...verified the '${ruleString}' rule.`);
     }
 
@@ -184,15 +184,13 @@ export default define(class Rule extends Element {
             premiseVerifies = await premise.verify(assignments, context)
 
       if (premiseVerifies) {
-        const assignmentsAssigned = assignAssignments(assignments, context);
+        assignAssignments(assignments, context);
 
-        if (assignmentsAssigned) {
-          const subproofOrProofAssertion = premise;  ////
+        const subproofOrProofAssertion = premise;  ////
 
-          context.addSubproofOrProofAssertion(subproofOrProofAssertion);
+        context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
-          return true;
-        }
+        return true;
       }
     });
 

package/src/element/statement.js

@@ -44,8 +44,8 @@ export default define(class Statement extends Element {
     return equalTo;
   }
 
-  matchMetavariableName(metavariableName) {
-    let metavariableNameMatches = false;
+  compareMetavariableName(metavariableName) {
+    let comparesToMetavariableName = false;
 
     const singular = this.isSingular();
 
@@ -56,10 +56,10 @@ export default define(class Statement extends Element {
 
       const metavariableNameB = metavariableName; ///
 
-      metavariableNameMatches = (metavariableNameA === metavariableNameB);
+      comparesToMetavariableName = (metavariableNameA === metavariableNameB);
     }
 
-    return metavariableNameMatches;
+    return comparesToMetavariableName;
   }
 
   isValid(context) {
@@ -90,7 +90,7 @@ export default define(class Statement extends Element {
           statementNodeTermNodes = statementNode.getTermNodes();
 
     termContained = statementNodeTermNodes.some((statementNodeTermNode) => {  ///
-      const statementNodeTermNodeMatches = term.matchNode(statementNodeTermNode);
+      const statementNodeTermNodeMatches = term.matchTermNode(statementNodeTermNode);
 
       if (statementNodeTermNodeMatches) {
         return true;
@@ -130,31 +130,6 @@ export default define(class Statement extends Element {
     return frameContained;
   }
 
-  compareMetavariable(metavariable) {
-    let metavaraibleComparseTo;
-
-    const singular = this.isSingular();
-
-    if (singular) {
-      let metavariableName;
-
-      const statementNode = this.getStatementNode(),
-            singularMetavariableNode = statementNode.getSingularMetavariableNode();
-
-      metavariableName = singularMetavariableNode.getMetavariableName();
-
-      const metavariableNameA = metavariableName ///
-
-      metavariableName = metavariable.getName();
-
-      const metavariableNameB = metavariableName; ///
-
-      metavaraibleComparseTo = (metavariableNameA === metavariableNameB);
-    }
-
-    return metavaraibleComparseTo;
-  }
-
   compareParameter(parameter) {
     let comparesToParamter = false;
 
@@ -175,6 +150,28 @@ export default define(class Statement extends Element {
     return comparesToParamter;
   }
 
+  compareMetavariable(metavariable) {
+    let comparesToMetavariableName;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      let metavariableName;
+
+      metavariableName = metavariable.getName();
+
+      const metavariableNameA = metavariableName; ///
+
+      metavariableName = this.getMetavariableName();
+
+      const metavariableNameB = metavariableName; ///
+
+      comparesToMetavariableName = (metavariableNameA === metavariableNameB);
+    }
+
+    return comparesToMetavariableName;
+  }
+
   validate(assignments, stated, context) {
     let validates;
 

package/src/element/subDerivation.js

@@ -42,13 +42,11 @@ export default define(class SubDerivation extends Element {
             subproofOrProofAssertionVarifies = subproofOrProofAssertion.verify(substitutions, assignments, context);
 
       if (subproofOrProofAssertionVarifies) {
-        const assignmentsAssigned = assignAssignments(assignments, context);
+        assignAssignments(assignments, context);
 
-        if (assignmentsAssigned) {
-          context.addSubproofOrProofAssertion(subproofOrProofAssertion);
+        context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
-          return true;
-        }
+        return true;
       }
     });
 

package/src/element/substitution/frame.js

@@ -45,7 +45,7 @@ export default define(class FrameSubstitution extends Substitution {
     return replacementNode;
   }
 
-  matchMetavariableName(metavariableName) { return this.targetFrame.matchMetavariableName(metavariableName); }
+  compareMetavariableName(metavariableName) { return this.targetFrame.compareMetavariableName(metavariableName); }
 
   getMetavariableName() { return this.targetFrame.getMetavariableName(); }
 

package/src/element/substitution/reference.js

@@ -47,7 +47,7 @@ export default define(class ReferenceSubstitution extends Substitution {
 
   getMetavariableName() { return this.targetReference.getMetavariableName(); }
 
-  matchMetavariableName(metavariableName) { return this.targetReference.matchMetavariableName(metavariableName); }
+  compareMetavariableName(metavariableName) { return this.targetReference.compareMetavariableName(metavariableName); }
 
   isTrivial() {
     const targetReferenceEqualToReplacementReference = this.targetReference.isEqualTo(this.replacementReference),

package/src/element/substitution/statement.js

@@ -68,7 +68,7 @@ export default define(class StatementSubstitution extends Substitution {
 
   getMetavariableName() { return this.targetStatement.getMetavariableName(); }
 
-  matchMetavariableName(metavariableName) { return this.targetStatement.matchMetavariableName(metavariableName); }
+  compareMetavariableName(metavariableName) { return this.targetStatement.compareMetavariableName(metavariableName); }
 
   compareStatement(statement, context) {
     statement = stripBracketsFromStatement(statement, context); ///

package/src/element/substitution/term.js

@@ -48,6 +48,8 @@ export default define(class TermSubstitution extends Substitution {
 
   getVariableIdentifier() { return this.targetTerm.getVariableIdentifier(); }
 
+  compareVariableIdentifier(variableIdentifier) { return this.targetTerm.compareVariableIdentifier(variableIdentifier); }
+
   isTrivial() {
     const targetTermEqualToReplacementTerm = this.targetTerm.isEqualTo(this.replacementTerm),
           trivial = targetTermEqualToReplacementTerm; ///