occam-verify-cli 1.0.421 → 1.0.427

package/src/element/term/constructor.js

@@ -0,0 +1,82 @@
+"use strict";
+
+import elements from "../../elements";
+
+import { define } from "../../elements";
+import { unifyTermWithConstructorTerm } from "../../process/unify";
+import { termFromJSON, termToTermJSON } from "../../utilities/json";
+
+export default define(class ConstructorTerm {
+  constructor(term) {
+    this.term = term;
+  }
+
+  getTerm() {
+    return this.term;
+  }
+
+  getType() { return this.term.getType(); }
+
+  getString() { return this.term.getString(); }
+
+  isProvisional() { return this.term.isProvisional(); }
+
+  setType(type) { this.term.setType(type); }
+
+  unifyTerm(term, context, verifyAhead) {
+    let termUnifies = false;
+
+    const termString = term.getString(),
+          constructorTermString = this.getString();
+
+    context.trace(`Unifying the '${termString}' term with the '${constructorTermString}' constructor's term...`);
+
+    const constructorTerm = this, ///
+          termUnifiesWithConstructor = unifyTermWithConstructorTerm(term, constructorTerm, context);
+
+    if (termUnifiesWithConstructor) {
+      let verifiesAhead;
+
+      const type = this.getType();
+
+      term.setType(type);
+
+      verifiesAhead = verifyAhead();
+
+      termUnifies = verifiesAhead;  ///
+    }
+
+    if (termUnifies) {
+      context.debug(`...unified the '${termString}' term with the '${constructorTermString}' constructor's term.`);
+    }
+
+    return termUnifies;
+  }
+
+  toJSON() {
+    const termJSON = termToTermJSON(this.term),
+          term = termJSON,  ///
+          json = {
+            term
+          };
+
+    return json;
+  }
+
+  static name = "ConstructorTerm";
+
+  static fromJSON(json, context) {
+    const term = termFromJSON(json, context),
+          constructor = new ConstructorTerm(term);
+
+    return constructor;
+  }
+
+  static fromConstructorDeclarationNode(constructorDeclarationNode, context) {
+    const { Term } = elements,
+          term = Term.fromConstructorDeclarationNode(constructorDeclarationNode, context),
+          constructor = new ConstructorTerm(term);
+
+    return constructor;
+  }
+});

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

@@ -2,12 +2,12 @@
 
 import { arrayUtilities } from "necessary";
 
-import ontology from "../ontology";
+import elements from "../elements";
 import verifyMixins from "../mixins/term/verify";
 
-import { define } from "../ontology";
-import { termFromTermNode } from "../utilities/node";
-import { termNodeFromTermString } from "../context/partial/term";
+import { define } from "../elements";
+import { instantiateTerm } from "../process/instantiate";
+import { termFromTermNode } from "../utilities/node.old";
 import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 
 const { filter, compress } = arrayUtilities;
@@ -177,8 +177,7 @@ export default define(class Term {
 
   static fromJSON(json, context) {
     const { string } = json,
-          termString = string,  ///
-          termNode = termNodeFromTermString(termString, context),
+          termNode = instantiateTerm(string, context),
           node = termNode,  ///
           type = typeFromJSON(json, context),
           term = new Term(string, node, type);
@@ -200,18 +199,6 @@ export default define(class Term {
     return term;
   }
 
-  static fromTypeAssertionNode(typeAssertionNode, context) {
-    let term = null;
-
-    const termNode = typeAssertionNode.getTermNode();
-
-    if (termNode !== null) {
-      term = termFromTermNode(termNode, context);
-    }
-
-    return term;
-  }
-
   static fromDefinedAssertionNode(definedAssertionNode, context) {
     let term = null;
 
@@ -231,27 +218,8 @@ export default define(class Term {
     return term;
   }
 
-  static fromPropertyAssertionNode(propertyAssertionNode, context) {
-    const termNode = propertyAssertionNode.getTermNode(),
-          term = termFromTermNode(termNode, context);
-
-    return term;
-  }
-
-  static fromContainedAssertionNode(containedAssertionNode, context) {
-    let term = null;
-
-    const termNode = containedAssertionNode.getTermNode();
-
-    if (termNode !== null) {
-      term = termFromTermNode(termNode, context);
-    }
-
-    return term;
-  }
-
   static fromConstructorDeclarationNode(constructorDeclarationNode, context) {
-    const { Type } = ontology,
+    const { Type } = elements,
           termNode = constructorDeclarationNode.getTermNode(),
           term = termFromTermNode(termNode, context),
           type = Type.fromConstructorDeclarationNode(constructorDeclarationNode, context);

package/src/{ontology → element}/theorem.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 Theorem extends TopLevelAssertion {
+export default define(class Theorem extends AxiomLemmaTheoremConjecture {
   verify() {
     let verifies;
 
@@ -29,11 +29,11 @@ export default define(class Theorem extends TopLevelAssertion {
 
   static name = "Theorem";
 
-  static fromJSON(json, context) { return TopLevelAssertion.fromJSON(Theorem, json, context); }
+  static fromJSON(json, context) { return AxiomLemmaTheoremConjecture.fromJSON(Theorem, json, context); }
 
   static fromTheoremNode(theoremNode, context) {
     const node = theoremNode, ///
-          theorem = TopLevelAssertion.fromNode(Theorem, node, context);
+          theorem = AxiomLemmaTheoremConjecture.fromNode(Theorem, node, context);
 
     return theorem;
   }

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

@@ -2,19 +2,18 @@
 
 import { arrayUtilities } from "necessary";
 
-import ontology from "../ontology";
-
-import { define } from "../ontology";
+import { define } from "../elements";
 import { BASE_TYPE_SYMBOL } from "../constants";
-import { typeFromTypeNode } from "../utilities/node";
-import { stringFromTypeNameTypePrefixNameAndSuperTypes } from "../utilities/type";
+import { typeFromTypeNode } from "../utilities/node.old";
+import { typeStringFromTypeNameTypePrefixNameAndSuperTypes } from "../utilities/string";
 import { superTypesFromJSON, propertiesFromJSON, superTypesToSuperTypesJSON, propertiesToPropertiesJSON } from "../utilities/json";
 
 const { push, first } = arrayUtilities;
 
 class Type {
-  constructor(string, name, prefixName, superTypes, properties, provisional) {
+  constructor(string, node, name, prefixName, superTypes, properties, provisional) {
     this.string = string;
+    this.node = node;
     this.name = name;
     this.prefixName = prefixName;
     this.superTypes = superTypes;
@@ -26,6 +25,10 @@ class Type {
     return this.string;
   }
 
+  getNode() {
+    return this.node;
+  }
+
   getName() {
     return this.name;
   }
@@ -306,8 +309,8 @@ class Type {
           superTypes = superTypesFromJSON(json, context),
           typeName = name,  ///
           typePrefixName = null,
-          string = stringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),
-          type = new Type(string, name, prefixName, superTypes, properties, provisional);
+          string = typeStringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),
+          type = new Type(string, node, name, prefixName, superTypes, properties, provisional);
 
     return type;
   }
@@ -327,13 +330,6 @@ class Type {
     return type;
   }
 
-  static fromTypeAssertionNode(typeAssertionNode, context) {
-    const typeNode = typeAssertionNode.getTypeNode(),
-          type = typeFromTypeNode(typeNode, context);
-
-    return type;
-  }
-
   static fromTypeAndProvisional(type, provisional) {
     const name = type.getName(),
           prefixName = type.getPrefixName(),
@@ -343,10 +339,10 @@ class Type {
           superTypes = [
             superType
           ],
-          string = stringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),
+          string = typeStringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),
           properties = type.getProperties();
 
-    type = new Type(string, name, prefixName, superTypes, properties, provisional);  ///
+    type = new Type(string, node, name, prefixName, superTypes, properties, provisional);  ///
 
     return type;
   }
@@ -366,22 +362,8 @@ class Type {
           name = typeName,  ///
           prefixName = typePrefixName,  ///
           properties = [],
-          string = stringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),
-          type = new Type(string, name, prefixName, superTypes, properties, provisional);
-
-    return type;
-  }
-
-  static fromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
-    const typeName = complexTypeDeclarationNode.getTypeName(),
-          provisional = complexTypeDeclarationNode.isProvisional(),
-          typePrefixName = complexTypeDeclarationNode.getTypePrefixName(),
-          superTypes = superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
-          name = typeName,  ///
-          prefixName = typePrefixName,  ///
-          properties = propertiesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
-          string = stringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),
-          type = new Type(string, name, prefixName, superTypes, properties, provisional);
+          string = typeStringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),
+          type = new Type(string, node, name, prefixName, superTypes, properties, provisional);
 
     return type;
   }
@@ -425,45 +407,16 @@ function superTypesFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, cont
   return superTypes;
 }
 
-function superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
-  const superTypeNodes = complexTypeDeclarationNode.getSuperTypeNodes(),
-        superTypes = superTypeNodes.map((superTypeNode) => {
-          const superType = Type.fromSuperTypeNode(superTypeNode, context);
-
-          return superType;
-        }),
-        superTypesLength = superTypes.length;
-
-  if (superTypesLength === 0) {
-    const superType = baseType; ///
-
-    superTypes.push(superType);
-  }
-
-  return superTypes;
-}
-
-function propertiesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
-  const { Property } = ontology,
-        propertyDeclarationNodes = complexTypeDeclarationNode.getPropertyDeclarationNodes(),
-        properties = propertyDeclarationNodes.map((propertyDeclarationNode) => {
-          const property = Property.fromPropertyDeclarationNode(propertyDeclarationNode, context);
-
-          return property;
-        });
-
-  return properties;
-}
-
 class BaseType extends Type {
   static fromNothing() {
     const name = BASE_TYPE_SYMBOL,  ///
           string = name,  ///
+          node = null,
           prefixName = null,
           superTypes = [],
           properties = [],
           provisional = false,
-          baseType = new BaseType(string, name, prefixName, superTypes, properties, provisional);
+          baseType = new BaseType(string, node, name, prefixName, superTypes, properties, provisional);
 
     return baseType;
   }

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

@@ -1,10 +1,11 @@
 "use strict";
 
-import { define } from "../ontology";
+import { define } from "../elements";
 
-export default define (class TypePrefix {
-  constructor(string, name) {
+export default define(class TypePrefix {
+  constructor(string, node, name) {
     this.string = string;
+    this.node = node;
     this.name = name;
   }
 
@@ -12,6 +13,10 @@ export default define (class TypePrefix {
     return this.string;
   }
 
+  getNode() {
+    return this.node;
+  }
+
   getName() {
     return this.name;
   }
@@ -40,13 +45,4 @@ export default define (class TypePrefix {
 
     return typePrefix;
   }
-
-  static fromTypePrefixDeclarationNode(typePrefixDeclarationNode, context) {
-    const typePrefix = typePrefixDeclarationNode.getTypePrefix(),
-          name = typePrefix,  ///
-          string = name,  ///
-          type = new TypePrefix(string, name);
-
-    return type;
-  }
 });

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

@@ -1,12 +1,12 @@
 "use strict";
 
-import ontology from "../ontology";
+import elements from "../elements";
 
-import { define } from "../ontology";
+import { define } from "../elements";
 import { EMPTY_STRING } from "../constants";
-import { typeFromTypeNode } from "../utilities/node";
+import { typeFromTypeNode } from "../utilities/node.old";
+import { instantiateVariable } from "../process/instantiate";
 import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
-import { variableNodeFromVariableString } from "../context/partial/variable";
 
 export default define(class Variable {
   constructor(string, node, type, identifier, propertyRelations) {
@@ -41,6 +41,8 @@ export default define(class Variable {
     this.type = type;
   }
 
+  getTypeString() { return this.type.getString(); }
+
   isEqualTo(variable) {
     const variableNode = variable.getNode(),
           matches = this.node.match(variableNode),
@@ -156,7 +158,7 @@ export default define(class Variable {
             termTypeEqualToOrSubTypeOfVariableType = termType.isEqualToOrSubTypeOf(variableType);
 
       if (termTypeEqualToOrSubTypeOfVariableType) {
-        const { TermSubstitution } = ontology,
+        const { TermSubstitution } = elements,
               termSubstitution = TermSubstitution.fromTernAndVariable(term, variable, context),
               substitution = termSubstitution;  ///
 
@@ -189,8 +191,7 @@ export default define(class Variable {
 
   static fromJSON(json, context) {
     const { string } = json,
-          variableString = string,  ///
-          variableNode = variableNodeFromVariableString(variableString, context),
+          variableNode = instantiateVariable(string, context),
           variableIdentifier = variableNode.getVariableIdentifier(),
           node = variableNode,
           identifier = variableIdentifier,  ///
@@ -235,7 +236,7 @@ export default define(class Variable {
   }
 
   static fromVariableDeclarationNode(variableDeclarationNode, context) {
-    const { Variable } = ontology,
+    const { Variable } = elements,
           provisional = variableDeclarationNode.isProvisional(),
           typeNode = variableDeclarationNode.getTypeNode(),
           type = typeFromTypeNode(typeNode, context);
@@ -275,18 +276,6 @@ export default define(class Variable {
   }
 });
 
-function variableFromVariableNodeAndType(variableNode, type) {
-  const { Variable } = ontology,
-        node = variableNode,  ///
-        variableIdentifier = variableNode.getVariableIdentifier(),
-        string = variableIdentifier,  ///,
-        identifier = variableIdentifier,  ///
-        propertyRelations = [],
-        variable = new Variable(string, node, type, identifier, propertyRelations);
-
-  return variable;
-}
-
 function stringFromNameAndPropertyRelations(identifier, propertyRelations) {
   const propertyRelationsString = propertyRelations.reduce((propertyRelationsString, propertyRelation) => {
           const propertyRelationString = propertyRelation.getString();

package/src/elements.js

@@ -0,0 +1,13 @@
+"use strict";
+
+const elements = {};
+
+export function define(Element) {
+  const { name } = Element;
+
+  elements[name] = Element;
+
+  return Element;
+}
+
+export default elements;

package/src/mixins/statement/verify.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import ontology from "../../ontology";
+import elements from "../../elements";
 
 import { equalityFromStatement,
          judgementFromStatement,
@@ -10,7 +10,7 @@ import { equalityFromStatement,
          propertyAssertionFromStatement,
          subproofAssertionFromStatement,
          containedAssertionFromStatement,
-         satisfiesAssertionFromStatement } from "../../utilities/context";
+         satisfiesAssertionFromStatement } from "../../utilities/statement";
 
 function verifyAsMetavariableAndSubstitution(statement, assignments, stated, context) {
   let verifiesAsMetavariableAndSubstitution = false;
@@ -25,7 +25,7 @@ function verifyAsMetavariableAndSubstitution(statement, assignments, stated, con
     const metavariableVerifies = metavariable.verify(context);
 
     if (metavariableVerifies) {
-      const { TermSubstitution, FrameSubstitution } = ontology,
+      const { TermSubstitution, FrameSubstitution } = elements,
             frameSubstitution = FrameSubstitution.fromStatement(statement, context),
             termSubstitution = TermSubstitution.fromStatement(statement, context),
             substitution = (termSubstitution || frameSubstitution);
@@ -54,7 +54,7 @@ function unifyWithBracketedCombinator(statement, assignments, stated, context) {
 
   assignments = null; ///
 
-  const { BracketedCombinator } = ontology,
+  const { BracketedCombinator } = elements,
         bracketedCombinator = BracketedCombinator.fromNothing(),
         unifiesWithBracketedCombinator = bracketedCombinator.unifyStatement(statement, assignments, stated, context);
 

package/src/mixins/step/unify.js

@@ -2,13 +2,13 @@
 
 import { arrayUtilities } from "necessary";
 
-import ontology from "../../ontology";
+import elements from "../../elements";
 
 import { equalityFromStatement,
          judgementFromStatement,
          typeAssertionFromStatement,
          propertyAssertionFromStatement,
-         satisfiesAssertionFromStatement } from "../../utilities/context";
+         satisfiesAssertionFromStatement } from "../../utilities/statement";
 
 const { backwardsSome } = arrayUtilities;
 
@@ -52,7 +52,7 @@ function unifyWithReference(statement, reference, satisfiesAssertion, substituti
 
       context.trace(`Unifying the '${statementString}' statement with the '${referenceString}' reference...`);
 
-      const { StatementSubstitution } = ontology,
+      const { StatementSubstitution } = elements,
             metavariable = reference.getMetavariable(),
             statementSubstitution = StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context),
             substitution = statementSubstitution; ///
@@ -107,7 +107,7 @@ function unifyAsSatisfiesAssertion(statement, reference, satisfiesAssertion, sub
           const satisfiable = axiom.isSatisfiable();
 
           if (satisfiable) {
-            const { Substitutions } = ontology,
+            const { Substitutions } = elements,
                   substitutions = Substitutions.fromNothing(),
                   axiomLemmaTheoremOrConjectureUnifies = axiom.unifyAxiomLemmaTheoremOrConjecture(axiomLemmaTheoremOrConjecture, substitutions, context);
 
@@ -139,7 +139,7 @@ function unifyWithAxiomLemmaTheoremOrConjecture(statement, reference, satisfiesA
   let unifiesWithAxiomLemmaTheoremOrConjecture = false;
 
   if (reference !== null) {
-    const { Substitutions } = ontology,
+    const { Substitutions } = elements,
           axiomLemmaTheoremOrConjecture = context.findAxiomLemmaTheoremOrConjectureByReference(reference),
           generalSubstitutions = substitutions; ///
 
@@ -156,7 +156,7 @@ function unifyWithAxiomLemmaTheoremOrConjecture(statement, reference, satisfiesA
       const statementAndStepsUnify = axiomLemmaTheoremOrConjecture.unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, substitutions, context);
 
       if (statementAndStepsUnify) {
-        const { StatementSubstitution } = ontology,
+        const { StatementSubstitution } = elements,
               metavariable = reference.getMetavariable(),
               statementSubstitution = StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context),
               substitution = statementSubstitution;  ///

package/src/mixins/term/verify.js

@@ -1,11 +1,11 @@
 "use strict";
 
-import ontology from "../../ontology";
+import elements from "../../elements";
 
 function unifyWithBracketedConstructor(term, context, verifyAhead) {
   let unifiesWithBracketedConstructor;
 
-  const { BracketedConstructor } = ontology,
+  const { BracketedConstructor } = elements,
         bracketedConstructor = BracketedConstructor.fromNothing();
 
   unifiesWithBracketedConstructor = bracketedConstructor.unifyTerm(term, context, verifyAhead);
@@ -32,7 +32,7 @@ function unifyWithConstructors(term, context, verifyAhead) {
 function verifyTermAsVariable(term, context, verifyAhead) {
   let termVerifiesAsVariable = false;
 
-  const { Variable } = ontology,
+  const { Variable } = elements,
         termNode = term.getNode(),
         singularVariableNode = termNode.getSingularVariableNode();
 

package/src/node/substitution/frame.js

@@ -5,6 +5,20 @@ import SubstitutionNode from "../../node/substitution";
 import { FRAME_RULE_NAME } from "../../ruleNames";
 
 export default class FrameSubstitutionNode extends SubstitutionNode {
+  getMetavariableNode() {
+    const lastMetavariableNode = this.getLastMetavariableNode(),
+          metavariableNode = lastMetavariableNode;  ///
+
+    return metavariableNode;
+  }
+
+  getFrameNode() {
+    const firstFrameNode = this.getFirstFrameNode(),
+          frameNode = firstFrameNode; ///
+
+    return frameNode;
+  }
+
   getLastFrameNode() {
     const ruleName = FRAME_RULE_NAME,
           lastFrameNode = this.getLastNodeByRuleName(ruleName);

package/src/node/substitution/statement.js

@@ -5,6 +5,20 @@ import SubstitutionNode from "../../node/substitution";
 import { STATEMENT_RULE_NAME } from "../../ruleNames";
 
 export default class StatementSubstitutionNode extends SubstitutionNode {
+  getMetavariableNode() {
+    const lastMetavariableNode = this.getLastVariableNode(),
+          metavariableNode = lastMetavariableNode;  ///
+
+    return metavariableNode;
+  }
+
+  getStatementNode() {
+    const firstStatementNode = this.getFirstStatementNode(),
+          statementNode = firstStatementNode; ///
+
+    return statementNode;
+  }
+
   getLastStatementNode() {
     const ruleName = STATEMENT_RULE_NAME,
           lastStatementNode = this.getLastNodeByRuleName(ruleName);
@@ -19,5 +33,31 @@ export default class StatementSubstitutionNode extends SubstitutionNode {
     return firstStatementNode;
   }
 
+  getLastMetavariableNode() {
+    let lastMetavariableNode = null;
+
+    const lastStatementNode = this.getLastStatementNode(),
+          singularMetavariableNode = lastStatementNode.getSingularMetavariableNode();
+
+    if (singularMetavariableNode !== null) {
+      lastMetavariableNode = singularMetavariableNode;  ///
+    }
+
+    return lastMetavariableNode;
+  }
+
+  getFirstMetavariableNode() {
+    let firstMetavariableNode = null;
+
+    const firstStatementNode = this.getFirstStatementNode(),
+          singularMetavariableNode = firstStatementNode.getSingularMetavariableNode();
+
+    if (singularMetavariableNode !== null) {
+      firstMetavariableNode = singularMetavariableNode;  ///
+    }
+
+    return firstMetavariableNode;
+  }
+
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return SubstitutionNode.fromRuleNameChildNodesOpacityAndPrecedence(StatementSubstitutionNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/substitution/term.js

@@ -5,6 +5,20 @@ import SubstitutionNode from "../../node/substitution";
 import { TERM_RULE_NAME } from "../../ruleNames";
 
 export default class TermSubstitutionNode extends SubstitutionNode {
+  getVariableNode() {
+    const lastVariableNode = this.getLastVariableNode(),
+          variableNode = lastVariableNode;  ///
+
+    return variableNode;
+  }
+
+  getTermNode() {
+    const firstTermNode = this.getFirstTermNode(),
+          termNode = firstTermNode; ///
+
+    return termNode;
+  }
+
   getLastTermNode() {
     const ruleName = TERM_RULE_NAME,
           lastTermNode = this.getLastNodeByRuleName(ruleName);
@@ -37,3 +51,4 @@ export default class TermSubstitutionNode extends SubstitutionNode {
 
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return SubstitutionNode.fromRuleNameChildNodesOpacityAndPrecedence(TermSubstitutionNode, ruleName, childNodes, opacity, precedence); }
 }
+