occam-verify-cli 0.0.526 → 0.0.529

package/src/{axiomLemmaTheorem.js → axiomLemmaTheoremConjecture.js}

@@ -7,7 +7,7 @@ import Consequence from "./consequence";
 import { prune } from "./utilities/array";
 import { someSubArray } from "./utilities/array";
 
-export default class AxiomLemmaTheorem {
+export default class AxiomLemmaTheoremConjecture {
   constructor(labels, suppositions, consequence) {
     this.labels = labels;
     this.suppositions = suppositions;
@@ -90,14 +90,14 @@ export default class AxiomLemmaTheorem {
     return json;
   }
 
-  static fromJSON(Class, json, releaseContext) {
+  static fromJSON(Class, json, lexer, parser) {
     let { labels } = json;
 
     const labelsJSON = labels;  ///
 
     labels = labelsJSON.map((labelJSON) => {
       const json = labelJSON, ///
-            label = Label.fromJSON(json, releaseContext);
+            label = Label.fromJSON(json, lexer, parser);
 
       return label;
     });
@@ -108,7 +108,7 @@ export default class AxiomLemmaTheorem {
 
     suppositions = suppositionsJSON.map((suppositionJSON) => {
       const json = suppositionJSON, ///
-            supposition = Supposition.fromJSON(json, releaseContext);
+            supposition = Supposition.fromJSON(json, lexer, parser);
 
       return supposition;
     });
@@ -119,7 +119,7 @@ export default class AxiomLemmaTheorem {
 
     json = consequenceJSON;  ///
 
-    consequence = Consequence.fromJSON(json, releaseContext);
+    consequence = Consequence.fromJSON(json, lexer, parser);
 
     return new Class(labels, suppositions, consequence);  ///
   }
@@ -156,7 +156,7 @@ function matchSupposition(supposition, proofSteps, substitutions) {
 }
 
 function matchSuppositions(supposition, proofSteps, substitutions) {
-  const suppositionsMatches = supposition.every((supposition) => {
+  const suppositionsMatch = supposition.every((supposition) => {
     const suppositionMatches = matchSupposition(supposition, proofSteps, substitutions);
 
     if (suppositionMatches) {
@@ -164,7 +164,7 @@ function matchSuppositions(supposition, proofSteps, substitutions) {
     }
   });
 
-  return suppositionsMatches;
+  return suppositionsMatch;
 }
 
 function matchConsequence(consequence, statementNode, substitutions) {
@@ -178,9 +178,9 @@ function matchSuppositionsAndConsequence(suppositions, consequence, proofSteps,
   let suppositionsMatchConsequence = false;
 
   const substitutions = [],
-        suppositionsMatches = matchSuppositions(suppositions, proofSteps, substitutions);
+        suppositionsMatch = matchSuppositions(suppositions, proofSteps, substitutions);
 
-  if (suppositionsMatches) {
+  if (suppositionsMatch) {
     const consequenceMatches = matchConsequence(consequence, statementNode, substitutions);
 
     suppositionsMatchConsequence = consequenceMatches;  ///

package/src/combinator.js

@@ -2,7 +2,7 @@
 
 import { nodeAsString } from "./utilities/string";
 import { COMBINATOR_KIND } from "./kinds";
-import { statementNodeFromStatementString } from "./utilities/string";
+import { statementNodeFromStatementString } from "./utilities/node";
 
 export default class Combinator {
   constructor(statementNode) {
@@ -35,10 +35,10 @@ export default class Combinator {
     return json;
   }
 
-  static fromJSON(json, releaseContext) {
+  static fromJSON(json, lexer, parser) {
     const { statement } = json,
           statementString = statement,  ///
-          statementNode = statementNodeFromStatementString(statementString, releaseContext),
+          statementNode = statementNodeFromStatementString(statementString, lexer, parser),
           combinator = new Combinator(statementNode);
 
     return combinator;

package/src/conclusion.js

@@ -1,9 +1,9 @@
 "use strict";
 
 import { nodeAsString } from "./utilities/string";
-import { metastatementNodeFromMetastatementString } from "./utilities/string";
-import { conclusionStatementForMetavariableMatcher } from "./matcher/statementForMetavariable/conclusion";
-import { conclusionMetastatementForMetavariableMatcher } from "./matcher/metastatementForMetavariable/conclusion";
+import { metastatementNodeFromMetastatementString } from "./utilities/node";
+import { conclusionStatementForMetavariableVerifier } from "./verifier/statementForMetavariable/conclusion";
+import { conclusionMetastatementForMetavariableVerifier } from "./verifier/metastatementForMetavariable/conclusion";
 
 export default class Conclusion {
   constructor(metastatementNode) {
@@ -17,7 +17,7 @@ export default class Conclusion {
   matchStatementNode(statementNode, substitutions) {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = statementNode,  ///
-          nonTerminalNodeMatches = conclusionStatementForMetavariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
+          nonTerminalNodeMatches = conclusionStatementForMetavariableVerifier.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
           statementNodeMatches = nonTerminalNodeMatches; ///
 
     return statementNodeMatches;
@@ -26,7 +26,7 @@ export default class Conclusion {
   matchMetastatementNode(metastatementNode, substitutions) {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = metastatementNode,  ///
-          nonTerminalNodeMatches = conclusionMetastatementForMetavariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
+          nonTerminalNodeMatches = conclusionMetastatementForMetavariableVerifier.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
           metastatementNodeMatches = nonTerminalNodeMatches; ///
 
     return metastatementNodeMatches;
@@ -42,10 +42,10 @@ export default class Conclusion {
     return json;
   }
 
-  static fromJSON(json, releaseContext) {
+  static fromJSON(json, lexer, parser) {
     const { metastatement } = json,
           metastatementString = metastatement,  ///
-          metastatementNode = metastatementNodeFromMetastatementString(metastatementString, releaseContext),
+          metastatementNode = metastatementNodeFromMetastatementString(metastatementString, lexer, parser),
           conclusion = new Conclusion(metastatementNode);
 
     return conclusion;

package/src/conjecture.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import AxiomLemmaTheoremConjecture from "./axiomLemmaTheoremConjecture";
+
+import { CONJECTURE_KIND } from "./kinds";
+
+export default class Conjecture extends AxiomLemmaTheoremConjecture {
+  static kind = CONJECTURE_KIND;
+
+  static fromJSON(json, lexer, parser) { return AxiomLemmaTheoremConjecture.fromJSON(Conjecture, json, lexer, parser); }
+
+  static fromLabelsSuppositionsAndConsequence(labels, suppositions, consequence) { return AxiomLemmaTheoremConjecture.fromLabelsSuppositionsAndConsequence(Conjecture, labels, suppositions, consequence); }
+}

package/src/consequence.js

@@ -1,8 +1,8 @@
 "use strict";
 
 import { nodeAsString } from "./utilities/string";
-import { statementNodeFromStatementString } from "./utilities/string";
-import { consequenceStatementForVariableMatcher } from "./matcher/statementForVariable/consequence";
+import { statementNodeFromStatementString } from "./utilities/node";
+import { consequenceTermForVariableVerifier } from "./verifier/termForVariable/consequence";
 
 export default class Consequence {
   constructor(statementNode) {
@@ -16,7 +16,7 @@ export default class Consequence {
   matchStatementNode(statementNode, substitutions) {
     const nonTerminalNodeA = this.statementNode,  ///
           nonTerminalNodeB = statementNode,  ///
-          nonTerminalNodeMatches = consequenceStatementForVariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
+          nonTerminalNodeMatches = consequenceTermForVariableVerifier.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
           statementNodeMatches = nonTerminalNodeMatches; ///
 
     return statementNodeMatches;
@@ -32,10 +32,10 @@ export default class Consequence {
     return json;
   }
 
-  static fromJSON(json, releaseContext) {
+  static fromJSON(json, lexer, parser) {
     const { statement } = json,
           statementString = statement,  ///
-          statementNode = statementNodeFromStatementString(statementString, releaseContext),
+          statementNode = statementNodeFromStatementString(statementString, lexer, parser),
           consequence = new Consequence(statementNode);
 
     return consequence;

package/src/constants.js

@@ -1,13 +1,9 @@
 "use strict";
 
 export const COMMA = ',';
-export const STRING = "string";
-export const NUMBER = "number";
-export const BOOLEAN = "boolean";
 export const EMPTY_STRING = "";
-export const LEFT_BRACKET = "(";
-export const RIGHT_BRACKET = ")";
-export const EQUALS_CHARACTER = "=";
+export const EQUALITY_DEPTH = 2;
 export const MAXIMUM_INDEXES_LENGTH = 10;
+export const BRACKETED_STATEMENT_DEPTH = 2;
 export const MAXIMUM_PERMUTATION_LENGTH = 5;
-export const BRACKETED_CHILD_NODES_LENGTH = 3;
+export const BRACKETED_METASTATEMENT_DEPTH = 1;

package/src/constructor.js

@@ -4,7 +4,7 @@ import Type from "./type";
 
 import { nodeAsString } from "./utilities/string";
 import { CONSTRUCTOR_KIND } from "./kinds";
-import { termNodeFromTermString } from "./utilities/string";
+import { termNodeFromTermString } from "./utilities/node";
 
 export default class Constructor {
   constructor(termNode, type) {
@@ -54,10 +54,10 @@ export default class Constructor {
     return json;
   }
 
-  static fromJSON(json, releaseContext) {
+  static fromJSON(json, lexer, parser) {
     const { term } = json,
           termString = term,  ///
-          termNode = termNodeFromTermString(termString, releaseContext);
+          termNode = termNodeFromTermString(termString, lexer, parser);
 
     let { type } = json;
 
@@ -66,7 +66,7 @@ export default class Constructor {
 
       json = typeJSON;  ///
 
-      type = Type.fromJSON(json, releaseContext);
+      type = Type.fromJSON(json, lexer, parser);
 
       const typeName = type.getName();
 

package/src/context/file.js

@@ -4,10 +4,9 @@ import { rewriteNodes } from "occam-grammar-utilities";
 
 import { push } from "../utilities/array";
 import { nodeAsString, nodesAsString } from "../utilities/string";
-import { leastLineIndexFromNodeAndTokens, greatestLineIndexFromNodeAndTokens } from "../utilities/tokens";
 
 export default class FileContext {
-  constructor(releaseContext, filePath, tokens, node, types, rules, axioms, lemmas, theorems, variables, combinators, constructors) {
+  constructor(releaseContext, filePath, tokens, node, types, rules, axioms, lemmas, theorems, conjectures, combinators, constructors, variables, metavariables) {
     this.releaseContext = releaseContext;
     this.filePath = filePath;
     this.tokens = tokens;
@@ -17,9 +16,11 @@ export default class FileContext {
     this.axioms = axioms;
     this.lemmas = lemmas;
     this.theorems = theorems;
-    this.variables = variables;
+    this.conjectures = conjectures;
     this.combinators = combinators;
     this.constructors = constructors;
+    this.variables = variables;
+    this.metavariables = metavariables;
   }
 
   getReleaseContext() {
@@ -38,8 +39,16 @@ export default class FileContext {
     return this.node;
   }
 
-  getVariables() {
-    return this.variables;
+  getProofSteps() {
+    const proofSteps = [];  ///
+
+    return proofSteps;
+  }
+
+  getMetaproofSteps() {
+    const metaproofSteps = [];  ///
+
+    return metaproofSteps;
   }
 
   getLabels(includeRelease = true) {
@@ -148,6 +157,20 @@ export default class FileContext {
     return theorems;
   }
 
+  getConjectures(includeRelease = true) {
+    const conjectures = [];
+
+    push(conjectures, this.conjectures);
+
+    if (includeRelease) {
+      const releaseContextConjectures = this.releaseContext.getConjectures();
+
+      push(conjectures, releaseContextConjectures);
+    }
+
+    return conjectures;
+  }
+
   getCombinators(includeRelease = true) {
     const combinators = [];
 
@@ -176,16 +199,12 @@ export default class FileContext {
     return constructors;
   }
 
-  getProofSteps() {
-    const proofSteps = [];  ///
-
-    return proofSteps;
+  getVariables() {
+    return this.variables;
   }
 
-  getMetaproofSteps() {
-    const metaproofSteps = [];  ///
-
-    return metaproofSteps;
+  getMetavariables() {
+    return this.metavariables;
   }
 
   findTypeByTypeName(typeName) {
@@ -271,18 +290,25 @@ export default class FileContext {
     return theorem;
   }
 
-  findVariableByVariableName(variableName) {
-    const name = variableName,  ///
-          variables = this.getVariables(),
-          variable = variables.find((variable) => {
-            const matches = variable.matchName(name);
+  findConjectureByReferenceName(referenceName) {
+    const labelName = referenceName,  ///
+          conjectures = this.getConjectures(),
+          conjecture = conjectures.find((conjecture) => {
+            const conjectureMatchesLabelName = conjecture.matchLabelName(labelName);
 
-            if (matches) {
+            if (conjectureMatchesLabelName) {
               return true;
             }
           }) || null;
 
-    return variable;
+    return conjecture;
+  }
+
+  isLabelPresentByLabelName(labelName) {
+    const label = this.findLabelByLabelName(labelName),
+          labelPresent = (label !== null);
+
+    return labelPresent;
   }
 
   isTypePresentByTypeName(typeName) {
@@ -292,11 +318,30 @@ export default class FileContext {
     return typePresent;
   }
 
-  isLabelPresentByLabelName(labelName) {
-    const label = this.findLabelByLabelName(labelName),
-          labelPresent = (label !== null);
+  nodeAsString(node) {
+    const string = nodeAsString(node, this.tokens);
 
-    return labelPresent;
+    return string;
+  }
+
+  nodesAsString(node) {
+    const string = nodesAsString(node, this.tokens);
+
+    return string;
+  }
+
+  findVariableByVariableName(variableName) {
+    const name = variableName,  ///
+          variables = this.getVariables(),
+          variable = variables.find((variable) => {
+            const matches = variable.matchName(name);
+
+            if (matches) {
+              return true;
+            }
+          }) || null;
+
+    return variable;
   }
 
   isVariablePresentByVariableName(variableName) {
@@ -344,50 +389,17 @@ export default class FileContext {
     this.constructors.push(constructor);
   }
 
-  nodeAsString(node) {
-    const string = nodeAsString(node, this.tokens);
-
-    return string;
-  }
-
-  nodesAsString(node) {
-    const string = nodesAsString(node, this.tokens);
+  trace(message, node) { this.releaseContext.trace(message, node, this.tokens, this.filePath); }
 
-    return string;
-  }
-
-  trace(message) { this.releaseContext.trace(message); }
+  debug(message, node) { this.releaseContext.debug(message, node, this.tokens, this.filePath); }
 
-  debug(message) { this.releaseContext.debug(message); }
+  info(message, node) { this.releaseContext.info(message, node, this.tokens, this.filePath); }
 
-  info(message) { this.releaseContext.info(message); }
+  warning(message, node) { this.releaseContext.warning(message, node, this.tokens, this.filePath); }
 
-  warning(message) { this.releaseContext.warning(message); }
+  error(message, node) { this.releaseContext.error(message, node, this.tokens, this.filePath); }
 
-  error(message) { this.releaseContext.error(message); }
-
-  fatal(message) { this.releaseContext.fatal(message); }
-
-  halt(node) {
-    const leastLineIndex = leastLineIndexFromNodeAndTokens(node, this.tokens),
-          greatestLineIndex = greatestLineIndexFromNodeAndTokens(node, this.tokens);
-
-    this.releaseContext.halt(this.filePath, leastLineIndex, greatestLineIndex);
-  }
-
-  begin(node) {
-    const leastLineIndex = leastLineIndexFromNodeAndTokens(node, this.tokens),
-          greatestLineIndex = greatestLineIndexFromNodeAndTokens(node, this.tokens);
-
-    this.releaseContext.begin(this.filePath, leastLineIndex, greatestLineIndex);
-  }
-
-  complete(node) {
-    const leastLineIndex = leastLineIndexFromNodeAndTokens(node, this.tokens),
-          greatestLineIndex = greatestLineIndexFromNodeAndTokens(node, this.tokens);
-
-    this.releaseContext.complete(this.filePath, leastLineIndex, greatestLineIndex);
-  }
+  fatal(message, node) { this.releaseContext.fatal(message, node, this.tokens, this.filePath); }
 
   toJSON() {
     const json = [];
@@ -422,6 +434,12 @@ export default class FileContext {
       json.push(theoremJSON);
     });
 
+    this.conjectures.forEach((conjecture) => {
+      const conjectureJSON = conjecture.toJSON(this.tokens);
+
+      json.push(conjectureJSON);
+    });
+
     this.combinators.forEach((combinator) => {
       const combinatorJSON = combinator.toJSON(this.tokens);
 
@@ -452,10 +470,12 @@ export default class FileContext {
           axioms = [],
           lemmas = [],
           theorems = [],
-          variables = [],
+          conjectures = [],
           combinators = [],
           constructors = [],
-          fileContext = new FileContext(releaseContext, filePath, tokens, node, types, rules, axioms, lemmas, theorems, variables, combinators, constructors);
+          variables = [],
+          metavariables = [],
+          fileContext = new FileContext(releaseContext, filePath, tokens, node, types, rules, axioms, lemmas, theorems, conjectures, combinators, constructors, variables, metavariables);
 
     return fileContext;
   }

package/src/context/metaproof.js

@@ -2,13 +2,13 @@
 
 import fileMixins from "../mixins/file";
 import loggingMixins from "../mixins/logging";
-import callbacksMixins from "../mixins/callbacks";
 
-import { last } from "../utilities/array";
+import { push, last } from "../utilities/array";
 
 class MetaproofContext {
-  constructor(context, metaproofSteps) {
+  constructor(context, metavariables, metaproofSteps) {
     this.context = context;
+    this.metavariables = metavariables;
     this.metaproofSteps = metaproofSteps;
   }
 
@@ -16,6 +16,20 @@ class MetaproofContext {
     return this.context;
   }
 
+  getVariables() { return this.context.getVariables(); }
+
+  getMetavariables() {
+    const metavariables = [];
+
+    push(metavariables, this.metavariables);
+
+    const contextMetavariables = this.context.getMetavariables();
+
+    push(metavariables, contextMetavariables);
+
+    return metavariables;
+  }
+
   getMetaproofSteps() {
     let metaproofSteps = this.context.getMetaproofSteps();
 
@@ -39,20 +53,28 @@ class MetaproofContext {
     return lastMetaproofStep;
   }
 
+  addMetavariable(metavariable) {
+    this.metavariables.push(metavariable);
+  }
+
   addMetaproofStep(metaproofStep) {
     this.metaproofSteps.push(metaproofStep);
   }
 
   matchMetastatement(metastatementNode) {
-    let metastatementMatches;
+    let metastatementMatches = false;
 
-    metastatementMatches = this.metaproofSteps.some((metaproofStep) => {
-      metastatementMatches = metaproofStep.matchMetastatement(metastatementNode);
+    if (!metastatementMatches) {
+      const proofStepMatchesMetastatement = this.metaproofSteps.some((metaproofStep) => {
+        const proofStepMatchesMetastatement = metaproofStep.match(metastatementNode);
+
+        if (proofStepMatchesMetastatement) {
+          return true;
+        }
+      });
 
-      if (metastatementMatches) {
-        return true;
-      }
-    });
+      metastatementMatches = proofStepMatchesMetastatement; ///
+    }
 
     if (!metastatementMatches) {
       metastatementMatches = this.context.matchMetastatement(metastatementNode);
@@ -61,23 +83,42 @@ class MetaproofContext {
     return metastatementMatches;
   }
 
-  nodeAsString(node) { return this.context.nodeAsString(node); }
+  findMetavariableByMetavariableName(metavariableName) {
+    const name = metavariableName,  ///
+          metavariables = this.getMetavariables(),
+          metavariable = metavariables.find((metavariable) => {
+            const matches = metavariable.matchName(name);
+
+            if (matches) {
+              return true;
+            }
+          }) || null;
+
+    return metavariable;
+  }
+
+  isMetavariablePresentByVariableName(metavariableName) {
+    const metavariable = this.findMetavariableByMetavariableName(metavariableName),
+          metavariablePresent = (metavariable !== null);
 
-  nodesAsString(node) { return this.context.nodesAsString(node); }
+    return metavariablePresent;
+  }
 
   static fromFileContext(fileContext) {
     const context = fileContext,  ///
+          metavariables = [],
           metaproofSteps = [],
-          metaproofContext = new MetaproofContext(context, metaproofSteps);
+          metaproofContext = new MetaproofContext(context, metavariables, metaproofSteps);
 
     return metaproofContext;
   }
 
   static fromMetaproofContext(metaproofContext) {
     const context = metaproofContext,  ///
+          metavariables = [],
           metaproofSteps = [];
 
-    metaproofContext = new MetaproofContext(context, metaproofSteps);  ///
+    metaproofContext = new MetaproofContext(context, metavariables, metaproofSteps);  ///
 
     return metaproofContext;
   }
@@ -85,6 +126,5 @@ class MetaproofContext {
 
 Object.assign(MetaproofContext.prototype, fileMixins);
 Object.assign(MetaproofContext.prototype, loggingMixins);
-Object.assign(MetaproofContext.prototype, callbacksMixins);
 
 export default MetaproofContext;