occam-verify-cli 1.0.448 → 1.0.472

package/src/element/proofAssertion.js

@@ -25,7 +25,7 @@ export default class ProofAssertion extends Element {
     let comparesToStatement = false;
 
     const statementString = statement.getString(),
-          proofAssertionString = this.getString();
+          proofAssertionString = this.getString();  ///
 
     context.trace(`Comparing the '${statementString}' statement to the '${proofAssertionString}' proof assertion...`);
 
@@ -46,28 +46,39 @@ export default class ProofAssertion extends Element {
     return comparesToStatement;
   }
 
-  unifyStatement(statement, substitutions, context) {
-    let statementUnifies = false;
+  validateStatement(assignments, context) {
+    let statementValidates;
 
-    if (this.statement !== null) {
-      const node = this.getNode(),
-            premiseString = this.getString(), ///
-            statementString = statement.getString();
+    const statementString = this.statement.getString(),
+          proofAssertionString = this.getString();  ///
 
-      context.trace(`Unifying the '${statementString}' statement with the '${premiseString}' premise...`, node);
+    context.trace(`Validating the '${proofAssertionString}' proof assertion's '${statementString}' statement... `);
 
-      const specificContext = context;  ///
+    const stated = this.isStated();
 
-      context = this.getContext();  ///
+    statementValidates = this.statement.validate(assignments, stated, context);
 
-      const generalContext = context; ///
+    if (statementValidates) {
+      context.debug(`...validated the '${proofAssertionString}' proof assertion's '${statementString}' reference. `);
+    }
+
+    return statementValidates;
+  }
+
+  unifyStatement(statement, substitutions, generalContext, specificContext) {
+    let statementUnifies = false;
+
+    if (this.statement !== null) {
+      const context = specificContext, ///
+            statementString = statement.getString(),
+            proorAssertionString = this.getString();  ///
 
-      context = specificContext;  ///
+      context.trace(`Unifying the '${statementString}' statement with the '${proorAssertionString}' proof assertion...`);
 
       statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
 
       if (statementUnifies) {
-        context.debug(`...unified the '${statementString}' statement with the '${premiseString}' premise.`, node);
+        context.debug(`...unified the '${statementString}' statement with the '${proorAssertionString}' proof assertion.`);
       }
     }
 

package/src/element/propertyRelation.js

@@ -23,7 +23,7 @@ export default define(class PropertyRelation extends Element {
   verify(context) {
     let verifies = false;
 
-    const propertyRelationString = this.string; ///
+    const propertyRelationString = this.getString(); ///
 
     context.trace(`Verifying the '${propertyRelationString}' property relation...`);
 

package/src/element/reference.js

@@ -4,7 +4,9 @@ import Element from "../element";
 import elements from "../elements";
 
 import { define } from "../elements";
-import { referenceMetaTypeFromNothing } from "../metaTypes";
+import { attempt } from "../utilities/context";
+import { REFERENCE_META_TYPE_NAME } from "../metaTypeNames";
+import { findMetaTypeByMetaTypeName } from "../metaTypes";
 import { unifyMetavariableIntrinsically } from "../process/unify";
 import { metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
 
@@ -35,45 +37,62 @@ 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); }
 
-  verify(context) {
-    let verifies = false;
+  validate(context) {
+    let validate = false;
 
     const referenceString = this.getString(); ///
 
-    context.trace(`Verifying the '${referenceString}' reference...`);
+    context.trace(`Validating the '${referenceString}' reference...`);
 
-    if (!verifies) {
+    if (!validate) {
       const metavariableValidates = this.validateMetavariable(context);
 
-      verifies = metavariableValidates; ///
+      validate = metavariableValidates; ///
     }
 
-    if (!verifies) {
+    if (!validate) {
       const reference = this, ///
             labelPresent = context.isLabelPresentByReference(reference);
 
-      verifies = labelPresent;  ///
+      validate = labelPresent;  ///
     }
 
-    if (verifies) {
+    if (validate) {
       const reference = this; ///
 
       context.addReference(reference);
 
-      context.debug(`...verified the '${referenceString}' reference.`);
+      context.debug(`...validated the '${referenceString}' reference.`);
     }
 
-    return verifies;
+    return validate;
   }
 
   validateMetavariable(context) {
     let metavariableValidates = false;
 
-    const referenceMetaType = referenceMetaTypeFromNothing(),
+    const metaTypeName = REFERENCE_META_TYPE_NAME,
+          referenceMetaType = findMetaTypeByMetaTypeName(metaTypeName),
           metaType = referenceMetaType, ///
           metavariableValidatesGivenMetaType = this.metavariable.validateGivenMetaType(metaType, context);
 
@@ -84,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;  ///
 
@@ -104,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; ///
 
@@ -116,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.`);
@@ -141,27 +191,27 @@ export default define(class Reference extends Element {
     return metavariableUnifies;
   }
 
-  unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context) {
-    let metaLemmaMetatheoremUnifies;
+  unifyTopLevelMetaAssertion(topLevelMetaAssertion, context) {
+    let topLevelMetaAssertionUnifies;
 
     const reference = this, ///
           referenceString = reference.getString(),
-          metaLemmaMetatheoremString = metaLemmaMetatheorem.getString();
+          topLevelMetaAssertionString = topLevelMetaAssertion.getString();
 
-    context.trace(`Unifying the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${referenceString}' reference...`);
+    context.trace(`Unifying the '${topLevelMetaAssertionString}' top level meta-assertion with the '${referenceString}' reference...`);
 
     const { Substitutions } = elements,
-          label = metaLemmaMetatheorem.getLabel(),
-          substitutions = Substitutions.fromNothing(),
+          label = topLevelMetaAssertion.getLabel(),
+          substitutions = Substitutions.fromNothing(context),
           labelUnifies = this.unifyLabel(label, substitutions, context);
 
-    metaLemmaMetatheoremUnifies = labelUnifies;  ///
+    topLevelMetaAssertionUnifies = labelUnifies;  ///
 
-    if (metaLemmaMetatheoremUnifies) {
-      context.trace(`...unified the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${referenceString}' reference.`);
+    if (topLevelMetaAssertionUnifies) {
+      context.trace(`...unified the '${topLevelMetaAssertionString}' top level meta-assertion with the '${referenceString}' reference.`);
     }
 
-    return metaLemmaMetatheoremUnifies;
+    return topLevelMetaAssertionUnifies;
   }
 
   toJSON() {

package/src/element/rule.js

@@ -4,8 +4,8 @@ import { arrayUtilities } from "necessary";
 
 import Element from "../element";
 import elements from "../elements";
-import LocalContext from "../context/local";
 
+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 localContext = LocalContext.fromNothing(context);
-
-      context = localContext; ///
-
-      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,18 +38,18 @@ 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);
 
     const hypothesesVerify = this.verifyHypotheses();
 
     if (hypothesesVerify) {
-      const axiomLemmaTheoremOrConjecture = (this.axiom || this.lemma || this.theorem || this.conjecture),
-            axiomLemmaTheoremOrConjectureVerifies = axiomLemmaTheoremOrConjecture.verify(this.context);
+      const topLevelAssertion = (this.axiom || this.lemma || this.theorem || this.conjecture),
+            topLevelAssertionVerifies = topLevelAssertion.verify(this.context);
 
-      if (axiomLemmaTheoremOrConjectureVerifies) {
-        axiomLemmaTheoremOrConjecture.setHypotheses(this.hypotheses);
+      if (topLevelAssertionVerifies) {
+        topLevelAssertion.setHypotheses(this.hypotheses);
 
         verifies = true;
       }

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...`);