occam-verify-cli 1.0.438 → 1.0.444

package/src/node/property.js

@@ -5,13 +5,6 @@ import NonTerminalNode from "../nonTerminalNode";
 import { SINGLE_SPACE } from "../constants";
 
 export default class PropertyNode extends NonTerminalNode {
-  getPropertyName() {
-    const names = this.getNames(),
-          propertyName = names.join(SINGLE_SPACE);
-
-    return propertyName;
-  }
-
   getNames() {
     const names = this.mapChildNode((childNode) => {
       const terminalNode = childNode, ///
@@ -24,5 +17,12 @@ export default class PropertyNode extends NonTerminalNode {
     return names;
   }
 
+  getPropertyName() {
+    const names = this.getNames(),
+          propertyName = names.join(SINGLE_SPACE);
+
+    return propertyName;
+  }
+
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(PropertyNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/propertyRelation.js

@@ -5,6 +5,13 @@ import NonTerminalNode from "../nonTerminalNode";
 import { TERM_RULE_NAME, PROPERTY_RULE_NAME } from "../ruleNames";
 
 export default class PropertyRelationNode extends NonTerminalNode {
+  getPropertyName() {
+    const propertyNode = this.getPropertyNode(),
+          propertyName = propertyNode.getPropertyName();
+
+    return propertyName;
+  }
+
   getTermNode() {
     const ruleName = TERM_RULE_NAME,
           termNode = this.getNodeByRuleName(ruleName);
@@ -19,12 +26,5 @@ export default class PropertyRelationNode extends NonTerminalNode {
     return propertyNode;
   }
 
-  getPropertyName() {
-    const propertyNode = this.getPropertyNode(),
-          propertyName = propertyNode.getPropertyName();
-
-    return propertyName;
-  }
-
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(PropertyRelationNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/rule.js

@@ -5,18 +5,11 @@ import NonTerminalNode from "../nonTerminalNode";
 import { RULE_BODY_RULE_NAME, RULE_HEADER_RULE_NAME } from "../ruleNames";
 
 export default class RuleNode extends NonTerminalNode {
-  getRuleBodyNode() {
-    const ruleName = RULE_BODY_RULE_NAME,
-          ruleBodyNode = this.getNodeByRuleName(ruleName);
-
-    return ruleBodyNode;
-  }
-
-  getRuleHeaderNode() {
-    const ruleName = RULE_HEADER_RULE_NAME,
-          ruleHeaderNode = this.getNodeByRuleName(ruleName);
+  getProofNode() {
+    const ruleBodyNode = this.getRuleBodyNode(),
+          proofNode = ruleBodyNode.getProofNode();
 
-    return ruleHeaderNode;
+    return proofNode;
   }
 
   getLabelNodes() {
@@ -40,11 +33,18 @@ export default class RuleNode extends NonTerminalNode {
     return conclusionNode;
   }
 
-  getProofNode() {
-    const ruleBodyNode = this.getRuleBodyNode(),
-          proofNode = ruleBodyNode.getProofNode();
+  getRuleBodyNode() {
+    const ruleName = RULE_BODY_RULE_NAME,
+          ruleBodyNode = this.getNodeByRuleName(ruleName);
 
-    return proofNode;
+    return ruleBodyNode;
+  }
+
+  getRuleHeaderNode() {
+    const ruleName = RULE_HEADER_RULE_NAME,
+          ruleHeaderNode = this.getNodeByRuleName(ruleName);
+
+    return ruleHeaderNode;
   }
 
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(RuleNode, ruleName, childNodes, opacity, precedence); }

package/src/node/statement.js

@@ -19,6 +19,18 @@ import { TERM_RULE_NAME,
          STATEMENT_SUBSTITUTION_RULE_NAME } from "../ruleNames";
 
 export default class StatementNode extends NonTerminalNode {
+  isSingular() {
+    let singular = false;
+
+    const singularMetavariableNode = this.getSingularMetavariableNode();
+
+    if (singularMetavariableNode !== null) {
+      singular = true;
+    }
+
+    return singular;
+  }
+
   getMetavariableName() {
     let metavariableName = null;
 
@@ -46,18 +58,6 @@ export default class StatementNode extends NonTerminalNode {
     return substitutionNode;
   }
 
-  isSingular() {
-    let singular = false;
-
-    const singularMetavariableNode = this.getSingularMetavariableNode();
-
-    if (singularMetavariableNode !== null) {
-      singular = true;
-    }
-
-    return singular;
-  }
-
   getTermNodes() {
     const ruleName = TERM_RULE_NAME,
           termNodes = this.getDescendantNodesByRuleName(ruleName);

package/src/node/step.js

@@ -17,27 +17,6 @@ export default class StepNode extends NonTerminalNode {
     return subproofNode;
   }
 
-  getNonsenseNode() {
-    const ruleName = NONSENSE_RULE_NAME,
-          nonsenseNode = this.getNodeByRuleName(ruleName);
-
-    return nonsenseNode;
-  }
-
-  getStatementNode() {
-    const ruleName = STATEMENT_RULE_NAME,
-          statementNode = this.getNodeByRuleName(ruleName);
-
-    return statementNode;
-  }
-
-  getQualificationNode() {
-    const ruleName = QUALIFICATION_RULE_NAME,
-          qualificationNode = this.getNodeByRuleName(ruleName);
-
-    return qualificationNode;
-  }
-
   getReferenceNode() {
     let referenceNode = null;
 
@@ -62,5 +41,26 @@ export default class StepNode extends NonTerminalNode {
     return satisfiedAssertionNode;
   }
 
+  getNonsenseNode() {
+    const ruleName = NONSENSE_RULE_NAME,
+          nonsenseNode = this.getNodeByRuleName(ruleName);
+
+    return nonsenseNode;
+  }
+
+  getStatementNode() {
+    const ruleName = STATEMENT_RULE_NAME,
+          statementNode = this.getNodeByRuleName(ruleName);
+
+    return statementNode;
+  }
+
+  getQualificationNode() {
+    const ruleName = QUALIFICATION_RULE_NAME,
+          qualificationNode = this.getNodeByRuleName(ruleName);
+
+    return qualificationNode;
+  }
+
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(StepNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/subproof.js

@@ -24,13 +24,6 @@ export default class SubproofNode extends NonTerminalNode {
     return lastStepNode;
   }
 
-  getSubDerivationNode() {
-    const ruleName = SUB_DERIVATION_RULE_NAME,
-          subDerivationNode = this.getNodeByRuleName(ruleName);
-
-    return subDerivationNode;
-  }
-
   getSuppositionNodes() {
     const ruleName = SUPPOSITION_RULE_NAME,
           suppositionNodes = this.getNodesByRuleName(ruleName);
@@ -38,5 +31,12 @@ export default class SubproofNode extends NonTerminalNode {
     return suppositionNodes;
   }
 
+  getSubDerivationNode() {
+    const ruleName = SUB_DERIVATION_RULE_NAME,
+          subDerivationNode = this.getNodeByRuleName(ruleName);
+
+    return subDerivationNode;
+  }
+
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(SubproofNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/substitution/frame.js

@@ -5,13 +5,6 @@ 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; ///
@@ -19,18 +12,11 @@ export default class FrameSubstitutionNode extends SubstitutionNode {
     return frameNode;
   }
 
-  getLastFrameNode() {
-    const ruleName = FRAME_RULE_NAME,
-          lastFrameNode = this.getLastNodeByRuleName(ruleName);
-
-    return lastFrameNode;
-  }
-
-  getFirstFrameNode() {
-    const ruleName = FRAME_RULE_NAME,
-          firstFrameNode = this.getFirstNodeByRuleName(ruleName);
+  getMetavariableNode() {
+    const lastMetavariableNode = this.getLastMetavariableNode(),
+          metavariableNode = lastMetavariableNode;  ///
 
-    return firstFrameNode;
+    return metavariableNode;
   }
 
   getLastMetavariableNode() {
@@ -59,5 +45,19 @@ export default class FrameSubstitutionNode extends SubstitutionNode {
     return firstMetavariableNode;
   }
 
+  getLastFrameNode() {
+    const ruleName = FRAME_RULE_NAME,
+          lastFrameNode = this.getLastNodeByRuleName(ruleName);
+
+    return lastFrameNode;
+  }
+
+  getFirstFrameNode() {
+    const ruleName = FRAME_RULE_NAME,
+          firstFrameNode = this.getFirstNodeByRuleName(ruleName);
+
+    return firstFrameNode;
+  }
+
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return SubstitutionNode.fromRuleNameChildNodesOpacityAndPrecedence(FrameSubstitutionNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/substitution/statement.js

@@ -5,13 +5,6 @@ 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; ///
@@ -19,18 +12,11 @@ export default class StatementSubstitutionNode extends SubstitutionNode {
     return statementNode;
   }
 
-  getLastStatementNode() {
-    const ruleName = STATEMENT_RULE_NAME,
-          lastStatementNode = this.getLastNodeByRuleName(ruleName);
-
-    return lastStatementNode;
-  }
-
-  getFirstStatementNode() {
-    const ruleName = STATEMENT_RULE_NAME,
-          firstStatementNode = this.getFirstNodeByRuleName(ruleName);
+  getMetavariableNode() {
+    const lastMetavariableNode = this.getLastVariableNode(),
+          metavariableNode = lastMetavariableNode;  ///
 
-    return firstStatementNode;
+    return metavariableNode;
   }
 
   getLastMetavariableNode() {
@@ -59,5 +45,19 @@ export default class StatementSubstitutionNode extends SubstitutionNode {
     return firstMetavariableNode;
   }
 
+  getLastStatementNode() {
+    const ruleName = STATEMENT_RULE_NAME,
+          lastStatementNode = this.getLastNodeByRuleName(ruleName);
+
+    return lastStatementNode;
+  }
+
+  getFirstStatementNode() {
+    const ruleName = STATEMENT_RULE_NAME,
+          firstStatementNode = this.getFirstNodeByRuleName(ruleName);
+
+    return firstStatementNode;
+  }
+
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return SubstitutionNode.fromRuleNameChildNodesOpacityAndPrecedence(StatementSubstitutionNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/substitution/term.js

@@ -5,13 +5,6 @@ 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; ///
@@ -19,18 +12,11 @@ export default class TermSubstitutionNode extends SubstitutionNode {
     return termNode;
   }
 
-  getLastTermNode() {
-    const ruleName = TERM_RULE_NAME,
-          lastTermNode = this.getLastNodeByRuleName(ruleName);
-
-    return lastTermNode;
-  }
-
-  getFirstTermNode() {
-    const ruleName = TERM_RULE_NAME,
-          firstTermNode = this.getFirstNodeByRuleName(ruleName);
+  getVariableNode() {
+    const lastVariableNode = this.getLastVariableNode(),
+          variableNode = lastVariableNode;  ///
 
-    return firstTermNode;
+    return variableNode;
   }
 
   getLastVariableNode() {
@@ -49,6 +35,20 @@ export default class TermSubstitutionNode extends SubstitutionNode {
     return firstVariableNode;
   }
 
+  getLastTermNode() {
+    const ruleName = TERM_RULE_NAME,
+          lastTermNode = this.getLastNodeByRuleName(ruleName);
+
+    return lastTermNode;
+  }
+
+  getFirstTermNode() {
+    const ruleName = TERM_RULE_NAME,
+          firstTermNode = this.getFirstNodeByRuleName(ruleName);
+
+    return firstTermNode;
+  }
+
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return SubstitutionNode.fromRuleNameChildNodesOpacityAndPrecedence(TermSubstitutionNode, ruleName, childNodes, opacity, precedence); }
 }
 

package/src/node/term.js

@@ -5,27 +5,6 @@ import NonTerminalNode from "../nonTerminalNode";
 import { ARGUMENT_RULE_NAME, VARIABLE_RULE_NAME } from "../ruleNames";
 
 export default class TermNode extends NonTerminalNode {
-  getVariableIdentifier() {
-    let variableIdentifier = null;
-
-    const singular = this.isSingular();
-
-    if (singular) {
-      const singularVariableNode = this.getSingularVariableNode();
-
-      variableIdentifier = singularVariableNode.getVariableIdentifier();
-    }
-
-    return variableIdentifier;
-  }
-
-  getVariableNode() {
-    const singularVariableNode = this.getSingularVariableNode(),
-          variableNode = singularVariableNode;  //
-
-    return variableNode;
-  }
-
   isSingular() {
     let singular = false;
 
@@ -38,11 +17,11 @@ export default class TermNode extends NonTerminalNode {
     return singular;
   }
 
-  getVariableNodes() {
-    const ruleName = VARIABLE_RULE_NAME,
-          variableNodes = this.getNodesByRuleName(ruleName);
+  getVariableNode() {
+    const singularVariableNode = this.getSingularVariableNode(),
+          variableNode = singularVariableNode;  //
 
-    return variableNodes;
+    return variableNode;
   }
 
   getSingularTermNode() {
@@ -57,18 +36,18 @@ export default class TermNode extends NonTerminalNode {
     return singularTermNode;
   }
 
-  getSingularArgumentNode() {
-    const ruleName = ARGUMENT_RULE_NAME,
-          singularArgumentNode = this.getSingularNodeByRuleName(ruleName);
+  getVariableIdentifier() {
+    let variableIdentifier = null;
 
-    return singularArgumentNode;
-  }
+    const singular = this.isSingular();
 
-  getSingularVariableNode() {
-    const ruleName = VARIABLE_RULE_NAME,
-          singularVariableNode = this.getSingularNodeByRuleName(ruleName);
+    if (singular) {
+      const singularVariableNode = this.getSingularVariableNode();
 
-    return singularVariableNode;
+      variableIdentifier = singularVariableNode.getVariableIdentifier();
+    }
+
+    return variableIdentifier;
   }
 
   getSingularVariableIdentifier() {
@@ -85,5 +64,26 @@ export default class TermNode extends NonTerminalNode {
     return singularVariableIdentifier;
   }
 
+  getVariableNodes() {
+    const ruleName = VARIABLE_RULE_NAME,
+          variableNodes = this.getNodesByRuleName(ruleName);
+
+    return variableNodes;
+  }
+
+  getSingularArgumentNode() {
+    const ruleName = ARGUMENT_RULE_NAME,
+          singularArgumentNode = this.getSingularNodeByRuleName(ruleName);
+
+    return singularArgumentNode;
+  }
+
+  getSingularVariableNode() {
+    const ruleName = VARIABLE_RULE_NAME,
+          singularVariableNode = this.getSingularNodeByRuleName(ruleName);
+
+    return singularVariableNode;
+  }
+
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(TermNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/preamble.js

@@ -31,6 +31,8 @@ import Conclusion from "./element/conclusion";
 import Derivation from "./element/derivation";
 import Hypothesis from "./element/hypothesis";
 import Assumption from "./element/assumption";
+import Combinator from "./element/combinator";
+import Constructor from "./element/constructor";
 import Supposition from "./element/supposition";
 import Metatheorem from "./element/metatheorem";
 import Equivalence from "./element/equivalence";
@@ -40,7 +42,6 @@ import Substitutions from "./element/substitutions";
 import ProcedureCall from "./element/procedureCall";
 import SubDerivation from "./element/subDerivation";
 import TypeAssertion from "./element/assertion/type";
-import ConstructorTerm from "./element/term/constructor";
 import PropertyRelation from "./element/propertyRelation";
 import DefinedAssertion from "./element/assertion/defined";
 import TermSubstitution from "./element/substitution/term";
@@ -51,7 +52,8 @@ import ProcedureReference from "./element/procedureReference";
 import ContainedAssertion from "./element/assertion/contained";
 import SatisfiesAssertion from "./element/assertion/satisfies";
 import VariableDeclaration from "./element/declaration/variable";
-import CombinatorStatement from "./element/statement/combinator";
+import BracketedCombinator from "./element/combinator/bracketed";
+import BracketedConstructor from "./element/constructor/bracketed";
 import SimpleTypeDeclaration from "./element/declaration/simpleType";
 import StatementSubstitution from "./element/substitution/statement";
 import ReferenceSubstitution from "./element/substitution/reference";
@@ -60,5 +62,3 @@ import TypePrefixDeclaration from "./element/declaration/typePrefix";
 import ConstructorDeclaration from "./element/declaration/constructor";
 import ComplexTypeDeclaration from "./element/declaration/complexType";
 import MetavariableDeclaration from "./element/declaration/metavariable";
-import BracketedConstructorTerm from "./element/term/constructor/bracketed";
-import BracketedCombinatorStatement from "./element/statement/combinator/bracketed";

package/src/process/instantiate.js

@@ -3,9 +3,12 @@
 import { ruleFromBNF } from "../utilities/bnf";
 
 const termPlaceholderBNF = ` _ ::= term... <END_OF_LINE> ; `,
+      stepPlaceholderBNF = ` _ ::= step... <END_OF_LINE> ; `,
       variablePlaceholderBNF = ` _ ::= variable... <END_OF_LINE> ; `,
       referencePlaceholderBNF = ` _ ::= reference... <END_OF_LINE> ; `,
       statementPlaceholderBNF = ` _ ::= statement... <END_OF_LINE> ; `,
+      combinatorPlaceholderBNF = ` _ ::= combinator... <END_OF_LINE> ; `,
+      constructorPlaceholderBNF = ` _ ::= constructor... <END_OF_LINE> ; `,
       equivalencePlaceholderBNF = ` _ ::= equivalence... <END_OF_LINE> ; `,
       metavariablePlaceholderBNF = ` _ ::= metavariable... <END_OF_LINE> ; `,
       termSubstitutionPlaceholderBNF = ` _ ::= termSubstitution... <END_OF_LINE> ; `,
@@ -13,9 +16,12 @@ const termPlaceholderBNF = ` _ ::= term... <END_OF_LINE> ; `,
       statementSubstitutionPlaceholderBNF = ` _ ::= statementSubstitution... <END_OF_LINE> ; `,
       referenceSubstitutionPlaceholderBNF = ` _ ::= referenceSubstitution... <END_OF_LINE> ; `,
       termPlaceholderRule = ruleFromBNF(termPlaceholderBNF),
+      stepPlaceholderRule = ruleFromBNF(stepPlaceholderBNF),
       variablePlaceholderRule = ruleFromBNF(variablePlaceholderBNF),
       referencePlaceholderRule = ruleFromBNF(referencePlaceholderBNF),
       statementPlaceholderRule = ruleFromBNF(statementPlaceholderBNF),
+      combinatorPlaceholderRule = ruleFromBNF(combinatorPlaceholderBNF),
+      constructorPlaceholderRule = ruleFromBNF(constructorPlaceholderBNF),
       equivalencePlaceholderRule = ruleFromBNF(equivalencePlaceholderBNF),
       metavariablePlaceholderRule = ruleFromBNF(metavariablePlaceholderBNF),
       termSubstitutionPlaceholderRule = ruleFromBNF(termSubstitutionPlaceholderBNF),
@@ -25,12 +31,18 @@ const termPlaceholderBNF = ` _ ::= term... <END_OF_LINE> ; `,
 
 export function instantiateTerm(string, context) { return instantiate(termPlaceholderRule, string, context); }
 
+export function instantiateStep(string, context) { return instantiate(stepPlaceholderRule, string, context); }
+
 export function instantiateVariable(string, context) { return instantiate(variablePlaceholderRule, string, context); }
 
 export function instantiateReference(string, context) { return instantiate(referencePlaceholderRule, string, context); }
 
 export function instantiateStatement(string, context) { return instantiate(statementPlaceholderRule, string, context); }
 
+export function instantiateCombinator(string, context) { return instantiate(combinatorPlaceholderRule, string, context); }
+
+export function instantiateConstructor(string, context) { return instantiate(constructorPlaceholderRule, string, context); }
+
 export function instantiateEquivalence(string, context) { return instantiate(equivalencePlaceholderRule, string, context); }
 
 export function instantiateMetavariable(string, context) { return instantiate(metavariablePlaceholderRule, string, context); }