occam-verify-cli 1.0.388 → 1.0.404

package/src/ontology/declaration.js

@@ -1,352 +1,21 @@
 "use strict";
 
-import ontology from "../ontology";
-import Substitutions from "../substitutions";
-
-import { define } from "../ontology";
-import { unifyStatementIntrinsically } from "../utilities/unification";
-
-export default define(class Declaration {
-  constructor(string, node, statement, metavariable) {
-    this.string = string;
+export default class Declaration {
+  constructor(context, node, string) {
+    this.context = context;
     this.node = node;
-    this.statement = statement;
-    this.metavariable = metavariable;
+    this.string = string;
   }
 
-  getString() {
-    return this.string;
+  getContext() {
+    return this.context;
   }
 
   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 declarationString = this.string,  ///
-          substitutionString = substitution.getString();
-
-    context.trace(`Matching the '${substitutionString}' substitution against the '${declarationString}' declaration...`);
-
-    const simple = this.isSimple();
-
-    if (simple) {
-      const judgement = context.findJudgementByMetavariable(this.metavariable);
-
-      if (judgement !== null) {
-        const declaration = judgement.getDeclaration();
-
-        substitutionMatches = declaration.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 '${declarationString}' substitution against the '${substitutionString}' declaration.`);
-    }
-
-    return substitutionMatches;
-  }
-
-  verify(assignments, stated, context) {
-    let verifies = false;
-
-    const declarationString = this.string;  ///
-
-    context.trace(`Verifying the '${declarationString}' declaration...`);
-
-    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 '${declarationString}' declaration.`);
-      }
-    }
-
-    return verifies;
-  }
-
-  verifyMetavariableAsReference(assignments, stated, context) {
-    let metavariableVerifiesAsReference;
-
-    const declarationString = this.string,
-          metavariableString = this.metavariable.getString();
-
-    context.trace(`Verifying the '${declarationString}' declaration's '${metavariableString}' metavariable as a reference...`);
-
-    const reference = referenceFromMetavariable(this.metavariable, context),
-          referenceVerifies = reference.verify(context);
-
-    metavariableVerifiesAsReference = referenceVerifies;  ///
-
-    if (metavariableVerifiesAsReference) {
-      context.debug(`...verified the '${declarationString}' declaration'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 declarationString = this.string,  ///
-          metavariableString = this.metavariable.getString();
-
-    context.trace(`Verifying the '${declarationString}' declaration's '${metavariableString}' metavariable...`);
-
-    verifiesAsMetavariable = this.metavariable.verify(context);
-
-    if (verifiesAsMetavariable) {
-      context.debug(`...verified the '${declarationString}' declaration's '${metavariableString}' metavariable.`);
-    }
-
-    return verifiesAsMetavariable;
-  }
-
-  verifyWhenStated(assignments, context) {
-    let verifiesWhenStated;
-
-    const declarationString = this.string;  ///
-
-    context.trace(`Verifying the '${declarationString}' stated declaration...`);
-
-    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 '${declarationString}' stated declaration.`);
-    }
-
-    return verifiesWhenStated;
-  }
-
-  verifyWhenDerived(context) {
-    let verifiesWhenDerived;
-
-    const declarationString = this.string;  ///
-
-    context.trace(`Verifying the '${declarationString}' derived declaration...`);
-
-    const reference = referenceFromMetavariable(this.metavariable, context),
-          metaLemmaMetatheoremPresent = context.isMetaLemmaMetatheoremPresentByReference(reference);
-
-    verifiesWhenDerived = metaLemmaMetatheoremPresent; ///
-
-    if (verifiesWhenDerived) {
-      context.debug(`...verified the '${declarationString}' derived declaration.`);
-    }
-
-    return verifiesWhenDerived;
-  }
-
-  unifyStatement(statement, substitutions, generalContext, specificContext) {
-    let statementUnifies;
-
-    const simple = this.isSimple();
-
-    if (simple) {
-      statementUnifies = false;
-    } else {
-      const context = generalContext,  ///
-            statementString = statement.getString(),
-            declarationStatementString = this.statement.getString();
-
-      context.trace(`Unifying the '${statementString}' statement with the '${declarationStatementString}' 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 '${declarationStatementString}' statement.`);
-      }
-    }
-
-    return statementUnifies;
-  }
-
-  unifyLabel(label, substitutions, generalContext, specificContext) {
-    let labelUnifiesWithReference;
-
-    const context = generalContext, ///
-          labelString = label.getString(),
-          declarationString = this.string;  //;/
-
-    context.trace(`Unifying the '${labelString}' label with the '${declarationString}' declaration...`);
-
-    const reference = referenceFromMetavariable(this.metavariable, context),
-          labelUnifies = reference.unifyLabel(label, substitutions, context);
-
-    labelUnifiesWithReference = labelUnifies; ///
-
-    if (labelUnifiesWithReference) {
-      context.debug(`...unified the '${labelString}' label with the '${declarationString}' declaration.`);
-    }
-
-    return labelUnifiesWithReference;
-  }
-
-  unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context) {
-    let metaLemmaMetatheoremUnifies = false;
-
-    const declarationString = this.string,  ///
-          metaLemmaMetatheoremString = metaLemmaMetatheorem.getString();
-
-    context.trace(`Unifying the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${declarationString}' declaration...`);
-
-    const generalContext = context; ///
-
-    context = metaLemmaMetatheorem.getContext();  ///
-
-    const 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.trace(`...unified the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${declarationString}' declaration...`);
-    }
-
-    return metaLemmaMetatheoremUnifies;
-  }
-
-  static name = "Declaration";
-
-  static fromJudgementNode(judgementNode, context) {
-    const declarationNode = judgementNode.getDeclarationNode(),
-          declaration = declarationFromDeclarationNode(declarationNode, context);
-
-    return declaration;
-  }
-
-  static fromDeclarationNode(declarationNode, context) {
-    const declaration = declarationFromDeclarationNode(declarationNode, context);
-
-    return declaration;
+  getString() {
+    return this.string;
   }
-});
-
-function referenceFromMetavariable(metavariable, context) {
-  const { Reference } = ontology,
-        metavariableNode = metavariable.getNode(),
-        reference = Reference.fromMetavariableNode(metavariableNode, context);
-
-  return reference;
-}
-
-function declarationFromDeclarationNode(declarationNode, context) {
-  const { Metavariable, Declaration, Statement } = ontology,
-        node = declarationNode,  ///
-        string = context.nodeAsString(node),
-        metavariable = Metavariable.fromDeclarationNode(declarationNode, context),
-        statement = Statement.fromDeclarationNode(declarationNode, context),
-        declaration = new Declaration(string, node, statement, metavariable);
-
-  return declaration;
 }

package/src/ontology/deduction.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 Deduction {
-  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(node) {
     return this.node;
   }
@@ -27,6 +33,10 @@ export default define(class Deduction {
   verify(context) {
     let verifies = false;
 
+    const temporaryContext = TemporaryContext.fromNothing(context);
+
+    context = temporaryContext; ///
+
     const deductionString = this.string;  ///
 
     context.trace(`Verifying the '${deductionString}' deduction...`, this.node);
@@ -42,25 +52,30 @@ export default define(class Deduction {
     }
 
     if (verifies) {
+      this.context = context;
+
       context.debug(`...verified the '${deductionString}' deduction.`, this.node);
     }
 
     return verifies;
   }
 
-  unifyStatement(statement, substitutions, generalContext, specificContext) {
+  unifyStatement(statement, substitutions, context) {
     let statementUnifies;
 
     const deduction = this,  ///
           statementString = statement.getString(),
           deductionString = deduction.getString();
 
-    specificContext.trace(`Unifying the '${statementString}' statement with the '${deductionString}' deduction...`);
+    context.trace(`Unifying the '${statementString}' statement with the '${deductionString}' deduction...`);
+
+    const generalContext = this.context,  ///
+          specificContext = context;  ///
 
     statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
 
     if (statementUnifies) {
-      specificContext.debug(`...unified the '${statementString}' statement with the '${deductionString}' deduction.`);
+      context.debug(`...unified the '${statementString}' statement with the '${deductionString}' deduction.`);
     }
 
     return statementUnifies;
@@ -89,10 +104,26 @@ export default define(class Deduction {
   }
 
   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;
@@ -101,10 +132,16 @@ export default define(class Deduction {
   static name = "Deduction";
 
   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(),
-          deduction = new Deduction(node, string, statement);
+          temporaryContext = TemporaryContext.fromTermsAndFrames(terms, frames, context);
+
+    context = temporaryContext; ///
+
+    const deduction = new Deduction(context, node, string, statement);
 
     return deduction;
   }
@@ -114,7 +151,11 @@ export default define(class Deduction {
           node = deductionNode,  ///
           string = context.nodeAsString(node),
           statement = Statement.fromDeductionNode(deductionNode, context),
-          deduction = new Deduction(node, string, statement);
+          temporaryContext = null;
+
+    context = temporaryContext;  ///
+
+    const deduction = new Deduction(context, node, string, statement);
 
     return deduction;
   }

package/src/{equivalence.js → ontology/equivalence.js}

@@ -2,11 +2,12 @@
 
 import { arrayUtilities } from "necessary";
 
-import { stripBracketsFromTermNode } from "./utilities/brackets";
+import { define } from "../ontology";
+import { stripBracketsFromTermNode } from "../utilities/brackets";
 
 const { compress } = arrayUtilities;
 
-export default class Equivalence {
+export default define(class Equivalence {
   constructor(terms) {
     this.terms = terms;
   }
@@ -265,4 +266,4 @@ export default class Equivalence {
 
     return equivalence;
   }
-}
+});

package/src/{equivalences.js → ontology/equivalences.js}

@@ -2,9 +2,12 @@
 
 import { arrayUtilities } from "necessary";
 
+import { define } from "../ontology";
+import { variablesFromTerm } from "./term";
+
 const { push, separate } = arrayUtilities;
 
-export default class Equivalences {
+export default define(class Equivalences {
   constructor(array) {
     this.array = array;
   }
@@ -188,22 +191,21 @@ export default class Equivalences {
 
     return equivalences;
   }
-}
+});
 
-function definedVariablesFromGroundedTerms(groundedTerms, definedVariables, context) {
-  const terms = groundedTerms,  ///
-        variables = definedVariables; ///
 
-  terms.forEach((term) => {
-    const termVariables = term.getVariables(context);
+function definedVariablesFromGroundedTerms(groundedTerms, definedVariables, context) {
+  groundedTerms.forEach((groundedTerm) => {
+    const term = groundedTerm,  ///
+          variables = variablesFromTerm(term, context);
 
-    termVariables.forEach((termVariable) => {
-      const variablesIncludesTermVariable = variables.includes(termVariable);
+    variables.forEach((variable) => {
+      const definedVariablesIncludesTermVariable = definedVariables.includes(variable);
 
-      if (!variablesIncludesTermVariable) {
-        const variable = termVariable;  ///
+      if (!definedVariablesIncludesTermVariable) {
+        const definedVariable = variable;  ///
 
-        variables.push(variable);
+        definedVariables.push(definedVariable);
       }
     });
   });