occam-verify-cli 1.0.427 → 1.0.436

package/src/element/term.js

@@ -2,29 +2,20 @@
 
 import { arrayUtilities } from "necessary";
 
-import elements from "../elements";
+import Element from "../element";
 import verifyMixins from "../mixins/term/verify";
 
 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;
 
-export default define(class Term {
-  constructor(string, node, type) {
-    this.string = string;
-    this.node = node;
-    this.type = type;
-  }
-
-  getString() {
-    return this.string;
-  }
+export default define(class Term extends Element {
+  constructor(context, string, node, type) {
+    super(context, string, node);
 
-  getNode() {
-    return this.node;
+    this.type = type;
   }
 
   getType() {
@@ -180,51 +171,7 @@ export default define(class Term {
           termNode = instantiateTerm(string, context),
           node = termNode,  ///
           type = typeFromJSON(json, context),
-          term = new Term(string, node, type);
-
-    return term;
-  }
-
-  static fromTermNode(termNode, context) {
-    const term = termFromTermNode(termNode, context);
-
-    return term;
-  }
-
-  static fromTermNodeAndType(termNode, type, context) {
-    const node = termNode,  ///
-          string = context.nodeAsString(node),
-          term = new Term(string, node, type);
-
-    return term;
-  }
-
-  static fromDefinedAssertionNode(definedAssertionNode, context) {
-    let term = null;
-
-    const termNode = definedAssertionNode.getTermNode();
-
-    if (termNode !== null) {
-      term = termFromTermNode(termNode, context);
-    }
-
-    return term;
-  }
-
-  static fromPropertyRelationNode(propertyRelationNode, context) {
-    const termNode = propertyRelationNode.getTermNode(),
-          term = termFromTermNode(termNode, context);
-
-    return term;
-  }
-
-  static fromConstructorDeclarationNode(constructorDeclarationNode, context) {
-    const { Type } = elements,
-          termNode = constructorDeclarationNode.getTermNode(),
-          term = termFromTermNode(termNode, context),
-          type = Type.fromConstructorDeclarationNode(constructorDeclarationNode, context);
-
-    term.setType(type);
+          term = new Term(context, string, node, type);
 
     return term;
   }

package/src/element/theorem.js

@@ -30,11 +30,4 @@ export default define(class Theorem extends AxiomLemmaTheoremConjecture {
   static name = "Theorem";
 
   static fromJSON(json, context) { return AxiomLemmaTheoremConjecture.fromJSON(Theorem, json, context); }
-
-  static fromTheoremNode(theoremNode, context) {
-    const node = theoremNode, ///
-          theorem = AxiomLemmaTheoremConjecture.fromNode(Theorem, node, context);
-
-    return theorem;
-  }
 });

package/src/element/type.js

@@ -2,18 +2,18 @@
 
 import { arrayUtilities } from "necessary";
 
+import Element from "../element";
+
 import { define } from "../elements";
 import { BASE_TYPE_SYMBOL } from "../constants";
-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, node, name, prefixName, superTypes, properties, provisional) {
-    this.string = string;
-    this.node = node;
+class Type extends Element {
+  constructor(context, string, node, name, prefixName, superTypes, properties, provisional) {
+    super(context, string, node);
     this.name = name;
     this.prefixName = prefixName;
     this.superTypes = superTypes;
@@ -21,14 +21,6 @@ class Type {
     this.provisional = provisional;
   }
 
-  getString() {
-    return this.string;
-  }
-
-  getNode() {
-    return this.node;
-  }
-
   getName() {
     return this.name;
   }
@@ -310,78 +302,8 @@ class Type {
           typeName = name,  ///
           typePrefixName = null,
           string = typeStringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),
-          type = new Type(string, node, name, prefixName, superTypes, properties, provisional);
-
-    return type;
-  }
-
-  static fromTypeNode(typeNode, context) {
-    const type = typeFromTypeNode(typeNode, context);
-
-    return type;
-  }
-
-  static fromSuperTypeNode(superTypeNode, context) {
-    context = null; ///
-
-    const typeNode = superTypeNode, ///
-          type = typeFromTypeNode(typeNode, context);
-
-    return type;
-  }
-
-  static fromTypeAndProvisional(type, provisional) {
-    const name = type.getName(),
-          prefixName = type.getPrefixName(),
-          superType = type, ///
-          typeName = name,  ///
-          typePrefixName = prefixName,  ///
-          superTypes = [
-            superType
-          ],
-          string = typeStringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),
-          properties = type.getProperties();
-
-    type = new Type(string, node, name, prefixName, superTypes, properties, provisional);  ///
-
-    return type;
-  }
-
-  static fromPropertyDeclarationNode(propertyDeclarationNode, context) {
-    const typeNode = propertyDeclarationNode.getTypeNode(),
-          type = typeFromTypeNode(typeNode, context);
-
-    return type;
-  }
-
-  static fromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
-    const typeName = simpleTypeDeclarationNode.getTypeName(),
-          provisional = simpleTypeDeclarationNode.isProvisional(),
-          typePrefixName = simpleTypeDeclarationNode.getTypePrefixName(),
-          superTypes = superTypesFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context),
-          name = typeName,  ///
-          prefixName = typePrefixName,  ///
-          properties = [],
-          string = typeStringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),
-          type = new Type(string, node, name, prefixName, superTypes, properties, provisional);
-
-    return type;
-  }
-
-  static fromConstructorDeclarationNode(constructorDeclarationNode, context) {
-    let type;
-
-    const typeNode = constructorDeclarationNode.getTypeNode();
-
-    if (typeNode === null) {
-      type = baseType;
-    } else {
-      const provisional = constructorDeclarationNode.isProvisional();
-
-      type = typeFromTypeNode(typeNode, context);
-
-      type.setProvisional(provisional);
-    }
+          node = null,
+          type = new Type(context, string, node, name, prefixName, superTypes, properties, provisional);
 
     return type;
   }
@@ -389,34 +311,17 @@ class Type {
 
 export default define(Type);
 
-function superTypesFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
-  const superTypeNodes = simpleTypeDeclarationNode.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;
-}
-
 class BaseType extends Type {
   static fromNothing() {
     const name = BASE_TYPE_SYMBOL,  ///
+          context = null,
           string = name,  ///
           node = null,
           prefixName = null,
           superTypes = [],
           properties = [],
           provisional = false,
-          baseType = new BaseType(string, node, name, prefixName, superTypes, properties, provisional);
+          baseType = new BaseType(context, string, node, name, prefixName, superTypes, properties, provisional);
 
     return baseType;
   }

package/src/element/typePrefix.js

@@ -1,20 +1,14 @@
 "use strict";
 
-import { define } from "../elements";
+import Element from "../element";
 
-export default define(class TypePrefix {
-  constructor(string, node, name) {
-    this.string = string;
-    this.node = node;
-    this.name = name;
-  }
+import { define } from "../elements";
 
-  getString() {
-    return this.string;
-  }
+export default define(class TypePrefix extends Element {
+  constructor(context, string, node, name) {
+    super(context, string, node);
 
-  getNode() {
-    return this.node;
+    this.name = name;
   }
 
   getName() {
@@ -41,7 +35,8 @@ export default define(class TypePrefix {
   static fromJSON(json, context) {
     const { name } = json,
           string = name,  ///
-          typePrefix = new TypePrefix(string, name);
+          node = null,
+          typePrefix = new TypePrefix(context, string, node, name);
 
     return typePrefix;
   }

package/src/element/variable.js

@@ -1,30 +1,21 @@
 "use strict";
 
+import Element from "../element";
 import elements from "../elements";
 
 import { define } from "../elements";
-import { EMPTY_STRING } from "../constants";
-import { typeFromTypeNode } from "../utilities/node.old";
 import { instantiateVariable } from "../process/instantiate";
 import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 
-export default define(class Variable {
-  constructor(string, node, type, identifier, propertyRelations) {
-    this.string = string;
-    this.node = node;
+export default define(class Variable extends Element {
+  constructor(context, string, node, type, identifier, propertyRelations) {
+    super(context, string, node);
+
     this.type = type;
     this.identifier = identifier;
     this.propertyRelations = propertyRelations;
   }
 
-  getString() {
-    return this.string;
-  }
-
-  getNode() {
-    return this.node;
-  }
-
   getIdentifier() {
     return this.identifier;
   }
@@ -43,14 +34,6 @@ export default define(class Variable {
 
   getTypeString() { return this.type.getString(); }
 
-  isEqualTo(variable) {
-    const variableNode = variable.getNode(),
-          matches = this.node.match(variableNode),
-          equalTo = matches;  ///
-
-    return equalTo;
-  }
-
   matchParameter(parameter) {
     const parameterName = parameter.getName(),
           parameterNameMatchesIdentifier = (parameterName === this.identifier),
@@ -197,94 +180,8 @@ export default define(class Variable {
           identifier = variableIdentifier,  ///
           type = typeFromJSON(json, context),
           propertyRelations = [],
-          variable = new Variable(string, node, type, identifier, propertyRelations);
-
-    return variable;
-  }
-
-  static fromTermNode(termNode, context) {
-    let variable = null;
-
-    const singularVariableNode = termNode.getSingularVariableNode();
-
-    if (singularVariableNode !== null) {
-      const variableNode = singularVariableNode,  ///
-            type = null;
-
-      variable = variableFromVariableNodeAndType(variableNode, type);
-    }
-
-    return variable;
-  }
-
-  static fromVariableNode(variableNode, context) {
-    let variable = null;
-
-    if (variableNode !== null) {
-      const type = null;
-
-      variable = variableFromVariableNodeAndType(variableNode, type);
-    }
-
-    return variable;
-  }
-
-  static fromVariableNodeAndType(variableNode, type, context) {
-    const variable = variableFromVariableNodeAndType(variableNode, type);
-
-    return variable;
-  }
-
-  static fromVariableDeclarationNode(variableDeclarationNode, context) {
-    const { Variable } = elements,
-          provisional = variableDeclarationNode.isProvisional(),
-          typeNode = variableDeclarationNode.getTypeNode(),
-          type = typeFromTypeNode(typeNode, context);
-
-    type.setProvisional(provisional);
-
-    const variableNode = variableDeclarationNode.getVariableNode(),
-          variableIdentifier = variableDeclarationNode.getVariableIdentifier(),
-          node = variableNode,  ///
-          identifier = variableIdentifier,  ///
-          string = identifier,  ///
-          propertyRelations = [],
-          variable = new Variable(string, node, type, identifier, propertyRelations);
-
-    return variable;
-  }
-
-  static fromVariableAndPropertyRelation(variable, propertyRelation, context) {
-    let propertyRelations;
-
-    const node = variable.getNode(),
-          type = variable.getType(),
-          identifier = variable.getIdentifier();
-
-    propertyRelations = variable.getPropertyRelations();
-
-    propertyRelations = [
-      ...propertyRelations,
-      propertyRelation
-    ];
-
-    const string = stringFromNameAndPropertyRelations(identifier, propertyRelations);
-
-    variable = new Variable(string, node, type, identifier, propertyRelations);
+          variable = new Variable(context, string, node, type, identifier, propertyRelations);
 
     return variable;
   }
 });
-
-function stringFromNameAndPropertyRelations(identifier, propertyRelations) {
-  const propertyRelationsString = propertyRelations.reduce((propertyRelationsString, propertyRelation) => {
-          const propertyRelationString = propertyRelation.getString();
-
-          propertyRelationsString = `${propertyRelationsString}, ${propertyRelationString}`;
-
-          return propertyRelationsString;
-        }, EMPTY_STRING),
-        string = `${identifier}${propertyRelationsString}`;
-
-  return string;
-}

package/src/element.js

@@ -0,0 +1,29 @@
+"use strict";
+
+export default class 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;
+  }
+
+  isEQualTo(element) {
+    const elementNode = element.getNode(),
+          matches = this.node.match(elementNode),
+          equalTo = matches;  ///
+
+    return equalTo;
+  }
+}

package/src/node/equivalence.js

@@ -0,0 +1,16 @@
+"use strict";
+
+import NonTerminalNode from "../nonTerminalNode";
+
+import { TERM_RULE_NAME } from "../ruleNames";
+
+export default class EquivalenceNode extends NonTerminalNode {
+  getTermNodes() {
+    const ruleName = TERM_RULE_NAME,
+          termNodes = this.getNodesByRuleName(ruleName);
+
+    return termNodes;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(EquivalenceNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/{nonsense.js → equivalences.js}

@@ -2,6 +2,6 @@
 
 import NonTerminalNode from "../nonTerminalNode";
 
-export default class NonsenseNode extends NonTerminalNode {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(NonsenseNode, ruleName, childNodes, opacity, precedence); }
+export default class EquivalencesNode extends NonTerminalNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(EquivalencesNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/frame.js

@@ -27,17 +27,22 @@ export default class FrameNode extends NonTerminalNode {
   getMetavariableName() {
     let metavariableName = null;
 
-    const singular = this.isSingular();
+    const metavariableNode = this.getMetavariableNode();
 
-    if (singular) {
-      const singularMetavariableNode = this.getSingularMetavariableNode();
-
-      metavariableName = singularMetavariableNode.getMetavariableName();
+    if (metavariableName !== null) {
+      metavariableName = metavariableNode.getMetavariableName();
     }
 
     return metavariableName;
   }
 
+  getMetavariableNode() {
+    const singularMetavariableNode = this.getSingularMetavariableNode(),
+          metavariableNode = singularMetavariableNode;  ///
+
+    return metavariableNode;
+  }
+
   getMetavariableNodes() {
     const ruleName = METAVARIABLE_RULE_NAME,
           metavariableNodes = this.getNodesByRuleName(ruleName);

package/src/node/procedureReference.js

@@ -3,8 +3,8 @@
 import NonTerminalNode from "../nonTerminalNode";
 
 export default class ProcedureReferenceNode extends NonTerminalNode {
-  getProcedureName() {
-    let procedureName;
+  getName() {
+    let name;
 
     this.someChildNode((childNode) => {
       const childNodeTerminalNode = childNode.isTerminalNode();
@@ -13,13 +13,13 @@ export default class ProcedureReferenceNode extends NonTerminalNode {
         const terminalNode = childNode, ///
               content = terminalNode.getContent();
 
-        procedureName = content; ///
+        name = content; ///
 
         return true;
       }
     });
 
-    return procedureName;
+    return name;
   }
 
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ProcedureReferenceNode, ruleName, childNodes, opacity, precedence); }

package/src/node/statement.js

@@ -22,17 +22,22 @@ export default class StatementNode extends NonTerminalNode {
   getMetavariableName() {
     let metavariableName = null;
 
-    const singular = this.isSingular();
+    const metavariableNode = this.getMetavariableNode();
 
-    if (singular) {
-      const singularMetavariableNode = this.getSingularMetavariableNode();
-
-      metavariableName = singularMetavariableNode.getMetavariableName();
+    if (metavariableName !== null) {
+      metavariableName = metavariableNode.getMetavariableName();
     }
 
     return metavariableName;
   }
 
+  getMetavariableNode() {
+    const singularMetavariableNode = this.getSingularMetavariableNode(),
+          metavariableNode = singularMetavariableNode;  ///
+
+    return metavariableNode;
+  }
+
   getSubstitutionNode() {
     const frameSubstitutionNode = this.getFrameSubstitutionNode(),
           termSubstitutionNode = this.getTermSubstitutionNode(),

package/src/node/term.js

@@ -19,6 +19,13 @@ export default class TermNode extends NonTerminalNode {
     return variableIdentifier;
   }
 
+  getVariableNode() {
+    const singularVariableNode = this.getSingularVariableNode(),
+          variableNode = singularVariableNode;  //
+
+    return variableNode;
+  }
+
   isSingular() {
     let singular = false;
 

package/src/nonTerminalNodeMap.js

@@ -15,7 +15,6 @@ import LabelsNode from "./node/labels";
 import SectionNode from "./node/section";
 import PremiseNode from "./node/premise";
 import TheoremNode from "./node/theorem";
-import NonsenseNode from "./node/nonsense";
 import ArgumentNode from "./node/argument";
 import SubproofNode from "./node/subproof";
 import PropertyNode from "./node/property";
@@ -44,10 +43,12 @@ import RuleHeaderNode from "./node/header/rule";
 import SuppositionNode from "./node/supposition";
 import PlaceholderNode from "./node/placeholder";
 import ConstructorNode from "./node/constructor";
-import MetatheoremNode from "./node/metatheorem";
 import TheoremBodyNode from "./node/body/theorem";
 import AxiomHeaderNode from "./node/header/axiom";
 import LemmaHeaderNode from "./node/header/lemma";
+import MetatheoremNode from "./node/metatheorem";
+import EquivalenceNode from "./node/equivalence";
+import EquivalencesNode from "./node/equivalences";
 import MetaArgumentNode from "./node/metaArgument";
 import MetavariableNode from "./node/metavariable";
 import QualificationNode from "./node/qualification";
@@ -98,7 +99,6 @@ import {
   THEOREM_RULE_NAME,
   PREMISE_RULE_NAME,
   SECTION_RULE_NAME,
-  NONSENSE_RULE_NAME,
   ARGUMENT_RULE_NAME,
   SUBPROOF_RULE_NAME,
   PROPERTY_RULE_NAME,
@@ -128,6 +128,8 @@ import {
   RULE_HEADER_RULE_NAME,
   CONSTRUCTOR_RULE_NAME,
   METATHEOREM_RULE_NAME,
+  EQUIVALENCE_RULE_NAME,
+  EQUIVALENCES_RULE_NAME,
   AXIOM_HEADER_RULE_NAME,
   LEMMA_HEADER_RULE_NAME,
   THEOREM_BODY_RULE_NAME,
@@ -186,7 +188,6 @@ const NonTerminalNodeMap = {
   [SUBPROOF_RULE_NAME]: SubproofNode,
   [EQUALITY_RULE_NAME]: EqualityNode,
   [VARIABLE_RULE_NAME]: VariableNode,
-  [NONSENSE_RULE_NAME]: NonsenseNode,
   [DOCUMENT_RULE_NAME]: DocumentNode,
   [RULE_BODY_RULE_NAME]: RuleBodyNode,
   [META_TYPE_RULE_NAME]: MetaTypeNode,
@@ -211,10 +212,12 @@ const NonTerminalNodeMap = {
   [SUPPOSITION_RULE_NAME]: SuppositionNode,
   [CONSTRUCTOR_RULE_NAME]: ConstructorNode,
   [METATHEOREM_RULE_NAME]: MetatheoremNode,
+  [EQUIVALENCE_RULE_NAME]: EquivalenceNode,
   [AXIOM_HEADER_RULE_NAME]: AxiomHeaderNode,
   [LEMMA_HEADER_RULE_NAME]: LemmaHeaderNode,
   [THEOREM_BODY_RULE_NAME]: TheoremBodyNode,
   [METAVARIABLE_RULE_NAME]: MetavariableNode,
+  [EQUIVALENCES_RULE_NAME]: EquivalencesNode,
   [META_ARGUMENT_RULE_NAME]: MetaArgumentNode,
   [QUALIFICATION_RULE_NAME]: QualificationNode,
   [TYPE_ASSERTION_RULE_NAME]: TypeAssertionNode,