occam-verify-cli 1.0.427 → 1.0.436

package/src/element/rule.js

@@ -2,11 +2,11 @@
 
 import { arrayUtilities } from "necessary";
 
+import Element from "../element";
 import elements from "../elements";
 import LocalContext from "../context/local";
 
 import { define } from "../elements";
-import { labelsStringFromLabels } from "./axiomLemmaTheoremConjecture";
 import { labelsFromJSON,
          premisesFromJSON,
          conclusionFromJSON,
@@ -16,29 +16,16 @@ import { labelsFromJSON,
 
 const { reverse, extract, backwardsEvery } = arrayUtilities;
 
-export default define(class Rule {
+export default define(class Rule extends Element {
   constructor(context, string, node, labels, premises, conclusion, proof) {
-    this.context = context;
-    this.string = string;
-    this.node = node;
+    super(context, string, node);
+
     this.labels = labels;
     this.premises = premises;
     this.conclusion = conclusion;
     this.proof = proof;
   }
 
-  getContext() {
-    return this.context;
-  }
-
-  getNode() {
-    return this.node;
-  }
-
-  getString() {
-    return this.string;
-  }
-
   getLabels() {
     return this.labels;
   }
@@ -319,27 +306,3 @@ function conclusionFromRuleNode(ruleNode, context) {
   return conclusion;
 }
 
-function premisesStringFromPremises(premises) {
-  const premisesString = premises.reduce((premisesString, premise) => {
-    const premiseString = premise.getString();
-
-    premisesString = (premisesString !== null) ?
-                       `${premisesString}, ${premiseString}` :
-                         premiseString;  ///
-
-    return premisesString;
-  }, null);
-
-  return premisesString;
-}
-
-function stringFromLabelsPremisesAndConclusion(labels, premises, conclusion) {
-  const premisesString = premisesStringFromPremises(premises),
-        conclusionString = conclusion.getString(),
-        labelsString = labelsStringFromLabels(labels),
-        string = (premisesString !== null) ?
-                    `${labelsString} :: [${premisesString}] ... ${conclusionString}` :
-                      `${labelsString} :: ${conclusionString}`;
-
-  return string;
-}

package/src/element/section.js

@@ -1,15 +1,13 @@
 "use strict";
 
-import elements from "../elements";
-import LocalContext from "../context/local";
+import Element from "../element";
 
 import { define } from "../elements";
 
-export default define(class Section {
+export default define(class Section extends Element {
   constructor(context, string, node, hypotheses, axiom, lemma, theorem, conjecture) {
-    this.context = context;
-    this.string = string;
-    this.node = node;
+    super(context, string, node);
+
     this.hypotheses = hypotheses;
     this.axiom = axiom;
     this.lemma = lemma;
@@ -17,18 +15,6 @@ export default define(class Section {
     this.conjecture = conjecture;
   }
 
-  getContext() {
-    return this.context;
-  }
-
-  getNode() {
-    return this.node;
-  }
-
-  getString() {
-    return this.string;
-  }
-
   getHypotheses() {
     return this.hypotheses;
   }
@@ -89,115 +75,4 @@ export default define(class Section {
   }
 
   static name = "Section";
-
-  static fromSectionNode(sectionNode, context) {
-    const localContext = LocalContext.fromNothing(context);
-
-    context = localContext; ///
-
-    const hypothesisNodes = sectionNode.getHypothesisNodes(),
-          hypotheses = hypothesesFromHypothesisNodes(hypothesisNodes, context),
-          axiom = axiomFroSectionNode(sectionNode, context),
-          lemma = lemmaFroSectionNode(sectionNode, context),
-          theorem = theoremFroSectionNode(sectionNode, context),
-          conjecture = conjectureFroSectionNode(sectionNode, context),
-          node = sectionNode, ///
-          string = stringFromHypothesesAxiomLemmaTheoremAndConjecture(hypotheses, axiom, lemma, theorem, conjecture, context),
-          section = new Section(context, string, node, hypotheses, axiom, lemma, theorem, conjecture);
-
-    return section;
-  }
 });
-
-function axiomFroSectionNode(sectionNode, context) {
-  let axiom = null;
-
-  const axiomNode = sectionNode.getAxiomNode();
-
-  if (axiomNode !== null) {
-    const { Axiom } = elements;
-
-    axiom = Axiom.fromAxiomNode(axiomNode, context);
-  }
-
-  return axiom;
-}
-
-function lemmaFroSectionNode(sectionNode, context) {
-  let lemma = null;
-
-  const lemmaNode = sectionNode.getLemmaNode();
-
-  if (lemmaNode !== null) {
-    const { Lemma } = elements;
-
-    lemma = Lemma.fromLemmaNode(lemmaNode, context);
-  }
-
-  return lemma;
-}
-
-function theoremFroSectionNode(sectionNode, context) {
-  let theorem = null;
-
-  const theoremNode = sectionNode.getTheoremNode();
-
-  if (theoremNode !== null) {
-    const { Theorem } = elements;
-
-    theorem = Theorem.fromTheoremNode(theoremNode, context);
-  }
-
-  return theorem;
-}
-
-function conjectureFroSectionNode(sectionNode, context) {
-  let conjecture = null;
-
-  const conjectureNode = sectionNode.getConjectureNode();
-
-  if (conjectureNode !== null) {
-    const { Conjecture } = elements;
-
-    conjecture = Conjecture.fromConjectureNode(conjectureNode, context);
-  }
-
-  return conjecture;
-}
-
-function hypothesesFromHypothesisNodes(hypothesisNodes, context) {
-  const hypotheses = hypothesisNodes.map((hypothesisNode) => {
-    const { Hypothesis } = elements,
-          hypothesis = Hypothesis.fromHypothesisNode(hypothesisNode, context);
-
-    return hypothesis;
-  });
-
-  return hypotheses;
-}
-
-function hypothesesStringFromHypotheses(hypotheses, context) {
-  const hypothesesString = hypotheses.reduce((hypothesesString, hypothesis) => {
-    const hypothesisString = hypothesis.getString();
-
-    hypothesesString = (hypothesesString !== null) ?
-                         `${hypothesesString}, ${hypothesisString}` :
-                           hypothesisString;  ///
-
-    return hypothesesString;
-  }, null);
-
-  return hypothesesString;
-}
-
-function stringFromHypothesesAxiomLemmaTheoremAndConjecture(hypotheses, axiom, lemma, theorem, conjecture, context) {
-  const axiomLemmaTheoremOrConjecture = (axiom || lemma || theorem || conjecture),
-        axiomLemmaTheoremOrConjectureString = axiomLemmaTheoremOrConjecture.getString(),
-        hypothesesString = hypothesesStringFromHypotheses(hypotheses, context),
-        string = (axiomLemmaTheoremOrConjectureString !== null) ?
-                   `[${hypothesesString}]::: ${axiomLemmaTheoremOrConjectureString}` :
-                     `[${hypothesesString}]::: `;
-
-
-  return string;
-}

package/src/element/signature.js

@@ -2,6 +2,7 @@
 
 import { arrayUtilities } from "necessary";
 
+import Element from "../element";
 import elements from "../elements";
 
 import { define } from "../elements";
@@ -10,19 +11,11 @@ import { termsFromJSON, termsToTermsJSON } from "../utilities/json";
 
 const { match, compare, correlate } = arrayUtilities;
 
-export default define(class Signature {
-  constructor(string, node, terms) {
-    this.string = string;
-    this.node = node;
-    this.terms = terms;
-  }
+export default define(class Signature extends Element {
+  constructor(context, string, node, terms) {
+    super(context, string, node);
 
-  getString() {
-    return this.string;
-  }
-
-  getNode() {
-    return this.node;
+    this.terms = terms;
   }
 
   getTerms() {
@@ -160,7 +153,8 @@ export default define(class Signature {
     const terms = termsFromJSON(json, context),
           signatureString = signatureStringFromTerms(terms),
           string = signatureString, ///
-          signature = new Signature(string, terms);
+          node = null,
+          signature = new Signature(context, string, node, terms);
 
     return signature;
   }

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

@@ -2,9 +2,8 @@
 
 import CombinatorStatement from "../../statement/combinator";
 
-import { define } from "../../elements";
-import { statementFromStatementNode } from "../../utilities/element";
-import { bracketedCombinatorStatementString, instantiateBracketedCombinatorStatement } from "../../../process/instantiate";
+import { define } from "../../../elements";
+import { bracketedCombinatorStatementFromNothing } from "../../../utilities/instance";
 
 export default define(class BracketedCombinatorStatement extends CombinatorStatement {
   unifyStatement(statement, assignments, stated, context) {
@@ -26,12 +25,7 @@ export default define(class BracketedCombinatorStatement extends CombinatorState
   static name = "BracketedCombinatorStatement";
 
   static fromNothing() {
-    const bracketedCombinatorStatementNode = instantiateBracketedCombinatorStatement(),
-          nodeAsString = () => bracketedCombinatorStatementString,
-          context = {
-            nodeAsString
-          },
-          bracketedCombinatorStatement = statementFromStatementNode(bracketedCombinatorStatementNode, context);
+    const bracketedCombinatorStatement = bracketedCombinatorStatementFromNothing();
 
     return bracketedCombinatorStatement;
   }

package/src/element/statement.js

@@ -2,33 +2,19 @@
 
 import { arrayUtilities } from "necessary";
 
+import Element from "../element";
 import verifyMixins from "../mixins/statement/verify";
 
 import { define } from "../elements";
 import { unifyStatement } from "../process/unify";
 import { instantiateStatement } from "../process/instantiate";
 import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
-import { stripBracketsFromStatementNode } from "../utilities/brackets";
 
 const { match, backwardsSome } = arrayUtilities;
 
-export default define(class Statement {
+export default define(class Statement extends Element {
   constructor(context, string, node) {
-    this.context = context;
-    this.string = string;
-    this.node = node;
-  }
-
-  getContext() {
-    return this.context;
-  }
-
-  getString() {
-    return this.string;
-  }
-
-  getNode() {
-    return this.node;
+    super(context, string, node);
   }
 
   getMetavariableName() {
@@ -45,14 +31,6 @@ export default define(class Statement {
 
   isSingular() { return this.node.isSingular(); }
 
-  isEqualTo(statement) {
-    const statementNode = statement.getNode(),
-          matches = this.node.match(statementNode),
-          equalTo = matches;  ///
-
-    return equalTo;
-  }
-
   isTermContained(term, context) {
     let termContained;
 
@@ -300,105 +278,4 @@ export default define(class Statement {
 
     return statement;
   }
-
-  static fromStepNode(stepNode, context) {
-    let statement = null;
-
-    const statementNode = stepNode.getStatementNode();
-
-    if (statementNode !== null) {
-      statement = statementFromStatementNode(statementNode, context);
-    }
-
-    return statement;
-  }
-
-  static fromPremiseNode(premiseNode, context) {
-    let statement = null;
-
-    const statementNode = premiseNode.getStatementNode();
-
-    if (statementNode !== null) {
-      statement = statementFromStatementNode(statementNode, context);
-    }
-
-    return statement;
-  }
-
-  static fromStatementNode(statementNode, context) {
-    const statement = statementFromStatementNode(statementNode, context);
-
-    return statement;
-  }
-
-  static fromDeductionNode(deductionNode, context) {
-    let statement = null;
-
-    const statementNode = deductionNode.getStatementNode();
-
-    if (statementNode !== null) {
-      statement = statementFromStatementNode(statementNode, context);
-    }
-
-    return statement;
-  }
-
-  static fromHypothesisNode(hypothesisNode, context) {
-    let statement = null;
-
-    const statementNode = hypothesisNode.getStatementNode();
-
-    if (statementNode !== null) {
-      statement = statementFromStatementNode(statementNode, context);
-    }
-
-    return statement;
-  }
-
-  static fromConclusionNode(conclusionNode, context) {
-    let statement = null;
-
-    const statementNode = conclusionNode.getStatementNode();
-
-    if (statementNode !== null) {
-      statement = statementFromStatementNode(statementNode, context);
-    }
-
-    return statement;
-  }
-
-  static fromAssumptionNode(assumptionNode, context) {
-    let statement = null;
-
-    let statementNode;
-
-    statementNode = assumptionNode.getStatementNode(); ///
-
-    if (statementNode !== null) {
-      statementNode = stripBracketsFromStatementNode(statementNode);  ///
-
-      statement = statementFromStatementNode(statementNode, context);
-    }
-
-    return statement;
-  }
-
-  static fromSuppositionNode(suppositionNode, context) {
-    let statement = null;
-
-    const statementNode = suppositionNode.getStatementNode();
-
-    if (statementNode !== null) {
-      statement = statementFromStatementNode(statementNode, context);
-    }
-
-    return statement;
-  }
-
-  static fromCombinatorDeclarationNode(combinatorDeclarationNode, context) {
-    const statementNode = combinatorDeclarationNode.getStatementNode(),
-          statement = statementFromStatementNode(statementNode, context);
-
-    return statement;
-  }
 });

package/src/element/step.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import Element from "../element";
 import elements from "../elements";
 import unifyMixins from "../mixins/step/unify";
 import TemporaryContext from "../context/temporary";
@@ -8,28 +9,15 @@ import { define } from "../elements";
 import { equateStatements } from "../process/equate";
 import { propertyAssertionFromStatement } from "../utilities/statement";
 
-export default define(class Step {
+export default define(class Step extends Element {
   constructor(context, string, node, statement, reference, satisfiesAssertion) {
-    this.context = context;
-    this.string = string;
-    this.node = node;
+    super(context, string, node);
+
     this.statement = statement;
     this.reference = reference;
     this.satisfiesAssertion = satisfiesAssertion;
   }
 
-  getContext() {
-    return this.context;
-  }
-
-  getString() {
-    return this.string;
-  }
-
-  getNode() {
-    return this.node;
-  }
-
   getStatement() {
     return this.statement;
   }

package/src/element/subDerivation.js

@@ -2,15 +2,17 @@
 
 import { arrayUtilities } from "necessary";
 
-import elements from "../elements";
+import Element from "../element";
 import assignAssignments from "../process/assign";
 
 import { define } from "../elements";
 
 const { last } = arrayUtilities;
 
-export default define(class SubDerivation {
-  constructor(stepsOrSubproofs) {
+export default define(class SubDerivation extends Element {
+  constructor(context, string, node, stepsOrSubproofs) {
+    super(context, string, node);
+
     this.stepsOrSubproofs = stepsOrSubproofs;
   }
 

package/src/element/subproof.js

@@ -1,26 +1,19 @@
 "use strict";
 
+import Element from "../element";
 import elements from "../elements";
 import LocalContext from "../context/local";
 
 import { define } from "../elements";
 
-export default define(class Subproof {
-  constructor(string, node, suppositions, subDerivation) {
-    this.string = string;
-    this.node = node;
+export default define(class Subproof extends Element {
+  constructor(context, string, node, suppositions, subDerivation) {
+    super(context, string, node);
+
     this.suppositions = suppositions;
     this.subDerivation = subDerivation;
   }
 
-  getString() {
-    return this.string;
-  }
-
-  getNode() {
-    return this.node;
-  }
-
   getSuppositions() {
     return this.suppositions;
   }

package/src/element/substitution.js

@@ -1,22 +1,10 @@
 "use strict";
 
-export default class Substitution {
-  constructor(context, string, node) {
-    this.context = context;
-    this.string = string;
-    this.node = node;
-  }
-
-  getContext() {
-    return this.context;
-  }
-
-  getString() {
-    return this.string;
-  }
+import Element from "../element";
 
-  getNode() {
-    return this.node;
+export default class Substitution extends Element {
+  constructor(context, string, node) {
+    super(context, string, node);
   }
 
   getTerm() {
@@ -86,14 +74,6 @@ export default class Substitution {
     return trivial;
   }
 
-  isEqualTo(substitution) {
-    const substitutionNode = substitution.getNode(),
-          matches = this.node.match(substitutionNode),
-          equalTo = matches;  ///
-
-    return equalTo;
-  }
-
   isTermEqualToTerm(term, context) {
     const termEqualToTerm = false;
 

package/src/element/substitutions.js

@@ -2,13 +2,17 @@
 
 import { arrayUtilities } from "necessary";
 
+import Element from "../element";
+
 import { define } from "../elements";
 import { EMPTY_STRING } from "../constants";
 
 const { find, first, clear, prune, filter, compress, correlate } = arrayUtilities;
 
-export default define(class Substitutions {
-  constructor(array, savedArray) {
+export default define(class Substitutions extends Element {
+  constructor(context, string, node, array, savedArray) {
+    super(context, string, node);
+
     this.array = array;
     this.savedArray = savedArray;
   }

package/src/element/supposition.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import Element from "../element";
 import elements from "../elements";
 import TemporaryContext from "../context/temporary";
 import assignAssignments from "../process/assign";
@@ -8,27 +9,14 @@ 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 {
+export default define(class Supposition extends Element {
   constructor(context, string, node, statement, procedureCall) {
-    this.context = context;
-    this.string = string;
-    this.node = node;
+    super(context, string, node);
+
     this.statement = statement;
     this.procedureCall = procedureCall;
   }
 
-  getContext() {
-    return this.context;
-  }
-
-  getNode() {
-    return this.node;
-  }
-
-  getString() {
-    return this.string;
-  }
-
   getStatement() {
     return this.statement;
   }
@@ -300,19 +288,4 @@ export default define(class Supposition {
 
     return supposition;
   }
-
-  static fromSuppositionNode(suppositionNode, context) {
-    const { Statement, ProcedureCall } = elements,
-          node = suppositionNode, ///
-          string = context.nodeAsString(node),
-          statement = Statement.fromSuppositionNode(suppositionNode, context),
-          procedureCall = ProcedureCall.fromSuppositionNode(suppositionNode, context),
-          temporaryContext = null;
-
-    context = temporaryContext; ///
-
-    const supposition = new Supposition(context, string, node, statement, procedureCall);
-
-    return supposition
-  }
 });

package/src/element/term/constructor/bracketed.js

@@ -1,10 +1,10 @@
 "use strict";
 
-import elements from "../../elements";
+import elements from "../../../elements";
 import Constructor from "../constructor";
 
-import { define } from "../../elements";
-import { bracketedConstructorTermString, instantiateBracketedConstructorTerm } from "../../../process/instantiate";
+import { define } from "../../../elements";
+import { bracketedConstructorTermFromNothing } from "../../../utilities/instance";
 
 export default define(class BracketedConstructor extends Constructor {
   unifyTerm(term, context, verifyAhead) {
@@ -55,12 +55,7 @@ export default define(class BracketedConstructor extends Constructor {
   static name = "BracketedConstructor";
 
   static fromNothing() {
-    const bracketedConstructorTermNode = instantiateBracketedConstructorTerm(),
-          nodeAsString = () => bracketedConstructorTermString,
-          context = {
-            nodeAsString
-          },
-          bracketedConstructorTerm = statementFromTermNode(bracketedConstructorTermNode, context);
+    const bracketedConstructorTerm = bracketedConstructorTermFromNothing();
 
     return bracketedConstructorTerm;
   }