occam-verify-cli 1.0.764 → 1.0.776

package/src/context/file/nominal.js

@@ -378,8 +378,6 @@ export default class NominalFileContext extends FileContext {
     return metavariable;
   }
 
-  findMetaTypeByMetaTypeName(metaTypeName) { return findMetaTypeByMetaTypeName(metaTypeName); }
-
   findRuleByReference(reference) {
     const rules = this.getRules(),
           metavariableName = reference.getMetavariableName(),
@@ -436,19 +434,6 @@ export default class NominalFileContext extends FileContext {
     return theorem;
   }
 
-  findMetaLemmaByReference(reference) {
-    const metaLemmas = this.getMetaLemmas(),
-          metaLemma = metaLemmas.find((metaLemma) => {
-            const metaLemmaComparesToReference = metaLemma.compareReference(reference);
-
-            if (metaLemmaComparesToReference) {
-              return true;
-            }
-          }) || null;
-
-    return metaLemma;
-  }
-
   findConjectureByReference(reference) {
     const conjectures = this.getConjectures(),
           metavariableName = reference.getMetavariableName(),
@@ -467,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;
@@ -479,26 +463,12 @@ export default class NominalFileContext extends FileContext {
     return metaLemmas;
   }
 
-  findMetatheoremByReference(reference) {
-    const metatheorems = this.getMetatheorems(),
-          metatheorem = metatheorems.find((metatheorem) => {
-            const metatheoremComparesToReference = metatheorem.compareReference(reference);
-
-            if (metatheoremComparesToReference) {
-              return true;
-            }
-          }) || null;
-
-    return metatheorem;
-  }
-
   findMetatheoremsByReference(reference) {
     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;
@@ -613,19 +583,6 @@ export default class NominalFileContext extends FileContext {
     return typePrefix;
   }
 
-  findJudgementByMetavariableName(metavariableName) {
-    const judgements = this.getJudgements(),
-          judgement = judgements.find((judgement) => {
-            const judgementMetavariableComparesToMetavariable = judgement.compareMetavariableName(metavariableName);
-
-            if (judgementMetavariableComparesToMetavariable) {
-              return true;
-            }
-          }) || null;
-
-    return judgement;
-  }
-
   findVariableByVariableIdentifier(variableIdentifier) {
     const variables = this.getVariables(),
           variable = variables.find((variable) => {
@@ -665,26 +622,22 @@ export default class NominalFileContext extends FileContext {
     return procedure;
   }
 
-  isLabelPresentByReference(reference) {
-    const labels = this.getLabels(),
-      labelPresent = labels.some((label) => {
-        const context = this, ///
-          labelUnifies = reference.unifyLabel(label, context);
+  findMetaTypeByMetaTypeName(metaTypeName) { return findMetaTypeByMetaTypeName(metaTypeName); }
 
-        if (labelUnifies) {
-          return true;
-        }
-      });
+  isMetavariablePresent(metavariable, context) {
+    metavariable = this.findMetavariable(metavariable, context);  ///
 
-    return labelPresent;
+    const metavariablePresent = (metavariable !== null);
+
+    return metavariablePresent;
   }
 
-  isLabelPresentByLabelNode(labelNode) {
+  isLabelPresentByReference(reference) {
     const labels = this.getLabels(),
           labelPresent = labels.some((label) => {
-            const labelNodeMatches = label.matchLabelNode(labelNode);
+            const labelUnifies = reference.unifyLabel(label);
 
-            if (labelNodeMatches) {
+            if (labelUnifies) {
               return true;
             }
           });
@@ -692,20 +645,6 @@ export default class NominalFileContext extends FileContext {
     return labelPresent;
   }
 
-  isMetavariablePresentByReference(reference) {
-    const metavariables = this.getMetavariables(),
-          metavariablePresent = metavariables.some((metavariable) => {
-            const context = this, ///
-                  metavariableUnifies = reference.unifyMetavariable(metavariable, context);
-
-            if (metavariableUnifies) {
-              return true;
-            }
-          });
-
-    return metavariablePresent;
-  }
-
   isTopLevelMetaAssertionPresentByReference(reference) {
     const topLevelMetaAssertion = this.findTopLevelMetaAssertionByReference(reference),
           topLevelMetaAssertionPresent = (topLevelMetaAssertion !== null);
@@ -713,6 +652,19 @@ export default class NominalFileContext extends FileContext {
     return topLevelMetaAssertionPresent;
   }
 
+  isLabelPresentByLabelNode(labelNode) {
+    const labels = this.getLabels(),
+          labelPresent = labels.some((label) => {
+            const labelNodeMatches = label.matchLabelNode(labelNode);
+
+            if (labelNodeMatches) {
+              return true;
+            }
+          });
+
+    return labelPresent;
+  }
+
   isTypePresentByTypeName(typeName, includeRelease = true) {
     const type = this.findTypeByTypeName(typeName, includeRelease),
           typePresent = (type !== null);

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,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/nominal.js

@@ -14,7 +14,7 @@ const { nominalLexerFromNothing } = lexersUtilities,
 const nominalLexer = nominalLexerFromNothing(NominalLexer),
       nominalParser = nominalParserFromNothing(NominalParser); ///
 
-class NominalContext extends Context {
+export default class NominalContext extends Context {
   constructor(context, lexer, parser) {
     super(context);
 
@@ -41,7 +41,3 @@ class NominalContext extends Context {
     return nominalContext;
   }
 }
-
-const nominalContext = NominalContext.fromNothing();
-
-export default nominalContext;

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

@@ -136,6 +136,18 @@ export default class Context extends ContextBase {
     return ephemeralContext;
   }
 
+  findMetavariable(metavariable, context) {
+    const childContext = context; ///
+
+    context = this.getContext();
+
+    const parentContext = context; ///
+
+    metavariable = parentContext.findMetavariable(metavariable, childContext);  ///
+
+    return metavariable;
+  }
+
   findRuleByReference(reference) {
     const context = this.getContext(),
           rule = context.findRuleByReference(reference);
@@ -171,18 +183,6 @@ export default class Context extends ContextBase {
     return metaType;
   }
 
-  findMetavariable(metavariable, context) {
-    const childContext = context; ///
-
-    context = this.getContext();
-
-    const parentContext = context; ///
-
-    metavariable = parentContext.findMetavariable(metavariable, childContext);  ///
-
-    return metavariable;
-  }
-
   findTermByTermNode(termNode) {
     const context = this.getContext(),
           term = context.findTermByTermNode(termNode);
@@ -192,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;
   }
@@ -325,9 +325,12 @@ export default class Context extends ContextBase {
   }
 
   isMetavariablePresent(metavariable, context) {
-    metavariable = this.findMetavariable(metavariable, context);  ///
+    const childContext = context; ///
 
-    const metavariablePresent = (metavariable !== null);
+    context = this.getContext();
+
+    const parentContext = context,  ///
+          metavariablePresent = parentContext.isMetavariablePresent(metavariable, childContext);
 
     return metavariablePresent;
   }
@@ -339,6 +342,13 @@ export default class Context extends ContextBase {
     return labelPresent;
   }
 
+  isTopLevelMetaAssertionPresentByReference(reference) {
+    const context = this.getContext(),
+          topLevelMetaAssertionPresent = context.isTopLevelMetaAssertionPresentByReference(reference);
+
+    return topLevelMetaAssertionPresent;
+  }
+
   isTermPresentByTermNode(termNode) {
     const context = this.getContext(),
           termPresent = context.isTermPresentByTermNode(termNode);
@@ -437,6 +447,19 @@ export default class Context extends ContextBase {
     return metaLevelSubstitutions;
   }
 
+  isStated() {
+    const context = this.getContext(),
+          stated = context.isStated();
+
+    return stated;
+  }
+
+  addTerms(terms) {
+    const context = this.getContext();
+
+    context.addTerms(terms);
+  }
+
   addTerm(term) {
     const context = this.getContext();
 
@@ -449,22 +472,40 @@ export default class Context extends ContextBase {
     context.addFrame(frame);
   }
 
+  addEquality(equality) {
+    const context = this.getContext();
+
+    context.addEquality(equality);
+  }
+
+  addJudgement(judgement) {
+    const context = this.getContext();
+
+    context.addJudgement(judgement);
+  }
+
   addStatement(statement) {
     const context = this.getContext();
 
     context.addStatement(statement);
   }
 
+  addAssertion(assertion) {
+    const context = this.getContext();
+
+    context.addAssertion(assertion);
+  }
+
   addReference(reference) {
     const context = this.getContext();
 
     context.addReference(reference);
   }
 
-  addJudgement(judgement) {
+  addAssumption(assumption) {
     const context = this.getContext();
 
-    context.addJudgement(judgement);
+    context.addAssumption(assumption);
   }
 
   addAssignment(assignment) {