occam-verify-cli 1.0.768 → 1.0.781

package/src/context/file/nominal.js

@@ -452,9 +452,8 @@ export default class NominalFileContext extends FileContext {
     const metaLemmas = this.getMetaLemmas();
 
     filter(metaLemmas, (metaLemma) => {
-      const context = this, ///
-            topLevelMetaAssertion = metaLemma, ///
-            topLevelMetaAssertionCompares = reference.compareTopLevelMetaAssertion(topLevelMetaAssertion, context);
+      const topLevelMetaAssertion = metaLemma, ///
+            topLevelMetaAssertionCompares = reference.compareTopLevelMetaAssertion(topLevelMetaAssertion);
 
       if (topLevelMetaAssertionCompares) {
         return true;
@@ -468,9 +467,8 @@ export default class NominalFileContext extends FileContext {
     const metatheorems = this.getMetatheorems();
 
     filter(metatheorems, (metatheorem) => {
-      const context = this, ///
-            topLevelMetaAssertion = metatheorem, ///
-            topLevelMetaAssertionCompares = reference.compareTopLevelMetaAssertion(topLevelMetaAssertion, context);
+      const topLevelMetaAssertion = metatheorem, ///
+            topLevelMetaAssertionCompares = reference.compareTopLevelMetaAssertion(topLevelMetaAssertion);
 
       if (topLevelMetaAssertionCompares) {
         return true;
@@ -490,17 +488,17 @@ export default class NominalFileContext extends FileContext {
     return topLevelAssertion;
   }
 
-  findTopLevelMetaAssertionByReference(reference, context) {
-    const metaLemma = this.findMetaLemmaByReference(reference, context),
-          metatheorem = this.findMetatheoremByReference(reference, context),
+  findTopLevelMetaAssertionByReference(reference) {
+    const metaLemma = this.findMetaLemmaByReference(reference),
+          metatheorem = this.findMetatheoremByReference(reference),
           topLevelMetaAssertion = (metaLemma || metatheorem);  ///
 
     return topLevelMetaAssertion;
   }
 
-  findTopLevelMetaAssertionsByReference(reference, context) {
-    const metaLemmas = this.findMetaLemmasByReference(reference, context),
-          metatheorems = this.findMetatheoremsByReference(reference, context),
+  findTopLevelMetaAssertionsByReference(reference) {
+    const metaLemmas = this.findMetaLemmasByReference(reference),
+          metatheorems = this.findMetatheoremsByReference(reference),
           topLevelMetaAssertions = [
             ...metaLemmas,
             ...metatheorems
@@ -634,10 +632,10 @@ export default class NominalFileContext extends FileContext {
     return metavariablePresent;
   }
 
-  isLabelPresentByReference(reference, context) {
+  isLabelPresentByReference(reference) {
     const labels = this.getLabels(),
           labelPresent = labels.some((label) => {
-            const labelUnifies = reference.unifyLabel(label, context);
+            const labelUnifies = reference.unifyLabel(label);
 
             if (labelUnifies) {
               return true;
@@ -647,8 +645,8 @@ export default class NominalFileContext extends FileContext {
     return labelPresent;
   }
 
-  isTopLevelMetaAssertionPresentByReference(reference, context) {
-    const topLevelMetaAssertion = this.findTopLevelMetaAssertionByReference(reference, context),
+  isTopLevelMetaAssertionPresentByReference(reference) {
+    const topLevelMetaAssertion = this.findTopLevelMetaAssertionByReference(reference),
           topLevelMetaAssertionPresent = (topLevelMetaAssertion !== null);
 
     return topLevelMetaAssertionPresent;

package/src/context/illative.js

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

package/src/context/nested.js

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

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

@@ -5,9 +5,9 @@ import { arrayUtilities } from "necessary";
 import Context from "../context";
 import elements from "../elements";
 
-const { last } = arrayUtilities;
+const { last, filter } = 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,20 +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; ///
+  addSubproofOrProofAssertion(subproofOrProofAssertion) {
+    const context = this, ///
+          subproofOrProofAssertionString = subproofOrProofAssertion.getString();
 
-    this.assignments.forEach((assignment) => {
-      assignment(context);
-    });
+    context.trace(`Adding the '${subproofOrProofAssertionString}' subproof or proof assertion to the proof context...`);
+
+    this.subproofOrProofAssertions.push(subproofOrProofAssertion);
+
+    context.debug(`...added the '${subproofOrProofAssertionString}' subproof or proof assertion to the proof context.`);
+  }
+
+  compareTermAndPropertyRelation(term, propertyRelation) {
+    const context = this, ///
+          proofAssertions = this.getProofAssertions(),
+          comparesToTermAndPropertyRelation = proofAssertions.some((proofAssertion) => {
+            const comparesToTermAndPropertyRelation = proofAssertion.compareTermAndPropertyRelation(term, propertyRelation, context);
+
+            if (comparesToTermAndPropertyRelation) {
+              return true;
+            }
+          });
+
+    return comparesToTermAndPropertyRelation;
   }
 
   findEquivalenceByTerm(term) { return this.equivalences.findEquivalenceByTerm(term); }
@@ -272,25 +286,18 @@ class ScopedContext extends Context {
     return metaLevelSubstitution;
   }
 
-  isTermGrounded(term) {
-    const context = this, ///
-          equivalences = this.getEquivalences(),
-          groundedTerms = [],
-          definedVariables = [];
+  findJudgementsByMetavariableNode(metavariableNode) {
+    const judgements = this.getJudgements();
 
-    equivalences.separateGroundedTermsAndDefinedVariables(groundedTerms, definedVariables, context);
+    filter(judgements, (judgement) => {
+      const metavariableNodeMatches = judgement.matchMetavariableNode(metavariableNode);
 
-    const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
-        const groundedTermNode = groundedTerm.getNode(),
-              groundedTermNodeMatches = term.matchTermNode(groundedTermNode);
-
-            if (groundedTermNodeMatches) {
-              return true;
-            }
-          }),
-          termGrounded = termMatchesGroundedTerm; ///
+      if (metavariableNodeMatches) {
+        return true;
+      }
+    });
 
-    return termGrounded;
+    return judgements;
   }
 
   isJudgementPresentByMetavariableName(metavariableName) {
@@ -307,18 +314,25 @@ class ScopedContext extends Context {
     return variablePresent;
   }
 
-  compareTermAndPropertyRelation(term, propertyRelation) {
+  isTermGrounded(term) {
     const context = this, ///
-          proofAssertions = this.getProofAssertions(),
-          comparesToTermAndPropertyRelation = proofAssertions.some((proofAssertion) => {
-            const comparesToTermAndPropertyRelation = proofAssertion.compareTermAndPropertyRelation(term, propertyRelation, context);
+          equivalences = this.getEquivalences(),
+          groundedTerms = [],
+          definedVariables = [];
 
-            if (comparesToTermAndPropertyRelation) {
+    equivalences.separateGroundedTermsAndDefinedVariables(groundedTerms, definedVariables, context);
+
+    const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
+            const groundedTermNode = groundedTerm.getNode(),
+                  groundedTermNodeMatches = term.matchTermNode(groundedTermNode);
+
+            if (groundedTermNodeMatches) {
               return true;
             }
-          });
+          }),
+          termGrounded = termMatchesGroundedTerm; ///
 
-    return comparesToTermAndPropertyRelation;
+    return termGrounded;
   }
 
   static fromMetaLevelSubstitutions(metaLevelSubstitutions, context) {
@@ -328,10 +342,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;
   }
@@ -258,6 +246,13 @@ export default class Context extends ContextBase {
     return reference;
   }
 
+  findJudgementsByMetavariableNode(metavariableNode) {
+    const context = this.getContext(),
+          judgement = context.findJudgementsByMetavariableNode(metavariableNode);
+
+    return judgement;
+  }
+
   findSubstitutionBySubstitutionNode(substitutionNode) {
     const context = this.getContext(),
           substitution = context.findSubstitutionBySubstitutionNode(substitutionNode);
@@ -347,24 +342,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 +454,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,10 +3,14 @@
 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";
+import { termFromContainedAssertionNode,
+         frameFromContainedAssertionNode,
+         negatedFromContainedAssertionNode,
+         statementFromContainedAssertionNode,
+         containedAssertionFromStatementNode } from "../../utilities/element";
 
 export default define(class ContainedAssertion extends Assertion {
   constructor(context, string, node, term, frame, negated, statement) {
@@ -41,7 +45,7 @@ export default define(class ContainedAssertion extends Assertion {
     return containedAssertionNode;
   }
 
-  validate(stated, context) {
+  validate(context) {
     let containedAssertion = null;
 
     const containedAssertionString = this.getString(); ///
@@ -57,11 +61,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 +96,7 @@ export default define(class ContainedAssertion extends Assertion {
     return containedAssertion;
   }
 
-  validateTerm(stated, context) {
+  validateTerm(context) {
     let termValidates = false;
 
     if (this.term !== null) {
@@ -125,7 +131,7 @@ export default define(class ContainedAssertion extends Assertion {
     return termValidates;
   }
 
-  validateFrame(stated, context) {
+  validateFrame(context) {
     let frameValidates = false;
 
     if (this.frame !== null) {
@@ -136,18 +142,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;  ///
+      if (frameSingular) {
+        descend((context) => {
+          const frame = this.frame.validate(context);
 
-        const frame = this.frame.validate(stated, 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 +164,7 @@ export default define(class ContainedAssertion extends Assertion {
     return frameValidates;
   }
 
-  validateStatement(stated, context) {
+  validateStatement(context) {
     let statementValidates = false;
 
     if (this.statement !== null) {
@@ -166,13 +172,13 @@ export default define(class ContainedAssertion extends Assertion {
 
       context.trace(`Validating the '${statementString}' statement...`);
 
-      stated = true;  ///
+      descend((context) => {
+        const statement = this.statement.validate(context);
 
-      const statement = this.statement.validate(stated, context);
-
-      if (statement !== null) {
-        statementValidates = true;
-      }
+        if (statement !== null) {
+          statementValidates = true;
+        }
+      }, context);
 
       if (statementValidates) {
         context.debug(`...validated the '${statementString}' statement.`);
@@ -218,7 +224,7 @@ export default define(class ContainedAssertion extends Assertion {
   }
 
   unifyIndependently(generalContext, specificContext) {
-    let unifiesIndependently;
+    let unifiesIndependently = false;
 
     const context = specificContext,  ///
           containedAssertionString = this.getString(); ///
@@ -230,7 +236,9 @@ export default define(class ContainedAssertion extends Assertion {
           statement = statementFromStatementAndSubstitutions(this.statement, generalContext, specificContext),
           validatesWhenDerived = validateWhenDerived(term, frame, statement, this.negated, generalContext, specificContext);
 
-    unifiesIndependently = validatesWhenDerived; ///
+    if (validatesWhenDerived) {
+      unifiesIndependently = true;
+    }
 
     if (unifiesIndependently) {
       context.debug(`...unified the '${containedAssertionString}' contained assertion independently.`);
@@ -247,7 +255,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,14 +266,19 @@ 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);
     }
 
     return containedAssertion;
   }
+
+  static fromStatement(statement, context) {
+    const statementNode = statement.getNode(),
+          containedAssertion = containedAssertionFromStatementNode(statementNode, context);
+
+    return containedAssertion;
+  }
 });
 
 function validateWhenDerived(term, frame, statement, negated, generalContext, specificContext) {