occam-verify-cli 1.0.612 → 1.0.631

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);
 
@@ -41,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;
 
@@ -148,10 +161,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 +221,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 +262,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;
+        }
       }
     }
 
@@ -313,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/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; ///
 
@@ -53,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;
   }
@@ -100,7 +87,7 @@ export default define(class Reference extends Element {
   }
 
   compareMetavariable(metavariable) {
-    let metavaraibleComparseTo = false;
+    let comparesToMetavariable = false;
 
     let metavariableName;
 
@@ -113,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;
@@ -167,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

@@ -43,6 +43,13 @@ export default define(class Rule extends Element {
     return this.conclusion;
   }
 
+  getRuleNode() {
+    const node = this.getNode(),
+          ruleNode = node;  ///
+
+    return ruleNode;
+  }
+
   compareMetavariableName(metavariableName) {
     const comparesToMetavariableName = this.labels.some((label) => {
       const labelComparesToMetavariableName = label.compareMetavariableName(metavariableName);
@@ -125,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;
             }
           }
@@ -137,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.`);
     }
 
@@ -177,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;
       }
     });
 
@@ -221,15 +226,7 @@ export default define(class Rule extends Element {
       const subproofOrProofAssertionsUnifiesWithPremises = await this.unifySubproofOrProofAssertionsWithPremises(subproofOrProofAssertions, context);
 
       if (subproofOrProofAssertionsUnifiesWithPremises) {
-        const specificContext = context;  ///
-
-        context = this.getContext();
-
-        const generalContext = context; ///
-
-        context = specificContext;  ///
-
-        const substitutionsResolved = context.areSubstitutionsResolved(generalContext, specificContext);
+        const substitutionsResolved = context.areSubstitutionsResolved();
 
         if (substitutionsResolved) {
           statementAndSubproofOrProofAssertionsUnify = true;

package/src/element/section.js

@@ -35,6 +35,13 @@ export default define(class Section extends Element {
     return this.conjecture;
   }
 
+  getSectionNode() {
+    const node = this.getNode(),
+          sectionNode = node; ///
+
+    return sectionNode;
+  }
+
   verifyHypotheses() {
     const hypothesesVerify = this.hypotheses.every((hypothesis) => {
       const hypothesisVerifies = hypothesis.verify(this.context);

package/src/element/signature.js

@@ -20,6 +20,13 @@ export default define(class Signature extends Element {
     return this.terms;
   }
 
+  getSignatureNode() {
+    const node = this.getNode(),
+          signatureNode = node; ///
+
+    return signatureNode;
+  }
+
   verify(context) {
     let verifies;
 

package/src/element/statement.js

@@ -11,30 +11,25 @@ import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 const { match, backwardsSome } = arrayUtilities;
 
 export default define(class Statement extends Element {
-  constructor(context, string, node) {
-    super(context, string, node);
-  }
-
-  isSingular() {
+  getStatementNode() {
     const node = this.getNode(),
-          statementNode = node, ///
-          singular = statementNode.isSingular();
+          statementNode = node; ///
 
-    return singular;
+    return statementNode;
   }
 
   getMetavariableName() {
-    const node = this.getNode(),
-          metavariableName = node.getMetavariableName();
+    const sttaementNode = this.getStatementNode(),
+          metavariableName = sttaementNode.getMetavariableName();
 
     return metavariableName;
   }
 
-  getStatementNode() {
-    const node = this.getNode(),
-          statementNode = node; ///
+  isSingular() {
+    const statementNode = this.getStatementNode(),
+          singular = statementNode.isSingular();
 
-    return statementNode;
+    return singular;
   }
 
   matchStatementNode(statementNode) {
@@ -49,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();
 
@@ -61,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) {
@@ -95,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;
@@ -135,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;
 
@@ -180,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

@@ -20,6 +20,13 @@ export default define(class SubDerivation extends Element {
     return this.subproofOrProofAssertions;
   }
 
+  getSubDerivationNode() {
+    const node = this.getNode(),
+          subDerivationNode = node; ///
+
+    return subDerivationNode;
+  }
+
   getLastProofAssertion() {
     const lastSubproofOrProofAssertion = last(this.subproofOrProofAssertions),
           lastProofAssertion = lastSubproofOrProofAssertion;  ///
@@ -35,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/subproof.js

@@ -21,6 +21,13 @@ export default define(class Subproof extends Element {
     return this.subDerivation;
   }
 
+  getSubproofNode() {
+    const node = this.getNode(),
+          subproofNode = node;  ///
+
+    return subproofNode;
+  }
+
   getLastProofAssertion() { return this.subDerivation.getLastProofAssertion(); }
 
   getStatements() {

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(); }
 
@@ -99,9 +99,9 @@ export default define(class FrameSubstitution extends Substitution {
       }
 
       if (validates) {
-        const substititoin = this;  ///
+        const substitution = this;  ///
 
-        context.addSubstitution(substititoin);
+        context.addSubstitution(substitution);
 
         context.debug(`...validated the '${frameSubstitutionString}' frame substitution.`);
       }