occam-verify-cli 1.0.457 → 1.0.473

package/src/element/reference.js

@@ -4,6 +4,7 @@ import Element from "../element";
 import elements from "../elements";
 
 import { define } from "../elements";
+import { attempt } from "../utilities/context";
 import { REFERENCE_META_TYPE_NAME } from "../metaTypeNames";
 import { findMetaTypeByMetaTypeName } from "../metaTypes";
 import { unifyMetavariableIntrinsically } from "../process/unify";
@@ -36,6 +37,22 @@ export default define(class Reference extends Element {
 
   isMetavariableEqualToMetavariable(metavariable) { return this.metavariable.isEqualTo(metavariable); }
 
+  compareParameter(parameter) {
+    let comparesToParamter = false;
+
+    const parameterName = parameter.getName();
+
+    if (parameterName !== null) {
+      const metavariableName = this.getMetavariableName();
+
+      if (parameterName === metavariableName) {
+        comparesToParamter = true;
+      }
+    }
+
+    return comparesToParamter;
+  }
+
   compareMetavariableName(metavariableName) { return this.metavariable.compareMetavariableName(metavariableName); }
 
   matchMetavariableNode(metavariableNode) { return this.metavariable.matchNode(metavariableNode); }
@@ -86,12 +103,34 @@ export default define(class Reference extends Element {
     return metavariableValidates;
   }
 
-  unifyLabel(label, substitutions, context) {
+  validateAsMetavariable(context) {
+    let validatesAsMetavariable = false;
+
+    const referenceString = this.getString();
+
+    context.trace(`Validating the '${referenceString}' reference as a metavaraible...`);
+
+    const metavariable = this.getMetavariable(),
+          metavariableName = metavariable.getName(),
+          metavariablePresent = context.isMetavariablePresentByMetavariableName(metavariableName);
+
+    if (metavariablePresent) {
+      validatesAsMetavariable = true;
+    }
+
+    if (validatesAsMetavariable) {
+      context.debug(`...validated the '${referenceString}' reference as a metavaraible.`);
+    }
+
+    return validatesAsMetavariable;
+  }
+
+  unifyLabel(label, context) {
     let labelUnifies;
 
     const specificContext = context; ///
 
-    context = label.getContext();
+    context = this.getContext();
 
     const generalContext = context;  ///
 
@@ -106,7 +145,7 @@ export default define(class Reference extends Element {
     const labelMetavariable = label.getMetavariable(),
           generalMetavariable = this.metavariable,  ///
           specificMetavariable = labelMetavariable, ///
-          metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, substitutions, generalContext, specificContext);
+          metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, generalContext, specificContext);
 
     labelUnifies = metavariableUnifiesIntrinsically; ///
 
@@ -118,23 +157,32 @@ export default define(class Reference extends Element {
   }
 
   unifyMetavariable(metavariable, context) {
-    let metavariableUnifies;
+    let metavariableUnifies = false;
 
-    const reference = this, ///
-          metavariableString = metavariable.getString(),
-          referenceString = reference.getString();
+    const specificContext = context; ///
+
+    context = this.getContext();
+
+    const generalContext = context;  ///
+
+    context = specificContext;  ///
+
+    const referenceString = this.getString(), ///
+          metavariableString = metavariable.getString();
 
     context.trace(`Unifying the '${metavariableString}' metavariable with the '${referenceString}' reference...`);
 
-    const { Substitutions } = elements,
-          substitutions = Substitutions.fromNothing(),
-          generalContext = context, ///
-          specificContext = context,  ///
-          generalMetavariable = this.metavariable,  ///
-          specificMetavariable = metavariable, ///
-          metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, substitutions, generalContext, specificContext);
+    const metavariableUnifiesIntrinsically = attempt((specificContext) => {
+      const generalMetavariable = this.metavariable,  ///
+            specificMetavariable = metavariable, ///
+            metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, generalContext, specificContext);
+
+      return metavariableUnifiesIntrinsically;
+    }, specificContext);
 
-    metavariableUnifies = metavariableUnifiesIntrinsically; ///
+    if (metavariableUnifiesIntrinsically) {
+      metavariableUnifies = true;
+    }
 
     if (metavariableUnifies) {
       context.debug(`...unified the '${metavariableString}' metavariable with the '${referenceString}' reference.`);
@@ -154,7 +202,7 @@ export default define(class Reference extends Element {
 
     const { Substitutions } = elements,
           label = topLevelMetaAssertion.getLabel(),
-          substitutions = Substitutions.fromNothing(),
+          substitutions = Substitutions.fromNothing(context),
           labelUnifies = this.unifyLabel(label, substitutions, context);
 
     topLevelMetaAssertionUnifies = labelUnifies;  ///

package/src/element/rule.js

@@ -4,8 +4,8 @@ import { arrayUtilities } from "necessary";
 
 import Element from "../element";
 import elements from "../elements";
-import ScopedContext from "../context/scoped";
 
+import { scope } from "../utilities/context";
 import { define } from "../elements";
 import { labelsFromJSON,
          premisesFromJSON,
@@ -57,44 +57,38 @@ export default define(class Rule extends Element {
   verify() {
     let verifies = false;
 
-    let context;
-
-    const node = this.getNode();
-
-    context = this.getContext();
-
-    const ruleString = this.getString(); ///
+    const node = this.getNode(),
+          context = this.getContext(),
+          ruleString = this.getString(); ///
 
     context.trace(`Verifying the '${ruleString}' rule...`, node);
 
-    const labelsVerify = this.verifyLabels();
-
-    if (labelsVerify) {
-      const scopedContext = ScopedContext.fromNothing(context);
-
-      context = scopedContext; ///
-
-      const premisesVerify = this.verifyPremises(context);
-
-      if (premisesVerify) {
-        const conclusionVerifies = this.verifyConclusion(context);
+    scope((context) => {
+      const labelsVerify = this.verifyLabels();
 
-        if (conclusionVerifies) {
-          const proofVerifies = this.verifyProof(context);
+      if (labelsVerify) {
+        const premisesVerify = this.verifyPremises(context);
 
-          if (proofVerifies) {
-            const rule = this,  ///
-                  context = this.getContext();
+        if (premisesVerify) {
+          const conclusionVerifies = this.verifyConclusion(context);
 
-            context.addRule(rule);
+          if (conclusionVerifies) {
+            const proofVerifies = this.verifyProof(context);
 
-            verifies = true;
+            if (proofVerifies) {
+              verifies = true;
+            }
           }
         }
       }
-    }
+
+    }, context);
 
     if (verifies) {
+      const rule = this;  ///
+
+      context.addRule(rule);
+
       context.debug(`...verified the '${ruleString}' rule.`, node);
     }
 
@@ -145,7 +139,7 @@ export default define(class Rule extends Element {
       proofVerifies = true;
     } else {
       const { Substitutions } = elements,
-            substitutions = Substitutions.fromNothing();
+            substitutions = Substitutions.fromNothing(context);
 
       proofVerifies = this.proof.verify(substitutions, this.conclusion, context);
     }
@@ -169,7 +163,7 @@ export default define(class Rule extends Element {
     let statementAndSubproofOrProofAssertionsUnify = false;
 
     const { Substitutions } = elements,
-          substitutions = Substitutions.fromNothing(),
+          substitutions = Substitutions.fromNothing(context),
           statementUnifiesWithConclusion = this.unifyStatementWithConclusion(statement, substitutions, context);
 
     if (statementUnifiesWithConclusion) {
@@ -190,14 +184,6 @@ export default define(class Rule extends Element {
   unifySubproofOrProofAssertionsWithPremise(subproofOrProofAssertions, premise, substitutions, context) {
     let subproofOrProofAssertionsUnifiesWithPremise = false;
 
-    if (!subproofOrProofAssertionsUnifiesWithPremise) {
-      const premiseUnifiesIndependently = premise.unifyIndependently(substitutions, context);
-
-      if (premiseUnifiesIndependently) {
-        subproofOrProofAssertionsUnifiesWithPremise = true;
-      }
-    }
-
     if (!subproofOrProofAssertionsUnifiesWithPremise) {
       const subproofOrProofAssertion = extract(subproofOrProofAssertions, (subproofOrProofAssertion) => {
         const subproofOrProofAssertionUnifies = premise.unifySubproofOrProofAssertion(subproofOrProofAssertion, substitutions, context);
@@ -212,6 +198,14 @@ export default define(class Rule extends Element {
       }
     }
 
+    if (!subproofOrProofAssertionsUnifiesWithPremise) {
+      const premiseUnifiesIndependently = premise.unifyIndependently(substitutions, context);
+
+      if (premiseUnifiesIndependently) {
+        subproofOrProofAssertionsUnifiesWithPremise = true;
+      }
+    }
+
     return subproofOrProofAssertionsUnifiesWithPremise;
   }
 

package/src/element/section.js

@@ -38,7 +38,7 @@ export default define(class Section extends Element {
   verify() {
     let verifies = false;
 
-    const sectionString = this.string;  ///
+    const sectionString = this.getString();  ///
 
     this.context.trace(`Verifying the '${sectionString}' section...`, this.node);
 

package/src/element/signature.js

@@ -6,6 +6,7 @@ import Element from "../element";
 import elements from "../elements";
 
 import { define } from "../elements";
+import { synthetically } from "../utilities/context";
 import { signatureStringFromTerms } from "../utilities/string";
 import { termsFromJSON, termsToTermsJSON } from "../utilities/json";
 
@@ -25,7 +26,7 @@ export default define(class Signature extends Element {
   verify(context) {
     let verifies;
 
-    const signatureString = this.string;  ///
+    const signatureString = this.getString();  ///
 
     context.trace(`Verifying the '${signatureString}' signature...`);
 
@@ -64,12 +65,11 @@ export default define(class Signature extends Element {
                     termTypeEqualToOrSubTypeOfVariableType = termType.isEqualToOrSubTypeOf(variableType);
 
               if (termTypeEqualToOrSubTypeOfVariableType) {
-                const { TermSubstitution } = elements,
-                      context = specificContext,  ///
-                      termSubstitution = TermSubstitution.fromTernAndVariable(term, variable, context),
-                      substitution = termSubstitution;  ///
+                synthetically((context) => {
+                  const { TermSubstitution } = elements;
 
-                substitutions.addSubstitution(substitution, context);
+                  TermSubstitution.fromTermAndVariable(term, variable, context);
+                });
 
                 return true;
               }
@@ -83,7 +83,7 @@ export default define(class Signature extends Element {
   compareSubstitutions(substitutions, context) {
     let substitutionsCompares = false;
 
-    const signatureString = this.string,  ///
+    const signatureString = this.getString(),  ///
           substitutionsString = substitutions.asString();
 
     context.trace(`Comparing the '${substitutionsString}' substitutions against the '${signatureString}' signature...`);
@@ -112,7 +112,7 @@ export default define(class Signature extends Element {
   correlateSubstitutions(substitutions, context) {
     let substitutionsCorrelates = false;
 
-    const signatureString = this.string,  ///
+    const signatureString = this.getString(),  ///
           substitutionsString = substitutions.asString();
 
     context.trace(`Correlating the '${substitutionsString}' substitutions against the '${signatureString}' signature...`);

package/src/element/statement.js

@@ -7,7 +7,6 @@ import Element from "../element";
 import { define } from "../elements";
 import { unifyStatement } from "../process/unify";
 import { validateStatements } from "../utilities/validation";
-import { instantiateStatement } from "../process/instantiate";
 import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 
 const { match, backwardsSome } = arrayUtilities;
@@ -17,18 +16,18 @@ export default define(class Statement extends Element {
     super(context, string, node);
   }
 
-  getMetavariableName() {
+  isSingular() {
     const node = this.getNode(),
-          metavariableName = node.getMetavariableName();
+          singular = node.isSingular();
 
-    return metavariableName;
+    return singular;
   }
 
-  isSingular() {
+  getMetavariableName() {
     const node = this.getNode(),
-          singular = node.isSingular();
+          metavariableName = node.getMetavariableName();
 
-    return singular;
+    return metavariableName;
   }
 
   isTermContained(term, context) {
@@ -38,7 +37,7 @@ export default define(class Statement extends Element {
           termString = term.getString(),
           statementString = this.getString();  ///
 
-    context.trace(`Is the '${termString}' term contained in the '${statementString}' statement...`, node);
+    context.trace(`Is the '${termString}' term contained in the '${statementString}' statement...`);
 
     const statementNode = node, ///
           statementNodeTermNodes = statementNode.getTermNodes();
@@ -52,7 +51,7 @@ export default define(class Statement extends Element {
     });
 
     if (termContained) {
-      context.debug(`...the '${termString}' term is contained in the '${statementString}' statement.`, node);
+      context.debug(`...the '${termString}' term is contained in the '${statementString}' statement.`);
     }
 
     return termContained;
@@ -61,13 +60,13 @@ export default define(class Statement extends Element {
   isFrameContained(frame, context) {
     let frameContained;
 
-    const node = this.getNode(),
-          frameString = frame.getString(),
+    const frameString = frame.getString(),
           statementString = this.getString();  ///
 
-    context.trace(`Is the '${frameString}' frame contained in the '${statementString}' statement...`, node);
+    context.trace(`Is the '${frameString}' frame contained in the '${statementString}' statement...`);
 
-    const statementNode = node,
+    const node = this.getNode(),
+          statementNode = node, ///
           statementNodeFrameNodes = statementNode.getFrameNodes();
 
     frameContained = statementNodeFrameNodes.some((statementNodeFrameNode) => {  ///
@@ -79,7 +78,7 @@ export default define(class Statement extends Element {
     });
 
     if (frameContained) {
-      context.debug(`...the '${frameString}' frame is contained in the '${statementString}' statement.`, node);
+      context.debug(`...the '${frameString}' frame is contained in the '${statementString}' statement.`);
     }
 
     return frameContained;
@@ -107,13 +106,32 @@ export default define(class Statement extends Element {
     return metavariableEqualToMetavariable;
   }
 
+  compareParameter(parameter) {
+    let comparesToParamter = false;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      const parameterName = parameter.getName();
+
+      if (parameterName !== null) {
+        const metavariableName = this.getMetavariableName();
+
+        if (parameterName === metavariableName) {
+          comparesToParamter = true;
+        }
+      }
+    }
+
+    return comparesToParamter;
+  }
+
   validate(assignments, stated, context) {
     let validates;
 
-    const node = this.getNode(),
-          statementString = this.getString();  ///
+    const statementString = this.getString();  ///
 
-    context.trace(`Validating the '${statementString}' statement...`, node);
+    context.trace(`Validating the '${statementString}' statement...`);
 
     validates = validateStatements.some((validateStatement) => {
       const statement = this, ///
@@ -129,7 +147,7 @@ export default define(class Statement extends Element {
 
       context.addStatement(statement);
 
-      context.debug(`...validated the '${statementString}' statement.`, node);
+      context.debug(`...validated the '${statementString}' statement.`);
     }
 
     return validates;
@@ -138,11 +156,10 @@ export default define(class Statement extends Element {
   validateGivenMetaType(metaType, assignments, stated, context) {
     let validatesGivenMetaType = false;
 
-    const node = this.getNode(),
-          metaTypeString = metaType.getString(),
+    const metaTypeString = metaType.getString(),
           statementString = this.getString();  ///
 
-    context.trace(`Validating the '${statementString}' statement given the '${metaTypeString}' meta-type...`, node);
+    context.trace(`Validating the '${statementString}' statement given the '${metaTypeString}' meta-type...`);
 
     const metaTypeName = metaType.getName();
 
@@ -153,7 +170,7 @@ export default define(class Statement extends Element {
     }
 
     if (validatesGivenMetaType) {
-      context.debug(`...validated the '${statementString}' statement given the '${metaTypeString}' meta-type.`, node);
+      context.debug(`...validated the '${statementString}' statement given the '${metaTypeString}' meta-type.`);
     }
 
     return validatesGivenMetaType;
@@ -163,13 +180,13 @@ export default define(class Statement extends Element {
     let subproofUnifies = false;
 
     const node = this.getNode(),
-          context = specificContext,  ///
-          statementNode = node,
+          statementNode = node, ///
           subproofAssertionNode = statementNode.getSubproofAssertionNode(),
           assertionNode = subproofAssertionNode;  ///
 
     if (assertionNode !== null) {
-      const assertion = generalContext.findAssertionByAssertionNode(assertionNode),
+      const context = generalContext, ///
+            assertion = context.findAssertionByAssertionNode(assertionNode),
             subproofAssertion = assertion;  ///
 
       const subproofString = subproof.getString(),
@@ -201,17 +218,18 @@ export default define(class Statement extends Element {
   unifyStatement(statement, substitutions, generalContext, specificContext) {
     let statementUnifies;
 
-    const generalStatement = this,  ///
+    const context = specificContext,  ///
+          generalStatement = this,  ///
           specificStatement = statement, ///
           generalStatementString = generalStatement.getString(),
           specificStatementString = specificStatement.getString();
 
-    specificContext.trace(`Unifying the '${specificStatementString}' statement with the '${generalStatementString}' statement...`);
+    context.trace(`Unifying the '${specificStatementString}' statement with the '${generalStatementString}' statement...`);
 
     statementUnifies = unifyStatement(generalStatement, specificStatement, substitutions, generalContext, specificContext);
 
     if (statementUnifies) {
-      specificContext.debug(`...unified the '${specificStatementString}' statement with the '${generalStatementString}' statement.`);
+      context.debug(`...unified the '${specificStatementString}' statement with the '${generalStatementString}' statement.`);
     }
 
     return statementUnifies;
@@ -231,8 +249,9 @@ export default define(class Statement extends Element {
           containedAssertionNode = statementNode.getContainedAssertionNode();
 
     if ((definedAssertionNode !== null) || (containedAssertionNode !== null)) {
-      const assertionNode = (definedAssertionNode || containedAssertionNode),
-            assertion = generalContext.findAssertionByAssertionNode(assertionNode),
+      const context = generalContext, ///
+            assertionNode = (definedAssertionNode || containedAssertionNode),
+            assertion = context.findAssertionByAssertionNode(assertionNode),
             assertionUnifiesIndependently = assertion.unifyIndependently(substitutions, generalContext, specificContext);
 
       if (assertionUnifiesIndependently) {
@@ -263,7 +282,7 @@ export default define(class Statement extends Element {
   }
 
   toJSON() {
-    const string = this.getString(),
+    const string = this.getString(),  ///
           json = {
             string
           };
@@ -274,14 +293,6 @@ export default define(class Statement extends Element {
   static name = "Statement";
 
   static fromJSON(json, context) {
-    const { string } = json,
-          statmentNode = instantiateStatement(string, context),
-          node = statmentNode;  ///,
-
-    context = null;
-
-    const statement = new Statement(context, string, node);
-
-    return statement;
+    ///
   }
 });

package/src/element/subproof.js

@@ -2,8 +2,8 @@
 
 import Element from "../element";
 import elements from "../elements";
-import ScopedContext from "../context/scoped";
 
+import { scope } from "../utilities/context";
 import { define } from "../elements";
 
 export default define(class Subproof extends Element {
@@ -49,25 +49,23 @@ export default define(class Subproof extends Element {
   verify(substitutions, assignments, context) {
     let verifies = false;
 
-    const scopedContext = ScopedContext.fromNothing(context);  ///
+    scope(() => {
+      const suppositionsVerify = this.suppositions.every((supposition) => {
+        const suppositionVerifies = supposition.verify(context);
 
-    context = scopedContext; ///
-
-    const suppositionsVerify = this.suppositions.every((supposition) => {
-      const suppositionVerifies = supposition.verify(context);
-
-      if (suppositionVerifies) {
-        return true;
-      }
-    });
+        if (suppositionVerifies) {
+          return true;
+        }
+      });
 
-    if (suppositionsVerify) {
-      const subDerivationVerifies = this.subDerivation.verify(substitutions, context);
+      if (suppositionsVerify) {
+        const subDerivationVerifies = this.subDerivation.verify(substitutions, context);
 
-      if (subDerivationVerifies) {
-        verifies = true;
+        if (subDerivationVerifies) {
+          verifies = true;
+        }
       }
-    }
+    }, context);
 
     return verifies;
   }
@@ -81,7 +79,7 @@ export default define(class Subproof extends Element {
   unifyWithSatisfiesAssertion(satisfiesAssertion, context) {
     let unifiesWithSatisfiesAssertion = false;
 
-    const subproofString = this.string, ///
+    const subproofString = this.getString(), ///
           satisfiesAssertionString = satisfiesAssertion.getString();
 
     context.trace(`Unifying the '${subproofString}' subproof with the '${satisfiesAssertionString}' satisfies assertion...`)
@@ -95,7 +93,7 @@ export default define(class Subproof extends Element {
       if (axiomSatisfiable) {
         const { Substitutions } = elements,
               subproof = this,  ///
-              substitutions = Substitutions.fromNothing(),
+              substitutions = Substitutions.fromNothing(context),
               statementUnifies = axiom.unifySubproof(subproof, substitutions, context);
 
         if (statementUnifies) {