occam-verify-cli 1.0.427 → 1.0.436

package/src/process/instantiate.js

@@ -1,14 +1,12 @@
 "use strict";
 
-import nominalContext from "../context/nominal";
-
 import { ruleFromBNF } from "../utilities/bnf";
-import { BASE_TYPE_SYMBOL } from "../constants";
-import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 
 const termPlaceholderBNF = ` _ ::= term... <END_OF_LINE> ; `,
       variablePlaceholderBNF = ` _ ::= variable... <END_OF_LINE> ; `,
+      referencePlaceholderBNF = ` _ ::= reference... <END_OF_LINE> ; `,
       statementPlaceholderBNF = ` _ ::= statement... <END_OF_LINE> ; `,
+      equivalencePlaceholderBNF = ` _ ::= equivalence... <END_OF_LINE> ; `,
       metavariablePlaceholderBNF = ` _ ::= metavariable... <END_OF_LINE> ; `,
       termSubstitutionPlaceholderBNF = ` _ ::= termSubstitution... <END_OF_LINE> ; `,
       frameSubstitutionPlaceholderBNF = ` _ ::= frameSubstitution... <END_OF_LINE> ; `,
@@ -16,25 +14,25 @@ const termPlaceholderBNF = ` _ ::= term... <END_OF_LINE> ; `,
       referenceSubstitutionPlaceholderBNF = ` _ ::= referenceSubstitution... <END_OF_LINE> ; `,
       termPlaceholderRule = ruleFromBNF(termPlaceholderBNF),
       variablePlaceholderRule = ruleFromBNF(variablePlaceholderBNF),
+      referencePlaceholderRule = ruleFromBNF(referencePlaceholderBNF),
       statementPlaceholderRule = ruleFromBNF(statementPlaceholderBNF),
+      equivalencePlaceholderRule = ruleFromBNF(equivalencePlaceholderBNF),
       metavariablePlaceholderRule = ruleFromBNF(metavariablePlaceholderBNF),
       termSubstitutionPlaceholderRule = ruleFromBNF(termSubstitutionPlaceholderBNF),
       frameSubstitutionPlaceholderRule = ruleFromBNF(frameSubstitutionPlaceholderBNF),
       statementSubstitutionPlaceholderRule = ruleFromBNF(statementSubstitutionPlaceholderBNF),
       referenceSubstitutionPlaceholderRule = ruleFromBNF(referenceSubstitutionPlaceholderBNF);
 
-let bracketedConstructorTermNode = null,
-    bracketedCombinatorStatementNode = null;
-
-export const bracketedConstructorTermString = `(${BASE_TYPE_SYMBOL})`;
-export const bracketedCombinatorStatementString = `(${STATEMENT_META_TYPE_NAME})`;
-
 export function instantiateTerm(string, context) { return instantiate(termPlaceholderRule, 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 instantiateEquivalence(string, context) { return instantiate(equivalencePlaceholderRule, string, context); }
+
 export function instantiateMetavariable(string, context) { return instantiate(metavariablePlaceholderRule, string, context); }
 
 export function instantiateTermSubstitution(string, context) { return instantiate(termSubstitutionPlaceholderRule, string, context); }
@@ -45,32 +43,6 @@ export function instantiateStatementSubstitution(string, context) { return insta
 
 export function instantiateReferenceSubstitution(string, context) { return instantiate(referenceSubstitutionPlaceholderRule, string, context); }
 
-export function instantiateBracketedConstructorTerm() {
-  if (bracketedConstructorTermNode === null) {
-    const placeholderRule = termPlaceholderRule, ///
-          string = bracketedConstructorTermString,
-          context = nominalContext, ///
-          node = instantiate(placeholderRule, string, context);
-
-    bracketedConstructorTermNode = node;  ///
-  }
-
-  return bracketedConstructorTermNode;
-}
-
-export function instantiateBracketedCombinatorStatement() {
-  if (bracketedCombinatorStatementNode === null) {
-    const placeholderRule = statementPlaceholderRule, ///
-          string = bracketedCombinatorStatementString,  ///
-          context = nominalContext, ///
-          node = instantiate(placeholderRule, string, context);
-
-    bracketedCombinatorStatementNode = node;  ///
-  }
-
-  return bracketedCombinatorStatementNode;
-}
-
 function instantiate(placeholderRule, string, context) {
   let node;
 

package/src/process/verify.js

@@ -1,22 +1,36 @@
 "use strict";
 
-import elements from "../elements";
-
 import { nodeQuery } from "../utilities/query";
 import { isLastRemainingArgumentFunction } from "../utilities/pass";
-
-const nonTerminalNodeQuery = nodeQuery("/*");
-
-const termNodeQuery = nodeQuery("/term"),
+import { termFromTermNode,
+         ruleFromRuleNode,
+         errorFromErrorNode,
+         axiomFromAxiomNode,
+         lemmaFromLemmaNode,
+         sectionFromSectionNode,
+         theoremFromTheoremNode,
+         metaLemmaFromMetaLemmaNode,
+         statementFromStatementNode,
+         conjectureFromConjectureNode,
+         metatheoremFromMetatheoremNode,
+         variableDeclarationFromVariableDeclarationNode,
+         simpleTypeDeclarationFromSimpleTypeDeclarationNode,
+         typePrefixDeclarationFromTypePrefixDeclarationNode,
+         combinatorDeclarationFromCombinatorDeclarationNode,
+         constructorDeclarationFromConstructorDeclarationNode,
+         complexTypeDeclarationFromComplexTypeDeclarationNode,
+         metavariableDeclarationFromMetavariableDeclarationNode } from "../utilities/element";
+
+const nonTerminalNodeQuery = nodeQuery("/*"),
+      termNodeQuery = nodeQuery("/term"),
       typeNodeQuery = nodeQuery("/type"),
-      statementNodeQuery = nodeQuery("/statement");
-
-const errorNodeQuery = nodeQuery("/error"),
       ruleNodeQuery = nodeQuery("/rule"),
+      errorNodeQuery = nodeQuery("/error"),
       axiomNodeQuery = nodeQuery("/axiom"),
       lemmaNodeQuery = nodeQuery("/lemma"),
       sectionNodeQuery = nodeQuery("/section"),
       theoremNodeQuery = nodeQuery("/theorem"),
+      statementNodeQuery = nodeQuery("/statement"),
       metaLemmaNodeQuery = nodeQuery("/metaLemma"),
       conjectureNodeQuery = nodeQuery("/conjecture"),
       metatheoremNodeQuery = nodeQuery("/metatheorem"),
@@ -182,8 +196,7 @@ class TopLevelPass extends Pass {
       run: (errorNode, context) => {
         let success = false;
 
-        const { Error } = elements,
-              error = Error.fromErrorNode(errorNode, context),
+        const error = errorFromErrorNode(errorNode, context),
               errorVerifies = error.verify();
 
         if (errorVerifies) {
@@ -198,8 +211,7 @@ class TopLevelPass extends Pass {
       run: (ruleNode, context) => {
         let success = false;
 
-        const { Rule } = elements,
-              rule = Rule.fromRuleNode(ruleNode, context),
+        const rule = ruleFromRuleNode(ruleNode, context),
               ruleVerifies = rule.verify();
 
         if (ruleVerifies) {
@@ -214,8 +226,7 @@ class TopLevelPass extends Pass {
       run: (axiomNode, context) => {
         let success = false;
 
-        const { Axiom } = elements,
-              axiom = Axiom.fromAxiomNode(axiomNode, context),
+        const axiom = axiomFromAxiomNode(axiomNode, context),
               axiomVerifies = axiom.verify();
 
         if (axiomVerifies) {
@@ -230,8 +241,7 @@ class TopLevelPass extends Pass {
       run: (lemmaNode, context) => {
         let success = false;
 
-        const { Lemma } = elements,
-              lemma = Lemma.fromLemmaNode(lemmaNode, context),
+        const lemma = lemmaFromLemmaNode(lemmaNode, context),
               lemmaVerifies = lemma.verify();
 
         if (lemmaVerifies) {
@@ -246,8 +256,7 @@ class TopLevelPass extends Pass {
       run: (sectionNode, context) => {
         let success = false;
 
-        const { Section } = elements,
-              section = Section.fromSectionNode(sectionNode, context),
+        const section = sectionFromSectionNode(sectionNode, context),
               sectionVerifies = section.verify();
 
         if (sectionVerifies) {
@@ -262,8 +271,7 @@ class TopLevelPass extends Pass {
       run: (theoremNode, context) => {
         let success = false;
 
-        const { Theorem } = elements,
-              theorem = Theorem.fromTheoremNode(theoremNode, context),
+        const theorem = theoremFromTheoremNode(theoremNode, context),
               theoremVerifies = theorem.verify();
 
         if (theoremVerifies) {
@@ -278,8 +286,7 @@ class TopLevelPass extends Pass {
       run: (metaLemmaNode, context) => {
         let success = false;
 
-        const { MetaLemma } = elements,
-              metaLemma = MetaLemma.fromMetaLemmaNode(metaLemmaNode, context),
+        const metaLemma = metaLemmaFromMetaLemmaNode(metaLemmaNode, context),
               metaLemmaVerifies = metaLemma.verify();
 
         if (metaLemmaVerifies) {
@@ -294,8 +301,7 @@ class TopLevelPass extends Pass {
       run: (conjectureNode, context) => {
         let success = false;
 
-        const { Conjecture } = elements,
-              conjecture = Conjecture.fromConjectureNode(conjectureNode, context),
+        const conjecture = conjectureFromConjectureNode(conjectureNode, context),
               conjectureVerifies = conjecture.verify();
 
         if (conjectureVerifies) {
@@ -310,8 +316,7 @@ class TopLevelPass extends Pass {
       run: (metatheoremNode, context) => {
         let success = false;
 
-        const { Metatheorem } = elements,
-              metatheorem = Metatheorem.fromMetatheoremNode(metatheoremNode, context),
+        const metatheorem = metatheoremFromMetatheoremNode(metatheoremNode, context),
               metatheoremVerifies = metatheorem.verify();
 
         if (metatheoremVerifies) {
@@ -326,8 +331,7 @@ class TopLevelPass extends Pass {
       run: (variableDeclarationNode, context) => {
         let success = false;
 
-        const { VariableDeclaration } = elements,
-              variableDeclaration = VariableDeclaration.fromVariableDeclarationNode(variableDeclarationNode, context),
+        const variableDeclaration = variableDeclarationFromVariableDeclarationNode(variableDeclarationNode, context),
               variableDeclarationVerifies = variableDeclaration.verify();
 
         if (variableDeclarationVerifies) {
@@ -342,8 +346,7 @@ class TopLevelPass extends Pass {
       run: (simpleTypeDeclarationNode, context) => {
         let success = false;
 
-        const { SimpleTypeDeclaration } = elements,
-              simpleTypeDeclaration = SimpleTypeDeclaration.fromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context),
+        const simpleTypeDeclaration = simpleTypeDeclarationFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context),
               simpleTypeDeclarationVerifies = simpleTypeDeclaration.verify();
 
         if (simpleTypeDeclarationVerifies) {
@@ -358,8 +361,7 @@ class TopLevelPass extends Pass {
       run: (typePrefixDeclarationNode, context) => {
         let success = false;
 
-        const { TypePrefixDeclaration } = elements,
-              typePrefixDeclaration = TypePrefixDeclaration.fromTypePrefixDeclarationNode(typePrefixDeclarationNode, context),
+        const typePrefixDeclaration = typePrefixDeclarationFromTypePrefixDeclarationNode(typePrefixDeclarationNode, context),
               typePrefixDeclarationVerifies = typePrefixDeclaration.verify();
 
         if (typePrefixDeclarationVerifies) {
@@ -374,8 +376,7 @@ class TopLevelPass extends Pass {
       run: (combinatorDeclarationNode, context) => {
         let success = false;
 
-        const { CombinatorDeclaration } = elements,
-              combinatorDeclaration = CombinatorDeclaration.fromCombinatorDeclarationNode(combinatorDeclarationNode, context),
+        const combinatorDeclaration = combinatorDeclarationFromCombinatorDeclarationNode(combinatorDeclarationNode, context),
               combinatorDeclarationVerifies = combinatorDeclaration.verify();
 
         if (combinatorDeclarationVerifies) {
@@ -390,8 +391,7 @@ class TopLevelPass extends Pass {
       run: (constructorDeclarationNode, context) => {
         let success = false;
 
-        const { ConstructorDeclaration } = elements,
-              constructorDeclaration = ConstructorDeclaration.fromConstructorDeclarationNode(constructorDeclarationNode, context),
+        const constructorDeclaration = constructorDeclarationFromConstructorDeclarationNode(constructorDeclarationNode, context),
               constructorDeclarationVerifies = constructorDeclaration.verify();
 
         if (constructorDeclarationVerifies) {
@@ -406,8 +406,7 @@ class TopLevelPass extends Pass {
       run: (complexTypeDeclarationNode, context) => {
         let success = false;
 
-        const { ComplexTypeDeclaration } = elements,
-              complexTypeDeclaration = ComplexTypeDeclaration.fromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
+        const complexTypeDeclaration = complexTypeDeclarationFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
               complexTypeDeclarationVerifies = complexTypeDeclaration.verify();
 
         if (complexTypeDeclarationVerifies) {
@@ -422,8 +421,7 @@ class TopLevelPass extends Pass {
       run: (metavariableDeclarationNode, context) => {
         let success = false;
 
-        const { MetavariableDeclaration } = elements,
-              metavariableDeclaration = MetavariableDeclaration.fromMetavariableDeclarationNode(metavariableDeclarationNode, context),
+        const metavariableDeclaration = metavariableDeclarationFromMetavariableDeclarationNode(metavariableDeclarationNode, context),
               metavariableDeclarationVerifies = metavariableDeclaration.verify();
 
         if (metavariableDeclarationVerifies) {
@@ -457,8 +455,7 @@ class CombinatorPass extends Pass {
       run: (statementNode, context) => {
         let success = false;
 
-        const { Statement } = elements,
-              statement = Statement.fromStatementNode(statementNode, context),
+        const statement = statementFromStatementNode(statementNode, context),
               assignments = null,
               stated = false,
               statementVerifies = statement.verify(assignments, stated, context);
@@ -475,8 +472,7 @@ class CombinatorPass extends Pass {
       run: (termNode, context) => {
         let success = false;
 
-        const { Term } = elements,
-              term = Term.fromTermNode(termNode, context),
+        const term = termFromTermNode(termNode, context),
               termVerifies = term.verify(context, () => {
                 const verifiesAhead = true;
 
@@ -529,8 +525,7 @@ class ConstructorPass extends Pass {
       run: (termNode, context, verifyAhead) => {
         let success = false;
 
-        const { Term } = elements,
-              term = Term.fromTermNode(termNode, context),
+        const term = termFromTermNode(termNode, context),
               termVerifies = term.verify(context, verifyAhead);
 
         if (termVerifies) {

package/src/ruleNames.js

@@ -20,7 +20,6 @@ export const PROPERTY_RULE_NAME = "property";
 export const EQUALITY_RULE_NAME = "equality";
 export const VARIABLE_RULE_NAME = "variable";
 export const SUBPROOF_RULE_NAME = "subproof";
-export const NONSENSE_RULE_NAME = "nonsense";
 export const DOCUMENT_RULE_NAME = "document";
 export const RULE_BODY_RULE_NAME = "ruleBody";
 export const META_TYPE_RULE_NAME = "metaType";
@@ -45,10 +44,12 @@ export const TYPE_PREFIX_RULE_NAME = "typePrefix";
 export const SUPPOSITION_RULE_NAME = "supposition";
 export const CONSTRUCTOR_RULE_NAME = "constructor";
 export const METATHEOREM_RULE_NAME = "metatheorem";
+export const EQUIVALENCE_RULE_NAME = "equivalence";
 export const AXIOM_HEADER_RULE_NAME = "axiomHeader";
 export const LEMMA_HEADER_RULE_NAME = "lemmaHeader";
 export const THEOREM_BODY_RULE_NAME = "theoremBody";
 export const METAVARIABLE_RULE_NAME = "metavariable";
+export const EQUIVALENCES_RULE_NAME = "equivalences";
 export const META_ARGUMENT_RULE_NAME = "metaArgument";
 export const QUALIFICATION_RULE_NAME = "qualification";
 export const PROCEDURE_CALL_RULE_NAME = "procedureCall";

package/src/utilities/brackets.js

@@ -3,7 +3,7 @@
 import elements from "../elements";
 
 import { BRACKETED_TERM_DEPTH, BRACKETED_STATEMENT_DEPTH } from "../constants";
-import { instantiateBracketedCombinatorStatement, instantiateBracketedConstructorTerm } from "../process/instantiate";
+import { bracketedConstructorTermFromNothing, bracketedCombinatorStatementFromNothing } from "../utilities/instance";
 
 export function stripBracketsFromTerm(term, context) {
   const termNode = term.getNode(),
@@ -19,6 +19,16 @@ export function stripBracketsFromTerm(term, context) {
   return term;
 }
 
+export function stripBracketsFromTermNode(termNode) {
+  const bracketedTermChildNode = bracketedTermChildNodeFromTermNode(termNode);
+
+  if (bracketedTermChildNode !== null) {
+    termNode = bracketedTermChildNode;  ///
+  }
+
+  return termNode;
+}
+
 export function stripBracketsFromStatement(statement, context) {
   const statementNode = statement.getNode(),
         bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);
@@ -33,16 +43,6 @@ export function stripBracketsFromStatement(statement, context) {
   return statement;
 }
 
-export function stripBracketsFromTermNode(termNode) {
-  const bracketedTermChildNode = bracketedTermChildNodeFromTermNode(termNode);
-
-  if (bracketedTermChildNode !== null) {
-    termNode = bracketedTermChildNode;  ///
-  }
-
-  return termNode;
-}
-
 export function stripBracketsFromStatementNode(statementNode) {
   const bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);
 
@@ -57,7 +57,7 @@ function bracketedTermChildNodeFromTermNode(termNode) {
   let bracketedTermChildNode = null;
 
   const depth = BRACKETED_TERM_DEPTH,
-        bracketedConstructorTermNode = instantiateBracketedConstructorTerm(),
+        bracketedConstructorTermNode = bracketedConstructorTermFromNothing(),
         termNodeMatchBracketedConstructorTermNode = termNode.match(bracketedConstructorTermNode, depth);
 
   if (termNodeMatchBracketedConstructorTermNode) {
@@ -73,7 +73,7 @@ function bracketedStatementChildNodeFromStatementNode(statementNode) {
   let bracketedStatementChildNode = null;
 
   const depth = BRACKETED_STATEMENT_DEPTH,
-        bracketedCombinatorStatementNode = instantiateBracketedCombinatorStatement(),
+        bracketedCombinatorStatementNode = bracketedCombinatorStatementFromNothing(),
         statementNodeMatchBracketedCombinatorStatementNode = statementNode.match(bracketedCombinatorStatementNode, depth);
 
   if (statementNodeMatchBracketedCombinatorStatementNode) {