occam-verify-cli 1.0.444 → 1.0.457

package/src/node/topLevelAssertion/conjecture.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import TopLevelAssertionNode from "../../node/topLevelAssertion";
+
+import { CONJECTURE_BODY_RULE_NAME, CONJECTURE_HEADER_RULE_NAME } from "../../ruleNames";
+
+export default class ConjectureNode extends TopLevelAssertionNode {
+  static bodyRuleName = CONJECTURE_BODY_RULE_NAME;
+
+  static headerRuleName = CONJECTURE_HEADER_RULE_NAME;
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TopLevelAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(ConjectureNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/topLevelAssertion/lemma.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import TopLevelAssertionNode from "../../node/topLevelAssertion";
+
+import { LEMMA_BODY_RULE_NAME, LEMMA_HEADER_RULE_NAME } from "../../ruleNames";
+
+export default class LemmaNode extends TopLevelAssertionNode {
+  static bodyRuleName = LEMMA_BODY_RULE_NAME;
+
+  static headerRuleName = LEMMA_HEADER_RULE_NAME;
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TopLevelAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(LemmaNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/topLevelAssertion/theorem.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import TopLevelAssertionNode from "../../node/topLevelAssertion";
+
+import { THEOREM_BODY_RULE_NAME, THEOREM_HEADER_RULE_NAME } from "../../ruleNames";
+
+export default class TheoremNode extends TopLevelAssertionNode {
+  static bodyRuleName = THEOREM_BODY_RULE_NAME;
+
+  static headerRuleName = THEOREM_HEADER_RULE_NAME;
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TopLevelAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(TheoremNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/{axiomLemmaTheoremConjecture.js → topLevelAssertion.js}

@@ -2,7 +2,7 @@
 
 import NonTerminalNode from "../nonTerminalNode";
 
-export default class AxiomLemmaTheoremConjectureNode extends NonTerminalNode {
+export default class TopLevelAssertionNode extends NonTerminalNode {
   getBodyNode() {
     const { bodyRuleName } = this.constructor,
           ruleName = bodyRuleName,  ///

package/src/node/topLevelMetaAssertion/metaLemma.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import TopLevelMetaAssertionNode from "../../node/topLevelMetaAssertion";
+
+import { META_LEMMA_BODY_RULE_NAME, META_LEMMA_HEADER_RULE_NAME } from "../../ruleNames";
+
+export default class MetaLemmaNode extends TopLevelMetaAssertionNode {
+  static bodyRuleName = META_LEMMA_BODY_RULE_NAME;
+
+  static headerRuleName = META_LEMMA_HEADER_RULE_NAME;
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TopLevelMetaAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(MetaLemmaNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/topLevelMetaAssertion/metatheorem.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import TopLevelMetaAssertionNode from "../../node/topLevelMetaAssertion";
+
+import { METATHEOREM_BODY_RULE_NAME, METATHEOREM_HEADER_RULE_NAME } from "../../ruleNames";
+
+export default class MetatheoremNode extends TopLevelMetaAssertionNode {
+  static bodyRuleName = METATHEOREM_BODY_RULE_NAME;
+
+  static headerRuleName = METATHEOREM_HEADER_RULE_NAME;
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TopLevelMetaAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(MetatheoremNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/{metaLemmaMetaTheorem.js → topLevelMetaAssertion.js}

@@ -2,7 +2,7 @@
 
 import NonTerminalNode from "../nonTerminalNode";
 
-export default class MetaLemmaMetaTheoremNode extends NonTerminalNode {
+export default class TopLevelMetaAssertionNode extends NonTerminalNode {
   getBodyNode() {
     const { bodyRuleName } = this.constructor,
           ruleName = bodyRuleName,  ///

package/src/nonTerminalNodeMap.js

@@ -2,32 +2,32 @@
 
 import TermNode from "./node/term";
 import RuleNode from "./node/rule";
-import StepNode from "./node/step";
+import StepNode from "./node/proofAssertion/step";
 import TypeNode from "./node/type";
 import TypesNode from "./node/types";
 import ErrorNode from "./node/error";
 import FrameNode from "./node/frame";
-import AxiomNode from "./node/axiom";
-import LemmaNode from "./node/lemma";
+import AxiomNode from "./node/topLevelAssertion/axiom";
+import LemmaNode from "./node/topLevelAssertion/lemma";
 import ProofNode from "./node/proof";
 import LabelNode from "./node/label";
 import LabelsNode from "./node/labels";
 import SectionNode from "./node/section";
-import PremiseNode from "./node/premise";
-import TheoremNode from "./node/theorem";
+import PremiseNode from "./node/proofAssertion/premise";
+import TheoremNode from "./node/topLevelAssertion/theorem";
 import ArgumentNode from "./node/argument";
 import SubproofNode from "./node/subproof";
 import PropertyNode from "./node/property";
 import MetaTypeNode from "./node/metaType";
 import EqualityNode from "./node/equality";
 import VariableNode from "./node/variable";
-import RuleBodyNode from "./node/body/rule";
 import DocumentNode from "./node/document";
+import RuleBodyNode from "./node/body/rule";
 import StatementNode from "./node/statement";
 import ReferenceNode from "./node/reference";
 import DeductionNode from "./node/deduction";
 import JudgementNode from "./node/judgement";
-import MetaLemmaNode from "./node/metaLemma";
+import MetaLemmaNode from "./node/topLevelMetaAssertion/metaLemma";
 import ParameterNode from "./node/parameter";
 import SignatureNode from "./node/signature";
 import AxiomBodyNode from "./node/body/axiom";
@@ -35,19 +35,19 @@ import LemmaBodyNode from "./node/body/lemma";
 import DerivationNode from "./node/derivation";
 import CombinatorNode from "./node/combinator";
 import ConclusionNode from "./node/conclusion";
-import ConjectureNode from "./node/conjecture";
+import ConjectureNode from "./node/topLevelAssertion/conjecture";
 import HypothesisNode from "./node/hypothesis";
 import TypePrefixNode from "./node/typePrefix";
 import AssumptionNode from "./node/assumption";
 import RuleHeaderNode from "./node/header/rule";
-import SuppositionNode from "./node/supposition";
+import SuppositionNode from "./node/proofAssertion/supposition";
 import PlaceholderNode from "./node/placeholder";
 import ConstructorNode from "./node/constructor";
+import MetatheoremNode from "./node/topLevelMetaAssertion/metatheorem";
+import EquivalenceNode from "./node/equivalence";
 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";
@@ -68,8 +68,8 @@ import MetatheoremHeaderNode from "./node/header/metatheorem";
 import PropertyAssertionNode from "./node/assertion/property";
 import SubproofAssertionNode from "./node/assertion/subproof";
 import FrameSubstitutionNode from "./node/substitution/frame";
-import ProcedureReferenceNode from "./node/procedureReference";
 import ParenthesisedLabelNode from "./node/parenthesisedLabel";
+import ProcedureReferenceNode from "./node/procedureReference";
 import ContainedAssertionNode from "./node/assertion/contained";
 import SatisfiesAssertionNode from "./node/assertion/satisfies";
 import ParenthesisedLabelsNode from "./node/parenthesisedLabels"

package/src/preamble.js

@@ -3,15 +3,15 @@
 import Type from "./element/type";
 import Term from "./element/term";
 import Rule from "./element/rule";
-import Step from "./element/step";
+import Step from "./element/proofAssertion/step";
 import Label from "./element/label";
-import Axiom from "./element/axiom";
-import Lemma from "./element/lemma";
+import Axiom from "./element/topLevelAssertion/axiom";
+import Lemma from "./element/topLevelAssertion/lemma";
 import Frame from "./element/frame";
 import Proof from "./element/proof";
 import Error from "./element/error";
-import Premise from "./element/premise";
-import Theorem from "./element/theorem";
+import Premise from "./element/proofAssertion/premise";
+import Theorem from "./element/topLevelAssertion/theorem";
 import Section from "./element/section";
 import Equality from "./element/equality";
 import MetaType from "./element/metaType";
@@ -22,19 +22,19 @@ import Parameter from "./element/parameter";
 import Reference from "./element/reference";
 import Statement from "./element/statement";
 import Judgement from "./element/judgement";
-import MetaLemma from "./element/metaLemma";
+import MetaLemma from "./element/topLevelMetaAssertion/metaLemma";
 import Deduction from "./element/deduction";
 import Signature from "./element/signature";
 import TypePrefix from "./element/typePrefix";
-import Conjecture from "./element/conjecture";
+import Conjecture from "./element/topLevelAssertion/conjecture";
 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 Supposition from "./element/proofAssertion/supposition";
+import Metatheorem from "./element/topLevelMetaAssertion/metatheorem";
 import Equivalence from "./element/equivalence";
 import Equivalences from "./element/equivalences";
 import Metavariable from "./element/metavariable";

package/src/process/instantiate.js

@@ -1,38 +1,34 @@
 "use strict";
 
-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> ; `,
-      frameSubstitutionPlaceholderBNF = ` _ ::= frameSubstitution... <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),
-      frameSubstitutionPlaceholderRule = ruleFromBNF(frameSubstitutionPlaceholderBNF),
-      statementSubstitutionPlaceholderRule = ruleFromBNF(statementSubstitutionPlaceholderBNF),
-      referenceSubstitutionPlaceholderRule = ruleFromBNF(referenceSubstitutionPlaceholderBNF);
+import { ruleFromRuleName } from "../utilities/bnf";
+import { TERM_RULE_NAME,
+         VARIABLE_RULE_NAME,
+         REFERENCE_RULE_NAME,
+         STATEMENT_RULE_NAME,
+         COMBINATOR_RULE_NAME,
+         CONSTRUCTOR_RULE_NAME,
+         EQUIVALENCE_RULE_NAME,
+         METAVARIABLE_RULE_NAME,
+         TERM_SUBSTITUTION_RULE_NAME,
+         FRAME_SUBSTITUTION_RULE_NAME,
+         STATEMENT_SUBSTITUTION_RULE_NAME,
+         REFERENCE_SUBSTITUTION_RULE_NAME } from "../ruleNames";
+
+const termPlaceholderRule = ruleFromRuleName(TERM_RULE_NAME),
+      variablePlaceholderRule = ruleFromRuleName(VARIABLE_RULE_NAME),
+      referencePlaceholderRule = ruleFromRuleName(REFERENCE_RULE_NAME),
+      statementPlaceholderRule = ruleFromRuleName(STATEMENT_RULE_NAME),
+      combinatorPlaceholderRule = ruleFromRuleName(COMBINATOR_RULE_NAME),
+      constructorPlaceholderRule = ruleFromRuleName(CONSTRUCTOR_RULE_NAME),
+      equivalencePlaceholderRule = ruleFromRuleName(EQUIVALENCE_RULE_NAME),
+      metavariablePlaceholderRule = ruleFromRuleName(METAVARIABLE_RULE_NAME),
+      termSubstitutionPlaceholderRule = ruleFromRuleName(TERM_SUBSTITUTION_RULE_NAME),
+      frameSubstitutionPlaceholderRule = ruleFromRuleName(FRAME_SUBSTITUTION_RULE_NAME),
+      statementSubstitutionPlaceholderRule = ruleFromRuleName(STATEMENT_SUBSTITUTION_RULE_NAME),
+      referenceSubstitutionPlaceholderRule = ruleFromRuleName(REFERENCE_SUBSTITUTION_RULE_NAME);
 
 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); }
@@ -62,8 +58,11 @@ function instantiate(placeholderRule, string, context) {
         parser = context.getParser(),
         content = `${string}
 `,
-        tokens = lexer.tokenise(content),
-        startRule = placeholderRule;  ///
+        tokens = lexer.tokenise(content);
+
+  context.setTokens(tokens);
+
+  const startRule = placeholderRule;  ///
 
   node = parser.parse(tokens, startRule);
 

package/src/process/unify.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import { nodeQuery } from "../utilities/query";
+import { findMetaTypeByMetaTypeName } from "../metaTypes";
 import { termFromTermNode, frameFromFrameNode, statementFromStatementNode } from "../utilities/element";
 import { terminalNodeMapFromNodes, areTerminalNodeMapsEqual, isLastRemainingArgumentFunction } from "../utilities/pass";
 
@@ -344,7 +345,7 @@ class CombinatorPass extends Pass {
         context = generalContext; ///
 
         const metaTypeName = metaTypeNode.getMetaTypeName(),
-              metaType = context.findMetaTypeByMetaTypeName(metaTypeName);
+              metaType = findMetaTypeByMetaTypeName(metaTypeName);
 
         context = specificContext;  ///
 
@@ -372,7 +373,7 @@ class CombinatorPass extends Pass {
         context = generalContext; ///
 
         const metaTypeName = metaTypeNode.getMetaTypeName(),
-              metaType = context.findMetaTypeByMetaTypeName(metaTypeName);
+              metaType = findMetaTypeByMetaTypeName(metaTypeName);
 
         context = specificContext;  ///
 
@@ -406,7 +407,7 @@ class CombinatorPass extends Pass {
           context = specificContext;  ///
 
           const term = termFromTermNode(termNode, context),
-                termValidatesGivenType = term.validateGivenType(type, generalContext, specificContext);
+                termValidatesGivenType = term.validateGivenType(type, context);
 
           if (termValidatesGivenType) {
             success = true;
@@ -441,7 +442,7 @@ class ConstructorPass extends Pass {
           context = specificContext;  ///
 
           const term = termFromTermNode(termNode, context),
-                termValidatesGivenType = term.validateGivenType(type, generalContext, specificContext);
+                termValidatesGivenType = term.validateGivenType(type, context);
 
           if (termValidatesGivenType) {
             success = true;
@@ -468,7 +469,7 @@ class MetavariablePass extends Pass {
               type = generalContext.findTypeByNominalTypeName(nominalTypeName),
               context = specificContext, ///
               term = context.findTermByTermNode(termNode),
-              termValidatesGivenType = term.validateGivenType(type, generalContext, specificContext);
+              termValidatesGivenType = term.validateGivenType(type, context);
 
         if (termValidatesGivenType) {
           success = true;

package/src/types.js

@@ -9,9 +9,11 @@ let baseType = null;
 export function baseTypeFromNothing() {
   if (baseType === null) {
     const { Type } = elements,
-          name = BASE_TYPE_SYMBOL;  ///
+          name = BASE_TYPE_SYMBOL,  ///
+          context = null,
+          provisional = false;
 
-    baseType = Type.fromName(name);
+    baseType = Type.fromNameAndProvisional(name, provisional, context);
   }
 
   return baseType;

package/src/utilities/bnf.js

@@ -9,8 +9,9 @@ const { first } = arrayUtilities;
 const bnfLexer = BNFLexer.fromNothing(),
       bnfParser = BNFParser.fromNothing();
 
-export function ruleFromBNF(bnf) {
-  const tokens = bnfLexer.tokensFromBNF(bnf),
+export function ruleFromRuleName(ruleName) {
+  const bnf = ` _ ::= ${ruleName}... <END_OF_LINE> ; `,
+        tokens = bnfLexer.tokensFromBNF(bnf),
         rules = bnfParser.rulesFromTokens(tokens),
         firstRule = first(rules),
         rule = firstRule; ///

package/src/utilities/brackets.js

@@ -1,7 +1,6 @@
 "use strict";
 
-import elements from "../elements";
-
+import { termFromTermNode, statementFromStatementNode } from "../utilities/element";
 import { BRACKETED_TERM_DEPTH, BRACKETED_STATEMENT_DEPTH } from "../constants";
 import { bracketedConstructorFromNothing, bracketedCombinatorFromNothing } from "../utilities/instance";
 
@@ -10,10 +9,9 @@ export function stripBracketsFromTerm(term, context) {
         bracketedTermChildNode = bracketedTermChildNodeFromTermNode(termNode);
 
   if (bracketedTermChildNode !== null) {
-    const { Term } = elements,
-          termNode = bracketedTermChildNode;  ///
+    const termNode = bracketedTermChildNode;  ///
 
-    term = Term.fromTermNode(termNode, context);
+    term = termFromTermNode(termNode, context);
   }
 
   return term;
@@ -34,10 +32,9 @@ export function stripBracketsFromStatement(statement, context) {
         bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);
 
   if (bracketedStatementChildNode !== null) {
-    const { Statement } = elements,
-          statementNode = bracketedStatementChildNode;  ///
+    const statementNode = bracketedStatementChildNode;  ///
 
-    statement = Statement.fromStatementNode(statementNode, context);
+    statement = statementFromStatementNode(statementNode, context);
   }
 
   return statement;

package/src/utilities/context.js

@@ -0,0 +1,20 @@
+"use strict";
+
+import { FUNCTION } from "../constants";
+
+export function chainContext(context) {
+  return new Proxy(context, {
+    get: (instance, name, receiver) => {
+      if (name in instance) {
+        return Reflect.get(instance, name, receiver);
+      }
+
+      const context = instance.context,
+            value = context[name];
+
+      return (typeof value === FUNCTION) ?
+               value.bind(context) :
+                 value;
+    }
+  });
+}