occam-verify-cli 0.0.525 → 0.0.527

package/src/constructor.js

@@ -20,16 +20,16 @@ export default class Constructor {
     return this.type;
   }
 
-  asString() {
+  asString(tokens) {
     let string;
 
-    const termString = nodeAsString(this.termNode);
+    const termString = nodeAsString(this.termNode, tokens);
 
     if (this.type === null) {
       string = `${termString}`;
     } else {
       const noSuperType = true,
-            typeString = this.type.asString(noSuperType);
+            typeString = this.type.asString(tokens, noSuperType);
 
       string = `${termString}:${typeString}`;
     }
@@ -37,11 +37,11 @@ export default class Constructor {
     return string;
   }
 
-  toJSON() {
-    const termString = nodeAsString(this.termNode),
+  toJSON(tokens) {
+    const termString = nodeAsString(this.termNode, tokens),
           typeJSON = (this.type === null) ?
                         null :
-                          this.type.toJSON(),
+                          this.type.toJSON(tokens),
           kind = CONSTRUCTOR_KIND,
           term = termString,  ///
           type = typeJSON,  ///

package/src/context/file.js

@@ -3,22 +3,27 @@
 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;
     this.node = node;
+
     this.types = types;
     this.rules = rules;
     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() {
@@ -37,8 +42,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) {
@@ -147,6 +160,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 = [];
 
@@ -175,16 +202,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) {
@@ -270,18 +293,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) {
@@ -291,11 +321,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) {
@@ -380,43 +429,49 @@ export default class FileContext {
     const json = [];
 
     this.types.forEach((type) => {
-      const typeJSON = type.toJSON();
+      const typeJSON = type.toJSON(this.tokens);
 
       json.push(typeJSON);
     });
 
     this.rules.forEach((rule) => {
-      const ruleJSON = rule.toJSON();
+      const ruleJSON = rule.toJSON(this.tokens);
 
       json.push(ruleJSON);
     });
 
     this.axioms.forEach((axiom) => {
-      const axiomJSON = axiom.toJSON();
+      const axiomJSON = axiom.toJSON(this.tokens);
 
       json.push(axiomJSON);
     });
 
     this.lemmas.forEach((lemma) => {
-      const lemmaJSON = lemma.toJSON();
+      const lemmaJSON = lemma.toJSON(this.tokens);
 
       json.push(lemmaJSON);
     });
 
     this.theorems.forEach((theorem) => {
-      const theoremJSON = theorem.toJSON();
+      const theoremJSON = theorem.toJSON(this.tokens);
 
       json.push(theoremJSON);
     });
 
+    this.conjectures.forEach((conjecture) => {
+      const conjectureJSON = conjecture.toJSON(this.tokens);
+
+      json.push(conjectureJSON);
+    });
+
     this.combinators.forEach((combinator) => {
-      const combinatorJSON = combinator.toJSON();
+      const combinatorJSON = combinator.toJSON(this.tokens);
 
       json.push(combinatorJSON);
     });
 
     this.constructors.forEach((constructor) => {
-      const constructorJSON = constructor.toJSON();
+      const constructorJSON = constructor.toJSON(this.tokens);
 
       json.push(constructorJSON)
     });
@@ -439,10 +494,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

@@ -4,11 +4,12 @@ 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 +17,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,6 +54,10 @@ class MetaproofContext {
     return lastMetaproofStep;
   }
 
+  addMetavariable(metavariable) {
+    this.metavariables.push(metavariable);
+  }
+
   addMetaproofStep(metaproofStep) {
     this.metaproofSteps.push(metaproofStep);
   }
@@ -61,6 +80,27 @@ class MetaproofContext {
     return metastatementMatches;
   }
 
+  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);
+
+    return metavariablePresent;
+  }
+
   static fromFileContext(fileContext) {
     const context = fileContext,  ///
           metaproofSteps = [],
@@ -71,9 +111,10 @@ class MetaproofContext {
 
   static fromMetaproofContext(metaproofContext) {
     const context = metaproofContext,  ///
+          metavariables = [],
           metaproofSteps = [];
 
-    metaproofContext = new MetaproofContext(context, metaproofSteps);  ///
+    metaproofContext = new MetaproofContext(context, metavariables, metaproofSteps);  ///
 
     return metaproofContext;
   }

package/src/context/proof.js

@@ -1,10 +1,12 @@
 "use strict";
 
+import Equality from "../equality";
 import fileMixins from "../mixins/file";
 import loggingMixins from "../mixins/logging";
 import callbacksMixins from "../mixins/callbacks";
 
 import { push, last } from "../utilities/array";
+import { MAXIMUM_INDEXES_LENGTH } from "../constants";
 
 class ProofContext {
   constructor(context, variables, proofSteps) {
@@ -17,6 +19,18 @@ class ProofContext {
     return this.context;
   }
 
+  getVariables() {
+    const variables = [];
+
+    push(variables, this.variables);
+
+    const contextVariables = this.context.getVariables();
+
+    push(variables, contextVariables);
+
+    return variables;
+  }
+
   getProofSteps() {
     let proofSteps = this.context.getProofSteps();
 
@@ -28,34 +42,34 @@ class ProofContext {
     return proofSteps;
   }
 
-  getTypes() { return this.context.getTypes(); }
-
-  getAxioms() { return this.context.getAxioms(); }
-
-  getLemmas() { return this.context.getLemmas(); }
-
-  getTheorems() { return this.context.getTheorems(); }
-
-  getCombinators() { return this.context.getCombinators(); }
+  getLastProofStep() {
+    let lastProofStep = null;
 
-  getConstructors() { return this.context.getConstructors(); }
+    const proofStepsLength = this.proofSteps.length;
 
-  getVariables() {
-    const variables = [];
+    if (proofStepsLength > 0) {
+      lastProofStep = last(this.proofSteps);
+    }
 
-    push(variables, this.variables);
+    return lastProofStep;
+  }
 
-    const contextVariables = this.context.getVariables();
+  getMetavariables() { return this.context.getMetavariables(); }
 
-    push(variables, contextVariables);
+  getEqualities() {
+    const equalities = [],
+          start = -MAXIMUM_INDEXES_LENGTH,  ///
+          proofSteps = this.proofSteps.slice(start); ///
 
-    return variables;
-  }
+    proofSteps.forEach((proofStep) => {
+      const equality = Equality.fromProofStep(proofStep);
 
-  getLastProofStep() {
-    const lastProofStep = last(this.proofSteps);
+      if (equality !== null) {
+        equalities.push(equality);
+      }
+    });
 
-    return lastProofStep;
+    return equalities;
   }
 
   addVariable(variable) {
@@ -100,27 +114,11 @@ class ProofContext {
 
   isVariablePresentByVariableName(variableName) {
     const variable = this.findVariableByVariableName(variableName),
-        variablePresent = (variable !== null);
+          variablePresent = (variable !== null);
 
     return variablePresent;
   }
 
-  findTypeByTypeName(typeName) { return this.context.findTypeByTypeName(typeName); }
-
-  findLabelByTypeName(labelName) { return this.context.findLabelByTypeName(labelName); }
-
-  findRuleByReferenceName(referenceName) { return this.context.findRuleByReferenceName(referenceName); }
-
-  findAxiomByReferenceName(referenceName) { return this.context.findAxiomByReferenceName(referenceName); }
-
-  findLemmaByReferenceName(referenceName) { return this.context.findLemmaByReferenceName(referenceName); }
-
-  findTheoremByReferenceName(referenceName) { return this.context.findTheoremByReferenceName(referenceName); }
-
-  isLabelPresentByLabelName(labelName) { return this.context.isLabelPresentByLabelName(labelName); }
-
-  isTypePresentByTypeName(typeName) { return this.context.isTypePresentByTypeName(typeName); }
-
   static fromFileContext(fileContext) {
     const context = fileContext,  ///
           variables = [],
@@ -146,3 +144,10 @@ Object.assign(ProofContext.prototype, loggingMixins);
 Object.assign(ProofContext.prototype, callbacksMixins);
 
 export default ProofContext;
+
+function equalitiesFromProofSteps(proofSteps, context) {
+  let equalities = [];
+
+
+  return equalities;
+}

package/src/context/release/directory.js

@@ -149,6 +149,30 @@ export default class DirectoryReleaseContext extends ReleaseContext {
     return theorems;
   }
 
+  getConjectures(includeDependencies = true) {
+    const conjectures = [];
+
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextConjectures = fileContext.getConjectures(includeRelease);
+
+      push(conjectures, fileContextConjectures);
+    });
+
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextConjectures = releaseContext.getConjectures(includeDependencies);
+
+        push(conjectures, releaseContextConjectures);
+      });
+    }
+
+    return conjectures;
+  }
+
   getCombinators(includeDependencies = true) {
     const combinators = [];
 

package/src/context/release/file.js

@@ -9,15 +9,16 @@ import Type from "../../type";
 import Axiom from "../../axiom";
 import Lemma from "../../lemma";
 import Theorem from "../../theorem";
+import Conjecture from "../../conjecture";
 import Combinator from "../../combinator";
 import Constructor from "../../constructor";
 
 import { push } from "../../utilities/array";
 import { customGrammarFromNameAndEntries } from "../../utilities/customGrammar";
-import { RULE_KIND, TYPE_KIND, AXIOM_KIND, LEMMA_KIND, THEOREM_KIND, COMBINATOR_KIND, CONSTRUCTOR_KIND } from "../../kinds";
+import { RULE_KIND, TYPE_KIND, AXIOM_KIND, LEMMA_KIND, THEOREM_KIND, CONJECTURE_KIND, COMBINATOR_KIND, CONSTRUCTOR_KIND } from "../../kinds";
 
 export default class FileReleaseContext extends ReleaseContext {
-  constructor(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts, contextJSON, types, rules, axioms, lemmas, theorems, combinators, constructors) {
+  constructor(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts, contextJSON, types, rules, axioms, lemmas, theorems, conjectures, combinators, constructors) {
     super(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts);
 
     this.types = types;
@@ -25,8 +26,10 @@ export default class FileReleaseContext extends ReleaseContext {
     this.axioms = axioms;
     this.lemmas = lemmas;
     this.theorems = theorems;
+    this.conjectures = conjectures;
     this.combinators = combinators;
     this.constructors = constructors;
+
     this.contextJSON = contextJSON;
   }
 
@@ -153,6 +156,25 @@ export default class FileReleaseContext extends ReleaseContext {
     return theorems;
   }
 
+  getConjectures(includeDependencies = true) {
+    const conjectures = [];
+
+    push(conjectures, this.conjectures);
+
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextConjectures = releaseContext.getConjectures(includeDependencies);
+
+        push(conjectures, releaseContextConjectures);
+      });
+    }
+
+    return conjectures;
+  }
+
   getCombinators(includeDependencies = true) {
     const combinators = [];
 
@@ -252,6 +274,14 @@ export default class FileReleaseContext extends ReleaseContext {
           break;
         }
 
+        case CONJECTURE_KIND: {
+          const conjecture = Conjecture.fromJSON(json, releaseContext);
+
+          this.conjectures.push(conjecture);
+
+          break;
+        }
+
         case COMBINATOR_KIND: {
           const combinator = Combinator.fromJSON(json, releaseContext);
 
@@ -288,9 +318,10 @@ export default class FileReleaseContext extends ReleaseContext {
           axioms = [],
           lemmas = [],
           theorems = [],
+          conjectures = [],
           combinators = [],
           constructors = [],
-          releaseContext = new FileReleaseContext(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts, contextJSON, types, rules, axioms, lemmas, theorems, combinators, constructors);
+          releaseContext = new FileReleaseContext(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts, contextJSON, types, rules, axioms, lemmas, theorems, conjectures, combinators, constructors);
 
     return releaseContext;
   }