occam-verify-cli 1.0.768 → 1.0.776

package/src/context/nested.js

@@ -0,0 +1,15 @@
+"use strict";
+
+import Context from "../context";
+
+export default class NestedContext extends Context {
+  addAssignment(assignment) {
+    ///
+  }
+
+  static fromNothing(context) {
+    const nestedContext = new NestedContext(context);
+
+    return nestedContext;
+  }
+}

package/src/context/{scoped.js → proof.js}

@@ -7,7 +7,7 @@ import elements from "../elements";
 
 const { last } = arrayUtilities;
 
-class ScopedContext extends Context {
+class ProofContext extends Context {
   constructor(context, variables, judgements, assignments, equivalences, subproofOrProofAssertions, metaLevelSubstitutions) {
     super(context);
 
@@ -134,7 +134,7 @@ class ScopedContext extends Context {
     const context = this, ///
           equalityString = equality.getString();
 
-    context.trace(`Adding the '${equalityString}' equality to the scoped context...`);
+    context.trace(`Adding the '${equalityString}' equality to the proof context...`);
 
     const equalityRelfexive = equality.isReflexive();
 
@@ -144,9 +144,9 @@ class ScopedContext extends Context {
 
       this.equivalences = this.equivalences.mergedWithEquivalence(equivalence, context);
 
-      context.debug(`...added the '${equalityString}' equality to the scoped context.`);
+      context.debug(`...added the '${equalityString}' equality to the proof context.`);
     } else {
-      context.debug(`The '${equalityString}' equality is reflexive and will not added to the scoped context.`);
+      context.debug(`The reflexive '${equalityString}' equality has not been added to the proof context.`);
     }
   }
 
@@ -154,37 +154,34 @@ class ScopedContext extends Context {
     const context = this, ///
           variableString = variable.getString();
 
-    context.trace(`Adding the '${variableString}' variable to the scoped context...`);
+    context.trace(`Adding the '${variableString}' variable to the proof context...`);
 
     this.variables.push(variable);
 
-    context.debug(`...added the '${variableString}' variable to the scoped context.`);
+    context.debug(`...added the '${variableString}' variable to the proof context.`);
   }
 
   addJudgement(judgement) {
     const context = this, ///
           judgementString = judgement.getString();
 
-    context.trace(`Adding the '${judgementString}' judgement to the scoped context...`);
+    context.trace(`Adding the '${judgementString}' judgement to the proof context...`);
 
     this.judgements.push(judgement);
 
-    context.debug(`...added the '${judgementString}' judgement to the scoped context.`);
+    context.debug(`...added the '${judgementString}' judgement to the proof context.`);
   }
 
   addAssignment(assignment) {
     this.assignments.push(assignment);
   }
 
-  addSubproofOrProofAssertion(subproofOrProofAssertion) {
-    const context = this, ///
-          subproofOrProofAssertionString = subproofOrProofAssertion.getString();
-
-    context.trace(`Adding the '${subproofOrProofAssertionString}' subproof or proof assertion to the scoped context...`);
-
-    this.subproofOrProofAssertions.push(subproofOrProofAssertion);
+  assignAssignments() {
+    const context = this; ///
 
-    context.debug(`...added the '${subproofOrProofAssertionString}' subproof or proof assertion to the scoped context.`);
+    this.assignments.forEach((assignment) => {
+      assignment(context);
+    });
   }
 
   addMetaLevelSubstitution(metaLevelSubstitution) {
@@ -198,7 +195,7 @@ class ScopedContext extends Context {
           metaLevelSubstitutionA = metaLevelSubstitution, ///
           metaLevelSubstitutionString = metaLevelSubstitution.getString();
 
-    context.trace(`Adding the '${metaLevelSubstitutionString}' meta-level substitution to the scoped context...`);
+    context.trace(`Adding the '${metaLevelSubstitutionString}' meta-level substitution to the proof context...`);
 
     const metaLevelSubstitutionB = this.metaLevelSubstitutions.find((metaLevelSubstitution) => {
       const metaLevelSubstitutionB = metaLevelSubstitution, ///
@@ -210,66 +207,37 @@ class ScopedContext extends Context {
     }) || null;
 
     if (metaLevelSubstitutionB !== null) {
-      context.debug(`The '${metaLevelSubstitutionString}' meta-level substitution has already been added to the scoped context.`);
+      context.debug(`The '${metaLevelSubstitutionString}' meta-level substitution has already been added to the proof context.`);
     } else {
       this.metaLevelSubstitutions.push(metaLevelSubstitution);
 
-      context.debug(`...added the '${metaLevelSubstitutionString}' substitution to the scoped context.`);
+      context.debug(`...added the '${metaLevelSubstitutionString}' substitution to the proof context.`);
     }
   }
 
-  assignAssignments() {
-    const context = this; ///
-
-    this.assignments.forEach((assignment) => {
-      assignment(context);
-    });
-  }
-
-  findEquivalenceByTerm(term) { return this.equivalences.findEquivalenceByTerm(term); }
+  addSubproofOrProofAssertion(subproofOrProofAssertion) {
+    const context = this, ///
+          subproofOrProofAssertionString = subproofOrProofAssertion.getString();
 
-  findJudgementByMetavariableName(metavariableName) {
-    const judgements = this.getJudgements(),
-          judgement = judgements.find((judgement) => {
-            const judgementMetavariableComparesToMetavariable = judgement.compareMetavariableName(metavariableName);
+    context.trace(`Adding the '${subproofOrProofAssertionString}' subproof or proof assertion to the proof context...`);
 
-            if (judgementMetavariableComparesToMetavariable) {
-              return true;
-            }
-          }) || null;
+    this.subproofOrProofAssertions.push(subproofOrProofAssertion);
 
-    return judgement;
+    context.debug(`...added the '${subproofOrProofAssertionString}' subproof or proof assertion to the proof context.`);
   }
 
-  findVariableByVariableIdentifier(variableIdentifier) {
-    const variables = this.getVariables(),
-          variable = variables.find((variable) => {
-            const variableComparesToVariableIdentifier = variable.compareVariableIdentifier(variableIdentifier);
+  compareTermAndPropertyRelation(term, propertyRelation) {
+    const context = this, ///
+          proofAssertions = this.getProofAssertions(),
+          comparesToTermAndPropertyRelation = proofAssertions.some((proofAssertion) => {
+            const comparesToTermAndPropertyRelation = proofAssertion.compareTermAndPropertyRelation(term, propertyRelation, context);
 
-            if (variableComparesToVariableIdentifier) {
+            if (comparesToTermAndPropertyRelation) {
               return true;
             }
-          }) || null;
-
-    return variable;
-  }
-
-  findMetaLevelSubstitutionByMetaLevelSubstitutionNode(metaLevelSubstitutionNode) {
-    let metaLevelSubstitution;
-
-    if (this.metaLevelSubstitutions === null) {
-      metaLevelSubstitution = super.findMetaLevelSubstitutionByMetaLevelSubstitutionNode(metaLevelSubstitutionNode);
-    } else {
-      metaLevelSubstitution = this.metaLevelSubstitutions.find((metaLevelSubstitution) => {
-        const metaLevelSubstitutionNodeMatches = metaLevelSubstitution.matchMetaLevelSubstitutionNode(metaLevelSubstitutionNode);
-
-        if (metaLevelSubstitutionNodeMatches) {
-          return true;
-        }
-      }) || null;
-    }
+          });
 
-    return metaLevelSubstitution;
+    return comparesToTermAndPropertyRelation;
   }
 
   isTermGrounded(term) {
@@ -307,18 +275,50 @@ class ScopedContext extends Context {
     return variablePresent;
   }
 
-  compareTermAndPropertyRelation(term, propertyRelation) {
-    const context = this, ///
-          proofAssertions = this.getProofAssertions(),
-          comparesToTermAndPropertyRelation = proofAssertions.some((proofAssertion) => {
-            const comparesToTermAndPropertyRelation = proofAssertion.compareTermAndPropertyRelation(term, propertyRelation, context);
+  findEquivalenceByTerm(term) { return this.equivalences.findEquivalenceByTerm(term); }
 
-            if (comparesToTermAndPropertyRelation) {
+  findJudgementByMetavariableName(metavariableName) {
+    const judgements = this.getJudgements(),
+          judgement = judgements.find((judgement) => {
+            const judgementMetavariableComparesToMetavariable = judgement.compareMetavariableName(metavariableName);
+
+            if (judgementMetavariableComparesToMetavariable) {
               return true;
             }
-          });
+          }) || null;
 
-    return comparesToTermAndPropertyRelation;
+    return judgement;
+  }
+
+  findVariableByVariableIdentifier(variableIdentifier) {
+    const variables = this.getVariables(),
+          variable = variables.find((variable) => {
+            const variableComparesToVariableIdentifier = variable.compareVariableIdentifier(variableIdentifier);
+
+            if (variableComparesToVariableIdentifier) {
+              return true;
+            }
+          }) || null;
+
+    return variable;
+  }
+
+  findMetaLevelSubstitutionByMetaLevelSubstitutionNode(metaLevelSubstitutionNode) {
+    let metaLevelSubstitution;
+
+    if (this.metaLevelSubstitutions === null) {
+      metaLevelSubstitution = super.findMetaLevelSubstitutionByMetaLevelSubstitutionNode(metaLevelSubstitutionNode);
+    } else {
+      metaLevelSubstitution = this.metaLevelSubstitutions.find((metaLevelSubstitution) => {
+        const metaLevelSubstitutionNodeMatches = metaLevelSubstitution.matchMetaLevelSubstitutionNode(metaLevelSubstitutionNode);
+
+        if (metaLevelSubstitutionNodeMatches) {
+          return true;
+        }
+      }) || null;
+    }
+
+    return metaLevelSubstitution;
   }
 
   static fromMetaLevelSubstitutions(metaLevelSubstitutions, context) {
@@ -328,10 +328,10 @@ class ScopedContext extends Context {
           assignments = [],
           equivalences = Equivalences.fromNothing(context),
           subproofOrProofAssertions = [],
-          scopedContext = new ScopedContext(context, variables, judgements, assignments, equivalences, subproofOrProofAssertions, metaLevelSubstitutions);
+          proofContext = new ProofContext(context, variables, judgements, assignments, equivalences, subproofOrProofAssertions, metaLevelSubstitutions);
 
-    return scopedContext;
+    return proofContext;
   }
 }
 
-export default ScopedContext;
+export default ProofContext;

package/src/context/thetic.js

@@ -0,0 +1,17 @@
+"use strict";
+
+import Context from "../context";
+
+export default class TheticContext extends Context {
+  isStated() {
+    const stated = true;
+
+    return stated;
+  }
+
+  static fromNothing(context) {
+    const theticContext = new TheticContext(context);
+
+    return theticContext;
+  }
+}

package/src/context.js

@@ -148,35 +148,23 @@ export default class Context extends ContextBase {
     return metavariable;
   }
 
-  findRuleByReference(reference, context) {
-    const childContext = context; ///
-
-    context = this.getContext();
-
-    const parentContext = context, ///
-          rule = parentContext.findRuleByReference(reference, childContext);
+  findRuleByReference(reference) {
+    const context = this.getContext(),
+          rule = context.findRuleByReference(reference);
 
     return rule;
   }
 
-  findTopLevelAssertionByReference(reference, context) {
-    const childContext = context; ///
-
-    context = this.getContext();
-
-    const parentContext = context, ///
-          topLevelAssertion = parentContext.findTopLevelAssertionByReference(reference, childContext);
+  findTopLevelAssertionByReference(reference) {
+    const context = this.getContext(),
+          topLevelAssertion = context.findTopLevelAssertionByReference(reference);
 
     return topLevelAssertion;
   }
 
-  findTopLevelMetaAssertionsByReference(reference, context) {
-    const childContext = context; ///
-
-    context = this.getContext();
-
-    const parentContext = context, ///
-          topLevelMetaAssertion = parentContext.findTopLevelMetaAssertionsByReference(reference, childContext);
+  findTopLevelMetaAssertionsByReference(reference) {
+    const context = this.getContext(),
+          topLevelMetaAssertion = context.findTopLevelMetaAssertionsByReference(reference);
 
     return topLevelMetaAssertion;
   }
@@ -204,7 +192,7 @@ export default class Context extends ContextBase {
 
   findFrameByFrameNode(frameNode) {
     const context = this.getContext(),
-      frame = context.findFrameByFrameNode(frameNode);
+          frame = context.findFrameByFrameNode(frameNode);
 
     return frame;
   }
@@ -347,24 +335,16 @@ export default class Context extends ContextBase {
     return metavariablePresent;
   }
 
-  isLabelPresentByReference(reference, context) {
-    const childContext = context; ///
-
-    context = this.getContext();
-
-    const parentContext = context, ///
-          labelPresent = parentContext.isLabelPresentByReference(reference, childContext);
+  isLabelPresentByReference(reference) {
+    const context = this.getContext(),
+          labelPresent = context.isLabelPresentByReference(reference);
 
     return labelPresent;
   }
 
-  isTopLevelMetaAssertionPresentByReference(reference, context) {
-    const childContext = context; ///
-
-    context = this.getContext();
-
-    const parentContext = context, ///
-          topLevelMetaAssertionPresent = parentContext.isTopLevelMetaAssertionPresentByReference(reference, childContext);
+  isTopLevelMetaAssertionPresentByReference(reference) {
+    const context = this.getContext(),
+          topLevelMetaAssertionPresent = context.isTopLevelMetaAssertionPresentByReference(reference);
 
     return topLevelMetaAssertionPresent;
   }
@@ -467,6 +447,13 @@ export default class Context extends ContextBase {
     return metaLevelSubstitutions;
   }
 
+  isStated() {
+    const context = this.getContext(),
+          stated = context.isStated();
+
+    return stated;
+  }
+
   addTerms(terms) {
     const context = this.getContext();
 

package/src/element/assertion/contained.js

@@ -3,7 +3,7 @@
 import Assertion from "../assertion";
 
 import { define } from "../../elements";
-import { instantiate } from "../../utilities/context";
+import { descend, instantiate } from "../../utilities/context";
 import { instantiateContainedAssertion } from "../../process/instantiate";
 import { termFromTermAndSubstitutions, frameFromFrameAndSubstitutions, statementFromStatementAndSubstitutions } from "../../utilities/substitutions";
 import { termFromContainedAssertionNode, frameFromContainedAssertionNode, negatedFromContainedAssertionNode, statementFromContainedAssertionNode } from "../../utilities/element";
@@ -41,7 +41,7 @@ export default define(class ContainedAssertion extends Assertion {
     return containedAssertionNode;
   }
 
-  validate(stated, context) {
+  validate(context) {
     let containedAssertion = null;
 
     const containedAssertionString = this.getString(); ///
@@ -57,11 +57,13 @@ export default define(class ContainedAssertion extends Assertion {
     } else {
       let validates = false;
 
-      const termValidates = this.validateTerm(stated, context),
-            frameValidates = this.validateFrame(stated, context),
-            statementValidates = this.validateStatement(stated, context)
+      const termValidates = this.validateTerm(context),
+            frameValidates = this.validateFrame(context),
+            statementValidates = this.validateStatement(context)
 
       if (termValidates || frameValidates || statementValidates) {
+        const stated = context.isStated();
+
         let validatesWhenStated = false,
             validatesWhenDerived = false;
 
@@ -90,7 +92,7 @@ export default define(class ContainedAssertion extends Assertion {
     return containedAssertion;
   }
 
-  validateTerm(stated, context) {
+  validateTerm(context) {
     let termValidates = false;
 
     if (this.term !== null) {
@@ -125,7 +127,7 @@ export default define(class ContainedAssertion extends Assertion {
     return termValidates;
   }
 
-  validateFrame(stated, context) {
+  validateFrame(context) {
     let frameValidates = false;
 
     if (this.frame !== null) {
@@ -136,18 +138,18 @@ export default define(class ContainedAssertion extends Assertion {
 
       const frameSingular = this.frame.isSingular();
 
-      if (!frameSingular) {
-        context.debug(`The '${frameString}' frame is not singular.`);
-      } else {
-        stated = true;  ///
-
-        const frame = this.frame.validate(stated, context);
+      if (frameSingular) {
+        descend((context) => {
+          const frame = this.frame.validate(context);
 
-        if (frame !== null) {
-          this.frame = frame;
+          if (frame !== null) {
+            this.frame = frame;
 
-          frameValidates = true;
-        }
+            frameValidates = true;
+          }
+        }, context);
+      } else {
+        context.debug(`The '${frameString}' frame is not singular.`);
       }
 
       if (frameValidates) {
@@ -158,7 +160,7 @@ export default define(class ContainedAssertion extends Assertion {
     return frameValidates;
   }
 
-  validateStatement(stated, context) {
+  validateStatement(context) {
     let statementValidates = false;
 
     if (this.statement !== null) {
@@ -166,13 +168,13 @@ export default define(class ContainedAssertion extends Assertion {
 
       context.trace(`Validating the '${statementString}' statement...`);
 
-      stated = true;  ///
-
-      const statement = this.statement.validate(stated, context);
+      descend((context) => {
+        const statement = this.statement.validate(context);
 
-      if (statement !== null) {
-        statementValidates = true;
-      }
+        if (statement !== null) {
+          statementValidates = true;
+        }
+      }, context);
 
       if (statementValidates) {
         context.debug(`...validated the '${statementString}' statement.`);
@@ -247,7 +249,7 @@ export default define(class ContainedAssertion extends Assertion {
     const { name } = json;
 
     if (this.name === name) {
-      containedAssertion = instantiate((context) => {
+      instantiate((context) => {
         const { string } = json,
               containedAssertionNode = instantiateContainedAssertion(string, context),
               node = containedAssertionNode,  ///
@@ -258,9 +260,7 @@ export default define(class ContainedAssertion extends Assertion {
 
         context = null;
 
-        const containedAssertion = new ContainedAssertion(context, string, node, term, frame, negated, statement);
-
-        return containedAssertion;
+        containedAssertion = new ContainedAssertion(context, string, node, term, frame, negated, statement);
       }, context);
     }
 

package/src/element/assertion/defined.js

@@ -3,7 +3,7 @@
 import Assertion from "../assertion";
 
 import { define } from "../../elements";
-import { instantiate } from "../../utilities/context";
+import { descend, instantiate } from "../../utilities/context";
 import { instantiateDefinedAssertion } from "../../process/instantiate";
 import { termFromTermAndSubstitutions, frameFromFrameAndSubstitutions } from "../../utilities/substitutions";
 import { termFromJDefinedAssertionNode, frameFromJDefinedAssertionNode, negatedFromJDefinedAssertionNode } from "../../utilities/element";
@@ -36,7 +36,7 @@ export default define(class DefinedAssertion extends Assertion {
     return definedAssertionNode;
   }
 
-  validate(stated, context) {
+  validate(context) {
     let definedAssertion = null;
 
     const definedAssertionString = this.getString(); ///
@@ -52,10 +52,12 @@ export default define(class DefinedAssertion extends Assertion {
     } else {
       let validates = false;
 
-      const termValidates = this.validateTerm(stated, context),
-            frameValidates = this.validateFrame(stated, context);
+      const termValidates = this.validateTerm(context),
+            frameValidates = this.validateFrame(context);
 
       if (termValidates || frameValidates) {
+        const stated = context.isStated();
+
         let verifiesWhenStated = false,
             verifiesWhenDerived = false;
 
@@ -84,7 +86,7 @@ export default define(class DefinedAssertion extends Assertion {
     return definedAssertion;
   }
 
-  validateTerm(stated, context) {
+  validateTerm(context) {
     let termValidates = false;
 
     if (this.term !== null) {
@@ -119,7 +121,7 @@ export default define(class DefinedAssertion extends Assertion {
     return termValidates;
   }
 
-  validateFrame(stated, context) {
+  validateFrame(context) {
     let frameValidates = false;
 
     if (this.frame !== null) {
@@ -130,22 +132,22 @@ export default define(class DefinedAssertion extends Assertion {
 
       const frameSingular = this.frame.isSingular();
 
-      if (!frameSingular) {
-        context.debug(`The '${frameString}' frame is not singular.`);
-      } else {
-        stated = true;  ///
-
-        const frame = this.frame.validate(stated, context);
+      if (frameSingular) {
+        descend((context) => {
+          const frame = this.frame.validate(context);
 
-        if (frame !== null) {
-          this.frame = frame;
+          if (frame !== null) {
+            this.frame = frame;
 
-          frameValidates = true;
-        }
+            frameValidates = true;
+          }
+        }, context);
+      } else {
+        context.debug(`The '${frameString}' frame is not singular.`);
+      }
 
-        if (frameValidates) {
-          context.debug(`...validates the'${definedAssertionString}' defined assertion's '${frameString}' frame.`);
-        }
+      if (frameValidates) {
+        context.debug(`...validates the'${definedAssertionString}' defined assertion's '${frameString}' frame.`);
       }
     }
 
@@ -216,7 +218,7 @@ export default define(class DefinedAssertion extends Assertion {
     const { name } = json;
 
     if (this.name === name) {
-      definedAssertion = instantiate((context) => {
+      instantiate((context) => {
         const { string } = json,
               definedAssertionNode = instantiateDefinedAssertion(string, context),
               node = definedAssertionNode,  ///
@@ -226,9 +228,7 @@ export default define(class DefinedAssertion extends Assertion {
 
         context = null;
 
-        const definedAssertion = new DefinedAssertion(context, string, node, term, frame, negated);
-
-        return definedAssertion;
+        definedAssertion = new DefinedAssertion(context, string, node, term, frame, negated);
       }, context);
     }