occam-verify-cli 1.0.421 → 1.0.428

package/src/element/statement/combinator/bracketed.js

@@ -0,0 +1,38 @@
+"use strict";
+
+import CombinatorStatement from "../../statement/combinator";
+
+import { define } from "../../elements";
+import { statementFromStatementNode } from "../../utilities/element";
+import { bracketedCombinatorStatementString, instantiateBracketedCombinatorStatement } from "../../../process/instantiate";
+
+export default define(class BracketedCombinatorStatement extends CombinatorStatement {
+  unifyStatement(statement, assignments, stated, context) {
+    let statementUnifies;
+
+    const statementString = statement.getString();
+
+    context.trace(`Unifying the '${statementString}' statement with the bracketed combinator...`);
+
+    statementUnifies = super.unifyStatement(statement, assignments, stated, context);
+
+    if (statementUnifies) {
+      context.debug(`...unified the '${statementString}' statement with the bracketed combinator.`);
+    }
+
+    return statementUnifies;
+  }
+
+  static name = "BracketedCombinatorStatement";
+
+  static fromNothing() {
+    const bracketedCombinatorStatementNode = instantiateBracketedCombinatorStatement(),
+          nodeAsString = () => bracketedCombinatorStatementString,
+          context = {
+            nodeAsString
+          },
+          bracketedCombinatorStatement = statementFromStatementNode(bracketedCombinatorStatementNode, context);
+
+    return bracketedCombinatorStatement;
+  }
+});

package/src/element/statement/combinator.js

@@ -0,0 +1,59 @@
+"use strict";
+
+import { define } from "../../elements";
+import { unifyStatementWithCombinatorStatement } from "../../process/unify";
+import { statementFromJSON, statementToStatementJSON } from "../../utilities/json";
+
+export default define(class CombinatorStatement {
+  constructor(statement) {
+    this.statement = statement;
+  }
+
+  getStatement() {
+    return this.statement;
+  }
+
+  getString() { return this.statement.getString(); }
+
+  getStatementNode() {
+    const statementNode = this.statement.getNode();
+
+    return statementNode;
+  }
+
+  unifyStatement(statement, assignments, stated, context) {
+    let statementUnifies;
+
+    const statementString = statement.getString(),
+          combinatorStatementString = this.getString();
+
+    context.trace(`Unifying the '${statementString}' statement with the '${combinatorStatementString}' combinator's statement...`);
+
+    const combinatorStatement = this, ///
+          statementUnifiesWithCombinator = unifyStatementWithCombinatorStatement(statement, combinatorStatement, assignments, stated, context);
+
+    statementUnifies = statementUnifiesWithCombinator; ///
+
+    if (statementUnifies) {
+      context.debug(`...unified the '${statementString}' statement with the '${combinatorStatementString}' combinator's statement.`);
+    }
+
+    return statementUnifies;
+  }
+
+  toJSON() {
+    const statementJSON = statementToStatementJSON(this.statement),
+          json = statementJSON;
+
+    return json;
+  }
+
+  static name = "CombinatorStatement";
+
+  static fromJSON(json, context) {
+    const statement = statementFromJSON(json, context),
+          combinator = new CombinatorStatement(statement);
+
+    return combinator;
+  }
+});

package/src/{ontology → element}/statement.js

@@ -3,21 +3,24 @@
 import { arrayUtilities } from "necessary";
 
 import verifyMixins from "../mixins/statement/verify";
-import StatementPartialContext from "../context/partial/statement";
 
-import { define } from "../ontology";
+import { define } from "../elements";
 import { unifyStatement } from "../process/unify";
+import { instantiateStatement } from "../process/instantiate";
 import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
-import { statementFromStatementNode } from "../utilities/node";
 import { stripBracketsFromStatementNode } from "../utilities/brackets";
 
 const { match, backwardsSome } = arrayUtilities;
 
 export default define(class Statement {
-  constructor(string, node, tokens) {
+  constructor(context, string, node) {
+    this.context = context;
     this.string = string;
     this.node = node;
-    this.tokens = tokens;
+  }
+
+  getContext() {
+    return this.context;
   }
 
   getString() {
@@ -28,10 +31,6 @@ export default define(class Statement {
     return this.node;
   }
 
-  getTokens() {
-    return this.tokens;
-  }
-
   getMetavariableName() {
     let metavariableName = null;
 
@@ -295,12 +294,9 @@ export default define(class Statement {
 
   static fromJSON(json, context) {
     const { string } = json,
-          lexer = context.getLexer(),
-          parser = context.getParser(),
-          statementPartialContext = StatementPartialContext.fromStringLexerAndParser(string, lexer, parser),
-          node = statementPartialContext.getNode(),
-          tokens = statementPartialContext.getTokens(),
-          statement = new Statement(string, node, tokens);
+          statmentNode = instantiateStatement(string, context),
+          node = statmentNode,  ///,
+          statement = new Statement(string, node);
 
     return statement;
   }
@@ -399,18 +395,6 @@ export default define(class Statement {
     return statement;
   }
 
-  static fromContainedAssertionNode(containedAssertionNode, context) {
-    let statement = null;
-
-    const statementNode = containedAssertionNode.getStatementNode();
-
-    if (statementNode !== null) {
-      statement = statementFromStatementNode(statementNode, context);
-    }
-
-    return statement;
-  }
-
   static fromCombinatorDeclarationNode(combinatorDeclarationNode, context) {
     const statementNode = combinatorDeclarationNode.getStatementNode(),
           statement = statementFromStatementNode(statementNode, context);

package/src/{ontology → element}/step.js

@@ -1,18 +1,18 @@
 "use strict";
 
-import ontology from "../ontology";
+import elements from "../elements";
 import unifyMixins from "../mixins/step/unify";
 import TemporaryContext from "../context/temporary";
 
-import { define } from "../ontology";
+import { define } from "../elements";
 import { equateStatements } from "../process/equate";
-import { propertyAssertionFromStatement } from "../utilities/context";
+import { propertyAssertionFromStatement } from "../utilities/statement";
 
 export default define(class Step {
-  constructor(context, node, string, statement, reference, satisfiesAssertion) {
+  constructor(context, string, node, statement, reference, satisfiesAssertion) {
     this.context = context;
-    this.node = node;
     this.string = string;
+    this.node = node;
     this.statement = statement;
     this.reference = reference;
     this.satisfiesAssertion = satisfiesAssertion;
@@ -22,14 +22,14 @@ export default define(class Step {
     return this.context;
   }
 
-  getNode() {
-    return this.node;
-  }
-
   getString() {
     return this.string;
   }
 
+  getNode() {
+    return this.node;
+  }
+
   getStatement() {
     return this.statement;
   }
@@ -181,7 +181,7 @@ export default define(class Step {
           axiom = context.findAxiomByReference(reference);
 
     if (axiom !== null) {
-      const { Substitutions } = ontology,
+      const { Substitutions } = elements,
             step = this,  ///
             substitutions = Substitutions.fromNothing(),
             stepUnifies = axiom.unifyStep(step, substitutions, context);
@@ -203,38 +203,4 @@ export default define(class Step {
   }
 
   static name = "Step";
-
-  static fromStatement(statement, context) {
-    const statementString = statement.getString(),
-          string = statementString, ///
-          node = null,
-          reference = null,
-          satisfiesAssertion = null,
-          step = new Step(context, node, string, statement, reference, satisfiesAssertion);
-
-    return step;
-  }
-
-  static fromStepOrSubproofNode(stepOrSubproofNode, context) {
-    let step = null;
-
-    const stepNode = stepOrSubproofNode.isStepNode();
-
-    if (stepNode) {
-      const { Statement, Reference, SatisfiesAssertion } = ontology,
-            stepNode = stepOrSubproofNode,  ///
-            node = stepNode, ///
-            string = context.nodeAsString(node),
-            statement = Statement.fromStepNode(stepNode, context),
-            reference = Reference.fromStepNode(stepNode, context),
-            satisfiesAssertion = SatisfiesAssertion.fromStepNode(stepNode, context),
-            temporaryContext = null;
-
-      context = temporaryContext; ///
-
-      step = new Step(context, node, string, statement, reference, satisfiesAssertion)
-    }
-
-    return step;
-  }
 });

package/src/{ontology → element}/subDerivation.js

@@ -2,10 +2,10 @@
 
 import { arrayUtilities } from "necessary";
 
-import ontology from "../ontology";
+import elements from "../elements";
+import assignAssignments from "../process/assign";
 
-import { define } from "../ontology";
-import { assignAssignments } from "../utilities/assignments";
+import { define } from "../elements";
 
 const { last } = arrayUtilities;
 
@@ -51,25 +51,4 @@ export default define(class SubDerivation {
   }
 
   static name = "SubDerivation";
-
-  static fromSubDerivationNode(subDerivationNode, context) {
-    const stepsOrSubproofs = stepOrSubproofFromSubDerivationNode(subDerivationNode, context),
-          subDerivation = new SubDerivation(stepsOrSubproofs);
-
-    return subDerivation;
-  }
 });
-
-function stepOrSubproofFromSubDerivationNode(subDerivationNode, context) {
-  const { Step, Subproof } = ontology,
-        stepOrSubproofNodes = subDerivationNode.getStepOrSubproofNodes(),
-        stepsOrSubproofs = stepOrSubproofNodes.map((stepOrSubproofNode) => {
-          const subproof = Subproof.fromStepOrSubproofNode(stepOrSubproofNode, context),
-                step = Step.fromStepOrSubproofNode(stepOrSubproofNode, context),
-                stepOrSubproof = (step || subproof);
-
-          return stepOrSubproof;
-        });
-
-  return stepsOrSubproofs;
-}

package/src/{ontology → element}/subproof.js

@@ -1,10 +1,9 @@
 "use strict";
 
-import ontology from "../ontology";
+import elements from "../elements";
 import LocalContext from "../context/local";
 
-import { define } from "../ontology";
-import { subproofStringFromSubproofNode } from "../utilities/subproof";
+import { define } from "../elements";
 
 export default define(class Subproof {
   constructor(string, node, suppositions, subDerivation) {
@@ -109,7 +108,7 @@ export default define(class Subproof {
       const axiomSatisfiable = axiom.isSatisfiable();
 
       if (axiomSatisfiable) {
-        const { Substitutions } = ontology,
+        const { Substitutions } = elements,
               subproof = this,  ///
               substitutions = Substitutions.fromNothing(),
               statementUnifies = axiom.unifySubproof(subproof, substitutions, context);
@@ -132,43 +131,4 @@ export default define(class Subproof {
   }
 
   static name = "Subproof";
-
-  static fromStepOrSubproofNode(sStepOrSubproofNode, context) {
-    let subproof = null;
-
-    const subproofNode = sStepOrSubproofNode.isSubproofNode();
-
-    if (subproofNode) {
-      const subproofNode = sStepOrSubproofNode, ///
-            suppositions = suppositionsFromSubproofNode(subproofNode, context),
-            subDerivation = subDerivationFromSubproofNode(subproofNode, context),
-            subproofString = subproofStringFromSubproofNode(subproofNode, context),
-            node = subproofNode,  ///
-            string = subproofString;  ///
-
-      subproof = new Subproof(string, node, suppositions, subDerivation);
-    }
-
-    return subproof;
-  }
 });
-
-function suppositionsFromSubproofNode(subproofNode, context) {
-  const { Supposition } = ontology,
-        suppositionNodes = subproofNode.getSuppositionNodes(),
-        suppositions = suppositionNodes.map((suppositionNode) => {
-          const supposition = Supposition.fromSuppositionNode(suppositionNode, context);
-
-          return supposition;
-        });
-
-  return suppositions;
-}
-
-function subDerivationFromSubproofNode(subproofNode, context) {
-  const { SubDerivation } = ontology,
-        subDerivationNode = subproofNode.getSubDerivationNode(),
-        subDerivation = SubDerivation.fromSubDerivationNode(subDerivationNode, context);
-
-  return subDerivation;
-}

package/src/{ontology → element}/substitution/frame.js

@@ -1,10 +1,10 @@
 "use strict";
 
-import ontology from "../../ontology";
 import Substitution from "../substitution";
 
-import { define } from "../../ontology";
+import { define } from "../../elements";
 import { instantiateFrameSubstitution } from "../../process/instantiate";
+import { frameSubstitutionFromFrameSubstitutionNode, frameSubstitutionFromStatementNode } from "../../utilities/element";
 
 export default define(class FrameSubstitution extends Substitution {
   constructor(context, string, node, frame, metavariable) {
@@ -81,24 +81,8 @@ export default define(class FrameSubstitution extends Substitution {
   static name = "FrameSubstitution";
 
   static fromStatement(statement, context) {
-    let frameSubstitution = null;
-
     const statementNode = statement.getNode(),
-          frameSubstitutionNode = statementNode.getFrameSubstitutionNode();
-
-    if (frameSubstitutionNode !== null) {
-      const { Frame, Metavariable } = ontology,
-            firstFrameNode = frameSubstitutionNode.getFirstFrameNode(),
-            lastMetavariableNode = frameSubstitutionNode.getLastMetavariableNode(),
-            metavariableNode = lastMetavariableNode,  ///
-            frameNode = firstFrameNode, ///
-            node = frameSubstitutionNode,  ///
-            string = context.nodeAsString(node),
-            frame = Frame.fromFrameNode(frameNode, context),
-            metavariable = Metavariable.fromMetavariableNode(metavariableNode, context);
-
-      frameSubstitution = new FrameSubstitution(context, string, node, frame, metavariable);
-    }
+          frameSubstitution = frameSubstitutionFromStatementNode(statementNode, context);
 
     return frameSubstitution;
   }
@@ -106,8 +90,7 @@ export default define(class FrameSubstitution extends Substitution {
   static fromFrameAndMetavariable(frame, metavariable, context) {
     const string = stringFromFrameAndMetavariable(frame, metavariable),
           frameSubstitutionNode = instantiateFrameSubstitution(string, context),
-          node = frameSubstitutionNode, ///
-          frameSubstitution = new FrameSubstitution(context, string, node, frame, metavariable);
+          frameSubstitution = frameSubstitutionFromFrameSubstitutionNode(frameSubstitutionNode, context);
 
     return frameSubstitution;
   }

package/src/{ontology → element}/substitution/reference.js

@@ -2,8 +2,9 @@
 
 import Substitution from "../substitution";
 
-import { define } from "../../ontology";
+import { define } from "../../elements";
 import { instantiateReferenceSubstitution } from "../../process/instantiate";
+import { referenceSubstitutionFromReferenceSubstitutionNode } from "../../utilities/element";
 
 export default define(class ReferenceSubstitution extends Substitution {
   constructor(context, string, node, reference, metavariable) {
@@ -32,8 +33,7 @@ export default define(class ReferenceSubstitution extends Substitution {
   static fromReferenceAndMetavariable(reference, metavariable, context) {
     const string = stringFromReferenceAndMetavariable(reference, metavariable),
           referenceSubstitutionNode = instantiateReferenceSubstitution(string, context),
-          node = referenceSubstitutionNode, ///
-          referenceSubstitution = new ReferenceSubstitution(context, string, node, reference, metavariable);
+          referenceSubstitution = referenceSubstitutionFromReferenceSubstitutionNode(referenceSubstitutionNode, context);
 
     return referenceSubstitution;
   }

package/src/{ontology → element}/substitution/statement.js

@@ -1,12 +1,13 @@
 "use strict";
 
-import ontology from "../../ontology";
+import elements from "../../elements";
 import Substitution from "../substitution";
 
-import { define } from "../../ontology";
+import { define } from "../../elements";
 import { unifySubstitution } from "../../process/unify";
 import { stripBracketsFromStatement } from "../../utilities/brackets";
 import { instantiateStatementSubstitution } from "../../process/instantiate";
+import { statementSubstitutionFromStatementSubstitutionNode } from "../../utilities/element";
 import { statementFromJSON, statementToStatementJSON, metavariableFromJSON, metavariableToMetavariableJSON } from "../../utilities/json";
 
 export default define(class StatementSubstitution extends Substitution {
@@ -79,7 +80,7 @@ export default define(class StatementSubstitution extends Substitution {
   unifyStatement(statement, context) {
     let substitution = null;
 
-    const { Substitutions } = ontology,
+    const { Substitutions } = elements,
           substitutions = Substitutions.fromNothing(),
           specificContext = context; ///
 
@@ -205,10 +206,7 @@ export default define(class StatementSubstitution extends Substitution {
 
     const string = stringFromStatementAndMetavariable(statement, metavariable),
           statementSubstitutionNode = instantiateStatementSubstitution(string, context),
-          node = statementSubstitutionNode,
-          resolved = true,
-          substitution = null,
-          statementSubstitution = new StatementSubstitution(context, string, node, resolved, statement, metavariable, substitution);
+          statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context);
 
     return statementSubstitution;
   }
@@ -218,9 +216,7 @@ export default define(class StatementSubstitution extends Substitution {
 
     const string = stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context),
           statementSubstitutionNode = instantiateStatementSubstitution(string, context),
-          node = statementSubstitutionNode,
-          resolved = false,
-          statementSubstitution = new StatementSubstitution(context, string, node, resolved, statement, metavariable, substitution);
+          statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, substitution, context);
 
     return statementSubstitution;
   }

package/src/{ontology → element}/substitution/term.js

@@ -1,11 +1,12 @@
 "use strict";
 
-import ontology from "../../ontology";
+import elements from "../../elements";
 import Substitution from "../substitution";
 
-import { define } from "../../ontology";
+import { define } from "../../elements";
 import { stripBracketsFromTerm } from "../../utilities/brackets";
 import { instantiateTermSubstitution } from "../../process/instantiate";
+import { termSubstitutionFromStatementNode, termSubstitutionFromTermSubstitutionNode } from "../../utilities/element";
 
 export default define(class TermSubstitution extends Substitution {
   constructor(context, string, node, term, variable) {
@@ -101,33 +102,16 @@ export default define(class TermSubstitution extends Substitution {
   static name = "TermSubstitution";
 
   static fromStatement(statement, context) {
-    let termSubstitution = null;
-
     const statementNode = statement.getNode(),
-          termSubstitutionNode = statementNode.getTermSubstitutionNode();
-
-    if (termSubstitutionNode !== null) {
-      const { Term, Variable } = ontology,
-            firstTermNode = termSubstitutionNode.getFirstTermNode(),
-            lastVariableNode = termSubstitutionNode.getLastVariableNode(),
-            termNode = firstTermNode, ///
-            variableNode = lastVariableNode,  ///
-            term = Term.fromTermNode(termNode, context),
-            variable = Variable.fromVariableNode(variableNode, context),
-            node = termSubstitutionNode,  ///
-            string = stringFromTermAndVariable(term, variable);
-
-      termSubstitution = new TermSubstitution(context, string, node, term, variable);
-    }
+          termSubstitution = termSubstitutionFromStatementNode(statementNode, context);
 
     return termSubstitution;
   }
 
-  static fromTernAndVariable(term, variable, context) {
-    const string = stringFromTermAndVariable(term, variable),
+  static fromTermAndMetavariable(term, metavariable, context) {
+    const string = stringFromTermAndVariable(term, metavariable),
           termSubstitutionNode = instantiateTermSubstitution(string, context),
-          node = termSubstitutionNode,  ///
-          termSubstitution = new TermSubstitution(context, string, node, term, variable);
+          termSubstitution = termSubstitutionFromTermSubstitutionNode(termSubstitutionNode, context);
 
     return termSubstitution;
   }

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

@@ -2,7 +2,7 @@
 
 import { arrayUtilities } from "necessary";
 
-import { define } from "../ontology";
+import { define } from "../elements";
 import { EMPTY_STRING } from "../constants";
 
 const { find, first, clear, prune, filter, compress, correlate } = arrayUtilities;

package/src/{ontology → element}/supposition.js

@@ -1,18 +1,18 @@
 "use strict";
 
-import ontology from "../ontology";
+import elements from "../elements";
 import TemporaryContext from "../context/temporary";
+import assignAssignments from "../process/assign";
 
-import { define } from "../ontology";
-import { assignAssignments } from "../utilities/assignments";
-import { subproofAssertionFromStatement } from "../utilities/context";
+import { define } from "../elements";
+import { subproofAssertionFromStatement } from "../utilities/statement";
 import { termsFromJSON, framesFromJSON, statementFromJSON, procedureCallFromJSON, termsToTermsJSON, framesToFramesJSON, statementToStatementJSON, procedureCallToProcedureCallJSON } from "../utilities/json";
 
 export default define(class Supposition {
-  constructor(context, node, string, statement, procedureCall) {
+  constructor(context, string, node, statement, procedureCall) {
     this.context = context;
-    this.node = node;
     this.string = string;
+    this.node = node;
     this.statement = statement;
     this.procedureCall = procedureCall;
   }
@@ -59,7 +59,7 @@ export default define(class Supposition {
         const assignmentsAssigned = assignAssignments(assignments, context);
 
         if (assignmentsAssigned) {
-          const { Step } = ontology,
+          const { Step } = elements,
                 step = Step.fromStatement(this.statement, context),
                 stepOrSubproof = step;  ///
 
@@ -296,13 +296,13 @@ export default define(class Supposition {
 
     context = temporaryContext; ///
 
-    const supposition = new Supposition(context, node, string, statement, procedureCall);
+    const supposition = new Supposition(context, string, node, statement, procedureCall);
 
     return supposition;
   }
 
   static fromSuppositionNode(suppositionNode, context) {
-    const { Statement, ProcedureCall } = ontology,
+    const { Statement, ProcedureCall } = elements,
           node = suppositionNode, ///
           string = context.nodeAsString(node),
           statement = Statement.fromSuppositionNode(suppositionNode, context),
@@ -311,7 +311,7 @@ export default define(class Supposition {
 
     context = temporaryContext; ///
 
-    const supposition = new Supposition(context, node, string, statement, procedureCall);
+    const supposition = new Supposition(context, string, node, statement, procedureCall);
 
     return supposition
   }

package/src/{ontology → element/term}/constructor/bracketed.js

@@ -1,10 +1,10 @@
 "use strict";
 
-import ontology from "../../ontology";
+import elements from "../../elements";
 import Constructor from "../constructor";
-import constructorBracketedContext from "../../context/bracketed/constructor";
 
-import { define } from "../../ontology";
+import { define } from "../../elements";
+import { bracketedConstructorTermString, instantiateBracketedConstructorTerm } from "../../../process/instantiate";
 
 export default define(class BracketedConstructor extends Constructor {
   unifyTerm(term, context, verifyAhead) {
@@ -17,7 +17,7 @@ export default define(class BracketedConstructor extends Constructor {
     termUnifies = super.unifyTerm(term, context, () => {
       let verifiesAhead = false;
 
-      const { Term } = ontology,
+      const { Term } = elements,
             bracketedTerm = term, ///
             bracketedTermNode = bracketedTerm.getNode(),
             singularTermNode = bracketedTermNode.getSingularTermNode();
@@ -55,14 +55,13 @@ export default define(class BracketedConstructor extends Constructor {
   static name = "BracketedConstructor";
 
   static fromNothing() {
-    const { Term } = ontology,
-          bracketedTermNode = constructorBracketedContext.getBracketedTermNode(),
-          termNode = bracketedTermNode,  ///
-          context = constructorBracketedContext, ///
-          term = Term.fromTermNode(termNode, context),
-          string = term.getString(),
-          bracketedConstructor = new BracketedConstructor(string, term);
-
-    return bracketedConstructor;
+    const bracketedConstructorTermNode = instantiateBracketedConstructorTerm(),
+          nodeAsString = () => bracketedConstructorTermString,
+          context = {
+            nodeAsString
+          },
+          bracketedConstructorTerm = statementFromTermNode(bracketedConstructorTermNode, context);
+
+    return bracketedConstructorTerm;
   }
 });