occam-verify-cli 1.0.396 → 1.0.405

package/src/ontology/assertion/defined.js

@@ -2,7 +2,6 @@
 
 import ontology from "../../ontology";
 import Assertion from "../assertion";
-import TemporaryContext from "../../context/temporary";
 
 import { define } from "../../ontology";
 import { termFromTermAndSubstitutions, frameFromFrameAndSubstitutions } from "../../utilities/substitutions";
@@ -139,7 +138,10 @@ export default define(class DefinedAssertion extends Assertion {
 
     context.trace(`Verifying the '${definedAssertionString}' derived defined assertion...`);
 
-    verifiesWhenDerived = verifyWhenDerived(this.term, this.frame, this.negated, context);
+    const generalContext = null,
+          specificContext = context;  ///
+
+    verifiesWhenDerived = verifyWhenDerived(this.term, this.frame, this.negated, generalContext, specificContext);
 
     if (verifiesWhenDerived) {
       context.debug(`...verified the '${definedAssertionString}' derived defined assertion.`);
@@ -148,21 +150,17 @@ export default define(class DefinedAssertion extends Assertion {
     return verifiesWhenDerived;
   }
 
-  unifyIndependently(substitutions, context) {
+  unifyIndependently(substitutions, generalContext, specificContext) {
     let unifiesIndependently;
 
-    const definedAssertionString = this.getString(); ///
+    const context = generalContext, ///
+          definedAssertionString = this.getString(); ///
 
     context.trace(`Unifying the '${definedAssertionString}' defined assertion independently...`);
 
-    const tokens = this.getTokens(),
-          temporaryContext = TemporaryContext.fromContextAndTokens(context, tokens);
-
-    context = temporaryContext; ///
-
-    const term = termFromTermAndSubstitutions(this.term, substitutions, context),
-          frame = frameFromFrameAndSubstitutions(this.frame, substitutions, context),
-          verifiesWhenDerived = verifyWhenDerived(term, frame, this.negated, context);
+    const term = termFromTermAndSubstitutions(this.term, substitutions, generalContext, specificContext),
+          frame = frameFromFrameAndSubstitutions(this.frame, substitutions, generalContext, specificContext),
+          verifiesWhenDerived = verifyWhenDerived(term, frame, this.negated, generalContext, specificContext);
 
     unifiesIndependently = verifiesWhenDerived; ///
 
@@ -196,9 +194,11 @@ export default define(class DefinedAssertion extends Assertion {
   }
 });
 
-function verifyWhenDerived(term, frame, negated, context) {
+function verifyWhenDerived(term, frame, negated, generalContext, specificContext) {
   let verifiesWhenDerived = false;
 
+  const context = specificContext;  ///
+
   if (term !== null) {
     const { Variable } = ontology,
           termNode = term.getNode(),

package/src/ontology/assertion/satisfies.js

@@ -2,7 +2,6 @@
 
 import ontology from "../../ontology";
 import Assertion from "../assertion";
-import Substitutions from "../../substitutions";
 
 import { define } from "../../ontology";
 
@@ -98,6 +97,8 @@ export default define(class SatisfiesAssertion extends Assertion {
     if (satisfiable) {
       let substitutions;
 
+      const { Substitutions } = ontology;
+
       substitutions = Substitutions.fromNothing();
 
       const signatureMatches = axiom.matchSignature(this.signature, substitutions, context);

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/declaration/combinator.js

@@ -1,31 +1,18 @@
 "use strict";
 
 import ontology from "../../ontology";
+import Declaration from "../declaration";
 
 import { define } from "../../ontology";
 
 import combinatorVerifier from "../../verifier/combinator";
 
-export default define(class CombinatorDeclaration {
+export default define(class CombinatorDeclaration extends Declaration {
   constructor(context, node, string, combinator) {
-    this.context = context;
-    this.node = node;
-    this.string = string;
+    super(context, node, string);
     this.combinator = combinator;
   }
 
-  getContext() {
-    return this.context;
-  }
-
-  getNode() {
-    return this.node;
-  }
-
-  getString() {
-    return this.string;
-  }
-
   getCombinator() {
     return this.combinator;
   }
@@ -33,20 +20,22 @@ export default define(class CombinatorDeclaration {
   verify() {
     let verifies = false;
 
-    const combinatorDeclarationString = this.string;  ///
+    const node = this.getNode(),
+          context = this.getContext(),
+          combinatorDeclarationString = this.getString();  ///
 
-    this.context.trace(`Verifying the '${combinatorDeclarationString}' combinator declaration...`, this.node);
+    context.trace(`Verifying the '${combinatorDeclarationString}' combinator declaration...`, node);
 
     const combinatorVerifies = this.verifyCombinator();
 
     if (combinatorVerifies) {
-      this.context.addCombinator(this.combinator);
+      context.addCombinator(this.combinator);
 
       verifies = true;
     }
 
     if (verifies) {
-      this.context.debug(`...verified the '${combinatorDeclarationString}' combinator declaration.`, this.node);
+      context.debug(`...verified the '${combinatorDeclarationString}' combinator declaration.`, node);
     }
 
     return verifies;
@@ -55,17 +44,19 @@ export default define(class CombinatorDeclaration {
   verifyCombinator() {
     let statementVerifies;
 
-    const combinatorString = this.combinator.getString();
+    const node = this.getNode(),
+          context = this.getContext(),
+          combinatorString = this.combinator.getString();
 
-    this.context.trace(`Verifying the '${combinatorString}' combinator...`, this.node);
+    context.trace(`Verifying the '${combinatorString}' combinator...`, node);
 
     const statement = this.combinator.getStatement(),
           statementNode = statement.getNode();
 
-    statementVerifies = combinatorVerifier.verifyStatement(statementNode, this.context);
+    statementVerifies = combinatorVerifier.verifyStatement(statementNode, context);
 
     if (statementVerifies) {
-      this.context.debug(`...verified the '${combinatorString}' combinator.`, this.node);
+      context.debug(`...verified the '${combinatorString}' combinator.`, node);
     }
 
     return statementVerifies;