occam-verify-cli 1.0.448 → 1.0.472

package/src/context/release.js

@@ -10,13 +10,15 @@ import FileContext from "../context/file";
 import NominalLexer from "../nominal/lexer";
 import NominalParser from "../nominal/parser";
 
+import { LEVELS } from "../constants";
 import { getMetaTypes } from "../metaTypes";
 import { customGrammarFromNameAndEntries, combinedCustomGrammarFromReleaseContexts } from "../utilities/customGrammar";
 
 const { nominalLexerFromCombinedCustomGrammar } = lexersUtilities,
       { nominalParserFromCombinedCustomGrammar } = parsersUtilities,
       { tail, push, first, clear, filter, resolve, compress } = arrayUtilities,
-      { isFilePathFurtleFilePath, isFilePathNominalFilePath } = filePathUtilities;
+      { isFilePathFurtleFilePath, isFilePathNominalFilePath } = filePathUtilities,
+      [ TRACE_LEVEL, DEBUG_LEVEL, INFO_LEVEL, WARNING_LEVEL, ERROR_LEVEL ] = LEVELS;
 
 export default class ReleaseContext {
   constructor(log, name, json, entries, lexer, parser, verified, initialised, fileContexts, customGrammar, dependencyReleaseContexts) {
@@ -430,15 +432,51 @@ export default class ReleaseContext {
 
   matchShortenedVersion(shortenedVersion) { return this.entries.matchShortenedVersion(shortenedVersion); }
 
-  trace(message, filePath = null, lineIndex = null) { this.log.trace(message, filePath, lineIndex); }
+  trace(message, filePath = null, lineIndex = null) {
+    const level = TRACE_LEVEL;
 
-  debug(message, filePath = null, lineIndex = null) { this.log.debug(message, filePath, lineIndex); }
+    this.writeToLog(level, message, filePath, lineIndex);
+  }
+
+  debug(message, filePath = null, lineIndex = null) {
+    const level = DEBUG_LEVEL
+
+    this.writeToLog(level, message, filePath, lineIndex);
+  }
+
+  info(message, filePath = null, lineIndex = null) {
+    const level = INFO_LEVEL;
 
-  info(message, filePath = null, lineIndex = null) { this.log.info(message, filePath, lineIndex); }
+    this.writeToLog(level, message, filePath, lineIndex);
+  }
+
+  warning(message, filePath = null, lineIndex = null) {
+    const level = WARNING_LEVEL;
 
-  warning(message, filePath = null, lineIndex = null) { this.log.warning(message, filePath, lineIndex); }
+    this.writeToLog(level, message, filePath, lineIndex);
+  }
 
-  error(message, filePath = null, lineIndex = null) { this.log.error(message, filePath, lineIndex); }
+  error(message, filePath = null, lineIndex = null) {
+    const level = ERROR_LEVEL;
+
+    this.writeToLog(level, message, filePath, lineIndex);
+  }
+
+  writeToLog(level, message, filePath, lineIndex) {
+    this.log.write(level, message, filePath, lineIndex);
+  }
+
+  getFileContext() {
+    const fileContext = null;
+
+    return fileContext;
+  }
+
+  getDepth() {
+    const depth = -1;
+
+    return depth;
+  }
 
   initialise(releaseContexts) {
     const combinedCustomGrammar = combinedCustomGrammarFromReleaseContexts(releaseContexts),
@@ -582,7 +620,8 @@ function fileContextsFromJSON(json,fileContexts, releaseContext) {
     }
 
     if (filePathNominalFilePath) {
-      const fileContext = FileContext.fromFilePath(filePath, releaseContext);
+      const context = releaseContext, ///
+            fileContext = FileContext.fromFilePath(filePath, context);
 
       fileContexts.push(fileContext);
 
@@ -605,7 +644,8 @@ function fileContextsFromEntries(entries, fileContexts, releaseContext) {
     }
 
     if (filePathNominalFilePath) {
-      const fileContext = FileContext.fromFile(file, releaseContext);
+      const context = releaseContext, ///
+            fileContext = FileContext.fromFile(file, context);
 
       fileContexts.push(fileContext);
     }

package/src/context/{local.js → scoped.js}

@@ -1,18 +1,22 @@
 "use strict";
 
 import { arrayUtilities } from "necessary";
+import { contextUtilities } from "occam-furtle";
 
 import elements from "../elements";
 
-const { last } = arrayUtilities;
+const { last } = arrayUtilities,
+      { chainContext } = contextUtilities;
 
-class LocalContext {
+class ScopedContext {
   constructor(context, variables, judgements, equivalences, subproofOrProofAssertions) {
     this.context = context;
     this.variables = variables;
     this.judgements = judgements;
     this.equivalences = equivalences;
     this.subproofOrProofAssertions = subproofOrProofAssertions;
+
+    return chainContext(this);
   }
 
   getContext() {
@@ -50,7 +54,9 @@ class LocalContext {
   getEquivalences() {
     let equivalences = this.context.getEquivalences();
 
-    equivalences = this.equivalences.mergedWith(equivalences);  ///
+    const context = this; ///
+
+    equivalences = this.equivalences.mergedWith(equivalences, context);  ///
 
     return equivalences;
   }
@@ -92,32 +98,6 @@ class LocalContext {
     return subproofOrProofAssertions;
   }
 
-  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) {
     let equalityAdded;
 
@@ -191,40 +171,7 @@ class LocalContext {
     this.subproofOrProofAssertions.push(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) {
-    const variables = this.getVariables(nested),
-          variable = variables.find((variable) => {
-            const variableComparesToVariableIdentifier = variable.compareVariableIdentifier(variableIdentifier);
-
-            if (variableComparesToVariableIdentifier) {
-              return true;
-            }
-          }) || null;
-
-    return variable;
-  }
+  findEquivalenceByTerm(term) { return this.equivalences.findEquivalenceByTerm(term); }
 
   findJudgementByMetavariable(metavariable) {
     const judgements = this.getJudgements(),
@@ -244,56 +191,17 @@ class LocalContext {
     return judgement;
   }
 
-  findEquivalenceByTerm(term) { return this.equivalences.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) {
-    const variable = this.findVariableByVariableIdentifier(variableIdentifier, nested),
-          variablePresent = (variable !== null);
-
-    return variablePresent;
-  }
-
-  isLabelPresentByMetavariableName(metavariableName) { return this.context.isLabelPresentByMetavariableName(metavariableName); }
-
-  isLabelPresentByMetavariable(metavariable) { return this.context.isLabelPresentByMetavariable(metavariable); }
-
-  isMetavariablePresentByMetavariableName(metavariableNode) { return this.context.isMetavariablePresentByMetavariableName(metavariableNode); }
+  findVariableByVariableIdentifier(variableIdentifier, nested = true) {
+    const variables = this.getVariables(nested),
+          variable = variables.find((variable) => {
+            const variableComparesToVariableIdentifier = variable.compareVariableIdentifier(variableIdentifier);
 
-  isJudgementPresentByMetavariable(metavariable) {
-    const judgement = this.findJudgementByMetavariable(metavariable),
-          judgementPresent = (judgement !== null);
+            if (variableComparesToVariableIdentifier) {
+              return true;
+            }
+          }) || null;
 
-    return judgementPresent;
+    return variable;
   }
 
   isTermGrounded(term) {
@@ -344,6 +252,20 @@ class LocalContext {
     return metavariableDefined
   }
 
+  isJudgementPresentByMetavariable(metavariable) {
+    const judgement = this.findJudgementByMetavariable(metavariable),
+          judgementPresent = (judgement !== null);
+
+    return judgementPresent;
+  }
+
+  isVariablePresentByVariableIdentifier(variableIdentifier, nested = true) {
+    const variable = this.findVariableByVariableIdentifier(variableIdentifier, nested),
+          variablePresent = (variable !== null);
+
+    return variablePresent;
+  }
+
   compareTermAndPropertyRelation(term, propertyRelation) {
     const context = this, ///
           proofAssertions = this.getProofAssertions(),
@@ -358,30 +280,26 @@ class LocalContext {
     return comparesToTermAndPropertyRelation;
   }
 
-  nodeAsString(node) { return this.context.nodeAsString(node); }
-
-  nodesAsString(node) { return this.context.nodesAsString(node); }
+  getFileContext() { return this.context.getFileContext(); }
 
-  trace(message, node = null) { this.context.trace(message, node); }
+  getDepth() {
+    let depth = this.context.getDepth();
 
-  debug(message, node = null) { this.context.debug(message, node); }
+    depth++;
 
-  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); }
+    return depth;
+  }
 
   static fromNothing(context) {
     const { Equivalences } = elements,
           variables = [],
           judgements = [],
-          equivalences = Equivalences.fromNothing(),
+          equivalences = Equivalences.fromNothing(context),
           subproofOrProofAssertions = [],
-          localContext = new LocalContext(context, variables, judgements, equivalences, subproofOrProofAssertions);
+          scopedContext = new ScopedContext(context, variables, judgements, equivalences, subproofOrProofAssertions);
 
-    return localContext;
+    return scopedContext;
   }
 }
 
-export default LocalContext;
+export default ScopedContext;

package/src/context/synthetic.js

@@ -0,0 +1,60 @@
+"use strict";
+
+import { contextUtilities } from "occam-furtle";
+
+const { chainContext } = contextUtilities;
+
+export default class SyntheticContext {
+  constructor(context, generalContext, specificContext) {
+    this.context = context;
+    this.generalContext = generalContext;
+    this.specificContext = specificContext;
+
+    return chainContext(this);
+  }
+
+  getContext() {
+    return this.context;
+  }
+
+  getGeneralContext() {
+    return this.generalContext;
+  }
+
+  getSpecificContext() {
+    return this.specificContext;
+  }
+
+  findTermByTermNode(termNode) { return this.specificContext.findTermByTermNode(termNode); }
+
+  findFrameByFrameNode(frameNode) { return this.specificContext.findFrameByFrameNode(frameNode); }
+
+  findTypeByNominalTypeName(nominalTypeName) { return this.specificContext.findTypeByNominalTypeName(nominalTypeName); }
+
+  isTypePresentByNominalTypeName(nominalTypeName) { return this.specificContext.isTypePresentByNominalTypeName(nominalTypeName); }
+
+  findVariableByVariableIdentifier(variableIdentifier) { return this.generalContext.findVariableByVariableIdentifier(variableIdentifier); }
+
+  findMetavariableByMetavariableName(metavariableName) { return this.generalContext.findMetavariableByMetavariableName(metavariableName); }
+
+  isVariablePresentByVariableIdentifier(variableIdentifier) { this.generalContext.isVariablePresentByVariableIdentifier(variableIdentifier); }
+
+  isMetavariablePresentByMetavariableName(metavariableName) { this.generalContext.isMetavariablePresentByMetavariableName(metavariableName); }
+
+  getFileContext() { return this.context.getFileContext(); }
+
+  getDepth() {
+    let depth = this.context.getDepth();
+
+    depth++;
+
+    return depth;
+  }
+
+  static fromNothing(generalContext, specificContext) {
+    const context = specificContext,  ///
+          syntheticContext = new SyntheticContext(context, generalContext, specificContext);
+
+    return syntheticContext;
+  }
+}

package/src/element/assertion/contained.js

@@ -6,7 +6,7 @@ import { define } from "../../elements";
 import { termFromTermAndSubstitutions, frameFromFrameAndSubstitutions, statementFromStatementAndSubstitutions } from "../../utilities/substitutions";
 
 export default define(class ContainedAssertion extends Assertion {
-  constructor(cpontext, string, node, term, frame, negated, statement) {
+  constructor(context, string, node, term, frame, negated, statement) {
     super(context, string, node);
 
     this.term = term;
@@ -31,46 +31,47 @@ export default define(class ContainedAssertion extends Assertion {
     return this.statement;
   }
 
-  verify(assignments, stated, context) {
-    let verifies = false;
+  validate(assignments, stated, context) {
+    let validates = false;
 
     const containedAssertionString = this.getString(); ///
 
-    context.trace(`Verifying the '${containedAssertionString}' contained assertion...`);
+    context.trace(`Validating the '${containedAssertionString}' contained assertion...`);
 
     const termValidates = this.validateTerm(assignments, stated, context),
-          frameVerifies = this.verifyFrame(assignments, stated, context),
+          frameVerifies = this.validateFrame(assignments, stated, context),
           statementValidates = this.validateStatement(assignments, stated, context)
 
     if (termValidates || frameVerifies || statementValidates) {
-      let verifiesWhenStated = false,
-          verifiesWhenDerived = false;
+      let validatesWhenStated = false,
+          validatesWhenDerived = false;
 
       if (stated) {
-        verifiesWhenStated = this.verifyWhenStated(assignments, context);
+        validatesWhenStated = this.validateWhenStated(assignments, context);
       } else {
-        verifiesWhenDerived = this.verifyWhenDerived(context);
+        validatesWhenDerived = this.validateWhenDerived(context);
       }
 
-      if (verifiesWhenStated || verifiesWhenDerived) {
-        verifies = true;
+      if (validatesWhenStated || validatesWhenDerived) {
+        validates = true;
       }
     }
 
-    if (verifies) {
-      context.debug(`...verified the '${containedAssertionString}' contained assertion.`);
+    if (validates) {
+      context.debug(`...validated the '${containedAssertionString}' contained assertion.`);
     }
 
-    return verifies;
+    return validates;
   }
 
   validateTerm(assignments, stated, context) {
     let termValidates = false;
 
     if (this.term !== null) {
-      const termString = this.term.getString();
+      const termString = this.term.getString(),
+            containedAssertionString = this.getString(); ///
 
-      context.trace(`Validating the '${termString}' term...`);
+      context.trace(`Validating the '${containedAssertionString}' contained assertino's '${termString}' term...`);
 
       const termSingular = this.term.isSingular();
 
@@ -78,13 +79,13 @@ export default define(class ContainedAssertion extends Assertion {
         context.debug(`The '${termString}' term is not singular.`);
       } else {
         termValidates = this.term.validate(context, () => {
-          const verifiesAhead = true;
+          const validatesAhead = true;
 
-          return verifiesAhead;
+          return validatesAhead;
         });
 
         if (termValidates) {
-          context.debug(`...validated the '${termString}' term.`);
+          context.debug(`...validated the '${containedAssertionString}' contained assertino's '${termString}' term.`);
         }
       }
     }
@@ -92,13 +93,14 @@ export default define(class ContainedAssertion extends Assertion {
     return termValidates;
   }
 
-  verifyFrame(assignments, stated, context) {
+  validateFrame(assignments, stated, context) {
     let frameVerifies = false;
 
     if (this.frame !== null) {
-      const frameString = this.frame.getString();
+      const frameString = this.frame.getString(),
+            containedAssertionString = this.getString(); ///
 
-      context.trace(`Verifying the '${frameString}' frame...`);
+      context.trace(`Validating the '${containedAssertionString}' contained assertino's '${frameString}' frame...`);
 
       const frameSingular = this.frame.isSingular();
 
@@ -109,10 +111,10 @@ export default define(class ContainedAssertion extends Assertion {
 
         assignments = null; ///
 
-        frameVerifies = this.frame.verify(assignments, stated, context);
+        frameVerifies = this.frame.validate(assignments, stated, context);
 
         if (frameVerifies) {
-          context.debug(`...verified the '${frameString}' frame.`);
+          context.debug(`...validated the '${containedAssertionString}' contained assertino's '${frameString}' frame.`);
         }
       }
     }
@@ -142,39 +144,39 @@ export default define(class ContainedAssertion extends Assertion {
     return statementValidates;
   }
 
-  verifyWhenStated(assignments, context) {
-    let verifiesWhenStated;
+  validateWhenStated(assignments, context) {
+    let validatesWhenStated;
 
     const containedAssertionString = this.getString(); ///
 
-    context.trace(`Verifying the '${containedAssertionString}' stated contained assertion...`);
+    context.trace(`Validating the '${containedAssertionString}' stated contained assertion...`);
 
-    verifiesWhenStated = true;
+    validatesWhenStated = true;
 
-    if (verifiesWhenStated) {
-      context.debug(`...verified the '${containedAssertionString}' stated contained assertion.`);
+    if (validatesWhenStated) {
+      context.debug(`...validated the '${containedAssertionString}' stated contained assertion.`);
     }
 
-    return verifiesWhenStated;
+    return validatesWhenStated;
   }
 
-  verifyWhenDerived(context) {
-    let verifiesWhenDerived;
+  validateWhenDerived(context) {
+    let validatesWhenDerived;
 
     const containedAssertionString = this.getString(); ///
 
-    context.trace(`Verifying the '${containedAssertionString}' derived contained assertion...`);
+    context.trace(`Validating the '${containedAssertionString}' derived contained assertion...`);
 
     const generalCotnext = null,
           specificContext = context; ///
 
-    verifiesWhenDerived = verifyWhenDerived(this.term, this.frame, this.statement, this.negated, generalCotnext, specificContext);
+    validatesWhenDerived = validateWhenDerived(this.term, this.frame, this.statement, this.negated, generalCotnext, specificContext);
 
-    if (verifiesWhenDerived) {
-      context.debug(`...verified the '${containedAssertionString}' derived contained assertion.`);
+    if (validatesWhenDerived) {
+      context.debug(`...validated the '${containedAssertionString}' derived contained assertion.`);
     }
 
-    return verifiesWhenDerived;
+    return validatesWhenDerived;
   }
 
   unifyIndependently(substitutions, generalContext, specificContext) {
@@ -188,9 +190,9 @@ export default define(class ContainedAssertion extends Assertion {
     const term = termFromTermAndSubstitutions(this.term, substitutions, generalContext, specificContext),
           frame = frameFromFrameAndSubstitutions(this.frame, substitutions, generalContext, specificContext),
           statement = statementFromStatementAndSubstitutions(this.statement, substitutions, generalContext, specificContext),
-          verifiesWhenDerived = verifyWhenDerived(term, frame, statement, this.negated, generalContext, specificContext);
+          validatesWhenDerived = validateWhenDerived(term, frame, statement, this.negated, generalContext, specificContext);
 
-    unifiesIndependently = verifiesWhenDerived; ///
+    unifiesIndependently = validatesWhenDerived; ///
 
     if (unifiesIndependently) {
       context.debug(`...unified the '${containedAssertionString}' contained assertion independently.`);
@@ -202,8 +204,8 @@ export default define(class ContainedAssertion extends Assertion {
   static name = "ContainedAssertion";
 });
 
-function verifyWhenDerived(term, frame, statement, negated, generalContext, specificContext) {
-  let verifiesWhenDerived = false;
+function validateWhenDerived(term, frame, statement, negated, generalContext, specificContext) {
+  let validatesWhenDerived = false;
 
   const context = specificContext;  ///
 
@@ -212,11 +214,11 @@ function verifyWhenDerived(term, frame, statement, negated, generalContext, spec
       const termContained = statement.isTermContained(term, context);
 
       if (!negated && termContained) {
-        verifiesWhenDerived = true;
+        validatesWhenDerived = true;
       }
 
       if (negated && !termContained) {
-        verifiesWhenDerived = true;
+        validatesWhenDerived = true;
       }
     }
 
@@ -224,14 +226,14 @@ function verifyWhenDerived(term, frame, statement, negated, generalContext, spec
       const frameContained = statement.isFrameContained(frame, context);
 
       if (!negated && frameContained) {
-        verifiesWhenDerived = true;
+        validatesWhenDerived = true;
       }
 
       if (negated && !frameContained) {
-        verifiesWhenDerived = true;
+        validatesWhenDerived = true;
       }
     }
   }
 
-  return verifiesWhenDerived;
+  return validatesWhenDerived;
 }