occam-verify-cli 1.0.448 → 1.0.472

package/src/context/temporary.js

@@ -1,476 +0,0 @@
-"use strict";
-
-import { arrayUtilities } from "necessary";
-
-const { extract, compress } = arrayUtilities;
-
-export default class TemporaryContext {
-  constructor(context, terms, frames, statements, assertions, references, substitutions) {
-    this.context = context;
-    this.terms = terms;
-    this.frames = frames;
-    this.statements = statements;
-    this.assertions = assertions;
-    this.references = references;
-    this.substitutions = substitutions;
-  }
-
-  getContext() {
-    return this.context;
-  }
-
-  getTerms() {
-    return this.terms;
-  }
-
-  getFrames() {
-    return this.frames;
-  }
-
-  getStatements() {
-    return this.statements;
-  }
-
-  getAssertions() {
-    return this.assertions;
-  }
-
-  getReferences() {
-    return this.references;
-  }
-
-  getSubstitutions() {
-    return this.substitutions;
-  }
-
-  addTerm(term) {
-    const termA = term, ///
-          context = this, ///
-          termString = term.getString();
-
-    extract(this.terms, (term) => {
-      const termB = term, ///
-            termAEqualToTermB = termA.isEqualTo(termB);
-
-      if (termAEqualToTermB) {
-        return true;
-      }
-    });
-
-    context.trace(`ADded the '${termString}' term to the context.`);
-
-    this.terms.push(term);
-  }
-
-  addFrame(frame) {
-    const frameA = frame, ///
-          context = this, ///
-          frameString = frame.getString();
-
-    extract(this.frames, (frame) => {
-      const frameB = frame, ///
-            frameAEqualToFrameB = frameA.isEqualTo(frameB);
-
-      if (frameAEqualToFrameB) {
-        return true;
-      }
-    });
-
-    context.trace(`Added the '${frameString}' frame to the context.`);
-
-    this.frames.push(frame);
-  }
-
-  addStatement(statement) {
-    const context = this, ///
-          statementA = statement, ///
-          statementString = statement.getString();
-
-    extract(this.statements, (statement) => {
-      const statementB = statement, ///
-            statementAEqualToFrameB = statementA.isEqualTo(statementB);
-
-      if (statementAEqualToFrameB) {
-        return true;
-      }
-    });
-
-    context.trace(`Added the '${statementString}' statement to the context.`);
-
-    this.statements.push(statement);
-  }
-
-  addAssertion(assertion) {
-    const context = this, ///
-          assertionA = assertion, ///
-          assertionString = assertion.getString();
-
-    extract(this.assertions, (assertion) => {
-      const assertionB = assertion, ///
-            assertionAEqualToAssertionB = assertionA.isEqualTo(assertionB);
-
-      if (assertionAEqualToAssertionB) {
-        return true;
-      }
-    });
-
-    context.trace(`Added the '${assertionString}' assertion to the context.`);
-
-    this.assertions.push(assertion);
-  }
-
-  addReference(reference) {
-    const context = this, ///
-          referenceA = reference, ///
-          referenceString = reference.getString();
-
-    extract(this.references, (reference) => {
-      const referenceB = reference, ///
-            referenceAEqualToReferenceB = referenceA.isEqualTo(referenceB);
-
-      if (referenceAEqualToReferenceB) {
-        return true;
-      }
-    });
-
-    context.trace(`Added the '${referenceString}' reference to the context.`);
-
-    this.references.push(reference);
-  }
-
-  addSubstitution(substitution) {
-    const context = this, ///
-          substitutionA = substitution, ///
-          substitutionString = substitution.getString();
-
-    extract(this.substitutions, (substitution) => {
-      const substitutionB = substitution, ///
-            substituionAEqualToSubstitutionB = substitutionA.isEqualTo(substitutionB);
-
-      if (substituionAEqualToSubstitutionB) {
-        return true;
-      }
-    });
-
-    context.trace(`Added the '${substitutionString}' substitution to the context.`);
-
-    this.substitutions.push(substitution);
-  }
-
-  findTermByTermNode(termNode) {
-    const term = this.terms.find((term) => {
-      const termNodeMatches = term.matchNode(termNode);
-
-      if (termNodeMatches) {
-        return true;
-      }
-    }) || null;
-
-    return term;
-  }
-
-  findFrameByFrameNode(frameNode) {
-    const frame = this.frames.find((frame) => {
-      const frameNodeMatches = frame.matchNode(frameNode);
-
-      if (frameNodeMatches) {
-        return true;
-      }
-    }) || null;
-
-    return frame;
-  }
-
-  findStatementByStatementNode(statementNode) {
-    const statement = this.statements.find((statement) => {
-      const statementNodeMatches = statement.matchNode(statementNode);
-
-      if (statementNodeMatches) {
-        return true;
-      }
-    }) || null;
-
-    return statement;
-  }
-
-  findAssertionByAssertionNode(assertionNode) {
-    const assertion = this.assertions.find((assertion) => {
-      const assertionNodeMatches = assertion.matchNode(assertionNode);
-
-      if (assertionNodeMatches) {
-        return true;
-      }
-    }) || null;
-
-    return assertion;
-  }
-
-  findReferenceByMetavariableNode(metavariableNode) {
-    const reference = this.references.find((reference) => {
-      const referenceMatcheMetavariableNode = reference.matchMetavariableNode(metavariableNode);
-
-      if (referenceMatcheMetavariableNode) {
-        return true;
-      }
-    }) || null;
-
-    return reference;
-  }
-
-  findSubstitutionBySubstitutionNode(substitutionNode) {
-    const substitution = this.substitutions.find((substitution) => {
-      const substitutionNodeMatches = substitution.matchNode(substitutionNode);
-
-      if (substitutionNodeMatches) {
-        return true;
-      }
-    }) || null;
-
-    return substitution;
-  }
-
-  getVariables(nested = true) { return this.context.getVariables(nested); }
-
-  getJudgements() { return this.context.getJudgements(); }
-
-  getEquivalences() { return this.context.getEquivalences(); }
-
-  getProofAssertions() { return this.context.getProofAssertions(); }
-
-  getLastProofAssertion() { return this.context.getLastProofAssertion(); }
-
-  getSubproofOrProofAssertions() { return this.context.getSubproofOrProofAssertions(); }
-
-  getFilePath() { return this.context.getFilePath(); }
-
-  getLexer() { return this.context.getLexer(); }
-
-  getParser() { return this.context.getParser(); }
-
-  getAxioms() { return this.context.getAxioms(); }
-
-  getLemmas() { return this.context.getLemmas(); }
-
-  getTheorems() { return this.context.getTheorems(); }
-
-  getConjectures() { return this.context.getConjectures(); }
-
-  getCombinators() { return this.context.getCombinators(); }
-
-  getConstructors() { return this.context.getConstructors(); }
-
-  getTypePrefix() { return this.context.getTypePrefix(); }
-
-  addAxiom(axiom) { this.context.addAxiom(axiom); }
-
-  addLemma(lemma) { this.context.addLemma(lemma); }
-
-  addTheorem(theorem) { this.context.addTheorem(theorem); }
-
-  addEquality(equality) { return this.context.addEquality(equality); }
-
-  addVariable(variable, nested = true) { return this.context.addVariable(variable, nested); }
-
-  addJudgement(judgement) { return this.context.addJudgement(judgement); }
-
-  addSubproofOrProofAssertion(subproofOrProofAssertion) { this.context.addSubproofOrProofAssertion(subproofOrProofAssertion); }
-
-  findProcedureByName(name) { return this.context.findProcedureByName(name); }
-
-  findLabelByReference(reference, context) { return this.context.findLabelByReference(reference, context); }
-
-  findRuleByReference(reference) { return this.context.findRuleByReference(reference); }
-
-  findAxiomByReference(reference) { return this.context.findAxiomByReference(reference); }
-
-  findLemmaByReference(reference) { return this.context.findLemmaByReference(reference); }
-
-  findTheoremByReference(reference) { return this.context.findTheoremByReference(reference); }
-
-  findConjectureByReference(reference) { return this.context.findConjectureByReference(reference); }
-
-  findMetaLemmasByReference(reference) { return this.context.findMetaLemmasByReference(reference); }
-
-  findMetatheoremsByReference(reference) { return this.context.findMetatheoremsByReference(reference); }
-
-  findMetaLemmaMetatheoremByReference(reference) { return this.context.findMetaLemmaMetatheoremByReference(reference); }
-
-  findMetaLemmaMetatheoremsByReference(reference) { return this.context.findMetaLemmaMetatheoremsByReference(reference); }
-
-  findVariableByVariableIdentifier(variableIdentifier, nested = true) { return this.context.findVariableByVariableIdentifier(variableIdentifier, nested); }
-
-  findJudgementByMetavariable(metavariable) { return this.context.findJudgementByMetavariable(metavariable); }
-
-  findEquivalenceByTerm(term) { return this.context.findEquivalenceByTerm(term); }
-
-  findMetavariable(metavariable) { return this.context.findMetavariable(metavariable); }
-
-  findLabelByMetavariable(metavariable) { return this.context.findLabelByMetavariable(metavariable); }
-
-  findTypeByNominalTypeName(nominalTypeName) { return this.context.findTypeByNominalTypeName(nominalTypeName); }
-
-  findMetaTypeByMetaTypeName(metaTypeName) { return this.context.findMetaTypeByMetaTypeName(metaTypeName); }
-
-  findMetavariableByMetavariableName(metavariableName) { return this.context.findMetavariableByMetavariableName(metavariableName); }
-
-  isProcedurePresentByName(name) { return this.context.isProcedurePresentByName(name); }
-
-  isLabelPresentByReference(reference) { return this.context.isLabelPresentByReference(reference); }
-
-  isMetavariablePresentByReference(reference) { return this.context.isMetavariablePresentByReference(reference); }
-
-  isMetaLemmaMetatheoremPresentByReference(reference) { return this.context.isMetaLemmaMetatheoremPresentByReference(reference); }
-
-  findAxiomLemmaTheoremOrConjectureByReference(reference) { return this.context.findAxiomLemmaTheoremOrConjectureByReference(reference); }
-
-  isMetavariablePresent(metavariable) { return this.context.isMetavariablePresent(metavariable); }
-
-  isTypePresentByTypeName(typeName, includeRelease = true, includeDependencies = true) { return this.context.isTypePresentByTypeName(typeName, includeRelease, includeDependencies); }
-
-  isTypePresentByNominalTypeName(nominalTypeName) { return this.context.isTypePresentByNominalTypeName(nominalTypeName); }
-
-  isTypePresentByPrefixedTypeName(prefixedTypeName) { return this.context.isTypePresentByPrefixedTypeName(prefixedTypeName); }
-
-  isTypePrefixPresentByTypePrefixName(typePrefixName) { return this.context.isTypePrefixPresentByTypePrefixName(typePrefixName); }
-
-  isVariablePresentByVariableIdentifier(variableIdentifier, nested = true) { return this.context.findVariableByVariableIdentifier(variableIdentifier, nested); }
-
-  isLabelPresentByMetavariableName(metavariableName) { return this.context.isLabelPresentByMetavariableName(metavariableName); }
-
-  isLabelPresentByMetavariable(metavariable) { return this.context.isLabelPresentByMetavariable(metavariable); }
-
-  isMetavariablePresentByMetavariableName(metavariableNode) { return this.context.isMetavariablePresentByMetavariableName(metavariableNode); }
-
-  isJudgementPresentByMetavariable(metavariable) { return this.context.isJudgementPresentByMetavariable(metavariable); }
-
-  isTermGrounded(term) { return this.context.isTermGrounded(term); }
-
-  isVariableDefined(variable) { return this.context.isVariableDefined(variable); }
-
-  isMetavariableDefined(metavariable) { return this.context.isMetavariableDefined(metavariable); }
-
-  compareTermAndPropertyRelation(term, propertyRelation) { return this.context.compareTermAndPropertyRelation(term, propertyRelation); }
-
-  nodeAsString(node) { return this.context.nodeAsString(node); }
-
-  nodesAsString(node) { return this.context.nodesAsString(node); }
-
-  trace(message, node = null) { this.context.trace(message, node); }
-
-  debug(message, node = null) { this.context.debug(message, node); }
-
-  info(message, node = null) { this.context.info(message, node); }
-
-  warning(message, node = null) { this.context.warning(message, node); }
-
-  error(message, node = null) { this.context.error(message, node); }
-
-  merge(context) {
-    const terms = context.getTerms(),
-          frames = context.getFrames(),
-          statements = context.getStatements(),
-          assertions = context.getAssertions(),
-          references = context.getReferences(),
-          substitutions = context.getSubstitutions();
-
-    this.terms = [
-      ...this.terms,
-      ...terms
-    ];
-
-    this.frames = [
-      ...this.frames,
-      ...frames
-    ];
-
-    this.statements = [
-      ...this.statements,
-      ...statements
-    ];
-
-    this.assertions = [
-      ...this.assertions,
-      ...assertions
-    ];
-
-    this.references = [
-      ...this.references,
-      ...references
-    ];
-
-    this.substitutions = [
-      ...this.substitutions,
-      ...substitutions
-    ];
-
-    compress(this.terms, (termA, termB) => {
-      const termAEqualToTermB = termA.isEqualTo(termB);
-
-      if (!termAEqualToTermB) {
-        return true;
-      }
-    });
-
-    compress(this.frames, (frameA, frameB) => {
-      const frameAEqualToFrameB = frameA.isEqualTo(frameB);
-
-      if (!frameAEqualToFrameB) {
-        return true;
-      }
-    });
-
-    compress(this.statements, (statementA, statementB) => {
-      const statementAEqualToStatementB = statementA.isEqualTo(statementB);
-
-      if (!statementAEqualToStatementB) {
-        return true;
-      }
-    });
-
-    compress(this.assertions, (assertionA, assertionB) => {
-      const assertionAEqualToAssertionB = assertionA.isEqualTo(assertionB);
-
-      if (!assertionAEqualToAssertionB) {
-        return true;
-      }
-    });
-
-    compress(this.references, (referenceA, referenceB) => {
-      const referenceAEqualToReferenceB = referenceA.isEqualTo(referenceB);
-
-      if (!referenceAEqualToReferenceB) {
-        return true;
-      }
-    });
-
-    compress(this.substitutions, (substitutionA, substitutionB) => {
-      const substitutionAEqualToSubstitutionB = substitutionA.isEqualTo(substitutionB);
-
-      if (!substitutionAEqualToSubstitutionB) {
-        return true;
-      }
-    });
-  }
-
-  static fromNothing(context) {
-    const terms = [],
-          frames = [],
-          statements = [],
-          assertions = [],
-          references = [],
-          substitutions = [],
-          temporaryContext = new TemporaryContext(context, terms, frames, statements, assertions, references, substitutions);
-
-    return temporaryContext;
-  }
-
-  static fromTermsAndFrames(terms, frames, context) {
-    const statements = [],
-          assertions = [],
-          references = [],
-          substitutions = [],
-          temporaryContext = new TemporaryContext(context, terms, frames, statements, assertions, references, substitutions);
-
-    return temporaryContext;
-  }
-}

package/src/log.js

@@ -1,118 +0,0 @@
-"use strict";
-
-import { levels } from "necessary";
-import {EMPTY_STRING} from "./constants";
-
-const { TRACE_LEVEL, DEBUG_LEVEL, INFO_LEVEL, WARNING_LEVEL, ERROR_LEVEL } = levels;
-
-export default class Log {
-  constructor(messages, logLevel, follow) {
-    this.messages = messages;
-    this.logLevel = logLevel;
-    this.follow = follow;
-  }
-
-  getMessages() {
-    return this.messages;
-  }
-
-  getLogLevel() {
-    return this.logLevel;
-  }
-
-  getFollow() {
-    return this.follow;
-  }
-
-  trace(message, filePath, lineIndex = null) {
-    const level = TRACE_LEVEL;
-
-    this.write(level, message, filePath, lineIndex);
-  }
-
-  debug(message, filePath, lineIndex = null) {
-    const level = DEBUG_LEVEL;
-
-    this.write(level, message, filePath, lineIndex);
-  }
-
-  info(message, filePath, lineIndex = null) {
-    const level = INFO_LEVEL;
-
-    this.write(level, message, filePath, lineIndex);
-  }
-
-  warning(message, filePath, lineIndex = null) {
-    const level = WARNING_LEVEL;
-
-    this.write(level, message, filePath, lineIndex);
-  }
-
-  error(message, filePath, lineIndex = null) {
-    const level = ERROR_LEVEL;
-
-    this.write(level, message, filePath, lineIndex);
-  }
-
-  write(level, message, filePath, lineIndex) {
-    const levels = [
-            TRACE_LEVEL,
-            DEBUG_LEVEL,
-            INFO_LEVEL,
-            WARNING_LEVEL,
-            ERROR_LEVEL
-          ],
-          levelIndex = levels.indexOf(level),
-          logLevelIndex = levels.indexOf(this.logLevel);
-
-    if (levelIndex < logLevelIndex) {
-      return;
-    }
-
-    message = formatMessage(level, message, filePath, lineIndex);  ///
-
-    this.follow ?
-      console.log(message) :
-        this.messages.push(message);
-  }
-
-  static fromNothing() {
-    const messages = [],
-          logLevel = TRACE_LEVEL,
-          follow = false,
-          log = new Log(messages, logLevel, follow);
-
-    return log;
-  }
-
-  static fromFollowAndLogLevel(follow, logLevel) {
-    const messages = follow ?
-                       null :
-                         [],
-          log = new Log(messages, logLevel, follow);
-
-    return log;
-  }
-}
-
-function formatMessage(level, message, filePath = null, lineIndex = null) {
-  let formattedMessage = EMPTY_STRING;
-
-  const upperCaseLevel = level.toUpperCase();
-
-  formattedMessage += `${upperCaseLevel}:`;
-
-  if (filePath !== null) {
-    formattedMessage += ` ${filePath}`;
-  }
-
-  if (lineIndex !== null) {
-    formattedMessage += ` [${lineIndex}]`;
-  }
-
-  formattedMessage += ` - ${message}`;
-
-  message = formattedMessage; ///
-
-  return message;
-}

package/src/node/axiom.js

@@ -1,13 +0,0 @@
-"use strict";
-
-import AxiomLemmaTheoremConjectureNode from "../node/axiomLemmaTheoremConjecture";
-
-import { AXIOM_BODY_RULE_NAME, AXIOM_HEADER_RULE_NAME } from "../ruleNames";
-
-export default class AxiomNode extends AxiomLemmaTheoremConjectureNode {
-  static bodyRuleName = AXIOM_BODY_RULE_NAME;
-
-  static headerRuleName = AXIOM_HEADER_RULE_NAME;
-
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return AxiomLemmaTheoremConjectureNode.fromRuleNameChildNodesOpacityAndPrecedence(AxiomNode, ruleName, childNodes, opacity, precedence); }
-}

package/src/node/conjecture.js

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

package/src/node/lemma.js

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

package/src/node/metaLemma.js

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

package/src/node/metatheorem.js

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

package/src/node/premise.js

@@ -1,30 +0,0 @@
-"use strict";
-
-import NonTerminalNode from "../nonTerminalNode";
-
-import { NONSENSE_RULE_NAME, STATEMENT_RULE_NAME, PROCEDURE_CALL_RULE_NAME } from "../ruleNames";
-
-export default class PremiseNode extends NonTerminalNode {
-  getNonsenseNode() {
-    const ruleName = NONSENSE_RULE_NAME,
-          nonsenseNode = this.getNodeByRuleName(ruleName);
-
-    return nonsenseNode;
-  }
-
-  getStatementNode() {
-    const ruleName = STATEMENT_RULE_NAME,
-          statementNode = this.getNodeByRuleName(ruleName);
-
-    return statementNode;
-  }
-
-  getProcedureCallNode() {
-    const ruleName = PROCEDURE_CALL_RULE_NAME,
-          procedureCallNode = this.getNodeByRuleName(ruleName);
-
-    return procedureCallNode;
-  }
-
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(PremiseNode, ruleName, childNodes, opacity, precedence); }
-}