occam-verify-cli 1.0.396 → 1.0.404

package/src/ontology/judgement.js

@@ -6,10 +6,10 @@ import JudgementAssignment from "../assignment/judgement";
 import { define } from "../ontology";
 
 export default define(class Judgement {
-  constructor(string, frame, declaration) {
+  constructor(string, frame, assumption) {
     this.string = string;
     this.frame = frame;
-    this.declaration = declaration;
+    this.assumption = assumption;
   }
 
   getString() {
@@ -21,7 +21,7 @@ export default define(class Judgement {
   }
 
   getDeclaration() {
-    return this.declaration;
+    return this.assumption;
   }
 
   isSimple() { return this.frame.isSimple(); }
@@ -88,7 +88,7 @@ export default define(class Judgement {
   verifyDeclaration(assignments, stated, context) {
     let declarationVerifies;
 
-    declarationVerifies = this.declaration.verify(assignments, stated, context);
+    declarationVerifies = this.assumption.verify(assignments, stated, context);
 
     return declarationVerifies;
   }
@@ -116,7 +116,7 @@ export default define(class Judgement {
 
     context.trace(`Verifying the '${judgementString}' derived judgement...`);
 
-    const metavariable = this.declaration.getMetavariable(),
+    const metavariable = this.assumption.getMetavariable(),
           reference = referenceFromMetavariable(metavariable, context),
           metaLemmaMetatheorem = context.findMetaLemmaMetatheoremByReference(reference),
           substitutions = metaLemmaMetatheorem.getSubstitutions(),
@@ -151,13 +151,13 @@ export default define(class Judgement {
     const judgementNode = statementNode.getJudgementNode();
 
     if (judgementNode !== null) {
-      const { Frame, Declaration } = ontology,
+      const { Frame, Assumption } = ontology,
             node = judgementNode, ///
             string = context.nodeAsString(node),
             frame = Frame.fromJudgementNode(judgementNode, context),
-            declaration = Declaration.fromJudgementNode(judgementNode, context);
+            assumption = Assumption.fromJudgementNode(judgementNode, context);
 
-      judgement = new Judgement(string, frame, declaration);
+      judgement = new Judgement(string, frame, assumption);
     }
 
     return judgement;

package/src/ontology/metavariable.js

@@ -474,8 +474,8 @@ export default define(class Metavariable {
     return metavariable;
   }
 
-  static fromDeclarationNode(declarationNode, context) {
-    const metavariableNode = declarationNode.getMetavariableNode(),
+  static fromAssumptionNode(assumptionNode, context) {
+    const metavariableNode = assumptionNode.getMetavariableNode(),
           metavariable = metavariableFromMetavariableNode(metavariableNode, context);
 
     return metavariable;

package/src/ontology/premise.js

@@ -90,18 +90,32 @@ export default define(class Premise {
   }
 
   unifyIndependently(substitutions, context) {
-    let unifiesIndependently;
+    let unifiesIndependently = false;
+
+    const premiseString = this.string,  ///
+          generalContext = this.context,  ///
+          specificContext = context;  ///
+
+    context.trace(`Unifying the '${premiseString}' premise independently...`, this.node);
 
     if (this.statement !== null) {
-      const statementResolvedIndependently = this.statement.unifyIndependently(substitutions, context);
+      const statementUnifiesIndependently = this.statement.unifyIndependently(substitutions, generalContext, specificContext);
 
-      unifiesIndependently = statementResolvedIndependently;  ///
+      if (statementUnifiesIndependently) {
+        unifiesIndependently = true;
+      }
     }
 
     if (this.procedureCall !== null) {
       const procedureCallResolvedIndependently = this.procedureCall.unifyIndependently(substitutions, context);
 
-      unifiesIndependently = procedureCallResolvedIndependently;  ///
+      if (procedureCallResolvedIndependently) {
+        unifiesIndependently = true;
+      }
+    }
+
+    if (unifiesIndependently) {
+      context.debug(`...unified the '${premiseString}' premise independenly.`, this.node);
     }
 
     return unifiesIndependently;

package/src/ontology/reference.js

@@ -1,7 +1,6 @@
 "use strict";
 
 import ontology from "../ontology";
-import Substitutions from "../substitutions";
 
 import { define } from "../ontology";
 import { referenceMetaType } from ".//metaType";
@@ -115,7 +114,8 @@ export default define(class Reference {
 
     context.trace(`Unifying the '${metavariableString}' metavariable with the '${referenceString}' reference...`);
 
-    const substitutions = Substitutions.fromNothing(),
+    const { Substitutions } = ontology,
+          substitutions = Substitutions.fromNothing(),
           generalContext = context, ///
           specificContext = context,  ///
           generalMetavariable = this.metavariable,  ///
@@ -140,7 +140,8 @@ export default define(class Reference {
 
     context.trace(`Unifying the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${referenceString}' reference...`);
 
-    const label = metaLemmaMetatheorem.getLabel(),
+    const { Substitutions } = ontology,
+          label = metaLemmaMetatheorem.getLabel(),
           substitutions = Substitutions.fromNothing(),
           labelUnifies = this.unifyLabel(label, substitutions, context);
 

package/src/ontology/rule.js

@@ -4,7 +4,6 @@ import { arrayUtilities } from "necessary";
 
 import ontology from "../ontology";
 import LocalContext from "../context/local";
-import Substitutions from "../substitutions";
 
 import { define } from "../ontology";
 import { labelsStringFromLabels } from "./topLevelAssertion";
@@ -149,7 +148,8 @@ export default define(class Rule {
     if (this.proof === null) {
       proofVerifies = true;
     } else {
-      const substitutions = Substitutions.fromNothing();
+      const { Substitutions } = ontology,
+            substitutions = Substitutions.fromNothing();
 
       proofVerifies = this.proof.verify(substitutions, this.conclusion, context);
     }
@@ -172,7 +172,8 @@ export default define(class Rule {
   unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, context) {
     let statementAndStepsOrSubproofsUnify = false;
 
-    const substitutions = Substitutions.fromNothing(),
+    const { Substitutions } = ontology,
+          substitutions = Substitutions.fromNothing(),
           statementUnifiesWithConclusion = this.unifyStatementWithConclusion(statement, substitutions, context);
 
     if (statementUnifiesWithConclusion) {

package/src/ontology/statement.js

@@ -10,7 +10,6 @@ import { unifyStatement } from "../utilities/unification";
 import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 import { statementFromStatementNode } from "../utilities/node";
 import { stripBracketsFromStatementNode } from "../utilities/brackets";
-import { definedAssertionFromStatement, containedAssertionFromStatement, subproofAssertionFromStatement } from "../utilities/context";
 
 const { match, backwardsSome } = arrayUtilities;
 
@@ -33,6 +32,8 @@ export default define(class Statement {
     return this.tokens;
   }
 
+  isSimple() { return this.node.isSimple();}
+
   isEqualTo(statement) {
     const statementString = statement.getString(),
           equalTo = (statementString === this.string);
@@ -150,14 +151,18 @@ export default define(class Statement {
     let subproofUnifies = false;
 
     const context = specificContext,  ///
-          statement = this, ///
-          subproofAssertion = subproofAssertionFromStatement(statement, context);
+          statementNode = this.node,
+          subproofAssertionNode = statementNode.getSubproofAssertionNode(),
+          assertionNode = subproofAssertionNode;  ///
+
+    if (assertionNode !== null) {
+      const assertion = generalContext.findAssertionByAssertionNode(assertionNode),
+            subproofAssertion = assertion;  ///
 
-    if (subproofAssertion !== null) {
       const subproofString = subproof.getString(),
             subproofAssertionString = subproofAssertion.getString();
 
-      specificContext.trace(`Unifying the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion...`);
+      context.trace(`Unifying the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion...`);
 
       const subproofStatements = subproof.getStatements(),
             subproofAssertionStatements = subproofAssertion.getStatements();
@@ -173,7 +178,7 @@ export default define(class Statement {
       });
 
       if (subproofUnifies) {
-        specificContext.debug(`...unified the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion.`);
+        context.debug(`...unified the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion.`);
       }
     }
 
@@ -199,27 +204,26 @@ export default define(class Statement {
     return statementUnifies;
   }
 
-  unifyIndependently(substitutions, context) {
+  unifyIndependently(substitutions, generalContext, specificContext) {
     let unifiesIndependently = false;
 
-    const statement = this, ///
+    const context = specificContext,  ///
           statementString = this.string;  ///
 
     context.trace(`Unifying the '${statementString}' statement independently...`);
 
-    const definedAssertion = definedAssertionFromStatement(statement, context),
-          containedAssertion = containedAssertionFromStatement(statement, context);
-
-    if (definedAssertion !== null) {
-      const definedAssertionUnifiesIndependently = definedAssertion.unifyIndependently(substitutions, context);
+    const statementNode = this.node,
+          definedAssertionNode = statementNode.getDefinedAssertionNode(),
+          containedAssertionNode = statementNode.getContainedAssertionNode();
 
-      unifiesIndependently = definedAssertionUnifiesIndependently; ///
-    }
-
-    if (containedAssertion !== null) {
-      const containedAssertionUnifiesIndependently = containedAssertion.unifyIndependently(substitutions, context);
+    if ((definedAssertionNode !== null) || (containedAssertionNode !== null)) {
+      const assertionNode = (definedAssertionNode || containedAssertionNode),
+            assertion = generalContext.findAssertionByAssertionNode(assertionNode),
+            assertionUnifiesIndependently = assertion.unifyIndependently(substitutions, generalContext, specificContext);
 
-      unifiesIndependently = containedAssertionUnifiesIndependently; ///
+      if (assertionUnifiesIndependently) {
+        unifiesIndependently = true;
+      }
     }
 
     if (unifiesIndependently) {
@@ -333,28 +337,28 @@ export default define(class Statement {
     return statement;
   }
 
-  static fromSuppositionNode(suppositionNode, context) {
+  static fromAssumptionNode(assumptionNode, context) {
     let statement = null;
 
-    const statementNode = suppositionNode.getStatementNode();
+    let statementNode;
+
+    statementNode = assumptionNode.getStatementNode(); ///
 
     if (statementNode !== null) {
+      statementNode = stripBracketsFromStatementNode(statementNode);  ///
+
       statement = statementFromStatementNode(statementNode, context);
     }
 
     return statement;
   }
 
-  static fromDeclarationNode(declarationNode, context) {
+  static fromSuppositionNode(suppositionNode, context) {
     let statement = null;
 
-    let statementNode;
-
-    statementNode = declarationNode.getStatementNode(); ///
+    const statementNode = suppositionNode.getStatementNode();
 
     if (statementNode !== null) {
-      statementNode = stripBracketsFromStatementNode(statementNode);  ///
-
       statement = statementFromStatementNode(statementNode, context);
     }
 

package/src/ontology/step.js

@@ -2,7 +2,6 @@
 
 import ontology from "../ontology";
 import unifyMixins from "../mixins/step/unify";
-import Substitutions from "../substitutions";
 import TemporaryContext from "../context/temporary";
 import equationalUnifier from "../unifier/equantional";
 
@@ -182,7 +181,8 @@ export default define(class Step {
           axiom = context.findAxiomByReference(reference);
 
     if (axiom !== null) {
-      const step = this,  ///
+      const { Substitutions } = ontology,
+            step = this,  ///
             substitutions = Substitutions.fromNothing(),
             stepUnifies = axiom.unifyStep(step, substitutions, context);
 

package/src/ontology/subproof.js

@@ -2,7 +2,6 @@
 
 import ontology from "../ontology";
 import LocalContext from "../context/local";
-import Substitutions from "../substitutions";
 
 import { define } from "../ontology";
 import { subproofStringFromSubproofNode } from "../utilities/subproof";
@@ -110,7 +109,8 @@ export default define(class Subproof {
       const axiomSatisfiable = axiom.isSatisfiable();
 
       if (axiomSatisfiable) {
-        const subproof = this,  ///
+        const { Substitutions } = ontology,
+              subproof = this,  ///
               substitutions = Substitutions.fromNothing(),
               statementUnifies = axiom.unifySubproof(subproof, substitutions, context);
 

package/src/ontology/substitution/statement.js

@@ -1,7 +1,7 @@
 "use strict";
 
+import ontology from "../../ontology";
 import Substitution from "../substitution";
-import Substitutions from "../../substitutions";
 import StatementSubstitutionPartialContext from "../../context/partial/substitution/statement";
 
 import { define } from "../../ontology";
@@ -67,7 +67,7 @@ export default define(class StatementSubstitution extends Substitution {
       if (substitution === null) {
         substitutionEqualToSubstitution = false;
       } else {
-        substitutionEqualToSubstitution = this.substitution.isEqualToSubstitution(substitution);
+        substitutionEqualToSubstitution = this.substitution.isEqualTo(substitution);
       }
     }
 
@@ -76,16 +76,63 @@ export default define(class StatementSubstitution extends Substitution {
 
   matchParameter(parameter) { return this.metavariable.matchParameter(parameter); }
 
+  resolve(substitutions, context) {
+    const substitutionString = this.string; ///
+
+    context.trace(`Resolving the ${substitutionString} substitution...`);
+
+    substitutions.snapshot();
+
+    const metavariable = this.getMetavariable(),
+          simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariable(metavariable);
+
+    if (simpleSubstitution !== null) {
+      let context;
+
+      context = this.getContext();
+
+      const substitution = simpleSubstitution.unifyStatement(this.statement, context);
+
+      if (substitution !== null) {
+        context = simpleSubstitution.getContext();
+
+        const terms = context.getTerms(),
+              frames = context.getFrames();
+
+        context = substitution.getContext();
+
+        context.addTerms(terms);
+
+        context.addFrames(frames);
+
+        const substitutionUnifies = this.unifySubstitution(substitution, substitutions, context);
+
+        if (substitutionUnifies) {
+          this.resolved = true;
+        }
+      }
+    }
+
+    this.resolved ?
+      substitutions.continue() :
+        substitutions.rollback(context);
+
+    if (this.resolved) {
+      context.debug(`...resolved the ${substitutionString} substitution.`);
+    }
+  }
+
   unifyStatement(statement, context) {
     let substitution = null;
 
-    const substitutions = Substitutions.fromNothing(),
-          generalContext = context; ///
+    const { Substitutions } = ontology,
+          substitutions = Substitutions.fromNothing(),
+          specificContext = context; ///
 
     context = this.getContext();
 
-    const specificContext = context, ///
-          statementUnifies = statement.unifyStatement(this.statement, substitutions, generalContext, specificContext);
+    const generalContext = context, ///
+          statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
 
     if (statementUnifies) {
       const substitutionsNonTrivialLength = substitutions.getNonTrivialLength();
@@ -101,8 +148,7 @@ export default define(class StatementSubstitution extends Substitution {
   }
 
   unifySubstitution(substitution, substitutions, context) {
-    const frame = context.getFrame(),
-          generalSubstitution = this.substitution,  ///
+    const generalSubstitution = this.substitution,  ///
           specificSubstitution = substitution,  ///
           generalSubstitutionString = generalSubstitution.getString(),
           specificSubstitutionString = specificSubstitution.getString();
@@ -117,19 +163,8 @@ export default define(class StatementSubstitution extends Substitution {
 
     substitutionContext = substitution.getContext();
 
-    const specificContext = substitutionContext;  ///
-
-    specificContext.addFrame(frame);
-
-    substitutions.snapshot();
-
-    const substitutionUnifies = unifySubstitution(generalSubstitution, specificSubstitution, substitutions, generalContext, specificContext);
-
-    specificContext.removeFrame(frame);
-
-    substitutionUnifies ?
-      substitutions.continue() :
-        substitutions.rollback(context);
+    const specificContext = substitutionContext,  ///
+          substitutionUnifies = unifySubstitution(generalSubstitution, specificSubstitution, substitutions, generalContext, specificContext);
 
     if (substitutionUnifies) {
       context.trace(`...unified the '${specificSubstitutionString}' substitution with the '${generalSubstitutionString}' substitution.`);
@@ -138,38 +173,6 @@ export default define(class StatementSubstitution extends Substitution {
     return substitutionUnifies;
   }
 
-  resolve(substitutions, context) {
-    const substitutionString = this.string; ///
-
-    context.trace(`Resolving the ${substitutionString} substitution...`);
-
-    const metavariable = this.getMetavariable(),
-          simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariable(metavariable);
-
-    if (simpleSubstitution !== null) {
-      let substitution;
-
-      substitution = simpleSubstitution;  ///
-
-      const context = substitution.getContext(),
-            statement = substitution.getStatement();
-
-      substitution = this.unifyStatement(statement, context);
-
-      if (substitution !== null) {
-        const substitutionUnifies = this.unifySubstitution(substitution, substitutions, context);
-
-        if (substitutionUnifies) {
-          this.resolved = true;
-        }
-      }
-    }
-
-    if (this.resolved) {
-      context.debug(`...resolved the ${substitutionString} substitution.`);
-    }
-  }
-
   toJSON() {
     const metavariableJSON = metavariableToMetavariableJSON(this.metavariable),
           statementJSON = statementToStatementJSON(this.statement),

package/src/ontology/substitution/term.js

@@ -1,14 +1,13 @@
 "use strict";
 
+import ontology from "../../ontology";
 import Substitution from "../substitution";
 import TermSubstitutionPartialContext from "../../context/partial/substitution/term";
 
-import ontology, { define } from "../../ontology";
-import { nodeQuery } from "../../utilities/query";
+import { define } from "../../ontology";
 import { stripBracketsFromTerm } from "../../utilities/brackets";
-import { variableIdentifierFromVariableNode } from "../../utilities/variable";
+import { termVariableIdentifierFromTermNode } from "../../utilities/variable";
 
-const termVariableNodeQuery = nodeQuery("/term/variable!");
 
 export default define(class TermSubstitution extends Substitution {
   constructor(context, string, node, tokens, term, variable) {
@@ -49,31 +48,6 @@ export default define(class TermSubstitution extends Substitution {
     return termEqualToTerm;
   }
 
-  isTermVariableEqualToTerm(termVariable, context) {
-    let termVariableEqualToTerm = false;
-
-    const termNode = this.term.getNode();
-
-    let termVariableNode;
-
-    termVariableNode = termVariableNodeQuery(termNode);
-
-    if (termVariableNode !== null) {
-      const termVariableNodeA = termVariableNode; ///
-
-      termVariableNode = termVariable.getNode();
-
-      const termVariableNodeB = termVariableNode, ///
-            termVariableNodeAMatchesTermVariableNodeB = termVariableNodeA.match(termVariableNodeB);
-
-      if (termVariableNodeAMatchesTermVariableNodeB) {
-        termVariableEqualToTerm = true;
-      }
-    }
-
-    return termVariableEqualToTerm;
-  }
-
   matchParameter(parameter) { return this.variable.matchParameter(parameter); }
 
   verify(context) {
@@ -89,15 +63,15 @@ export default define(class TermSubstitution extends Substitution {
       if (this.variable === null) {
         context.debug(`The specific term is not simple.`);
       } else {
-        const variableIdentigier = this.variable.getIdentifier(),
-              variablePresent = context.isVariablePresentByVariableIdentifier(variableIdentigier);
+        const variableIdentifier = this.variable.getIdentifier(),
+              variablePresent = context.isVariablePresentByVariableIdentifier(variableIdentifier);
 
         if (variablePresent) {
-          const variable = this.term.getVariable(),
-                variableIdentigier = variable.getIdentifier(),
-                variablePresent = context.isVariablePresentByVariableIdentifier(variableIdentigier);
+          const termNode = this.term.getNode(),
+                termVariableIdentifier = termVariableIdentifierFromTermNode(termNode),
+                termVariablePresent = context.isVariablePresentByVariableIdentifier(termVariableIdentifier);
 
-          if (variablePresent) {
+          if (termVariablePresent) {
             verifies = true;
           } else {
             const variableString = variable.getString();

package/src/ontology/substitution.js

@@ -66,6 +66,12 @@ export default class Substitution {
     return substitution;
   }
 
+  getReplacementNode() {
+    const replacementNode = null;
+
+    return replacementNode;
+  }
+
   isSimple() {
     const simple = true;
 
@@ -104,12 +110,6 @@ export default class Substitution {
     return frameEqualToFrame;
   }
 
-  isTermVariableEqualToTerm(termVariable, context) {
-    const termVariableEqualToTerm = false;
-
-    return termVariableEqualToTerm;
-  }
-
   isReferenceEqualToReference(reference, context) {
     const referenceEqualToReference = false;
 
@@ -134,21 +134,17 @@ export default class Substitution {
     return substitutionEqualToSubstitution;
   }
 
-  resolve(substitutions, context) {
-    const resolved = true;
-
-    return resolved;
-  }
-
   matchParameter(parameter) {
     const parameterMatches = false;
 
     return parameterMatches;
   }
 
-  getReplacementNode() {
-    const replacementNode = null;
+  matchSubstitutionNode(substitutionNode) { return this.node.match(substitutionNode); }
 
-    return replacementNode;
+  resolve(substitutions, context) {
+    const resolved = true;
+
+    return resolved;
   }
 }

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

@@ -2,11 +2,12 @@
 
 import { arrayUtilities } from "necessary";
 
-import { EMPTY_STRING } from "./constants";
+import { define } from "../ontology";
+import { EMPTY_STRING } from "../constants";
 
 const { find, first, clear, prune, filter, compress, correlate } = arrayUtilities;
 
-export default class Substitutions {
+export default define(class Substitutions {
   constructor(array, savedArray) {
     this.array = array;
     this.savedArray = savedArray;
@@ -357,7 +358,7 @@ export default class Substitutions {
 
     return substitutions;
   }
-}
+});
 
 function leftDifference(arrayA, arrayB) {
   filter(arrayA, (elementA) => {

package/src/ontology/supposition.js

@@ -112,18 +112,32 @@ export default define(class Supposition {
   }
 
   unifyIndependently(substitutions, context) {
-    let unifiesIndependently;
+    let unifiesIndependently = false;
+
+    const suppositionString = this.string,  ///
+          generalContext = this.context,  ///
+          specificContext = context;  ///
+
+    context.trace(`Unifying the '${suppositionString}' supposition independently...`, this.node);
 
     if (this.statement !== null) {
-      const statementResolvedIndependently = this.statement.unifyIndependently(substitutions, context);
+      const statementUnifiesIndependently = this.statement.unifyIndependently(substitutions, generalContext, specificContext);
 
-      unifiesIndependently = statementResolvedIndependently;  ///
+      if (statementUnifiesIndependently) {
+        unifiesIndependently = true;
+      }
     }
 
     if (this.procedureCall !== null) {
       const procedureCallResolvedIndependently = this.procedureCall.unifyIndependently(substitutions, context);
 
-      unifiesIndependently = procedureCallResolvedIndependently;  ///
+      if (procedureCallResolvedIndependently) {
+        unifiesIndependently = true;
+      }
+    }
+
+    if (unifiesIndependently) {
+      context.debug(`...unified the '${suppositionString}' supposition independenly.`, this.node);
     }
 
     return unifiesIndependently;