occam-verify-cli 1.0.421 → 1.0.428

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

@@ -1,23 +1,32 @@
 "use strict";
 
-import ontology from "../ontology";
-import EqualityAssignment from "../assignment/equality";
-import VariableAssignment from "../assignment/variable";
+import elements from "../elements";
 
-import { define } from "../ontology";
+import { define } from "../elements";
 import { equateTerms } from "../process/equate";
+import { equalityAssignmentFromEquality, variableAssignmentFromVariable } from "../process/assign";
 
 export default define(class Equality {
-  constructor(string, leftTerm, rightTerm) {
+  constructor(context, string, node, leftTerm, rightTerm) {
+    this.context = context;
     this.string = string;
+    this.node = node;
     this.leftTerm = leftTerm;
     this.rightTerm = rightTerm;
   }
 
+  getContext() {
+    return this.context;
+  }
+
   getString() {
     return this.string;
   }
 
+  getNode() {
+    return this.node;
+  }
+
   getLeftTerm() {
     return this.leftTerm;
   }
@@ -186,7 +195,7 @@ export default define(class Equality {
       return;
     }
 
-    const { Variable } = ontology,
+    const { Variable } = elements,
           type = this.getType(),
           leftTermNode = this.leftTerm.getNode(),
           rightTermNode = this.rightTerm.getNode(),
@@ -199,7 +208,7 @@ export default define(class Equality {
 
     if (leftVariableNode !== null) {
       const leftVariable = Variable.fromVariableNodeAndType(leftVariableNode, type, context),
-            leftVariableAssignment = VariableAssignment.fromVariable(leftVariable);
+            leftVariableAssignment = variableAssignmentFromVariable(leftVariable);
 
       assignment = leftVariableAssignment;  ///
 
@@ -208,7 +217,7 @@ export default define(class Equality {
 
     if (rightVariableNode !== null) {
       const rightVariable = Variable.fromVariableNodeAndType(rightVariableNode, type, context),
-            rightVariableAssignment = VariableAssignment.fromVariable(rightVariable);
+            rightVariableAssignment = variableAssignmentFromVariable(rightVariable);
 
       assignment = rightVariableAssignment;  ///
 
@@ -216,7 +225,7 @@ export default define(class Equality {
     }
 
     const equality = this,  //
-          equalityAssignment = EqualityAssignment.fromEquality(equality);
+          equalityAssignment = equalityAssignmentFromEquality(equality);
 
     assignment = equalityAssignment; ///
 
@@ -224,37 +233,4 @@ export default define(class Equality {
   }
 
   static name = "Equality";
-
-  static fromStatementNode(statementNode, context) {
-    let equality = null;
-
-    const equalityNode = statementNode.getEqualityNode();
-
-    if (equalityNode !== null) {
-      const node = equalityNode,  ///
-            string = context.nodeAsString(node),
-            leftTerm = leftTermFromEqualityNode(equalityNode, context),
-            rightTerm = rightTermFromEqualityNode(equalityNode, context);
-
-      equality = new Equality(string, leftTerm, rightTerm);
-    }
-
-    return equality;
-  }
 });
-
-function leftTermFromEqualityNode(equalityNode, context) {
-  const { Term } = ontology,
-        leftTermNode = equalityNode.getLeftTermNode(),
-        leftTerm = Term.fromTermNode(leftTermNode, context);
-
-  return leftTerm;
-}
-
-function rightTermFromEqualityNode(equalityNode, context) {
-  const { Term } = ontology,
-        rightTermNode = equalityNode.getRightTermNode(),
-        rightTerm = Term.fromTermNode(rightTermNode, context);
-
-  return rightTerm;
-}

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

@@ -2,16 +2,34 @@
 
 import { arrayUtilities } from "necessary";
 
-import { define } from "../ontology";
+import { define } from "../elements";
+import { termsStringFromTerms } from "../utilities/string";
+import { instantiateEquivalence } from "../process/instantiate";
 import { stripBracketsFromTermNode } from "../utilities/brackets";
+import { equalivanceFromEquivalenceNode } from "../utilities/element";
 
 const { compress } = arrayUtilities;
 
 export default define(class Equivalence {
-  constructor(terms) {
+  constructor(context, string, node, terms) {
+    this.context = context;
+    this.string = string;
+    this.node = node;
     this.terms = terms;
   }
 
+  getContext() {
+    return this.context;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getNode() {
+    return this.node;
+  }
+
   getTerms() {
     return this.terms;
   }
@@ -35,6 +53,17 @@ export default define(class Equivalence {
     if (!termPresent) {
       this.terms.push(term);
 
+      const termsString = termsStringFromTerms(this.terms),
+            string = termsString,  ///
+            equalivanceNode = instantiateEquivalence(string, context),
+            equalivance = equalivanceFromEquivalenceNode(equalivanceNode, context);
+
+      this.node = equalivance.getNode();
+
+      this.string = equalivance.getString();
+
+      const equivalenceString = this.string; ///
+
       context.debug(`...added the '${termString}' term to the '${equivalenceString}' equivalence.`);
     }
   }
@@ -243,27 +272,13 @@ export default define(class Equivalence {
     return implicitlyGroundedTerms;
   }
 
-  asString() {
-    const type = this.getType(),
-          typeString = type.getString(),
-          termsString = this.terms.reduce((termsString, term) => {
-            const termString = term.getString();
-
-            termsString = (termsString === null) ?
-                            termString :
-                             `${termsString} = ${termString}`;
-
-            return termsString;
-          }, null),
-          string = `${termsString}:${typeString}`;
-
-    return string;
-  }
-
-  static fromEquality(equality) {
+  static fromEquality(equality, context) {
     const terms = equality.getTerms(),
-          equivalence = new Equivalence(terms);
+          termsString = termsStringFromTerms(terms),
+          string = termsString,  ///
+          equalivanceNode = instantiateEquivalence(string, context),
+          equalivance = equalivanceFromEquivalenceNode(equalivanceNode, context);
 
-    return equivalence;
+    return equalivance;
   }
 });

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

@@ -2,7 +2,7 @@
 
 import { arrayUtilities } from "necessary";
 
-import { define } from "../ontology";
+import { define } from "../elements";
 import { variablesFromTerm } from "./term";
 
 const { push, separate } = arrayUtilities;
@@ -193,7 +193,6 @@ export default define(class Equivalences {
   }
 });
 
-
 function definedVariablesFromGroundedTerms(groundedTerms, definedVariables, context) {
   groundedTerms.forEach((groundedTerm) => {
     const term = groundedTerm,  ///

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

@@ -1,26 +1,26 @@
 "use strict";
 
-import { define } from "../ontology";
+import { define } from "../elements";
 
 export default define(class Error {
-  constructor(context, node, string) {
+  constructor(context, string, node) {
     this.context = context;
-    this.node = node;
     this.string = string;
+    this.node = node;
   }
 
   getContext() {
     return this.context;
   }
 
-  getNode() {
-    return this.node;
-  }
-
   getString() {
     return this.string;
   }
 
+  getNode() {
+    return this.node;
+  }
+
   verify() {
     let verifies = false;
 
@@ -36,7 +36,7 @@ export default define(class Error {
   static fromErrorNode(errorNode, context) {
     const node = errorNode, ///
           string = context.nodeAsString(node),
-          error = new Error(context, node, string);
+          error = new Error(context, string, node);
 
     return error;
   }

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

@@ -2,19 +2,19 @@
 
 import { arrayUtilities } from "necessary";
 
-import ontology from "../ontology";
+import elements from "../elements";
 
-import { define } from "../ontology";
+import { define } from "../elements";
 import { S, NOTHING } from "../constants";
+import { frameFromFrameNode } from "../utilities/element";
 import { FRAME_META_TYPE_NAME } from "../metaTypeNames";
 
 const { first } = arrayUtilities;
 
 export default define(class Frame {
-  constructor(string, node, tokens, assumptions) {
+  constructor(string, node, assumptions) {
     this.string = string;
     this.node = node;
-    this.tokens = tokens;
     this.assumptions = assumptions;
   }
 
@@ -26,10 +26,6 @@ export default define(class Frame {
     return this.node;
   }
 
-  getTokens() {
-    return this.tokens;
-  }
-
   getAssumptions() {
     return this.assumptions;
   }
@@ -305,30 +301,21 @@ export default define(class Frame {
     let frame = null;
 
     if (json !== null) {
-      const { Assumption } =ontology,
+      const { Assumption } =elements,
             assumption = Assumption.fromJSON(json, context),
             assumptions = [
               assumption
             ],
             string = null,
-            node = null,
-            tokens = null;
+            node = null;
 
-      frame = new Frame(string, node, tokens, assumptions);
+      frame = new Frame(string, node, assumptions);
     }
 
     return frame;
   }
 
-  static fromFrameNode(frameNode, context) {
-    let frame = null;
-
-    if (frameNode !== null) {
-      frame = frameFromFrameNode(frameNode, context);
-    }
-
-    return frame;
-  }
+  static fromFrameNode(frameNode, context) { return frameFromFrameNode(frameNode, context); }
 
   static fromJudgementNode(judgementNode, context) {
     const frameNode = judgementNode.getFrameNode(),
@@ -348,43 +335,8 @@ export default define(class Frame {
 
     return frame;
   }
-
-  static fromContainedAssertionNode(containedAssertionNode, context) {
-    let frame = null;
-
-    const frameNode = containedAssertionNode.getFrameNode();
-
-    if (frameNode !== null) {
-      frame = frameFromFrameNode(frameNode, context)
-    }
-
-    return frame;
-  }
 });
 
-function frameFromFrameNode(frameNode, context) {
-  const { Frame } = ontology,
-        node = frameNode, ///
-        string = context.nodeAsString(node),
-        tokens = context.nodeAsTokens(node),
-        assumptions = assumptionsFromFrameNode(frameNode, context),
-        frame = new Frame(string, node, tokens, assumptions);
-
-  return frame;
-}
-
-function assumptionsFromFrameNode(frameNode, context) {
-  const { Assumption } = ontology,
-        assumptionNodes = frameNode.getAssumptionNodes(),
-        assumptions = assumptionNodes.map((assumptionNode) => {
-          const assumption = Assumption.fromAssumptionNode(assumptionNode, context);
-
-          return assumption;
-        });
-
-  return assumptions;
-}
-
 function assumptionsStringFromAssumptions(assumptions) {
   const assumptionsString = assumptions.reduce((assumptionsString, assumption) => {
     const assumptionString = assumption.getString();

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

@@ -1,9 +1,9 @@
 "use strict";
 
-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";
 import { statementFromJSON, statementToStatementJSON } from "../utilities/json";
 
 export default define(class Hypothesis {
@@ -43,7 +43,7 @@ export default define(class Hypothesis {
         const assignmentsAssigned = assignAssignments(assignments, context);
 
         if (assignmentsAssigned) {
-          const { Step } = ontology,
+          const { Step } = elements,
                 step = Step.fromStatement(this.statement, context),
                 stepOrSubproof = step;  ///
 
@@ -113,7 +113,7 @@ export default define(class Hypothesis {
   }
 
   static fromHypothesisNode(hypothesisNode, context) {
-    const { Statement } = ontology,
+    const { Statement } = elements,
           node = hypothesisNode, ///
           string = context.nodeAsString(node),
           statement = Statement.fromHypothesisNode(hypothesisNode, context),

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

@@ -1,9 +1,9 @@
 "use strict";
 
-import ontology from "../ontology";
-import JudgementAssignment from "../assignment/judgement";
+import elements from "../elements";
 
-import { define } from "../ontology";
+import { define } from "../elements";
+import { judgementAssignmentFromJudgement } from "../process/assign";
 
 export default define(class Judgement {
   constructor(string, node, frame, assumption) {
@@ -142,8 +142,8 @@ export default define(class Judgement {
     }
 
     const judgement = this, ///
-          judgementAssignment = JudgementAssignment.fromJudgement(judgement),
-          assignment = judgementAssignment;
+          judgementAssignment = judgementAssignmentFromJudgement(judgement),
+          assignment = judgementAssignment; ///
 
     assignments.push(assignment);
   }
@@ -156,7 +156,7 @@ export default define(class Judgement {
     const judgementNode = statementNode.getJudgementNode();
 
     if (judgementNode !== null) {
-      const { Frame, Assumption } = ontology,
+      const { Frame, Assumption } = elements,
             node = judgementNode, ///
             string = context.nodeAsString(node),
             frame = Frame.fromJudgementNode(judgementNode, context),
@@ -170,7 +170,7 @@ export default define(class Judgement {
 });
 
 function referenceFromMetavariable(metavariable, context) {
-  const { Reference } = ontology,
+  const { Reference } = elements,
         metavariableNode = metavariable.getNode(),
         reference = Reference.fromMetavariableNode(metavariableNode, context);
 

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

@@ -1,8 +1,8 @@
 "use strict";
 
-import ontology from "../ontology";
+import elements from "../elements";
 
-import { define } from "../ontology";
+import { define } from "../elements";
 import { metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
 
 export default define(class Label {
@@ -97,7 +97,7 @@ export default define(class Label {
   }
 
   static fromLabelNode(labelNode, context) {
-    const { Metavariable } = ontology,
+    const { Metavariable } = elements,
           metavariable = Metavariable.fromLabelNode(labelNode, context),
           label = new Label(context, metavariable);
 

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

@@ -1,10 +1,10 @@
 "use strict";
 
-import TopLevelAssertion from "./topLevelAssertion";
+import AxiomLemmaTheoremConjecture from "./axiomLemmaTheoremConjecture";
 
-import { define } from "../ontology";
+import { define } from "../elements";
 
-export default define(class Lemma extends TopLevelAssertion {
+export default define(class Lemma extends AxiomLemmaTheoremConjecture {
   verify() {
     let verifies;
 
@@ -36,7 +36,7 @@ export default define(class Lemma extends TopLevelAssertion {
 
   static fromLemmaNode(lemmaNode, context) {
     const node = lemmaNode, ///
-          lemma = TopLevelAssertion.fromNode(Lemma, node, context);
+          lemma = AxiomLemmaTheoremConjecture.fromNode(Lemma, node, context);
 
     return lemma;
   }

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

@@ -1,10 +1,10 @@
 "use strict";
 
-import TopLevelMetaAssertion from "./topLevelMetaAssertion";
+import MetaLemmaMetatheorem from "./metaLemmaMetatheorem";
 
-import { define } from "../ontology";
+import { define } from "../elements";
 
-export default define(class MetaLemma extends TopLevelMetaAssertion {
+export default define(class MetaLemma extends MetaLemmaMetatheorem {
   verify() {
     let verifies;
 
@@ -30,11 +30,11 @@ export default define(class MetaLemma extends TopLevelMetaAssertion {
 
   static name = "MetaLemma";
 
-  static fromJSON(json, context) { return TopLevelMetaAssertion.fromJSON(MetaLemma, json, context); }
+  static fromJSON(json, context) { return MetaLemmaMetatheorem.fromJSON(MetaLemma, json, context); }
 
   static fromMetaLemmaNode(metaLemmaNode, context) {
     const node = metaLemmaNode, ///
-          metaLemma = TopLevelMetaAssertion.fromNode(MetaLemma, node, context);
+          metaLemma = MetaLemmaMetatheorem.fromNode(MetaLemma, node, context);
 
     return metaLemma;
   }

package/src/{ontology/topLevelMetaAssertion.js → element/metaLemmaMetatheorem.js}

@@ -1,9 +1,9 @@
 "use strict";
 
-import ontology from "../ontology";
+import elements from "../elements";
 import LocalContext from "../context/local";
 
-import { proofFromProofNode, deductionFromDeductionNode, suppositionsFromSuppositionNodes } from "./topLevelAssertion";
+import { proofFromProofNode, deductionFromDeductionNode, suppositionsFromSuppositionNodes } from "./axiomLemmaTheoremConjecture";
 import { labelFromJSON,
          labelToLabelJSON,
          deductionFromJSON,
@@ -13,11 +13,11 @@ import { labelFromJSON,
          suppositionsToSuppositionsJSON,
          substitutionsToSubstitutionsJSON } from "../utilities/json";
 
-export default class TopLevelMetaAssertion {
-  constructor(context, node, string, label, suppositions, deduction, proof, substitutions) {
+export default class MetaLemmaMetatheorem {
+  constructor(context, string, node, label, suppositions, deduction, proof, substitutions) {
     this.context = context;
-    this.node = node;
     this.string = string;
+    this.node = node;
     this.label = label;
     this.suppositions = suppositions;
     this.deduction = deduction;
@@ -162,13 +162,13 @@ export default class TopLevelMetaAssertion {
           node = null,
           proof = null,
           string = stringFromLabelASuppositionsAndDeduction(label, suppositions, deduction),
-          topLevelMetaAssertion = new Class(context, node, string, label, suppositions, deduction, proof, substitutions);
+          metaLemmaMetatheorem = new Class(context, string, node, label, suppositions, deduction, proof, substitutions);
 
-    return topLevelMetaAssertion;
+    return metaLemmaMetatheorem;
   }
 
   static fromNode(Class, node, context) {
-    const { Substitutions } = ontology,
+    const { Substitutions } = elements,
           topLevelAssertionNode = node, ///
           proofNode = topLevelAssertionNode.getProofNode(),
           labelNode = topLevelAssertionNode.getLabelNode(),
@@ -180,16 +180,16 @@ export default class TopLevelMetaAssertion {
           suppositions = suppositionsFromSuppositionNodes(suppositionNodes, context),
           substitutions = Substitutions.fromNothing(),
           string = stringFromLabelASuppositionsAndDeduction(label, suppositions, deduction),
-          topLevelMetaAssertion = new Class(context, node, string, label, suppositions, deduction, proof, substitutions);
+          metaLemmaMetatheorem = new Class(context, string, node, label, suppositions, deduction, proof, substitutions);
 
-    return topLevelMetaAssertion;
+    return metaLemmaMetatheorem;
   }
 }
 
 function labelFromLabelNode(labelNode, context) {
   let label = null;
 
-  const { Label } = ontology;
+  const { Label } = elements;
 
   if (labelNode !== null) {
     label = Label.fromLabelNode(labelNode, context);

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

@@ -1,21 +1,25 @@
 "use strict";
 
-import { define } from "../ontology";
+import { define } from "../elements";
 import { FRAME_META_TYPE_NAME, REFERENCE_META_TYPE_NAME, STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 
 class MetaType {
-  constructor(name) {
+  constructor(string, node, name) {
+    this.string = string;
+    this.node = node;
     this.name = name;
   }
 
-  getName() {
-    return this.name;
+  getString() {
+    return this.string;
   }
 
-  getString() {
-    const string = this.name; ///
+  getNode() {
+    return this.node;
+  }
 
-    return string;
+  getName() {
+    return this.name;
   }
 
   isEqualTo(metaType) {

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

@@ -1,10 +1,10 @@
 "use strict";
 
-import TopLevelMetaAssertion from "./topLevelMetaAssertion";
+import MetaLemmaMetatheorem from "./metaLemmaMetatheorem";
 
-import { define } from "../ontology";
+import { define } from "../elements";
 
-export default define(class Metatheorem extends TopLevelMetaAssertion {
+export default define(class Metatheorem extends MetaLemmaMetatheorem {
   verify() {
     let verifies;
 
@@ -30,11 +30,11 @@ export default define(class Metatheorem extends TopLevelMetaAssertion {
 
   static name = "Metatheorem";
 
-  static fromJSON(json, context) { return TopLevelMetaAssertion.fromJSON(Metatheorem, json, context); }
+  static fromJSON(json, context) { return MetaLemmaMetatheorem.fromJSON(Metatheorem, json, context); }
 
   static fromMetatheoremNode(metatheoremNode, context) {
     const node = metatheoremNode, ///
-          metatheorem = TopLevelMetaAssertion.fromNode(Metatheorem, node, context);
+          metatheorem = MetaLemmaMetatheorem.fromNode(Metatheorem, node, context);
 
     return metatheorem;
   }