occam-verify-cli 1.0.388 → 1.0.404

package/src/ontology/assumption.js

@@ -0,0 +1,385 @@
+"use strict";
+
+import ontology from "../ontology";
+
+import { define } from "../ontology";
+import { unifyStatementIntrinsically } from "../utilities/unification";
+import { metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
+
+export default define(class Assumption {
+  constructor(string, node, statement, metavariable) {
+    this.string = string;
+    this.node = node;
+    this.statement = statement;
+    this.metavariable = metavariable;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getNode() {
+    return this.node;
+  }
+
+  getStatement() {
+    return this.statement;
+  }
+
+  getMetavariable() {
+    return this.metavariable;
+  }
+
+  isSimple() {
+    const simple = (this.statement === null);
+
+    return simple;
+  }
+
+  matchSubstitution(substitution, context) {
+    let substitutionMatches = false;
+
+    const assumptionString = this.string,  ///
+          substitutionString = substitution.getString();
+
+    context.trace(`Matching the '${substitutionString}' substitution against the '${assumptionString}' assumption...`);
+
+    const simple = this.isSimple();
+
+    if (simple) {
+      const judgement = context.findJudgementByMetavariable(this.metavariable);
+
+      if (judgement !== null) {
+        const assumption = judgement.getDeclaration();
+
+        substitutionMatches = assumption.matchSubstitution(substitution, context);
+      }
+    } else {
+      const statement = substitution.getStatement(),
+            metavariable = substitution.getMetavariable(),
+            statementEqualToStatement = this.statement.isEqualTo(statement),
+            metavariableEqualToMetavariable = this.metavariable.isEqualTo(metavariable);
+
+      if (metavariableEqualToMetavariable && statementEqualToStatement) {
+        substitutionMatches = true;
+      }
+    }
+
+    if (substitutionMatches) {
+      context.debug(`...matches the '${assumptionString}' substitution against the '${substitutionString}' assumption.`);
+    }
+
+    return substitutionMatches;
+  }
+
+  verify(assignments, stated, context) {
+    let verifies = false;
+
+    const assumptionString = this.string;  ///
+
+    context.trace(`Verifying the '${assumptionString}' assumption...`);
+
+    const simple = this.isSimple();
+
+    if (simple) {
+      const verifiesAsMetavariable = this.verifyAsMetavariable(assignments, stated, context);
+
+      verifies = verifiesAsMetavariable; ///
+    } else {
+      const metavariableVerifiesAsReference = this.verifyMetavariableAsReference(assignments, stated, context);
+
+      if (metavariableVerifiesAsReference) {
+        const statementVerifies = this.verifyStatement(assignments, stated, context);
+
+        if (statementVerifies) {
+          let verifiesWhenStated = false,
+              verifiesWhenDerived = false;
+
+          if (stated) {
+            verifiesWhenStated = this.verifyWhenStated(assignments, context);
+          } else {
+            verifiesWhenDerived = this.verifyWhenDerived(context);
+          }
+
+          if (verifiesWhenStated || verifiesWhenDerived) {
+            verifies = true;
+          }
+        }
+      }
+
+      if (verifies) {
+        context.debug(`...verified the '${assumptionString}' assumption.`);
+      }
+    }
+
+    return verifies;
+  }
+
+  verifyMetavariableAsReference(assignments, stated, context) {
+    let metavariableVerifiesAsReference;
+
+    const assumptionString = this.string,
+          metavariableString = this.metavariable.getString();
+
+    context.trace(`Verifying the '${assumptionString}' assumption's '${metavariableString}' metavariable as a reference...`);
+
+    const reference = referenceFromMetavariable(this.metavariable, context),
+          referenceVerifies = reference.verify(context);
+
+    metavariableVerifiesAsReference = referenceVerifies;  ///
+
+    if (metavariableVerifiesAsReference) {
+      context.debug(`...verified the '${assumptionString}' assumption's '${metavariableString}' metavariable as a reference.`);
+    }
+
+    return metavariableVerifiesAsReference;
+  }
+
+  verifyStatement(assignments, stated, context) {
+    let statementVerifies;
+
+    if (this.statement === null) {
+      statementVerifies = true;
+    } else {
+      const statementString = this.statement.getString();
+
+      context.trace(`Verifying the '${statementString}' statement...`);
+
+      stated = true;  ///
+
+      assignments = null; ///
+
+      statementVerifies = this.statement.verify(assignments, stated, context);
+
+      if (statementVerifies) {
+        context.debug(`...verified the '${statementString}' statement.`);
+      }
+    }
+
+    return statementVerifies;
+  }
+
+  verifyAsMetavariable(assignments, stated, context) {
+    let verifiesAsMetavariable;
+
+    const assumptionString = this.string,  ///
+          metavariableString = this.metavariable.getString();
+
+    context.trace(`Verifying the '${assumptionString}' assumption's '${metavariableString}' metavariable...`);
+
+    verifiesAsMetavariable = this.metavariable.verify(context);
+
+    if (verifiesAsMetavariable) {
+      context.debug(`...verified the '${assumptionString}' assumption's '${metavariableString}' metavariable.`);
+    }
+
+    return verifiesAsMetavariable;
+  }
+
+  verifyWhenStated(assignments, context) {
+    let verifiesWhenStated;
+
+    const assumptionString = this.string;  ///
+
+    context.trace(`Verifying the '${assumptionString}' stated assumption...`);
+
+    const reference = referenceFromMetavariable(this.metavariable, context),
+          metavariablePresent = context.isMetavariablePresentByReference(reference);
+
+    if (metavariablePresent) {
+      verifiesWhenStated = true;
+    } else {
+      const metaLemmaMetatheorems = context.findMetaLemmaMetatheoremsByReference(reference),
+            metaLemmaMetatheoremsUnify = metaLemmaMetatheorems.every((metaLemmaMetatheorem) => {
+              const metaLemmaMetatheoremUnifies = this.unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context);
+
+              if (metaLemmaMetatheoremUnifies) {
+                return true;
+              }
+            });
+
+      verifiesWhenStated = metaLemmaMetatheoremsUnify; ///
+    }
+
+    if (verifiesWhenStated) {
+      context.debug(`...verified the '${assumptionString}' stated assumption.`);
+    }
+
+    return verifiesWhenStated;
+  }
+
+  verifyWhenDerived(context) {
+    let verifiesWhenDerived;
+
+    const assumptionString = this.string;  ///
+
+    context.trace(`Verifying the '${assumptionString}' derived assumption...`);
+
+    const reference = referenceFromMetavariable(this.metavariable, context),
+          metaLemmaMetatheoremPresent = context.isMetaLemmaMetatheoremPresentByReference(reference);
+
+    verifiesWhenDerived = metaLemmaMetatheoremPresent; ///
+
+    if (verifiesWhenDerived) {
+      context.debug(`...verified the '${assumptionString}' derived assumption.`);
+    }
+
+    return verifiesWhenDerived;
+  }
+
+  unifyStatement(statement, substitutions, generalContext, specificContext) {
+    let statementUnifies;
+
+    const simple = this.isSimple();
+
+    if (simple) {
+      statementUnifies = false;
+    } else {
+      const context = generalContext,  ///
+            statementString = statement.getString(),
+            assumptionStatementString = this.statement.getString();
+
+      context.trace(`Unifying the '${statementString}' statement with the '${assumptionStatementString}' statement...`);
+
+      const generalStatement = this.statement,
+            specificStatement = statement,  ///
+            statementUUnifiesIntrinsically = unifyStatementIntrinsically(generalStatement, specificStatement, substitutions, generalContext, specificContext);
+
+      statementUnifies = statementUUnifiesIntrinsically;  ///
+
+      if (statementUnifies) {
+        context.debug(`...unified the '${statementString}' statement with the '${assumptionStatementString}' statement.`);
+      }
+    }
+
+    return statementUnifies;
+  }
+
+  unifyLabel(label, substitutions, generalContext, specificContext) {
+    let labelUnifiesWithReference;
+
+    const context = generalContext, ///
+          labelString = label.getString(),
+          assumptionString = this.string;  //;/
+
+    context.trace(`Unifying the '${labelString}' label with the '${assumptionString}' assumption...`);
+
+    const reference = referenceFromMetavariable(this.metavariable, context),
+          labelUnifies = reference.unifyLabel(label, substitutions, context);
+
+    labelUnifiesWithReference = labelUnifies; ///
+
+    if (labelUnifiesWithReference) {
+      context.debug(`...unified the '${labelString}' label with the '${assumptionString}' assumption.`);
+    }
+
+    return labelUnifiesWithReference;
+  }
+
+  unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context) {
+    let metaLemmaMetatheoremUnifies = false;
+
+    const assumptionString = this.string,  ///
+          metaLemmaMetatheoremString = metaLemmaMetatheorem.getString();
+
+    context.trace(`Unifying the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${assumptionString}' assumption...`);
+
+    const generalContext = context; ///
+
+    context = metaLemmaMetatheorem.getContext();  ///
+
+    const { Substitutions } = ontology,
+          specificContext = context,  ///
+          labelSubstitutions = Substitutions.fromNothing(),
+          label = metaLemmaMetatheorem.getLabel(),
+          substitutions = labelSubstitutions, ///
+          labelUnifies = this.unifyLabel(label, substitutions, generalContext, specificContext);
+
+    if (labelUnifies) {
+      const statementSubstitutions = Substitutions.fromNothing(),
+            statement = metaLemmaMetatheorem.getStatement(),
+            substitutions = statementSubstitutions, ///
+            statementUUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+
+      if (statementUUnifies) {
+        const labelSubstitutionsCorrelateStatementSubstitutions = labelSubstitutions.correlateSubstitutions(statementSubstitutions);
+
+        if (labelSubstitutionsCorrelateStatementSubstitutions) {
+          metaLemmaMetatheoremUnifies = true; ///
+        }
+      }
+    }
+
+    if (metaLemmaMetatheoremUnifies) {
+      context = generalContext; ///
+
+      context.trace(`...unified the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${assumptionString}' assumption...`);
+    }
+
+    return metaLemmaMetatheoremUnifies;
+  }
+
+  toJSON() {
+    let json = null;
+
+    const simple = this.isSimple();
+
+    if (simple) {
+      const metavariable = this.getMetavariable(),
+            metavariableJSON = metavariableToMetavariableJSON(metavariable);
+
+      json = metavariableJSON;  ///
+    }
+
+    return json;
+  }
+
+  static name = "Assumption";
+
+  static fromJSON(json, context) {
+    let assumption = null;
+
+    if (json !== null) {
+      const string = null,
+            node = null,
+            statement = null,
+            metavariable = metavariableFromJSON(json, context);
+
+      assumption = new Assumption(string, node, statement, metavariable)
+    }
+
+    return assumption;
+  }
+
+  static fromJudgementNode(judgementNode, context) {
+    const assumptionNode = judgementNode.getAssumptionNode(),
+          assumption = assumptionFromAssumptionNode(assumptionNode, context);
+
+    return assumption;
+  }
+
+  static fromAssumptionNode(assumptionNode, context) {
+    const assumption = assumptionFromAssumptionNode(assumptionNode, context);
+
+    return assumption;
+  }
+});
+
+function referenceFromMetavariable(metavariable, context) {
+  const { Reference } = ontology,
+        metavariableNode = metavariable.getNode(),
+        reference = Reference.fromMetavariableNode(metavariableNode, context);
+
+  return reference;
+}
+
+function assumptionFromAssumptionNode(assumptionNode, context) {
+  const { Metavariable, Assumption, Statement } = ontology,
+        node = assumptionNode,  ///
+        string = context.nodeAsString(node),
+        statement = Statement.fromAssumptionNode(assumptionNode, context),
+        metavariable = Metavariable.fromAssumptionNode(assumptionNode, context),
+        assumption = new Assumption(string, node, statement, metavariable);
+
+  return assumption;
+}

package/src/ontology/axiom.js

@@ -82,6 +82,8 @@ export default define(class Axiom extends TopLevelAssertion {
   unifyStep(step, substitutions, context) {
     let stepUnifies = false;
 
+    context = step.getContext();
+
     const node = this.getNode(),
           stepString = step.getString(),
           axiomString = this.getString();
@@ -94,12 +96,7 @@ export default define(class Axiom extends TopLevelAssertion {
       context.trace(`Cannot unify the '${stepString}' step with the '${axiomString}' axiom because the axiom is not unconditional.`, node);
     } else {
       const statement = step.getStatement(),
-            specificContext = context;  ///
-
-      context = this.getContext();
-
-      const generalContext = context,  ///
-            statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, generalContext, specificContext);
+            statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, context);
 
       if (statementUnifiesWithDeduction) {
         stepUnifies = true;
@@ -113,18 +110,17 @@ export default define(class Axiom extends TopLevelAssertion {
     return stepUnifies;
   }
 
-  unifyLastStep(lastStep, substitutions, generalContext, specificContext) {
+  unifyLastStep(lastStep, substitutions, context) {
     let lastStepUnifies = false;
 
     const node = this.getNode(),
-          context = specificContext,  ///
           axiomString = this.getString(),
           lastStepString = lastStep.getString();
 
     context.trace(`Unifying the '${lastStepString}' last step with the '${axiomString}' axiom...`, node)
 
     const statement = lastStep.getStatement(),
-          statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, generalContext, specificContext);
+          statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, context);
 
     if (statementUnifiesWithDeduction) {
       lastStepUnifies = true;
@@ -152,16 +148,11 @@ export default define(class Axiom extends TopLevelAssertion {
       context.trace(`Cannot unify the '${subproofString}' subproof with the '${axiomString}' axiom because the axiom is unconditional.`, node);
     } else {
       const lastStep = subproof.getLastStep(),
-            specificContext = context;  ///
-
-      context = this.getContext();
-
-      const generalContext = context,  ///
-            lastStepUnifies = this.unifyLastStep(lastStep, substitutions, generalContext, specificContext);
+            lastStepUnifies = this.unifyLastStep(lastStep, substitutions, context);
 
       if (lastStepUnifies) {
         const suppositions = subproof.getSuppositions(),
-              suppositionsUnify = this.unifySuppositions(suppositions, substitutions, generalContext, specificContext);
+              suppositionsUnify = this.unifySuppositions(suppositions, substitutions, context);
 
         if (suppositionsUnify) {
           subproofUnifies = true;

package/src/ontology/combinator/bracketed.js

@@ -23,6 +23,8 @@ export default define(class BracketedCombinator extends Combinator {
     return statementUnifies;
   }
 
+  static name = "BracketedCombinator";
+
   static fromNothing() {
     const { Statement } = ontology,
           bracketedStatementNode = combinatorBracketedContext.getBracketedStatementNode(),

package/src/ontology/combinator.js

@@ -53,6 +53,8 @@ export default define(class Combinator {
     return json;
   }
 
+  static name = "Combinator";
+
   static fromJSON(json, context) {
     const statement = statementFromJSON(json, context),
           combinator = new Combinator(statement);

package/src/ontology/conclusion.js

@@ -1,17 +1,23 @@
 "use strict";
 
 import ontology from "../ontology";
+import TemporaryContext from "../context/temporary";
 
 import { define } from "../ontology";
-import { statementFromJSON, statementToStatementJSON } from "../utilities/json";
+import { termsFromJSON, framesFromJSON, statementFromJSON, termsToTermsJSON, framesToFramesJSON, statementToStatementJSON } from "../utilities/json";
 
 export  default define(class Conclusion {
-  constructor(node, string, statement) {
+  constructor(context, node, string, statement) {
+    this.context = context;
     this.node = node;
     this.string = string;
     this.statement = statement;
   }
 
+  getContext() {
+    return this.context;
+  }
+
   getNode() {
     return this.node;
   }
@@ -27,6 +33,10 @@ export  default define(class Conclusion {
   verify(context) {
     let verifies = false;
 
+    const temporaryContext = TemporaryContext.fromNothing(context);
+
+    context = temporaryContext; ///
+
     const conclusionString = this.string;  ///
 
     context.trace(`Verifying the '${conclusionString}' conclusion...`, this.node);
@@ -43,35 +53,56 @@ export  default define(class Conclusion {
     }
 
     if (verifies) {
+      this.context = context;
+
       context.debug(`...verified the '${conclusionString}' conclusion.`, this.node);
     }
 
     return verifies;
   }
 
-  unifyStatement(statement, substitutions, generalContext, specificContext) {
+  unifyStatement(statement, substitutions, context) {
     let statementUnifies;
 
     const conclusion = this,  ///
           statementString = statement.getString(),
           conclusionString = conclusion.getString();
 
-    specificContext.trace(`Unifying the '${statementString}' statement with the '${conclusionString}' conclusion...`);
+    context.trace(`Unifying the '${statementString}' statement with the '${conclusionString}' conclusion...`);
+
+    const generalContext = this.context,  ///
+          specificContext = context;  ///
 
     statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
 
     if (statementUnifies) {
-      specificContext.debug(`...unified the '${statementString}' statement with the '${conclusionString}' conclusion.`);
+      context.debug(`...unified the '${statementString}' statement with the '${conclusionString}' conclusion.`);
     }
 
     return statementUnifies;
   }
 
   toJSON() {
+    let frames,
+        terms;
+
+    frames = this.context.getFrames();
+
+    terms = this.context.getTerms();
+
     const statementJSON = statementToStatementJSON(this.statement),
-          statement = statementJSON,  ///
+          framesJSON = framesToFramesJSON(frames),
+          termsJSON = termsToTermsJSON(terms);
+
+    frames = framesJSON;  ///
+
+    terms = termsJSON;  ///
+
+    const statement = statementJSON,  ///
           json = {
-            statement
+            statement,
+            frames,
+            terms
           };
 
     return json;
@@ -80,10 +111,16 @@ export  default define(class Conclusion {
   static name = "Conclusion";
 
   static fromJSON(json, context) {
-    const statement = statementFromJSON(json, context),
+    const terms = termsFromJSON(json, context),
+          frames = framesFromJSON(json, context),
+          statement = statementFromJSON(json, context),
           node = null,
           string = statement.getString(),
-          conclusion = new Conclusion(node, string, statement);
+          temporaryContext = TemporaryContext.fromTermsAndFrames(terms, frames, context);
+
+    context = temporaryContext; ///
+
+    const conclusion = new Conclusion(context, node, string, statement);
 
     return conclusion;
   }
@@ -93,7 +130,11 @@ export  default define(class Conclusion {
           node = conclusionNode,  ///
           string = context.nodeAsString(node),
           statement = Statement.fromConclusionNode(conclusionNode, context),
-          conclusion = new Conclusion(node, string, statement);
+          temporaryContext = null;
+
+    context = temporaryContext; ///
+
+    const conclusion = new Conclusion(context, node, string, statement);
 
     return conclusion;
   }

package/src/ontology/constructor/bracketed.js

@@ -52,6 +52,8 @@ export default define(class BracketedConstructor extends Constructor {
     return termUnifies;
   }
 
+  static name = "BracketedConstructor";
+
   static fromNothing() {
     const { Term } = ontology,
           bracketedTermNode = constructorBracketedContext.getBracketedTermNode(),

package/src/ontology/constructor.js

@@ -67,6 +67,8 @@ export default define(class Constructor {
     return json;
   }
 
+  static name = "Constructor";
+
   static fromJSON(json, context) {
     const term = termFromJSON(json, context),
           string = stringFromTerm(term),