occam-verify-cli 1.0.396 → 1.0.404

package/src/ontology/declaration.js

@@ -1,385 +1,21 @@
 "use strict";
 
-import ontology from "../ontology";
-import Substitutions from "../substitutions";
-
-import { define } from "../ontology";
-import { unifyStatementIntrinsically } from "../utilities/unification";
-import { metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
-
-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 = generalContext; ///
-
-      context.trace(`...unified the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${declarationString}' declaration...`);
-    }
-
-    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 = "Declaration";
-
-  static fromJSON(json, context) {
-    let declaration = null;
-
-    if (json !== null) {
-      const string = null,
-            node = null,
-            statement = null,
-            metavariable = metavariableFromJSON(json, context);
-
-      declaration = new Declaration(string, node, statement, metavariable)
-    }
-
-    return 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),
-        statement = Statement.fromDeclarationNode(declarationNode, context),
-        metavariable = Metavariable.fromDeclarationNode(declarationNode, context),
-        declaration = new Declaration(string, node, statement, metavariable);
-
-  return declaration;
 }

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);
       }
     });
   });

package/src/ontology/frame.js

@@ -11,11 +11,11 @@ import { FRAME_META_TYPE_NAME } from "../metaTypeNames";
 const { first } = arrayUtilities;
 
 export default define(class Frame {
-  constructor(string, node, tokens, declarations) {
+  constructor(string, node, tokens, assumptions) {
     this.string = string;
     this.node = node;
     this.tokens = tokens;
-    this.declarations = declarations;
+    this.assumptions = assumptions;
   }
 
   getString() {
@@ -30,24 +30,24 @@ export default define(class Frame {
     return this.tokens;
   }
 
-  getDeclarations() {
-    return this.declarations;
+  getAssumptions() {
+    return this.assumptions;
   }
 
-  getLength() { return this.declarations.length; }
+  getLength() { return this.assumptions.length; }
 
-  getDeclaration() {
-    let declaration = null;
+  getAssumption() {
+    let assumption = null;
 
     const length = this.getLength();
 
     if (length === 1) {
-      const firstDeclaration = first(this.declarations);
+      const firstAssumption = first(this.assumptions);
 
-      declaration = firstDeclaration; ///
+      assumption = firstAssumption; ///
     }
 
-    return declaration;
+    return assumption;
   }
 
   getMetavariable() {
@@ -56,25 +56,15 @@ export default define(class Frame {
     const simple = this.isSimple();
 
     if (simple) {
-      const declaration = this.getDeclaration();
+      const assumption = this.getAssumption();
 
-      metavariable = declaration.getMetavariable();
+      metavariable = assumption.getMetavariable();
     }
 
     return metavariable;
   }
 
-  isSimple() {
-    let simple = false;
-
-    const declaration = this.getDeclaration();
-
-    if (declaration !== null) {
-      simple = declaration.isSimple();
-    }
-
-    return simple;
-  }
+  isSimple() { return this.node.isSimple();}
 
   isEqualTo(frame) {
     const frameString = frame.getString(),
@@ -94,10 +84,10 @@ export default define(class Frame {
     context.trace(`Matching the '${substitutionString}' substitution against the '${frameString}' frame...`);
 
     if (!substitutionMatches) {
-      substitutionMatches = this.declarations.some((declaration) => {
-        const substitutionMatchesDeclaration = declaration.matchSubstitution(substitution, context);
+      substitutionMatches = this.assumptions.some((assumption) => {
+        const substitutionMatchesAssumption = assumption.matchSubstitution(substitution, context);
 
-        if (substitutionMatchesDeclaration) {
+        if (substitutionMatchesAssumption) {
           return true;
         }
       });
@@ -140,9 +130,9 @@ export default define(class Frame {
 
     context.trace(`Verifying the '${frameString}' frame...`);
 
-    const declarationsVerify = this.verifyDeclarations(assignments, stated, context);
+    const assumptionsVerify = this.verifyAssumptions(assignments, stated, context);
 
-    if (declarationsVerify) {
+    if (assumptionsVerify) {
       let verifiesWhenStated = false,
           verifiesWhenDerived = false;
 
@@ -206,8 +196,8 @@ export default define(class Frame {
     return verifiesWhenDerived;
   }
 
-  verifyDeclarations(assignments, stated, context) {
-    let declarationsVerify = true;  ///
+  verifyAssumptions(assignments, stated, context) {
+    let assumptionsVerify = true;  ///
 
     const length = this.getLength();
 
@@ -215,26 +205,26 @@ export default define(class Frame {
       const sOrNothing = (length > 1) ?
                            S :
                              NOTHING,
-            declarationsString = declarationsStringFromDeclarations(this.declarations);
+            assumptionsString = assumptionsStringFromAssumptions(this.assumptions);
 
-      context.trace(`Verifying the '${declarationsString}' declaration${sOrNothing}...`);
+      context.trace(`Verifying the '${assumptionsString}' assumption${sOrNothing}...`);
 
       stated = true;  ///
 
       assignments = null; ///
 
-      declarationsVerify = this.declarations.every((declaration) => {
-        const declarationVerifies = declaration.verify(assignments, stated, context);
+      assumptionsVerify = this.assumptions.every((assumption) => {
+        const assumptionVerifies = assumption.verify(assignments, stated, context);
 
-        return declarationVerifies;
+        return assumptionVerifies;
       });
 
-      if (declarationsVerify) {
-        context.debug(`...verified the '${declarationsString}' declaration${sOrNothing}.`);
+      if (assumptionsVerify) {
+        context.debug(`...verified the '${assumptionsString}' assumption${sOrNothing}.`);
       }
     }
 
-    return declarationsVerify;
+    return assumptionsVerify;
   }
 
   verifyGivenMetaType(metaType, assignments, stated, context) {
@@ -266,10 +256,10 @@ export default define(class Frame {
     const simple = this.isSimple();
 
     if (simple) {
-      const declaration = this.getDeclaration(),
-            declarationJSON = declaration.toJSON();
+      const assumption = this.getAssumption(),
+            assumptionJSON = assumption.toJSON();
 
-      json = declarationJSON;  ///
+      json = assumptionJSON;  ///
     }
 
     return json;
@@ -281,16 +271,16 @@ export default define(class Frame {
     let frame = null;
 
     if (json !== null) {
-      const { Declaration } =ontology,
-            declaration = Declaration.fromJSON(json, context),
-            declarations = [
-              declaration
+      const { Assumption } =ontology,
+            assumption = Assumption.fromJSON(json, context),
+            assumptions = [
+              assumption
             ],
             string = null,
             node = null,
             tokens = null;
 
-      frame = new Frame(string, node, tokens, declarations);
+      frame = new Frame(string, node, tokens, assumptions);
     }
 
     return frame;
@@ -343,34 +333,34 @@ function frameFromFrameNode(frameNode, context) {
         node = frameNode, ///
         string = context.nodeAsString(node),
         tokens = context.nodeAsTokens(node),
-        declarations = declarationsFromFrameNode(frameNode, context),
-        frame = new Frame(string, node, tokens, declarations);
+        assumptions = assumptionsFromFrameNode(frameNode, context),
+        frame = new Frame(string, node, tokens, assumptions);
 
   return frame;
 }
 
-function declarationsFromFrameNode(frameNode, context) {
-  const { Declaration } = ontology,
-        declarationNodes = frameNode.getDeclarationNodes(),
-        declarations = declarationNodes.map((declarationNode) => {
-          const declaration = Declaration.fromDeclarationNode(declarationNode, context);
+function assumptionsFromFrameNode(frameNode, context) {
+  const { Assumption } = ontology,
+        assumptionNodes = frameNode.getAssumptionNodes(),
+        assumptions = assumptionNodes.map((assumptionNode) => {
+          const assumption = Assumption.fromAssumptionNode(assumptionNode, context);
 
-          return declaration;
+          return assumption;
         });
 
-  return declarations;
+  return assumptions;
 }
 
-function declarationsStringFromDeclarations(declarations) {
-  const declarationsString = declarations.reduce((declarationsString, declaration) => {
-    const declarationString = declaration.getString();
+function assumptionsStringFromAssumptions(assumptions) {
+  const assumptionsString = assumptions.reduce((assumptionsString, assumption) => {
+    const assumptionString = assumption.getString();
 
-    declarationsString = (declarationsString === null) ?
-                           declarationString :
-                            `${declarationsString}, ${declarationString}`;
+    assumptionsString = (assumptionsString === null) ?
+                           assumptionString :
+                            `${assumptionsString}, ${assumptionString}`;
 
-    return declarationsString;
+    return assumptionsString;
   }, null);
 
-  return declarationsString;
+  return assumptionsString;
 }