occam-verify-cli 1.0.421 → 1.0.427

package/src/context/nominal.js

@@ -0,0 +1,30 @@
+"use strict";
+
+import { nominalLexer, nominalParser } from "../utilities/nominal";
+
+class NominalContext {
+  constructor(lexer, parser) {
+    this.lexer = lexer;
+    this.parser = parser;
+  }
+
+  getLexer() {
+    return this.lexer;
+  }
+
+  getParser() {
+    return this.parser;
+  }
+
+  static fromNothing() {
+    const lexer = nominalLexer, ///
+          parser = nominalParser, ///
+          nominalContext = new NominalContext(lexer, parser);
+
+    return nominalContext;
+  }
+}
+
+const nominalContext = NominalContext.fromNothing();
+
+export default nominalContext;

package/src/context/release.js

@@ -10,7 +10,7 @@ import FileContext from "../context/file";
 import NominalLexer from "../nominal/lexer";
 import NominalParser from "../nominal/parser";
 
-import { frameMetaType, referenceMetaType, statementMetaType } from "../ontology/metaType";
+import { frameMetaType, referenceMetaType, statementMetaType } from "../element/metaType";
 import { customGrammarFromNameAndEntries, combinedCustomGrammarFromReleaseContexts } from "../utilities/customGrammar";
 
 const { nominalLexerFromCombinedCustomGrammar } = lexersUtilities,

package/src/context/temporary.js

@@ -5,9 +5,8 @@ import { arrayUtilities } from "necessary";
 const { extract, compress } = arrayUtilities;
 
 export default class TemporaryContext {
-  constructor(context, tokens, terms, frames, statements, assertions, references, substitutions) {
+  constructor(context, terms, frames, statements, assertions, references, substitutions) {
     this.context = context;
-    this.tokens = tokens;
     this.terms = terms;
     this.frames = frames;
     this.statements = statements;
@@ -20,10 +19,6 @@ export default class TemporaryContext {
     return this.context;
   }
 
-  getTokens() {
-    return tokens;
-  }
-
   getTerms() {
     return this.terms;
   }
@@ -356,47 +351,9 @@ export default class TemporaryContext {
 
   matchTermAndPropertyRelation(term, propertyRelation) { return this.context.matchTermAndPropertyRelation(term, propertyRelation); }
 
-  nodeAsString(node, tokens = null) {
-    if (tokens === null) {
-      tokens = this.tokens;
-    }
-
-    const string = this.context.nodeAsString(node, tokens);
-
-    return string;
-  }
-
-  nodesAsString(node, tokens = null) {
-    if (tokens === null) {
-      tokens = this.tokens;
-    }
-
-    const string = this.context.nodesAsString(node, tokens);
-
-    return string;
-  }
-
-  nodeAsTokens(node, tokens = null) {
-    if (tokens === null) {
-      tokens = this.tokens;
-    }
-
-    tokens = this.context.nodeAsTokens(node, tokens); ///
-
-    return tokens;
-  }
-
-  nodesAsTokens(node, tokens = null) {
-    if (tokens === null) {
-      tokens = this.tokens;
-    }
+  nodeAsString(node) { return this.context.nodeAsString(node); }
 
-    tokens = this.context.nodesAsTokens(node, tokens);  ///
-
-    return tokens;
-  }
-
-  tokensAsString(tokens) { return this.context.tokensAsString(tokens); }
+  nodesAsString(node) { return this.context.nodesAsString(node); }
 
   trace(message, node = null) { this.context.trace(message, node); }
 
@@ -498,35 +455,21 @@ export default class TemporaryContext {
   static fromNothing(context) {
     const terms = [],
           frames = [],
-          tokens = null,
           statements = [],
           assertions = [],
           references = [],
           substitutions = [],
-          temporaryContext = new TemporaryContext(context, tokens, terms, frames, statements, assertions, references, substitutions);
+          temporaryContext = new TemporaryContext(context, terms, frames, statements, assertions, references, substitutions);
 
     return temporaryContext;
   }
 
   static fromTermsAndFrames(terms, frames, context) {
-    const tokens = null,
-          statements = [],
-          assertions = [],
-          references = [],
-          substitutions = [],
-          temporaryContext = new TemporaryContext(context, tokens, terms, frames, statements, assertions, references, substitutions);
-
-    return temporaryContext;
-  }
-
-  static fromContextAndTokens(context, tokens) {
-    const terms = [],
-          frames = [],
-          statements = [],
+    const statements = [],
           assertions = [],
           references = [],
           substitutions = [],
-          temporaryContext = new TemporaryContext(context, tokens, terms, frames, statements, assertions, references, substitutions);
+          temporaryContext = new TemporaryContext(context, terms, frames, statements, assertions, references, substitutions);
 
     return temporaryContext;
   }

package/src/{ontology → element}/assertion/contained.js

@@ -1,14 +1,14 @@
 "use strict";
 
-import ontology from "../../ontology";
 import Assertion from "../assertion";
 
-import { define } from "../../ontology";
+import { define } from "../../elements";
+import { containedAssertionFromStatementNode } from "../../utilities/element";
 import { termFromTermAndSubstitutions, frameFromFrameAndSubstitutions, statementFromStatementAndSubstitutions } from "../../utilities/substitutions";
 
 export default define(class ContainedAssertion extends Assertion {
-  constructor(string, node, tokens, term, frame, negated, statement) {
-    super(string, node, tokens);
+  constructor(string, node, term, frame, negated, statement) {
+    super(string, node);
 
     this.term = term;
     this.frame = frame;
@@ -201,27 +201,6 @@ export default define(class ContainedAssertion extends Assertion {
   }
 
   static name = "ContainedAssertion";
-
-  static fromStatementNode(statementNode, context) {
-    let containedAssertion = null;
-
-    const containedAssertionNode = statementNode.getContainedAssertionNode();
-
-    if (containedAssertionNode !== null) {
-      const { Term, Frame, Statement } = ontology,
-            node = containedAssertionNode,  ///
-            string = context.nodeAsString(node),
-            tokens = context.nodeAsTokens(node),
-            negated = containedAssertionNode.isNegated(),
-            term = Term.fromContainedAssertionNode(containedAssertionNode, context),
-            frame = Frame.fromContainedAssertionNode(containedAssertionNode, context),
-            statement = Statement.fromContainedAssertionNode(containedAssertionNode, context);
-
-      containedAssertion = new ContainedAssertion(string, node, tokens, term, frame, negated, statement);
-    }
-
-    return containedAssertion;
-  }
 });
 
 function verifyWhenDerived(term, frame, statement, negated, generalContext, specificContext) {

package/src/{ontology → element}/assertion/defined.js

@@ -1,14 +1,15 @@
 "use strict";
 
-import ontology from "../../ontology";
+import elements from "../../elements";
 import Assertion from "../assertion";
 
-import { define } from "../../ontology";
+import { define } from "../../elements";
+import { definedAssertionFromStatementNode } from "../../utilities/element";
 import { termFromTermAndSubstitutions, frameFromFrameAndSubstitutions } from "../../utilities/substitutions";
 
 export default define(class DefinedAssertion extends Assertion {
-  constructor(string, node, tokens, term, frame, negated) {
-    super(string, node, tokens);
+  constructor(string, node, term, frame, negated) {
+    super(string, node);
 
     this.term = term;
     this.frame= frame;
@@ -172,26 +173,6 @@ export default define(class DefinedAssertion extends Assertion {
   }
 
   static name = "DefinedAssertion";
-
-  static fromStatementNode(statementNode, context) {
-    let definedAssertion = null;
-
-    const definedAssertionNode = statementNode.getDefinedAssertionNode();
-
-    if (definedAssertionNode !== null) {
-      const { Term, Frame } = ontology,
-            node = definedAssertionNode,  ///
-            string = context.nodeAsString(node),
-            tokens = context.nodeAsTokens(node),
-            negated = definedAssertionNode.isNegated(),
-            term = Term.fromDefinedAssertionNode(definedAssertionNode, context),
-            frame = Frame.fromDefinedAssertionNode(definedAssertionNode, context);
-
-      definedAssertion = new DefinedAssertion(string, node, tokens, term, frame, negated);
-    }
-
-    return definedAssertion;
-  }
 });
 
 function verifyWhenDerived(term, frame, negated, generalContext, specificContext) {
@@ -200,7 +181,7 @@ function verifyWhenDerived(term, frame, negated, generalContext, specificContext
   const context = specificContext;  ///
 
   if (term !== null) {
-    const { Variable } = ontology,
+    const { Variable } = elements,
           termNode = term.getNode(),
           variable = Variable.fromTermNode(termNode, context),
           generalContext = context, ///
@@ -216,7 +197,7 @@ function verifyWhenDerived(term, frame, negated, generalContext, specificContext
   }
 
   if (frame!== null) {
-    const { Metavariable } = ontology,
+    const { Metavariable } = elements,
           frameNode = frame.getNode(),
           metavariable = Metavariable.fromFrameNode(frameNode, context),
           metavariableDefined = context.isMetavariableDefined(metavariable);

package/src/{ontology → element}/assertion/property.js

@@ -1,14 +1,14 @@
 "use strict";
 
-import ontology from "../../ontology";
+import elements from "../../elements";
 import Assertion from "../assertion";
-import VariableAssignment from "../../assignment/variable";
 
-import { define } from "../../ontology";
+import { define } from "../../elements";
+import { variableAssignmentFromVariable } from "../../process/assign";
 
 export default define(class PropertyAssertion extends Assertion {
-  constructor(string, node, tokens, term, propertyRelation) {
-    super(string, node, tokens);
+  constructor(string, node, term, propertyRelation) {
+    super(string, node);
 
     this.term = term;
     this.propertyRelation = propertyRelation;
@@ -164,7 +164,7 @@ export default define(class PropertyAssertion extends Assertion {
 
     let variable;
 
-    const { Variable } = ontology,
+    const { Variable } = elements,
           termNode = this.term.getNode();
 
     variable = Variable.fromTermNode(termNode, context);
@@ -176,7 +176,7 @@ export default define(class PropertyAssertion extends Assertion {
 
       variable = Variable.fromVariableAndPropertyRelation(variable, this.propertyRelation);
 
-      const variableAssignment = VariableAssignment.fromVariable(variable),
+      const variableAssignment = variableAssignmentFromVariable(variable),
             assignment = variableAssignment;  ///
 
       assignments.push(assignment);
@@ -184,23 +184,4 @@ export default define(class PropertyAssertion extends Assertion {
   }
 
   static name = "PropertyAssertion";
-
-  static fromStatementNode(statementNode, context) {
-    let propertyAssertion = null;
-
-    const propertyAssertionNode = statementNode.getPropertyAssertionNode();
-
-    if (propertyAssertionNode !== null) {
-      const { Term, PropertyRelation } = ontology,
-            node = propertyAssertionNode,  ///
-            string = context.nodeAsString(node),
-            tokens = context.nodeAsTokens(node),
-            term = Term.fromPropertyAssertionNode(propertyAssertionNode, context),
-            propertyRelation = PropertyRelation.fromPropertyAssertionNode(propertyAssertionNode, context);
-
-      propertyAssertion = new PropertyAssertion(string, node, tokens, term, propertyRelation);
-    }
-
-    return propertyAssertion;
-  }
 });

package/src/{ontology → element}/assertion/satisfies.js

@@ -1,22 +1,18 @@
 "use strict";
 
-import ontology from "../../ontology";
+import elements from "../../elements";
 import Assertion from "../assertion";
 
-import { define } from "../../ontology";
+import { define } from "../../elements";
 
 export default define(class SatisfiesAssertion extends Assertion {
-  constructor(string, node, tokens, signature, reference) {
-    super(string, node, tokens);
+  constructor(string, node, signature, reference) {
+    super(string, node);
 
     this.signature = signature;
     this.reference = reference;
   }
 
-  getTokens() {
-    return this.tokens;
-  }
-
   getSignature() {
     return this.signature;
   }
@@ -97,7 +93,7 @@ export default define(class SatisfiesAssertion extends Assertion {
     if (satisfiable) {
       let substitutions;
 
-      const { Substitutions } = ontology;
+      const { Substitutions } = elements;
 
       substitutions = Substitutions.fromNothing();
 
@@ -134,48 +130,4 @@ export default define(class SatisfiesAssertion extends Assertion {
   }
 
   static name = "SatisfiesAssertion";
-
-  static fromStepNode(stepNode, context) {
-    let satisfiesAssertion = null;
-
-    const satisfiesAssertionNode = stepNode.getSatisfiedAssertionNode();
-
-    if (satisfiesAssertionNode !== null) {
-      satisfiesAssertion = satisfiesAssertionFromSatisfiesAssertionNode(satisfiesAssertionNode, context);
-    }
-
-    return satisfiesAssertion;
-  }
-
-  static fromStatementNode(statementNode, context) {
-    let satisfiesAssertion = null;
-
-    const satisfiesAssertionNode = statementNode.getSatisfiedAssertionNode();
-
-    if (satisfiesAssertionNode !== null) {
-      satisfiesAssertion = satisfiesAssertionFromSatisfiesAssertionNode(satisfiesAssertionNode, context);
-    }
-
-    return satisfiesAssertion;
-  }
 });
-
-function signatureFromSatisfiesAssertionNode(satisfiesAssertionNode, context) {
-  const { Signature } = ontology,
-        signatureNode = satisfiesAssertionNode.getSignatureNode(),
-        signature = Signature.fromSignatureNode(signatureNode, context);
-
-  return signature;
-}
-
-function satisfiesAssertionFromSatisfiesAssertionNode(satisfiesAssertionNode, context) {
-  const { Reference, SatisfiesAssertion } = ontology,
-        node = satisfiesAssertionNode,  ///
-        string = context.nodeAsString(node),
-        tokens = context.nodeAsTokens(node),
-        signature = signatureFromSatisfiesAssertionNode(satisfiesAssertionNode, context),
-        reference = Reference.fromSatisfiesAssertionNode(satisfiesAssertionNode, context),
-        satisfiesAssertion = new SatisfiesAssertion(string, node, tokens, signature, reference);
-
-  return satisfiesAssertion;
-}

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

@@ -2,17 +2,16 @@
 
 import { arrayUtilities } from "necessary";
 
-import ontology from "../../ontology";
 import Assertion from "../assertion";
 
-import { define } from "../../ontology";
+import { define } from "../../elements";
 import { unifyStatement } from "../../process/unify";
 
 const { match } = arrayUtilities;
 
 export default define(class SubproofAssertion extends Assertion {
-  constructor(string, node, tokens, statements) {
-    super(string, node, tokens);
+  constructor(string, node, statements) {
+    super(string, node);
 
     this.statements = statements;
   }
@@ -84,33 +83,5 @@ export default define(class SubproofAssertion extends Assertion {
   }
 
   static name = "SubproofAssertion";
-
-  static fromStatementNode(statementNode, context) {
-    let subproofAssertion = null;
-
-    const subproofAssertionNode = statementNode.getSubproofAssertionNode();
-
-    if (subproofAssertionNode !== null) {
-      const node = subproofAssertionNode, ///
-            tokens = null,
-            string = context.nodeAsString(node),
-            statements = statementsFromSubproofAssertionNode(subproofAssertionNode, context);
-
-      subproofAssertion = new SubproofAssertion(string, node, tokens, statements);
-    }
-
-    return subproofAssertion;
-  }
 });
 
-function statementsFromSubproofAssertionNode(subproofAssertionNode, context) {
-  const { Statement } = ontology,
-        statementNodes = subproofAssertionNode.getStatementNodes(),
-        statements = statementNodes.map((statementNode) => {
-          const statement = Statement.fromStatementNode(statementNode, context);
-
-          return statement;
-        });
-
-  return statements;
-}

package/src/{ontology → element}/assertion/type.js

@@ -1,14 +1,14 @@
 "use strict";
 
-import ontology from "../../ontology";
+import elements from "../../elements";
 import Assertion from "../assertion";
-import VariableAssignment from "../../assignment/variable";
 
-import { define } from "../../ontology";
+import { define } from "../../elements";
+import { variableAssignmentFromVariable } from "../../process/assign";
 
 export default define(class TypeAssertion extends Assertion {
-  constructor(string, node, tokens, term, type) {
-    super(string, node, tokens);
+  constructor(string, node, term, type) {
+    super(string, node);
 
     this.term = term;
     this.type = type;
@@ -151,7 +151,7 @@ export default define(class TypeAssertion extends Assertion {
       return;
     }
 
-    const { Type, Variable } = ontology,
+    const { Type, Variable } = elements,
           termNode = this.term.getNode();
 
     let type,
@@ -172,7 +172,7 @@ export default define(class TypeAssertion extends Assertion {
     if (singularVariableNode !== null) {
       const variableNode = singularVariableNode,  ///
             variable = Variable.fromVariableNodeAndType(variableNode, type, context),
-            variableAssignment = VariableAssignment.fromVariable(variable),
+            variableAssignment = variableAssignmentFromVariable(variable),
             assignment = variableAssignment;  ///
 
       assignments.push(assignment);
@@ -180,23 +180,4 @@ export default define(class TypeAssertion extends Assertion {
   }
 
   static name = "TypeAssertion";
-
-  static fromStatementNode(statementNode, context) {
-    let typeAssertion = null;
-
-    const typeAssertionNode = statementNode.getTypeAssertionNode();
-
-    if (typeAssertionNode !== null) {
-      const { Term, Type } = ontology,
-            node = typeAssertionNode, ///
-            tokens = null,
-            string = context.nodeAsString(node),
-            term = Term.fromTypeAssertionNode(typeAssertionNode, context),
-            type = Type.fromTypeAssertionNode(typeAssertionNode, context);
-
-      typeAssertion = new TypeAssertion(string, node, tokens, term, type);
-    }
-
-    return typeAssertion;
-  }
 });

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

@@ -1,10 +1,14 @@
 "use strict";
 
 export default class Assertion {
-  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() {
@@ -15,9 +19,5 @@ export default class Assertion {
     return this.node;
   }
 
-  getTokens() {
-    return this.tokens;
-  }
-
   matchAssertionNode(assertionNode) { return this.node.match(assertionNode); }
 }

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

@@ -1,8 +1,8 @@
 "use strict";
 
-import ontology from "../ontology";
+import elements from "../elements";
 
-import { define } from "../ontology";
+import { define } from "../elements";
 import { unifyStatementIntrinsically } from "../process/unify";
 import { referenceFromJSON, referenceToReferenceJSON } from "../utilities/json";
 
@@ -291,7 +291,7 @@ export default define(class Assumption {
 
     context = metaLemmaMetatheorem.getContext();  ///
 
-    const { Substitutions } = ontology,
+    const { Substitutions } = elements,
           specificContext = context,  ///
           labelSubstitutions = Substitutions.fromNothing(),
           label = metaLemmaMetatheorem.getLabel(),
@@ -353,28 +353,4 @@ export default define(class Assumption {
 
     return assumption;
   }
-
-  static fromJudgementNode(judgementNode, context) {
-    const assumptionNode = judgementNode.getAssumptionNode(),
-          assumption = assumptionFromAssumptionNode(assumptionNode, context);
-
-    return assumption;
-  }
-
-  static fromAssumptionNode(assumptionNode, context) {
-    const assumption = assumptionFromAssumptionNode(assumptionNode, context);
-
-    return assumption;
-  }
 });
-
-function assumptionFromAssumptionNode(assumptionNode, context) {
-  const { Reference, Assumption, Statement } = ontology,
-        node = assumptionNode,  ///
-        string = context.nodeAsString(node),
-        statement = Statement.fromAssumptionNode(assumptionNode, context),
-        reference = Reference.fromAssumptionNode(assumptionNode, context),
-        assumption = new Assumption(string, node, statement, reference);
-
-  return assumption;
-}

package/src/{ontology → element}/axiom.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 Axiom extends TopLevelAssertion {
+export default define(class Axiom extends AxiomLemmaTheoremConjecture {
   isSatisfiable() {
     const signature = this.getSignature(),
           satisfiable = (signature !== null);
@@ -266,12 +266,5 @@ export default define(class Axiom extends TopLevelAssertion {
 
   static name = "Axiom";
 
-  static fromJSON(json, context) { return TopLevelAssertion.fromJSON(Axiom, json, context); }
-
-  static fromAxiomNode(axiomNode, context) {
-    const node = axiomNode, ///
-          axiom = TopLevelAssertion.fromNode(Axiom, node, context);
-
-    return axiom;
-  }
+  static fromJSON(json, context) { return AxiomLemmaTheoremConjecture.fromJSON(Axiom, json, context); }
 });