occam-verify-cli 1.0.192 → 1.0.199

package/src/substitution/term.js

@@ -4,14 +4,9 @@ import dom from "../dom";
 import Substitution from "../substitution";
 import TermSubstitutionPartialContext from "../context/partial/substitution/term";
 
-import { nodeQuery } from "../utilities/query";
 import { stripBracketsFromTerm } from "../utilities/brackets";
 import { stripBracketsFromTermNode } from "../utilities/brackets";
 
-const termNodeQuery = nodeQuery("/termSubstitution/term[0]"),
-      variableNodeQuery = nodeQuery("/termSubstitution/term[1]/variable!"),
-      termSubstitutionNodeQuery = nodeQuery("/statement/termSubstitution");
-
 export default class TermSubstitution extends Substitution {
   constructor(string, node, tokens, term, variable) {
     super(string, node, tokens);
@@ -68,14 +63,17 @@ export default class TermSubstitution extends Substitution {
   static fromStatementNode(statementNode, context) {
     let termSubstitution = null;
 
-    const termSubstitutionNode = termSubstitutionNodeQuery(statementNode);
+    const termSubstitutionNode = statementNode.getTermSubstitutionNode();
 
     if (termSubstitutionNode !== null) {
-      const termNode = termNodeQuery(termSubstitutionNode),
-            variableNode = variableNodeQuery(termSubstitutionNode);
+      const lastTermNode = termSubstitutionNode.getLastTermNode(),
+            firstTermNode = termSubstitutionNode.getFirstTermNode(),
+            singularVariableNode = lastTermNode.getSingularVariableNode(lastTermNode);
 
-      if ((termNode !== null) && (variableNode !== null)) {
+      if (singularVariableNode !== null) {
         const { Term, Variable } = dom,
+              termNode = firstTermNode, ///
+              variableNode = singularVariableNode,  ///
               term = Term.fromTermNode(termNode, context),
               variable = Variable.fromVariableNode(variableNode, context),
               node = termSubstitutionNode,  ///

package/src/unifier/metaLevel.js

@@ -12,7 +12,6 @@ const termNodeQuery = nodeQuery("/term"),
       statementNodeQuery = nodeQuery("/statement"),
       termVariableNodeQuery = nodeQuery("/term/variable!"),
       frameMetavariableNodeQuery = nodeQuery("/frame/metavariable!"),
-      statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!"),
       declarationMetavariableNodeQuery = nodeQuery("/declaration/metavariable!");
 
 class MetaLevelUnifier extends Unifier {
@@ -34,9 +33,9 @@ class MetaLevelUnifier extends Unifier {
         let statementUnified;
 
         const statementNode = generalStatementNode, ///
-              statementMetavariableNode = statementMetavariableNodeQuery(statementNode);
+              singularMetavariableNode = statementNode.getSingularMetavariableNode();
 
-        if (statementMetavariableNode !== null) {
+        if (singularMetavariableNode !== null) {
           const { Metavariable, Statement } = dom; ///
 
           let context,

package/src/utilities/brackets.js

@@ -5,12 +5,8 @@ import LocalContext from "../context/local";
 import combinatorBracketedContext from "../context/bracketed/combinator";
 import constructorBracketedContext from "../context/bracketed/constructor";
 
-import { nodeQuery } from "../utilities/query";
 import { BRACKETED_TERM_DEPTH, BRACKETED_STATEMENT_DEPTH } from "../constants";
 
-const bracketedTermChildNodeQuery = nodeQuery("/term/argument/term"),
-      bracketedStatementChildNodeQuery = nodeQuery("/statement/metaArgument/statement");
-
 export function stripBracketsFromTerm(term, context) {
   const termNode = term.getNode(),
         bracketedTermChildNode = bracketedTermChildNodeFromTermNode(termNode);
@@ -69,7 +65,9 @@ export function bracketedTermChildNodeFromTermNode(termNode) {
         termNodeMatchBracketedTermNode = termNode.match(bracketedTermNode, depth);
 
   if (termNodeMatchBracketedTermNode) {
-    bracketedTermChildNode = bracketedTermChildNodeQuery(termNode);
+    const singularTermNode = termNode.getSingularTermNode();
+
+    bracketedTermChildNode = singularTermNode;  ///
   }
 
   return bracketedTermChildNode;
@@ -83,7 +81,9 @@ export function bracketedStatementChildNodeFromStatementNode(statementNode) {
         statementNodeMatchBracketedStatementNode = statementNode.match(bracketedStatementNode, depth);
 
   if (statementNodeMatchBracketedStatementNode) {
-    bracketedStatementChildNode = bracketedStatementChildNodeQuery(statementNode);
+    const singularStatementNode = statementNode.getSingularStatementNode();
+
+    bracketedStatementChildNode = singularStatementNode;  ///
   }
 
   return bracketedStatementChildNode;
@@ -91,8 +91,8 @@ export function bracketedStatementChildNodeFromStatementNode(statementNode) {
 
 function contextFromStatement(statement, context) {
   const statementTokens = statement.getTokens(),
-    tokens = statementTokens, ///
-    localContext = LocalContext.fromContextAndTokens(context, tokens);
+        tokens = statementTokens, ///
+        localContext = LocalContext.fromContextAndTokens(context, tokens);
 
   context = localContext; ///
 

package/src/utilities/json.js

@@ -160,6 +160,19 @@ export function rulesFromJSON(json, fileContext) {
   return rules;
 }
 
+export function labelFromJSON(json, fileContext) {
+  let { label } = json;
+
+  const { Label } = dom,
+        labelJSON = label;  ///
+
+  json = labelJSON; ///
+
+  label = Label.fromJSON(json, fileContext);
+
+  return label;
+}
+
 export function labelsFromJSON(json, fileContext) {
   let { labels } = json;
 
@@ -425,6 +438,12 @@ export function typeToTypeJSON(type) {
   return typeJSON;
 }
 
+export function labelToLabelJSON(label) {
+  const labelJSON = label.toJSON();
+
+  return labelJSON;
+}
+
 export function metaTypeToMetaTypeJSON(metaType) {
   const metaTypeJSON = (metaType !== null) ?
                          metaType.toJSON() :

package/src/utilities/node.js

@@ -3,156 +3,6 @@
 import dom from "../dom";
 
 import { objectType } from "../dom/type";
-import { RULE_RULE_NAME,
-         STEP_RULE_NAME,
-         TERM_RULE_NAME,
-         TYPE_RULE_NAME,
-         LEMMA_RULE_NAME,
-         AXIOM_RULE_NAME,
-         ERROR_RULE_NAME,
-         FRAME_RULE_NAME,
-         PROOF_RULE_NAME,
-         LABEL_RULE_NAME,
-         LABELS_RULE_NAME,
-         THEOREM_RULE_NAME,
-         PREMISE_RULE_NAME,
-         PROPERTY_RULE_NAME,
-         EQUALITY_RULE_NAME,
-         VARIABLE_RULE_NAME,
-         SUBPROOF_RULE_NAME,
-         META_TYPE_RULE_NAME,
-         PARAMETER_RULE_NAME,
-         DEDUCTION_RULE_NAME,
-         JUDGEMENT_RULE_NAME,
-         REFERENCE_RULE_NAME,
-         STATEMENT_RULE_NAME,
-         META_LEMMA_RULE_NAME,
-         COMBINATOR_RULE_NAME,
-         CONCLUSION_RULE_NAME,
-         CONJECTURE_RULE_NAME,
-         DERIVATION_RULE_NAME,
-         SUPPOSITION_RULE_NAME,
-         CONSTRUCTOR_RULE_NAME,
-         DECLARATION_RULE_NAME,
-         METATHEOREM_RULE_NAME,
-         METAVARIABLE_RULE_NAME,
-         PROCEDURE_CALL_RULE_NAME,
-         SUB_DERIVATION_RULE_NAME,
-         TYPE_ASSERTION_RULE_NAME,
-         TYPE_DECLARATION_RULE_NAME,
-         PROPERTY_RELATION_RULE_NAME,
-         DEFINED_ASSERTION_RULE_NAME,
-         PROPERTY_ASSERTION_RULE_NAME,
-         SUBPROOF_ASSERTION_RULE_NAME,
-         CONTAINED_ASSERTION_RULE_NAME,
-         SATISFIES_ASSERTION_RULE_NAME,
-         PROPERTY_DECLARATION_RULE_NAME,
-         VARIABLE_DECLARATION_RULE_NAME,
-         PARENTHESISED_LABELS_RULE_NAME,
-         COMBINATOR_DECLARATION_RULE_NAME,
-         CONSTRUCTOR_DECLARATION_RULE_NAME,
-         COMPLEX_TYPE_DECLARATION_RULE_NAME,
-         METAVARIABLE_DECLARATION_RULE_NAME } from "../ruleNames";
-
-export function isNodeRuleNode(node) { return isNodeRuleNodeByRuleName(node, RULE_RULE_NAME); }
-
-export function isNodeStepNode(node) { return isNodeRuleNodeByRuleName(node, STEP_RULE_NAME); }
-
-export function isNodeTermNode(node) { return isNodeRuleNodeByRuleName(node, TERM_RULE_NAME); }
-
-export function isNodeTypeNode(node) { return isNodeRuleNodeByRuleName(node, TYPE_RULE_NAME); }
-
-export function isNodeLemmaNode(node) { return isNodeRuleNodeByRuleName(node, LEMMA_RULE_NAME); }
-
-export function isNodeAxiomNode(node) { return isNodeRuleNodeByRuleName(node, AXIOM_RULE_NAME); }
-
-export function isNodeErrorNode(node) { return isNodeRuleNodeByRuleName(node, ERROR_RULE_NAME); }
-
-export function isNodeFrameNode(node) { return isNodeRuleNodeByRuleName(node, FRAME_RULE_NAME); }
-
-export function isNodeProofNode(node) { return isNodeRuleNodeByRuleName(node, PROOF_RULE_NAME); }
-
-export function isNodeLabelNode(node) { return isNodeRuleNodeByRuleName(node, LABEL_RULE_NAME); }
-
-export function isNodeLabelsNode(node) { return isNodeRuleNodeByRuleName(node, LABELS_RULE_NAME); }
-
-export function isNodeTheoremNode(node) { return isNodeRuleNodeByRuleName(node, THEOREM_RULE_NAME); }
-
-export function isNodePremiseNode(node) { return isNodeRuleNodeByRuleName(node, PREMISE_RULE_NAME); }
-
-export function isNodePropertyNode(node) { return isNodeRuleNodeByRuleName(node, PROPERTY_RULE_NAME); }
-
-export function isNodeEqualityNode(node) { return isNodeRuleNodeByRuleName(node, EQUALITY_RULE_NAME); }
-
-export function isNodeVariableNode(node) { return isNodeRuleNodeByRuleName(node, VARIABLE_RULE_NAME); }
-
-export function isNodeSubproofNode(node) { return isNodeRuleNodeByRuleName(node, SUBPROOF_RULE_NAME); }
-
-export function isNodeMetaTypeNode(node) { return isNodeRuleNodeByRuleName(node, META_TYPE_RULE_NAME); }
-
-export function isNodeParameterNode(node) { return isNodeRuleNodeByRuleName(node, PARAMETER_RULE_NAME); }
-
-export function isNodeDeductionNode(node) { return isNodeRuleNodeByRuleName(node, DEDUCTION_RULE_NAME); }
-
-export function isNodeJudgementNode(node) { return isNodeRuleNodeByRuleName(node, JUDGEMENT_RULE_NAME); }
-
-export function isNodeReferenceNode(node) { return isNodeRuleNodeByRuleName(node, REFERENCE_RULE_NAME); }
-
-export function isNodeStatementNode(node) { return isNodeRuleNodeByRuleName(node, STATEMENT_RULE_NAME); }
-
-export function isNodeMetaLemmaNode(node) { return isNodeRuleNodeByRuleName(node, META_LEMMA_RULE_NAME); }
-
-export function isNodeCombinatorNode(node) { return isNodeRuleNodeByRuleName(node, COMBINATOR_RULE_NAME); }
-
-export function isNodeConclusionNode(node) { return isNodeRuleNodeByRuleName(node, CONCLUSION_RULE_NAME); }
-
-export function isNodeConjectureNode(node) { return isNodeRuleNodeByRuleName(node, CONJECTURE_RULE_NAME); }
-
-export function isNodeDerivationNode(node) { return isNodeRuleNodeByRuleName(node, DERIVATION_RULE_NAME); }
-
-export function isNodeSuppositionNode(node) { return isNodeRuleNodeByRuleName(node, SUPPOSITION_RULE_NAME); }
-
-export function isNodeConstructorNode(node) { return isNodeRuleNodeByRuleName(node, CONSTRUCTOR_RULE_NAME); }
-
-export function isNodeDeclarationNode(node) { return isNodeRuleNodeByRuleName(node, DECLARATION_RULE_NAME); }
-
-export function isNodeMetatheoremNode(node) { return isNodeRuleNodeByRuleName(node, METATHEOREM_RULE_NAME); }
-
-export function isNodeMetavariableNode(node) { return isNodeRuleNodeByRuleName(node, METAVARIABLE_RULE_NAME); }
-
-export function isNodeProcedureCallNode(node) { return isNodeRuleNodeByRuleName(node, PROCEDURE_CALL_RULE_NAME); }
-
-export function isNodeSubDerivationNode(node) { return isNodeRuleNodeByRuleName(node, SUB_DERIVATION_RULE_NAME); }
-
-export function isNodeTypeAssertionNode(node) { return isNodeRuleNodeByRuleName(node, TYPE_ASSERTION_RULE_NAME); }
-
-export function isNodeTypeDeclarationNode(node) { return isNodeRuleNodeByRuleName(node, TYPE_DECLARATION_RULE_NAME); }
-
-export function isNodePropertyRelationNode(node) { return isNodeRuleNodeByRuleName(node, PROPERTY_RELATION_RULE_NAME); }
-
-export function isNodeDefinedAssertionNode(node) { return isNodeRuleNodeByRuleName(node, DEFINED_ASSERTION_RULE_NAME); }
-
-export function isNodePropertyAssertionNode(node) { return isNodeRuleNodeByRuleName(node, PROPERTY_ASSERTION_RULE_NAME); }
-
-export function isNodeSubproofAssertionNode(node) { return isNodeRuleNodeByRuleName(node, SUBPROOF_ASSERTION_RULE_NAME); }
-
-export function isNodeContainedAssertionNode(node) { return isNodeRuleNodeByRuleName(node, CONTAINED_ASSERTION_RULE_NAME); }
-
-export function isNodeSatisfiesAssertionNode(node) { return isNodeRuleNodeByRuleName(node, SATISFIES_ASSERTION_RULE_NAME); }
-
-export function isNodePropertyDeclarationNode(node) { return isNodeRuleNodeByRuleName(node, PROPERTY_DECLARATION_RULE_NAME); }
-
-export function isNodeVariableDeclarationNode(node) { return isNodeRuleNodeByRuleName(node, VARIABLE_DECLARATION_RULE_NAME); }
-
-export function isNodeParenthesisedLabelsNode(node) { return isNodeRuleNodeByRuleName(node, PARENTHESISED_LABELS_RULE_NAME); }
-
-export function isNodeCombinatorDeclarationNode(node) { return isNodeRuleNodeByRuleName(node, COMBINATOR_DECLARATION_RULE_NAME); }
-
-export function isNodeConstructorDeclarationNode(node) { return isNodeRuleNodeByRuleName(node, CONSTRUCTOR_DECLARATION_RULE_NAME); }
-
-export function isNodeComplexTypeDeclarationNode(node) { return isNodeRuleNodeByRuleName(node, COMPLEX_TYPE_DECLARATION_RULE_NAME); }
-
-export function isNodeMetavariableDeclarationNode(node) { return isNodeRuleNodeByRuleName(node, METAVARIABLE_DECLARATION_RULE_NAME); }
 
 export function typeFromTypeNode(typeNode) {
   let type;
@@ -193,21 +43,3 @@ export function statementFromStatementNode(statementNode, context) {
 
   return statement;
 }
-
-function isNodeRuleNodeByRuleName(node, ruleName) {
-  let nodeRuleNode = false;
-
-  const nodeNonTerminalNode = node.isNonTerminalNode();
-
-  if (nodeNonTerminalNode) {
-    const nonTerminalNode = node, ///
-          nonTerminalNodeRuleName = nonTerminalNode.getRuleName(),
-          nonTerminalNodeRuleNameRuleName = (nonTerminalNodeRuleName === ruleName);
-
-    if (nonTerminalNodeRuleNameRuleName) {
-      nodeRuleNode = true;
-    }
-  }
-
-  return nodeRuleNode;
-}

package/src/utilities/subproof.js

@@ -1,18 +1,34 @@
 "use strict";
 
-import { nodeQuery, nodesQuery } from "./query";
 import { nodeAsString, nodesAsString } from "./string";
 
-const lastStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/step[-1]/statement"),
-      suppositionStatementNodesQuery = nodesQuery("/subproof/supposition/statement");
-
 export function subproofStringFromSubproofNode(subproofNode, fileContext) {
   const tokens = fileContext.getTokens(),
-        suppositionStatementNodes = suppositionStatementNodesQuery(subproofNode),
-        lastStepStatementNode = lastStepStatementNodeQuery(subproofNode),
+        suppositionStatementNodes = suppositionStatementNodesFromSubproofNode(subproofNode),
+        lastStepStatementNode = lastStepStatementNodeFromSubproofNode(subproofNode),
         suppositionStatementsString = nodesAsString(suppositionStatementNodes, tokens),
         lastStepStatementString = nodeAsString(lastStepStatementNode, tokens),
         subproofString = `[${suppositionStatementsString}]...${lastStepStatementString}`;
 
   return subproofString;
 }
+
+function lastStepStatementNodeFromSubproofNode(subproofNode) {
+  const lastStepNode = subproofNode.getLastStepNode(),
+        lastStepNodeStatementNode = lastStepNode.getStatementNode(),
+        lastStepStatementNode = lastStepNodeStatementNode;  ///
+
+  return lastStepStatementNode;
+}
+
+function suppositionStatementNodesFromSubproofNode(subproofNode) {
+  const suppositionNodes = subproofNode.getSuppositionNodes(),
+        suppositionNodeStatementNodes = suppositionNodes.map((suppositionNode) => {
+          const suppositionNodeStatementNode = suppositionNode.getStatementNode();
+
+          return suppositionNodeStatementNode;
+        }),
+        suppositionStatementNodes = suppositionNodeStatementNodes;  ///
+
+  return suppositionStatementNodes;
+}