occam-verify-cli 1.0.388 → 1.0.404

package/src/context/temporary.js

@@ -0,0 +1,463 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+const { extract, compress } = arrayUtilities;
+
+export default class TemporaryContext {
+  constructor(context, tokens, terms, frames, statements, assertions, substitutions, reference) {
+    this.context = context;
+    this.tokens = tokens;
+    this.terms = terms;
+    this.frames = frames;
+    this.statements = statements;
+    this.assertions = assertions;
+    this.substitutions = substitutions;
+    this.reference = reference;
+  }
+
+  getContext() {
+    return this.context;
+  }
+
+  getTokens() {
+    return tokens;
+  }
+
+  getTerms() {
+    return this.terms;
+  }
+
+  getFrames() {
+    return this.frames;
+  }
+
+  getStatements() {
+    return this.statements;
+  }
+
+  getAssertions() {
+    return this.assertions;
+  }
+
+  getSubstitutions() {
+    return this.substitutions;
+  }
+
+  getReference() {
+    return this.reference;
+  }
+
+  addTerm(term) {
+    const context = this, ///
+          termNode = term.getNode(),
+          termString = term.getString();
+
+    extract(this.terms, (term) => {
+      const termMatchesTermNode = term.matchTermNode(termNode);
+
+      if (termMatchesTermNode) {
+        return true;
+      }
+    });
+
+    context.trace(`ADded the '${termString}' term.`);
+
+    this.terms.push(term);
+  }
+
+  addFrame(frame) {
+    const context = this, ///
+          frameNode = frame.getNode(),
+          frameString = frame.getString();
+
+    extract(this.frames, (frame) => {
+      const frameMatchesFrameNode = frame.matchFrameNode(frameNode);
+
+      if (frameMatchesFrameNode) {
+        return true;
+      }
+    });
+
+    context.trace(`Added the '${frameString}' frame.`);
+
+    this.frames.push(frame);
+  }
+
+  addStatement(statement) {
+    const context = this, ///
+          statementNode = statement.getNode(),
+          statementString = statement.getString();
+
+    extract(this.statements, (statement) => {
+      const statementMatchesFrameNode = statement.matchStatementNode(statementNode);
+
+      if (statementMatchesFrameNode) {
+        return true;
+      }
+    });
+
+    context.trace(`Added the '${statementString}' statement.`);
+
+    this.statements.push(statement);
+  }
+
+  addAssertion(assertion) {
+    const context = this, ///
+          assertionNode = assertion.getNode(),
+          assertionString = assertion.getString();
+
+    extract(this.assertions, (assertion) => {
+      const assertionMatchesFrameNode = assertion.matchAssertionNode(assertionNode);
+
+      if (assertionMatchesFrameNode) {
+        return true;
+      }
+    });
+
+    context.trace(`Added the '${assertionString}' assertion.`);
+
+    this.assertions.push(assertion);
+  }
+
+  addSubstitution(substitution) {
+    const context = this, ///
+          substitutionNode = substitution.getNode(),
+          substitutionString = substitution.getString();
+
+    extract(this.substitutions, (substitution) => {
+      const substitutionMatchesFrameNode = substitution.matchSubstitutionNode(substitutionNode);
+
+      if (substitutionMatchesFrameNode) {
+        return true;
+      }
+    });
+
+    context.trace(`Added the '${substitutionString}' substitution.`);
+
+    this.substitutions.push(substitution);
+  }
+
+  addReference(reference) {
+    const context = this, ///
+      referenceString = reference.getString();
+
+    this.reference = reference;
+
+    context.trace(`Added the '${referenceString}' reference.`);
+  }
+
+  findTermByTermNode(termNode) {
+    const term = this.terms.find((term) => {
+      const termMatchesTermNode = term.matchTermNode(termNode);
+
+      if (termMatchesTermNode) {
+        return true;
+      }
+    }) || null;
+
+    return term;
+  }
+
+  findFrameByFrameNode(frameNode) {
+    const frame = this.frames.find((frame) => {
+      const frameMatchesFrameNode = frame.matchFrameNode(frameNode);
+
+      if (frameMatchesFrameNode) {
+        return true;
+      }
+    }) || null;
+
+    return frame;
+  }
+
+  findAssertionByAssertionNode(assertionNode) {
+    const assertion = this.assertions.find((assertion) => {
+      const assertionMatchesAssertionNode = assertion.matchAssertionNode(assertionNode);
+
+      if (assertionMatchesAssertionNode) {
+        return true;
+      }
+    }) || null;
+
+    return assertion;
+  }
+
+  findStatementByStatementNode(statementNode) {
+    const statement = this.statements.find((statement) => {
+      const statementMatchesStatementNode = statement.matchStatementNode(statementNode);
+
+      if (statementMatchesStatementNode) {
+        return true;
+      }
+    }) || null;
+
+    return statement;
+  }
+
+  findSubtitutionBySubtitutionNode(substitutionNode) {
+    const substitution = this.substitutions.find((substitution) => {
+      const substitutionMatchesSubtitutionNode = substitution.matchSubtitutionNode(substitutionNode);
+
+      if (substitutionMatchesSubtitutionNode) {
+        return true;
+      }
+    }) || null;
+
+    return substitution;
+  }
+
+  getVariables(nested = true) { return this.context.getVariables(nested); }
+
+  getJudgements() { return this.context.getJudgements(); }
+
+  getEquivalences() { return this.context.getEquivalences(); }
+
+  getSteps() { return this.context.getSteps(); }
+
+  getLastStep() { return this.context.getLastStep(); }
+
+  getStepsOrSubproofs() { return this.context.getStepsOrSubproofs(); }
+
+  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); }
+
+  addStepOrSubproof(stepOrSubproof) { this.context.addStepOrSubproof(stepOrSubproof); }
+
+  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); }
+
+  matchTermAndPropertyRelation(term, propertyRelation) { return this.context.matchTermAndPropertyRelation(term, propertyRelation); }
+
+  nodeAsString(node, tokens = null) {
+    if (tokens === null) {
+      tokens = this.tokens;
+    }
+
+    const string = this.context.nodeAsString(node, tokens);
+
+    return string;
+  }
+
+  nodesAsString(node, tokens = null) {
+    if (tokens === null) {
+      tokens = this.tokens;
+    }
+
+    const string = this.context.nodesAsString(node, tokens);
+
+    return string;
+  }
+
+  nodeAsTokens(node, tokens = null) {
+    if (tokens === null) {
+      tokens = this.tokens;
+    }
+
+    tokens = this.context.nodeAsTokens(node, tokens); ///
+
+    return tokens;
+  }
+
+  nodesAsTokens(node, tokens = null) {
+    if (tokens === null) {
+      tokens = this.tokens;
+    }
+
+    tokens = this.context.nodesAsTokens(node, tokens);  ///
+
+    return tokens;
+  }
+
+  tokensAsString(tokens) { return this.context.tokensAsString(tokens); }
+
+  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); }
+
+  marge(context) {
+    const terms = context.getTerms(),
+          frames = context.getFrames(),
+          statements = context.getStatements(),
+          assertions = context.getAssertions(),
+          substitutions = context.getSubstitutions();
+
+    this.terms = [
+      ...this.terms,
+      ...terms
+    ];
+
+    this.frames = [
+      ...this.frames,
+      ...frames
+    ];
+
+    this.statements = [
+      ...this.statements,
+      ...statements
+    ];
+
+    this.assertions = [
+      ...this.assertions,
+      ...assertions
+    ];
+
+    this.substitutions = [
+      ...this.substitutions,
+      ...substitutions
+    ];
+
+    compress(this.terms, (termA, termB) => {
+      const termANode = termA.getNode(),
+            termBNode = termB.getNode(),
+            termANodeMatchesTermBNode = termANode.match(termBNode);
+
+      if (termAMatchesTermB) {
+        return true;
+      }
+    });
+
+  }
+
+  static fromNothing(context) {
+    const terms = [],
+          frames = [],
+          tokens = null,
+          statements = [],
+          assertions = [],
+          substitutions = [],
+          reference = null,
+          temporaryContext = new TemporaryContext(context, tokens, terms, frames, statements, assertions, substitutions, reference);
+
+    return temporaryContext;
+  }
+
+  static fromTermsAndFrames(terms, frames, context) {
+    const tokens = null,
+          statements = [],
+          assertions = [],
+          substitutions = [],
+          reference = null,
+          temporaryContext = new TemporaryContext(context, tokens, terms, frames, statements, assertions, substitutions, reference);
+
+    return temporaryContext;
+  }
+
+  static fromContextAndTokens(context, tokens) {
+    const terms = [],
+          frames = [],
+          statements = [],
+          assertions = [],
+          substitutions = [],
+          reference = null,
+          temporaryContext = new TemporaryContext(context, tokens, terms, frames, statements, assertions, substitutions, reference);
+
+    return temporaryContext;
+  }
+}

package/src/mixins/statement/verify.js

@@ -12,6 +12,41 @@ import { equalityFromStatement,
          containedAssertionFromStatement,
          satisfiesAssertionFromStatement } from "../../utilities/context";
 
+function verifyAsMetavariableAndSubstitution(statement, assignments, stated, context) {
+  let verifiesAsMetavariableAndSubstitution = false;
+
+  const metavariable = metavariableFromStatement(statement, context);
+
+  if (metavariable !== null) {
+    const statementString = statement.getString();
+
+    context.trace(`Verifying the '${statementString}' statement as a metavariable and substitution...`);
+
+    const metavariableVerifies = metavariable.verify(context);
+
+    if (metavariableVerifies) {
+      const { TermSubstitution, FrameSubstitution } = ontology,
+            substitution = TermSubstitution.fromStatement(statement, context) || FrameSubstitution.fromStatement(statement, context);
+
+      if (substitution !== null) {
+        const substitutionVerifies = substitution.verify(context);
+
+        if (substitutionVerifies) {
+          verifiesAsMetavariableAndSubstitution = true;
+        }
+      } else {
+        verifiesAsMetavariableAndSubstitution = true;
+      }
+    }
+
+    if (verifiesAsMetavariableAndSubstitution) {
+      context.debug(`...verified the '${statementString}' statement as a metavariable and substitution.`);
+    }
+  }
+
+  return verifiesAsMetavariableAndSubstitution;
+}
+
 function unifyWithBracketedCombinator(statement, assignments, stated, context) {
   stated = true;  ///
 
@@ -41,28 +76,6 @@ function unifyWithCombinators(statement, assignments, stated, context) {
   return unifiesWithCombinators;
 }
 
-function verifyAsMetavariable(statement, assignments, stated, context) {
-  let verifiesAsMetavariable = false;
-
-  const metavariable = metavariableFromStatement(statement, context);
-
-  if (metavariable !== null) {
-    const statementString = statement.getString();
-
-    context.trace(`Verifying the '${statementString}' statement as a metavariable...`);
-
-    const metavariableVerifies = metavariable.verify(context);
-
-    verifiesAsMetavariable = metavariableVerifies; ///
-
-    if (verifiesAsMetavariable) {
-      context.debug(`...verified the '${statementString}' statement as a metavariable.`);
-    }
-  }
-
-  return verifiesAsMetavariable;
-}
-
 function verifyAsEquality(statement, assignments, stated, context) {
   let verifiesAsEquality = false;
 
@@ -122,6 +135,10 @@ function verifyAsTypeAssertion(statement, assignments, stated, context) {
     verifiesAsTypeAssertion = typeAssertionVerifies; ///
 
     if (verifiesAsTypeAssertion) {
+      const assertion = typeAssertion;  ///
+
+      context.addAssertion(assertion);
+
       context.debug(`...verified the '${statementString}' statement as a type assertion.`);
     }
   }
@@ -144,6 +161,10 @@ function verifyAsDefinedAssertion(statement, assignments, stated, context) {
     verifiesAsDefinedAssertion = definedAssertionVerifies; ///
 
     if (verifiesAsDefinedAssertion) {
+      const assertion = definedAssertion;  ///
+
+      context.addAssertion(assertion);
+
       context.debug(`...verified the '${statementString}' statement as a defined assertion.`);
     }
   }
@@ -166,6 +187,10 @@ function verifyAsPropertyAssertion(statement, assignments, stated, context) {
     verifiesAsPropertyAssertion = propertyAssertionVerifies; ///
 
     if (verifiesAsPropertyAssertion) {
+      const assertion = propertyAssertion; ///
+
+      context.addAssertion(assertion);
+
       context.debug(`...verified the '${statementString}' statement as a property assertion.`);
     }
   }
@@ -188,6 +213,10 @@ function verifyAsSubproofAssertion(statement, assignments, stated, context) {
     verifiesAsSubproofAssertion = subproofAssertionVerifies; ///
 
     if (verifiesAsSubproofAssertion) {
+      const assertion = subproofAssertion; ///
+
+      context.addAssertion(assertion);
+
       context.debug(`...verified the '${statementString}' statement as a subproof assertion.`);
     }
   }
@@ -210,6 +239,10 @@ function verifyAsContainedAssertion(statement, assignments, stated, context) {
     verifiesAsContainedAssertion = containedAssertionVerifies; ///
 
     if (verifiesAsContainedAssertion) {
+      const assertion = containedAssertion; ///
+
+      context.addAssertion(assertion);
+
       context.debug(`...verified the '${statementString}' statement as a contained assertion.`);
     }
   }
@@ -232,6 +265,10 @@ function verifyAsSatisfiesAssertion(statement, assignments, stated, context) {
     verifiesAsSatisfiesAssertion = satisfiesAssertionVerifies; ///
 
     if (verifiesAsSatisfiesAssertion) {
+      const assertion = satisfiesAssertion; ///
+
+      context.addAssertion(assertion);
+
       context.debug(`...verified the '${statementString}' statement as a satisfies assertion.`);
     }
   }
@@ -240,9 +277,9 @@ function verifyAsSatisfiesAssertion(statement, assignments, stated, context) {
 }
 
 const verifyMixins = [
+  verifyAsMetavariableAndSubstitution,
   unifyWithBracketedCombinator,
   unifyWithCombinators,
-  verifyAsMetavariable,
   verifyAsEquality,
   verifyAsJudgement,
   verifyAsTypeAssertion,

package/src/mixins/step/unify.js

@@ -3,7 +3,6 @@
 import { arrayUtilities } from "necessary";
 
 import ontology from "../../ontology";
-import Substitutions from "../../substitutions";
 
 import { equalityFromStatement,
          judgementFromStatement,
@@ -59,7 +58,7 @@ function unifyWithReference(statement, reference, satisfiesAssertion, substituti
             statementSubstitution = StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context),
             substitution = statementSubstitution; ///
 
-      substitutions.addSubstitution(substitution, specificContext);
+      substitutions.addSubstitution(substitution, context);
 
       unifiesWithReference = true;
 
@@ -109,7 +108,8 @@ function unifyAsSatisfiesAssertion(statement, reference, satisfiesAssertion, sub
           const satisfiable = axiom.isSatisfiable();
 
           if (satisfiable) {
-            const substitutions = Substitutions.fromNothing(),
+            const { Substitutions } = ontology,
+                  substitutions = Substitutions.fromNothing(),
                   axiomLemmaTheoremOrConjectureUnifies = axiom.unifyAxiomLemmaTheoremOrConjecture(axiomLemmaTheoremOrConjecture, substitutions, context);
 
             if (axiomLemmaTheoremOrConjectureUnifies) {
@@ -140,7 +140,8 @@ function unifyWithAxiomLemmaTheoremOrConjecture(statement, reference, satisfiesA
   let unifiesWithAxiomLemmaTheoremOrConjecture = false;
 
   if (reference !== null) {
-    const axiomLemmaTheoremOrConjecture = context.findAxiomLemmaTheoremOrConjectureByReference(reference),
+    const { Substitutions } = ontology,
+          axiomLemmaTheoremOrConjecture = context.findAxiomLemmaTheoremOrConjectureByReference(reference),
           generalSubstitutions = substitutions; ///
 
     if (axiomLemmaTheoremOrConjecture !== null) {
@@ -158,13 +159,12 @@ function unifyWithAxiomLemmaTheoremOrConjecture(statement, reference, satisfiesA
       if (statementAndStepsUnify) {
         const { StatementSubstitution } = ontology,
               metavariable = reference.getMetavariable(),
-              specificContext = context,  ///
               statementSubstitution = StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context),
               substitution = statementSubstitution;  ///
 
         substitutions = generalSubstitutions; ///
 
-        substitutions.addSubstitution(substitution, specificContext);
+        substitutions.addSubstitution(substitution, context);
 
         unifiesWithAxiomLemmaTheoremOrConjecture = true;
       }

package/src/node/argument.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import NonTerminalNode from "../node/nonTerminal";
+import NonTerminalNode from "../nonTerminalNode";
 
 import { TERM_RULE_NAME, TYPE_RULE_NAME } from "../ruleNames";
 

package/src/node/assertion/contained.js

@@ -1,11 +1,11 @@
 "use strict";
 
-import NonTerminalNode from "../../node/nonTerminal";
+import AssertionNode from "../../node/assertion";
 
 import { MISSING } from "../../constants";
 import { TERM_RULE_NAME, FRAME_RULE_NAME, STATEMENT_RULE_NAME } from "../../ruleNames";
 
-export default class ContainedAssertionNode extends NonTerminalNode {
+export default class ContainedAssertionNode extends AssertionNode {
   isNegated() {
     let negated = false;
 
@@ -49,5 +49,5 @@ export default class ContainedAssertionNode extends NonTerminalNode {
     return statementNode;
   }
 
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ContainedAssertionNode, ruleName, childNodes, opacity, precedence); }
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return AssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(ContainedAssertionNode, ruleName, childNodes, opacity, precedence); }
 }