occam-verify-cli 1.0.776 → 1.0.785

package/src/context/proof.js

@@ -5,18 +5,22 @@ import { arrayUtilities } from "necessary";
 import Context from "../context";
 import elements from "../elements";
 
-const { last } = arrayUtilities;
+const { last, filter } = arrayUtilities;
 
 class ProofContext extends Context {
-  constructor(context, variables, judgements, assignments, equivalences, subproofOrProofAssertions, metaLevelSubstitutions) {
+  constructor(context, assumptions, variables, judgements, assignments, equivalences, subproofOrProofAssertions) {
     super(context);
 
+    this.assumptions = assumptions;
     this.variables = variables;
     this.judgements = judgements;
     this.assignments = assignments;
     this.equivalences = equivalences;
     this.subproofOrProofAssertions = subproofOrProofAssertions;
-    this.metaLevelSubstitutions = metaLevelSubstitutions;
+  }
+
+  getAssumptions() {
+    return this.assumptions;
   }
 
   getVariables() {
@@ -84,10 +88,6 @@ class ProofContext extends Context {
     return subproofOrProofAssertions;
   }
 
-  getMetaLevelSubstitutions() {
-    return this.metaLevelSubstitutions;
-  }
-
   getProofAssertions() {
     const subproofOrProofAssertions = this.getSubproofOrProofAssertions(),
           proofAssertions = subproofOrProofAssertions.filter((subproofOrProofAssertion) => {
@@ -116,18 +116,18 @@ class ProofContext extends Context {
     return lastStep;
   }
 
-  hasMetaLevelSubstitutions() {
-    let metaLevelSubstitutions;
+  isMetaLevel() {
+    let metaLevel = false;
 
-    if (this.metaLevelSubstitutions !== null) {
-      metaLevelSubstitutions = true;
+    if (this.assumptions !== null) {
+      metaLevel = true;
     } else {
       const context = this.getContext();
 
-      metaLevelSubstitutions = context.hasMetaLevelSubstitutions();
+      metaLevel = context.isMetaLevel();
     }
 
-    return metaLevelSubstitutions;
+    return metaLevel;
   }
 
   addEquality(equality) {
@@ -184,34 +184,38 @@ class ProofContext extends Context {
     });
   }
 
-  addMetaLevelSubstitution(metaLevelSubstitution) {
-    if (this.metaLevelSubstitutions === null) {
-      super.addMetaLevelSubstitution(metaLevelSubstitution);
+  addAssumption(assumption, metaLevel = true) {
+    if (!metaLevel) {
+      return;
+    }
+
+    if (this.assumptions === null) {
+      super.addAssumption(assumption, metaLevel);
 
       return;
     }
 
     const context = this, ///
-          metaLevelSubstitutionA = metaLevelSubstitution, ///
-          metaLevelSubstitutionString = metaLevelSubstitution.getString();
+          assumptionA = assumption, ///
+          assumptionString = assumption.getString();
 
-    context.trace(`Adding the '${metaLevelSubstitutionString}' meta-level substitution to the proof context...`);
+    context.trace(`Adding the '${assumptionString}' assumption to the proof context...`);
 
-    const metaLevelSubstitutionB = this.metaLevelSubstitutions.find((metaLevelSubstitution) => {
-      const metaLevelSubstitutionB = metaLevelSubstitution, ///
-            metaLevelSubstitutionAEqualToMetaLevelSubstitutionB = metaLevelSubstitutionA.isEqualTo(metaLevelSubstitutionB);
+    const assumptionB = this.assumptions.find((assumption) => {
+      const assumptionB = assumption, ///
+            assumptionAEqualToAssumptionB = assumptionA.isEqualTo(assumptionB);
 
-      if (metaLevelSubstitutionAEqualToMetaLevelSubstitutionB) {
+      if (assumptionAEqualToAssumptionB) {
         return true;
       }
     }) || null;
 
-    if (metaLevelSubstitutionB !== null) {
-      context.debug(`The '${metaLevelSubstitutionString}' meta-level substitution has already been added to the proof context.`);
+    if (assumptionB !== null) {
+      context.debug(`The '${assumptionString}' assumption has already been added to the proof context.`);
     } else {
-      this.metaLevelSubstitutions.push(metaLevelSubstitution);
+      this.assumptions.push(assumption);
 
-      context.debug(`...added the '${metaLevelSubstitutionString}' substitution to the proof context.`);
+      context.debug(`...added the '${assumptionString}' substitution to the proof context.`);
     }
   }
 
@@ -240,43 +244,28 @@ class ProofContext extends Context {
     return comparesToTermAndPropertyRelation;
   }
 
-  isTermGrounded(term) {
-    const context = this, ///
-          equivalences = this.getEquivalences(),
-          groundedTerms = [],
-          definedVariables = [];
-
-    equivalences.separateGroundedTermsAndDefinedVariables(groundedTerms, definedVariables, context);
-
-    const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
-        const groundedTermNode = groundedTerm.getNode(),
-              groundedTermNodeMatches = term.matchTermNode(groundedTermNode);
-
-            if (groundedTermNodeMatches) {
-              return true;
-            }
-          }),
-          termGrounded = termMatchesGroundedTerm; ///
+  findEquivalenceByTerm(term) { return this.equivalences.findEquivalenceByTerm(term); }
 
-    return termGrounded;
-  }
+  findAssumptionByAssumptionNode(assumptionNode, metaLevel = true) {
+    let assumption = null;
 
-  isJudgementPresentByMetavariableName(metavariableName) {
-    const judgement = this.findJudgementByMetavariableName(metavariableName),
-          judgementPresent = (judgement !== null);
+    if (metaLevel) {
+      if (this.assumptions === null) {
+        assumption = super.findAssumptionByAssumptionNode(assumptionNode, metaLevel);
+      } else {
+        assumption = this.assumptions.find((assumption) => {
+          const assumptionNodeMatches = assumption.matchAssumptionNode(assumptionNode);
 
-    return judgementPresent;
-  }
-
-  isVariablePresentByVariableIdentifier(variableIdentifier) {
-    const variable = this.findVariableByVariableIdentifier(variableIdentifier),
-          variablePresent = (variable !== null);
+          if (assumptionNodeMatches) {
+            return true;
+          }
+        }) || null;
+      }
+    }
 
-    return variablePresent;
+    return assumption;
   }
 
-  findEquivalenceByTerm(term) { return this.equivalences.findEquivalenceByTerm(term); }
-
   findJudgementByMetavariableName(metavariableName) {
     const judgements = this.getJudgements(),
           judgement = judgements.find((judgement) => {
@@ -303,32 +292,63 @@ class ProofContext extends Context {
     return variable;
   }
 
-  findMetaLevelSubstitutionByMetaLevelSubstitutionNode(metaLevelSubstitutionNode) {
-    let metaLevelSubstitution;
+  findJudgementsByMetavariableNode(metavariableNode) {
+    const judgements = this.getJudgements();
 
-    if (this.metaLevelSubstitutions === null) {
-      metaLevelSubstitution = super.findMetaLevelSubstitutionByMetaLevelSubstitutionNode(metaLevelSubstitutionNode);
-    } else {
-      metaLevelSubstitution = this.metaLevelSubstitutions.find((metaLevelSubstitution) => {
-        const metaLevelSubstitutionNodeMatches = metaLevelSubstitution.matchMetaLevelSubstitutionNode(metaLevelSubstitutionNode);
+    filter(judgements, (judgement) => {
+      const metavariableNodeMatches = judgement.matchMetavariableNode(metavariableNode);
 
-        if (metaLevelSubstitutionNodeMatches) {
-          return true;
-        }
-      }) || null;
-    }
+      if (metavariableNodeMatches) {
+        return true;
+      }
+    });
+
+    return judgements;
+  }
+
+  isJudgementPresentByMetavariableName(metavariableName) {
+    const judgement = this.findJudgementByMetavariableName(metavariableName),
+          judgementPresent = (judgement !== null);
+
+    return judgementPresent;
+  }
 
-    return metaLevelSubstitution;
+  isVariablePresentByVariableIdentifier(variableIdentifier) {
+    const variable = this.findVariableByVariableIdentifier(variableIdentifier),
+          variablePresent = (variable !== null);
+
+    return variablePresent;
+  }
+
+  isTermGrounded(term) {
+    const context = this, ///
+          equivalences = this.getEquivalences(),
+          groundedTerms = [],
+          definedVariables = [];
+
+    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 termGrounded;
   }
 
-  static fromMetaLevelSubstitutions(metaLevelSubstitutions, context) {
+  static fromAssumptions(assumptions, context) {
     const { Equivalences } = elements,
           variables = [],
           judgements = [],
           assignments = [],
           equivalences = Equivalences.fromNothing(context),
           subproofOrProofAssertions = [],
-          proofContext = new ProofContext(context, variables, judgements, assignments, equivalences, subproofOrProofAssertions, metaLevelSubstitutions);
+          proofContext = new ProofContext(context, assumptions, variables, judgements, assignments, equivalences, subproofOrProofAssertions);
 
     return proofContext;
   }

package/src/context.js

@@ -129,13 +129,6 @@ export default class Context extends ContextBase {
     return subproofOrProofAssertions;
   }
 
-  retrieveEphemeralContext() {
-    const context = this.getContext(),
-          ephemeralContext = context.retrieveEphemeralContext();
-
-    return ephemeralContext;
-  }
-
   findMetavariable(metavariable, context) {
     const childContext = context; ///
 
@@ -232,9 +225,9 @@ export default class Context extends ContextBase {
     return statement;
   }
 
-  findAssumptionByAssumptionNode(assumptionNode) {
+  findAssumptionByAssumptionNode(assumptionNode, metaLevel = false) {
     const context = this.getContext(),
-          assumption = context.findAssumptionByAssumptionNode(assumptionNode);
+          assumption = context.findAssumptionByAssumptionNode(assumptionNode, metaLevel);
 
     return assumption;
   }
@@ -246,18 +239,18 @@ export default class Context extends ContextBase {
     return reference;
   }
 
-  findSubstitutionBySubstitutionNode(substitutionNode) {
+  findJudgementsByMetavariableNode(metavariableNode) {
     const context = this.getContext(),
-          substitution = context.findSubstitutionBySubstitutionNode(substitutionNode);
+          judgement = context.findJudgementsByMetavariableNode(metavariableNode);
 
-    return substitution;
+    return judgement;
   }
 
-  findMetaLevelSubstitutionByMetaLevelSubstitutionNode(metaLevelSubstitutionNode) {
+  findSubstitutionBySubstitutionNode(substitutionNode) {
     const context = this.getContext(),
-          metaLevelSubstitution = context.findMetaLevelSubstitutionByMetaLevelSubstitutionNode(metaLevelSubstitutionNode);
+          substitution = context.findSubstitutionBySubstitutionNode(substitutionNode);
 
-    return metaLevelSubstitution;
+    return substitution;
   }
 
   findTypeByNominalTypeName(nominalTypeName) {
@@ -433,6 +426,20 @@ export default class Context extends ContextBase {
     return substitutionPresent;
   }
 
+  isSubstitutionPresentByMetavariableNameAndSubstitution(metavariableName, substitution) {
+    const context = this.getContext(),
+          substitutionPresent = context.isSubstitutionPresentByMetavariableNameAndSubstitution(metavariableName, substitution);
+
+    return substitutionPresent;
+  }
+
+  isSubstitutionPresentByMetavariableName(metavariableName) {
+    const context = this.getContext(),
+          substitutionPresent = context.isSubstitutionPresentByMetavariableName(metavariableName);
+
+    return substitutionPresent;
+  }
+
   isProcedurePresentByProcedureName(procedureName) {
     const context = this.getContext(),
           procedurePresent = context.isProcedurePresentByProcedureName(procedureName);
@@ -440,11 +447,11 @@ export default class Context extends ContextBase {
     return procedurePresent;
   }
 
-  hasMetaLevelSubstitutions() {
+  isMetaLevel() {
     const context = this.getContext(),
-          metaLevelSubstitutions = context.hasMetaLevelSubstitutions();
+          metaLevel = context.isMetaLevel();
 
-    return metaLevelSubstitutions;
+    return metaLevel;
   }
 
   isStated() {
@@ -502,10 +509,10 @@ export default class Context extends ContextBase {
     context.addReference(reference);
   }
 
-  addAssumption(assumption) {
+  addAssumption(assumption, metaLevel = false) {
     const context = this.getContext();
 
-    context.addAssumption(assumption);
+    context.addAssumption(assumption, metaLevel);
   }
 
   addAssignment(assignment) {
@@ -520,12 +527,6 @@ export default class Context extends ContextBase {
     context.addSubstitution(substitution);
   }
 
-  addMetaLevelSubstitution(metaLevelSubstitution) {
-    const context = this.getContext();
-
-    context.addMetaLevelSubstitution(metaLevelSubstitution);
-  }
-
   addSubproofOrProofAssertion(subproofOrProofAssertion) {
     const context = this.getContext();
 

package/src/element/assertion/contained.js

@@ -6,7 +6,11 @@ import { define } from "../../elements";
 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) {
@@ -220,7 +224,7 @@ export default define(class ContainedAssertion extends Assertion {
   }
 
   unifyIndependently(generalContext, specificContext) {
-    let unifiesIndependently;
+    let unifiesIndependently = false;
 
     const context = specificContext,  ///
           containedAssertionString = this.getString(); ///
@@ -232,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.`);
@@ -266,6 +272,13 @@ export default define(class ContainedAssertion extends Assertion {
 
     return containedAssertion;
   }
+
+  static fromStatement(statement, context) {
+    const statementNode = statement.getNode(),
+          containedAssertion = containedAssertionFromStatementNode(statementNode, context);
+
+    return containedAssertion;
+  }
 });
 
 function validateWhenDerived(term, frame, statement, negated, generalContext, specificContext) {

package/src/element/assertion/defined.js

@@ -6,7 +6,7 @@ import { define } from "../../elements";
 import { descend, instantiate } from "../../utilities/context";
 import { instantiateDefinedAssertion } from "../../process/instantiate";
 import { termFromTermAndSubstitutions, frameFromFrameAndSubstitutions } from "../../utilities/substitutions";
-import { termFromJDefinedAssertionNode, frameFromJDefinedAssertionNode, negatedFromJDefinedAssertionNode } from "../../utilities/element";
+import { termFromJDefinedAssertionNode, frameFromJDefinedAssertionNode, negatedFromJDefinedAssertionNode, definedAssertionFromStatementNode } from "../../utilities/element";
 
 export default define(class DefinedAssertion extends Assertion {
   constructor(context, string, node, term, frame, negated) {
@@ -58,16 +58,16 @@ export default define(class DefinedAssertion extends Assertion {
       if (termValidates || frameValidates) {
         const stated = context.isStated();
 
-        let verifiesWhenStated = false,
-            verifiesWhenDerived = false;
+        let validatesWhenStated = false,
+            validatesWhenDerived = false;
 
         if (stated) {
-          verifiesWhenStated = this.validateWhenStated(context);
+          validatesWhenStated = this.validateWhenStated(context);
         } else {
-          verifiesWhenDerived = this.validateWhenDerived(context);
+          validatesWhenDerived = this.validateWhenDerived(context);
         }
 
-        if (verifiesWhenStated || verifiesWhenDerived) {
+        if (validatesWhenStated || validatesWhenDerived) {
           validates = true;
         }
       }
@@ -155,23 +155,23 @@ export default define(class DefinedAssertion extends Assertion {
   }
 
   validateWhenStated(context) {
-    let verifiesWhenStated;
+    let validatesWhenStated;
 
     const definedAssertionString = this.getString(); ///
 
     context.trace(`Validating the '${definedAssertionString}' stated defined assertion...`);
 
-    verifiesWhenStated = true;
+    validatesWhenStated = true;
 
-    if (verifiesWhenStated) {
+    if (validatesWhenStated) {
       context.debug(`...validates the '${definedAssertionString}' stated defined assertion.`);
     }
 
-    return verifiesWhenStated;
+    return validatesWhenStated;
   }
 
   validateWhenDerived(context) {
-    let verifiesWhenDerived;
+    let validatesWhenDerived;
 
     const definedAssertionString = this.getString(); ///
 
@@ -180,17 +180,17 @@ export default define(class DefinedAssertion extends Assertion {
     const generalContext = null,
           specificContext = context;  ///
 
-    verifiesWhenDerived = validateWhenDerived(this.term, this.frame, this.negated, generalContext, specificContext);
+    validatesWhenDerived = validateWhenDerived(this.term, this.frame, this.negated, generalContext, specificContext);
 
-    if (verifiesWhenDerived) {
+    if (validatesWhenDerived) {
       context.debug(`...validates the '${definedAssertionString}' derived defined assertion.`);
     }
 
-    return verifiesWhenDerived;
+    return validatesWhenDerived;
   }
 
   unifyIndependently(generalContext, specificContext) {
-    let unifiesIndependently;
+    let unifiesIndependently = false;
 
     const context = specificContext, ///
           definedAssertionString = this.getString(); ///
@@ -199,9 +199,11 @@ export default define(class DefinedAssertion extends Assertion {
 
     const term = termFromTermAndSubstitutions(this.term, generalContext, specificContext),
           frame = frameFromFrameAndSubstitutions(this.frame, generalContext, specificContext),
-          verifiesWhenDerived = validateWhenDerived(term, frame, this.negated, generalContext, specificContext);
+          validatesWhenDerived = validateWhenDerived(term, frame, this.negated, generalContext, specificContext);
 
-    unifiesIndependently = verifiesWhenDerived; ///
+    if (validatesWhenDerived) {
+      unifiesIndependently = true;
+    }
 
     if (unifiesIndependently) {
       context.debug(`...unified the '${definedAssertionString}' defined assertion independently.`);
@@ -234,10 +236,17 @@ export default define(class DefinedAssertion extends Assertion {
 
     return definedAssertion;
   }
+
+  static fromStatement(statement, context) {
+    const statementNode = statement.getNode(),
+          definedAssertion = definedAssertionFromStatementNode(statementNode, context);
+
+    return definedAssertion;
+  }
 });
 
 function validateWhenDerived(term, frame, negated, generalContext, specificContext) {
-  let verifiesWhenDerived = false;
+  let validatesWhenDerived = false;
 
   const context = specificContext;  ///
 
@@ -247,11 +256,11 @@ function validateWhenDerived(term, frame, negated, generalContext, specificConte
           variableDefined = isVariableDefined(variable, context);
 
     if (!negated && variableDefined) {
-      verifiesWhenDerived = true;
+      validatesWhenDerived = true;
     }
 
     if (negated && !variableDefined) {
-      verifiesWhenDerived = true;
+      validatesWhenDerived = true;
     }
   }
 
@@ -261,15 +270,15 @@ function validateWhenDerived(term, frame, negated, generalContext, specificConte
           metavariableDefined = isMetavariableDefined(metavariable, context);
 
     if (!negated && metavariableDefined) {
-      verifiesWhenDerived = true;
+      validatesWhenDerived = true;
     }
 
     if (negated && !metavariableDefined) {
-      verifiesWhenDerived = true;
+      validatesWhenDerived = true;
     }
   }
 
-  return verifiesWhenDerived;
+  return validatesWhenDerived;
 }
 
 function isVariableDefined(variable, context) {

package/src/element/assertion/property.js

@@ -6,7 +6,7 @@ import { define } from "../../elements";
 import { instantiate } from "../../utilities/context";
 import { instantiatePropertyAssertion } from "../../process/instantiate";
 import { variableAssignmentFromPrepertyAssertion } from "../../process/assign";
-import { termFromPropertyAssertionNode, propertyRelationFromPropertyAssertionNode } from "../../utilities/element";
+import { termFromPropertyAssertionNode, propertyAssertionFromStatementNode, propertyRelationFromPropertyAssertionNode } from "../../utilities/element";
 
 export default define(class PropertyAssertion extends Assertion {
   constructor(context, string, node, term, propertyRelation) {
@@ -226,4 +226,11 @@ export default define(class PropertyAssertion extends Assertion {
 
     return propertyAssertion;
   }
+
+  static fromStatement(statement, context) {
+    const statementNode = statement.getNode(),
+          propertyAssertion = propertyAssertionFromStatementNode(statementNode, context);
+
+    return propertyAssertion;
+  }
 });

package/src/element/assertion/satisfies.js

@@ -5,7 +5,7 @@ import Assertion from "../assertion";
 import { define } from "../../elements";
 import { instantiate } from "../../utilities/context";
 import { instantiateSatisfiesAssertion } from "../../process/instantiate";
-import { signatureFromJSatisfiesAssertionNode, referenceFromJSatisfiesAssertionNode } from "../../utilities/element";
+import { signatureFromJSatisfiesAssertionNode, referenceFromJSatisfiesAssertionNode, satisfiesAssertionFromStatementNode } from "../../utilities/element";
 
 export default define(class SatisfiesAssertion extends Assertion {
   constructor(context, string, node, signature, reference) {
@@ -179,4 +179,11 @@ export default define(class SatisfiesAssertion extends Assertion {
 
     return satisfiesAssertion;
   }
+
+  static fromStatement(statement, context) {
+    const statementNode = statement.getNode(),
+          satisfiesAssertion = satisfiesAssertionFromStatementNode(statementNode, context);
+
+    return satisfiesAssertion;
+  }
 });

package/src/element/assertion/subproof.js

@@ -8,6 +8,7 @@ import { define } from "../../elements";
 import { reconcile } from "../../utilities/context";
 import { join, descend, instantiate } from "../../utilities/context";
 import { instantiateSubproofAssertion } from "../../process/instantiate";
+import { subproofAssertionFromStatementNode } from "../../utilities/element";
 
 const { last, front, backwardsEvery } = arrayUtilities;
 
@@ -310,6 +311,13 @@ export default define(class SubproofAssertion extends Assertion {
 
     return subproorAssertion;
   }
+
+  static fromStatement(statement, context) {
+    const statementNode = statement.getNode(),
+          subproofAssertion = subproofAssertionFromStatementNode(statementNode, context);
+
+    return subproofAssertion;
+  }
 });
 
 function statementsFromSubproofAssertionNode(subproofAssertionNode, context) {

package/src/element/assertion/type.js

@@ -5,9 +5,9 @@ import Assertion from "../assertion";
 import { define } from "../../elements";
 import { instantiate } from "../../utilities/context";
 import { instantiateTypeAssertion } from "../../process/instantiate";
-import { termFromTypeAssertionNode } from "../../utilities/element";
 import { typeFromJSON, typeToTypeJSON } from "../../utilities/json";
 import { variableAssignmentFromTypeAssertion } from "../../process/assign";
+import { termFromTypeAssertionNode, typeAssertionFromStatementNode } from "../../utilities/element";
 
 export default define(class TypeAssertion extends Assertion {
   constructor(context, string, node, term, type) {
@@ -229,4 +229,11 @@ export default define(class TypeAssertion extends Assertion {
 
     return typeAssertion;
   }
+
+  static fromStatement(statement, context) {
+    const statementNode = statement.getNode(),
+          typeAssertion = typeAssertionFromStatementNode(statementNode, context);
+
+    return typeAssertion;
+  }
 });