occam-verify-cli 1.0.617 → 1.0.632

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/signature.js

@@ -35,13 +35,13 @@ export default define(class Signature extends Element {
     context.trace(`Verifying the '${signatureString}' signature...`);
 
     verifies = this.terms.every((term) => {
-      const termVerifies = term.verify(context, () => {
-        const verifiesForwards = true;
+      const termValidates = term.validate(context, () => {
+        const validatesForwards = true;
 
-        return verifiesForwards;
+        return validatesForwards;
       });
 
-      if (termVerifies) {
+      if (termValidates) {
         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; ///
@@ -124,9 +126,9 @@ export default define(class TermSubstitution extends Substitution {
 
     if (targetTermSingular) {
       targetTermValidates = this.targetTerm.validate(context, () => {
-        const verifiesForwards = true;
+        const validatesForwards = true;
 
-        return verifiesForwards;
+        return validatesForwards;
       });
     } else {
       context.debug(`The '${termSubstitutionString}' term subtitution's '${targetTermString}' target term is not singular.`);

package/src/element/substitution.js

@@ -6,12 +6,6 @@ import { primitiveUtilities } from "occam-furtle";
 const { primitiveFromNode } =primitiveUtilities;
 
 export default class Substitution extends Element {
-  getSubstitution() {
-    const substitution = null;
-
-    return substitution;
-  }
-
   getPrimitive() {
     const context = this.getContext(),
           replacementNode = this.getReplacementNode(),
@@ -28,18 +22,6 @@ export default class Substitution extends Element {
     return substitutionNode;
   }
 
-  getNetavariableName() {
-    const metavariableName = null;
-
-    return metavariableName;
-  }
-
-  getVariableIdentifier() {
-    const variableIdentifier = null;
-
-    return variableIdentifier;
-  }
-
   matchSubstitutionNode(substitutionNode) {
     const substitutionNodeA = substitutionNode; ///
 
@@ -68,12 +50,6 @@ export default class Substitution extends Element {
     return equalTo;
   }
 
-  isSimple() {
-    const simple = true;
-
-    return simple;
-  }
-
   isComplex() {
     const simple = this.isSimple(),
           complex = !simple;
@@ -81,12 +57,6 @@ export default class Substitution extends Element {
     return complex;
   }
 
-  isTrivial() {
-    const trivial = false;
-
-    return trivial;
-  }
-
   isNonTrivial() {
     const trivial = this.isTrivial(),
           nonTrivlal = !trivial;
@@ -94,22 +64,64 @@ export default class Substitution extends Element {
     return nonTrivlal;
   }
 
+  getVariable() {
+    const variable = null;
+
+    return variable;
+  }
+
+  getSubstitution() {
+    const substitution = null;
+
+    return substitution;
+  }
+
+  getMetavariable() {
+    const metavariable = null;
+
+    return metavariable;
+  }
+
+  getMetavariableName() {
+    const metavariableName = null;
+
+    return metavariableName;
+  }
+
+  getVariableIdentifier() {
+    const variableIdentifier = null;
+
+    return variableIdentifier;
+  }
+
+  isSimple() {
+    const simple = true;
+
+    return simple;
+  }
+
+  isTermEqualToTerm(term) {
+    const termEqualToTerm = false;
+
+    return termEqualToTerm;
+  }
+
   isFrameEqualToFrame(frame) {
     const frameEqualToFrame = false;
 
     return frameEqualToFrame;
   }
 
-  isReferenceEqualToReference(reference) {
-    const referenceEqualToReference = false;
+  isStatementEqualToStatement(statement) {
+    const statementEqualToStatement = false;
 
-    return referenceEqualToReference;
+    return statementEqualToStatement;
   }
 
-  compare(substitution) {
-    const comparesToSubstitution = false;
+  isReferenceEqualToReference(reference) {
+    const referenceEqualToReference = false;
 
-    return comparesToSubstitution;
+    return referenceEqualToReference;
   }
 
   compareTerm(term, context) {
@@ -136,6 +148,18 @@ export default class Substitution extends Element {
     return compaaresToMetavariable;
   }
 
+  compareMetavariableName(metavariableName) {
+    const comparesToMetavariableName = false;
+
+    return comparesToMetavariableName;
+  }
+
+  compareVariableIdentifier(variableIdentifier) {
+    const comparesToVariableIdentifier = false;
+
+    return comparesToVariableIdentifier;
+  }
+
   resolve(substitutions, generalContext, specificContext) {
     const resolved = true;
 

package/src/element/term.js

@@ -44,12 +44,30 @@ export default define(class Term extends Element {
     termNode = this.getTermNode();
 
     const termNodeB = termNode, ///
-      termNodeAAMatchesTermBNodeB = termNodeA.match(termNodeB),
-      equalTo = termNodeAAMatchesTermBNodeB; ///
+          termNodeAAMatchesTermBNodeB = termNodeA.match(termNodeB),
+          equalTo = termNodeAAMatchesTermBNodeB; ///
 
     return equalTo;
   }
 
+  compareVariableIdentifier(variableIdentifier) {
+    let comparesToVariableIdentifier = false;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      const variableIdentifierA = variableIdentifier; ///
+
+      variableIdentifier = this.getVariableIdentifier();
+
+      const variableIdentifierB = variableIdentifier;
+
+      comparesToVariableIdentifier = (variableIdentifierA === variableIdentifierB);
+    }
+
+    return comparesToVariableIdentifier;
+  }
+
   isValid(context) {
     const termNode = this.getTermNode(),
           termPresent = context.isTermPresentByTermNode(termNode),
@@ -130,7 +148,7 @@ export default define(class Term extends Element {
     return comparesToParamter;
   }
 
-  validate(context, verifyForwards) {
+  validate(context, validateForwards) {
     let validates;
 
     const termString = this.getString();  ///
@@ -144,9 +162,10 @@ export default define(class Term extends Element {
 
       context.debug(`...the '${termString}' term is already valid.`);
     } else {
+      const term = this;  ///
+
       validates = validateTerms.some((validateTerm) => {  ///
-        const term = this, ///
-              termValidates = validateTerm(term, context, verifyForwards);
+        const termValidates = validateTerm(term, context, validateForwards);
 
         if (termValidates) {
           return true;

package/src/element/topLevelAssertion.js

@@ -255,15 +255,13 @@ export default class TopLevelAssertion extends Element {
             suppositionVerifies = await supposition.verify(assignments, context)
 
       if (suppositionVerifies) {
-        const assignmentsAssigned = assignAssignments(assignments, context);
+        assignAssignments(assignments, context);
 
-        if (assignmentsAssigned) {
-          const subproofOrProofAssertion = supposition;  ////
+        const subproofOrProofAssertion = supposition;  ////
 
-          context.addSubproofOrProofAssertion(subproofOrProofAssertion);
+        context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
-          return true;
-        }
+        return true;
       }
     });
 

package/src/element/topLevelMetaAssertion.js

@@ -159,15 +159,13 @@ export default class TopLevelMetaAssertion extends Element {
             suppositionVerifies = await supposition.verify(assignments, context)
 
       if (suppositionVerifies) {
-        const assignmentsAssigned = assignAssignments(assignments, context);
+        assignAssignments(assignments, context);
 
-        if (assignmentsAssigned) {
-          const subproofOrProofAssertion = supposition;  ////
+        const subproofOrProofAssertion = supposition;  ////
 
-          context.addSubproofOrProofAssertion(subproofOrProofAssertion);
+        context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
-          return true;
-        }
+        return true;
       }
     });
 

package/src/element/variable.js

@@ -2,6 +2,8 @@
 
 import { Element } from "occam-languages";
 
+import elements from "../elements";
+
 import { define } from "../elements";
 import { typeToTypeJSON } from "../utilities/json";