occam-verify-cli 0.0.864 → 0.0.866

package/src/context/file.js

@@ -5,23 +5,21 @@ import Axiom from "../axiom";
 import Lemma from "../lemma";
 import Theorem from "../theorem";
 import Variable from "../variable";
+import metaTypes from "../metaTypes";
+import MetaLemma from "../metaLemma";
 import Conjecture from "../conjecture";
 import Combinator from "../combinator";
 import Constructor from "../constructor";
+import Metatheorem from "../metatheorem";
 import Metavariable from "../metavariable";
 
 import { push } from "../utilities/array";
 import { objectType } from "../type";
-import { statementMetaType } from "../metaType";
 import { typeFromJSONAndFileContext } from "../type";
 import { nodeAsString, nodesAsString } from "../utilities/string";
 
-const metaTypes = [
-  statementMetaType
-];
-
 export default class FileContext {
-  constructor(releaseContext, filePath, tokens, node, types, rules, axioms, lemmas, theorems, variables, conjectures, combinators, constructors, metavariables) {
+  constructor(releaseContext, filePath, tokens, node, types, rules, axioms, lemmas, theorems, variables, metaLemmas, conjectures, combinators, constructors, metatheorems, metavariables) {
     this.releaseContext = releaseContext;
     this.filePath = filePath;
     this.tokens = tokens;
@@ -32,9 +30,11 @@ export default class FileContext {
     this.lemmas = lemmas;
     this.theorems = theorems;
     this.variables = variables;
+    this.metaLemmas = metaLemmas;
     this.conjectures = conjectures;
     this.combinators = combinators;
     this.constructors = constructors;
+    this.metatheorems = metatheorems;
     this.metavariables = metavariables;
   }
 
@@ -198,6 +198,20 @@ export default class FileContext {
     return this.variables;
   }
 
+  getMetaLemmas(includeRelease = true) {
+    const metaLemmas = [];
+
+    push(metaLemmas, this.metaLemmas);
+
+    if (includeRelease) {
+      const releaseContextMetaLemmas = this.releaseContext.getMetaLemmas();
+
+      push(metaLemmas, releaseContextMetaLemmas);
+    }
+
+    return metaLemmas;
+  }
+
   getMetaTypes(includeRelease = true) {
     return metaTypes;
   }
@@ -244,31 +258,47 @@ export default class FileContext {
     return constructors;
   }
 
+  getMetatheorems(includeRelease = true) {
+    const metatheorems = [];
+
+    push(metatheorems, this.metatheorems);
+
+    if (includeRelease) {
+      const releaseContextMetatheorems = this.releaseContext.getMetatheorems();
+
+      push(metatheorems, releaseContextMetatheorems);
+    }
+
+    return metatheorems;
+  }
+
   getMetavariables(includeRelease = true) {
     return this.metavariables;
   }
 
-  findLabelByLabelName(labelName) {
-    const name = labelName,  ///
-          labels = this.getLabels(),
-          label = labels.find((label) => {
-            const matches = label.matchName(name);
+  findTypeByTypeName(typeName) {
+    let types = this.getTypes();
 
-            if (matches) {
-              return true;
-            }
-          }) || null;
+    types.push(objectType);
 
-    return label;
+    const type = types.find((type) => {
+      const matches = type.matchTypeName(typeName);
+
+      if (matches) {
+        return true;
+      }
+    }) || null;
+
+    return type;
   }
 
-  findTypeByTypeName(typeName) {
+  findTypeByTypeNode(typeNode) {
     let types = this.getTypes();
 
     types.push(objectType);
 
     const type = types.find((type) => {
-      const matches = type.matchTypeName(typeName);
+      const matches = type.matchTypeNode(typeNode);
 
       if (matches) {
         return true;
@@ -278,13 +308,27 @@ export default class FileContext {
     return type;
   }
 
-  findRuleByReferenceName(referenceName) {
-    const labelName = referenceName,  ///
+  findLabelByLabelNode(labelNode) {
+    const name = labelNode,  ///
+          labels = this.getLabels(),
+          label = labels.find((label) => {
+            const matches = label.matchNode(name);
+
+            if (matches) {
+              return true;
+            }
+          }) || null;
+
+    return label;
+  }
+
+  findRuleByReferenceNode(referenceNode) {
+    const labelNode = referenceNode,  ///
           rules = this.getRules(),
           rule = rules.find((rule) => {
-            const ruleMatchesLabelName = rule.matchLabelName(labelName);
+            const ruleMatchesLabelNode = rule.matchLabelNode(labelNode);
 
-            if (ruleMatchesLabelName) {
+            if (ruleMatchesLabelNode) {
               return true;
             }
           }) || null;
@@ -292,13 +336,13 @@ export default class FileContext {
     return rule;
   }
 
-  findAxiomByReferenceName(referenceName) {
-    const labelName = referenceName,  ///
+  findAxiomByReferenceNode(referenceNode) {
+    const labelNode = referenceNode,  ///
           axioms = this.getAxioms(),
           axiom = axioms.find((axiom) => {
-            const axiomMatchesLabelName = axiom.matchLabelName(labelName);
+            const axiomMatchesLabelNode = axiom.matchLabelNode(labelNode);
 
-            if (axiomMatchesLabelName) {
+            if (axiomMatchesLabelNode) {
               return true;
             }
           }) || null;
@@ -306,13 +350,13 @@ export default class FileContext {
     return axiom;
   }
 
-  findLemmaByReferenceName(referenceName) {
-    const labelName = referenceName,  ///
+  findLemmaByReferenceNode(referenceNode) {
+    const labelNode = referenceNode,  ///
           lemmas = this.getLemmas(),
           lemma = lemmas.find((lemma) => {
-            const lemmaMatchesLabelName = lemma.matchLabelName(labelName);
+            const lemmaMatchesLabelNode = lemma.matchLabelNode(labelNode);
 
-            if (lemmaMatchesLabelName) {
+            if (lemmaMatchesLabelNode) {
               return true;
             }
           }) || null;
@@ -320,13 +364,13 @@ export default class FileContext {
     return lemma;
   }
 
-  findTheoremByReferenceName(referenceName) {
-    const labelName = referenceName,  ///
+  findTheoremByReferenceNode(referenceNode) {
+    const labelNode = referenceNode,  ///
           theorems = this.getTheorems(),
           theorem = theorems.find((theorem) => {
-            const theoremMatchesLabelName = theorem.matchLabelName(labelName);
+            const theoremMatchesLabelNode = theorem.matchLabelNode(labelNode);
 
-            if (theoremMatchesLabelName) {
+            if (theoremMatchesLabelNode) {
               return true;
             }
           }) || null;
@@ -334,6 +378,20 @@ export default class FileContext {
     return theorem;
   }
 
+  findMetaLemmaByReferenceNode(referenceNode) {
+    const labelNode = referenceNode,  ///
+          metaLemmas = this.getMetaLemmas(),
+          metaLemma = metaLemmas.find((metaLemma) => {
+            const metaLemmaMatchesLabelNode = metaLemma.matchLabelNode(labelNode);
+
+            if (metaLemmaMatchesLabelNode) {
+              return true;
+            }
+          }) || null;
+
+    return metaLemma;
+  }
+
   findVariableByVariableNode(variableNode) {
     const node = variableNode,  ///
           variables = this.getVariables(),
@@ -348,10 +406,10 @@ export default class FileContext {
     return variable;
   }
 
-  findMetaTypeByMetaTypeName(metaTypeName) {
+  findMetaTypeByMetaTypeNode(metaTypeNode) {
     const metaTypes = this.getMetaTypes(),
           metaType = metaTypes.find((metaType) => {
-            const matches = metaType.matchMetaTypeName(metaTypeName);
+            const matches = metaType.matchMetaTypeNode(metaTypeNode);
 
             if (matches) {
               return true;
@@ -361,13 +419,13 @@ export default class FileContext {
     return metaType;
   }
 
-  findConjectureByReferenceName(referenceName) {
-    const labelName = referenceName,  ///
+  findConjectureByReferenceNode(referenceNode) {
+    const labelNode = referenceNode,  ///
           conjectures = this.getConjectures(),
           conjecture = conjectures.find((conjecture) => {
-            const conjectureMatchesLabelName = conjecture.matchLabelName(labelName);
+            const conjectureMatchesLabelNode = conjecture.matchLabelNode(labelNode);
 
-            if (conjectureMatchesLabelName) {
+            if (conjectureMatchesLabelNode) {
               return true;
             }
           }) || null;
@@ -389,16 +447,18 @@ export default class FileContext {
     return metavariable;
   }
 
-  isTermGrounded(term) {
-    const termGrounded = false; ///
-
-    return termGrounded;
-  }
+  findMetatheoremByReferenceNode(referenceNode) {
+    const labelNode = referenceNode,  ///
+          metatheorems = this.getMetatheorems(),
+          metatheorem = metatheorems.find((metatheorem) => {
+            const metatheoremMatchesLabelNode = metatheorem.matchLabelNode(labelNode);
 
-  isVariableDefined(variable) {
-    const variableDefined = false;  ///
+            if (metatheoremMatchesLabelNode) {
+              return true;
+            }
+          }) || null;
 
-    return variableDefined;
+    return metatheorem;
   }
 
   isTypePresentByTypeName(typeName) {
@@ -408,8 +468,15 @@ export default class FileContext {
     return typePresent;
   }
 
-  isLabelPresentByLabelName(labelName) {
-    const label = this.findLabelByLabelName(labelName),
+  isTypePresentByTypeNode(typeNode) {
+    const type = this.findTypeByTypeNode(typeNode),
+          typePresent = (type !== null);
+
+    return typePresent;
+  }
+
+  isLabelPresentByLabelNode(labelNode) {
+    const label = this.findLabelByLabelNode(labelNode),
           labelPresent = (label !== null);
 
     return labelPresent;
@@ -429,6 +496,18 @@ export default class FileContext {
     return metavariablePresent;
   }
 
+  isTermGrounded(term) {
+    const termGrounded = false; ///
+
+    return termGrounded;
+  }
+
+  isVariableDefined(variable) {
+    const variableDefined = false;  ///
+
+    return variableDefined;
+  }
+
   matchStatement(statementNode) {
     const statementMatches = false;
 
@@ -488,6 +567,10 @@ export default class FileContext {
     return variableAdded;
   }
 
+  addMetaLemma(metaLemma) {
+    this.metaLemmas.push(metaLemma);
+  }
+
   addConjecture(conjecture) {
     this.conjectures.push(conjecture);
   }
@@ -500,6 +583,10 @@ export default class FileContext {
     this.constructors.push(constructor);
   }
 
+  addMetatheorem(metatheorem) {
+    this.metatheorems.push(metatheorem);
+  }
+
   addMetavariable(metavariable) {
     let metavariableAdded = false;
 
@@ -577,6 +664,13 @@ export default class FileContext {
 
             return variable;
           }),
+          metaLemmas = this.metaLemmas.map((metaLemma) => {
+            const metaLemmaJSON = metaLemma.toJSON(this.tokens);
+
+            metaLemma = metaLemmaJSON; ///
+
+            return metaLemma;
+          }),
           conjectures = this.conjectures.map((conjecture) => {
             const conjectureJSON = conjecture.toJSON(this.tokens);
 
@@ -598,6 +692,13 @@ export default class FileContext {
 
             return constructor;
           }),
+          metatheorems = this.metatheorems.map((metatheorem) => {
+            const metatheoremJSON = metatheorem.toJSON(this.tokens);
+
+            metatheorem = metatheoremJSON; ///
+
+            return metatheorem;
+          }),
           metavariables = this.metavariables.map((metavariable) => {
             const metavariableJSON = metavariable.toJSON(this.tokens);
 
@@ -613,9 +714,11 @@ export default class FileContext {
             lemmas,
             theorems,
             variables,
+            metaLemmas,
             conjectures,
             combinators,
             constructors,
+            metatheorems,
             metavariables
           };
 
@@ -623,27 +726,20 @@ export default class FileContext {
   }
 
   initialise(json) {
-    const fileContext = this, ///
-          { types,
-            rules,
-            axioms,
-            lemmas,
-            theorems,
-            variables,
-            conjectures,
-            combinators,
-            constructors,
-            metavariables } = json,
-          typesJSON = types,
-          rulesJSON = rules,
-          axiomsJSON = axioms,
-          lemmasJSON = lemmas,
-          theoremsJSON = theorems,
-          variablesJSON = variables,
-          conjecturesJSON = conjectures,
-          combinatorsJSON = combinators,
-          constructorsJSON = constructors,
-          metavariablesJSON = metavariables;
+    const { types, rules, axioms, lemmas, theorems, metaLemmas, variables, conjectures, combinators, constructors, metatheorems, metavariables } = json,
+          fileContext = this, ///
+          typesJSON = types,  ///
+          rulesJSON = rules,  ///
+          axiomsJSON = axioms,  ///
+          lemmasJSON = lemmas,  ///
+          theoremsJSON = theorems,  ///
+          variablesJSON = variables,  ///
+          metaLemmasJSON = metaLemmas || [],  ///
+          conjecturesJSON = conjectures,  ///
+          combinatorsJSON = combinators,  ///
+          constructorsJSON = constructors,  ///
+          metatheoremsJSON = metatheorems || [],  ///
+          metavariablesJSON = metavariables;  ///
 
     typesJSON.forEach((typeJSON) => {
       const json = typeJSON,  ///
@@ -687,6 +783,13 @@ export default class FileContext {
       this.variables.push(variable);
     });
 
+    metaLemmasJSON.forEach((metaLemmaJSON) => {
+      const json = metaLemmaJSON,  ///
+            metaLemma = MetaLemma.fromJSONAndFileContext(json, fileContext);
+
+      this.metaLemmas.push(metaLemma);
+    });
+
     conjecturesJSON.forEach((conjectureJSON) => {
       const json = conjectureJSON,  ///
             conjecture = Conjecture.fromJSONAndFileContext(json, fileContext);
@@ -708,6 +811,13 @@ export default class FileContext {
       this.constructors.push(constructor);
     });
 
+    metatheoremsJSON.forEach((metatheoremJSON) => {
+      const json = metatheoremJSON,  ///
+            metatheorem = Metatheorem.fromJSONAndFileContext(json, fileContext);
+
+      this.metatheorems.push(metatheorem);
+    });
+
     metavariablesJSON.forEach((metavariableJSON) => {
       const json = metavariableJSON,  ///
             metavariable = Metavariable.fromJSONAndFileContext(json, fileContext);
@@ -726,11 +836,13 @@ export default class FileContext {
           lemmas = [],
           theorems = [],
           variables = [],
+          metaLemmas = [],
           conjectures = [],
           combinators = [],
           constructors = [],
+          metatheorems = [],
           metavariables = [],
-          fileContext = new FileContext(releaseContext, filePath, tokens, node, types, rules, axioms, lemmas, variables, theorems, conjectures, combinators, constructors, metavariables);
+          fileContext = new FileContext(releaseContext, filePath, tokens, node, types, rules, axioms, lemmas, metaLemmas, variables, theorems, conjectures, combinators, constructors, metatheorems, metavariables);
 
     fileContext.initialise(json);
 
@@ -748,11 +860,13 @@ export default class FileContext {
           lemmas = [],
           theorems = [],
           variables = [],
+          metaLemmas = [],
           conjectures = [],
           combinators = [],
           constructors = [],
+          metatheorems = [],
           metavariables = [],
-          fileContext = new FileContext(releaseContext, filePath, tokens, node, types, rules, axioms, lemmas, variables, theorems, conjectures, combinators, constructors, metavariables);
+          fileContext = new FileContext(releaseContext, filePath, tokens, node, types, rules, axioms, lemmas, variables, metaLemmas, theorems, conjectures, combinators, constructors, metatheorems, metavariables);
 
     return fileContext;
   }

package/src/context/local.js

@@ -253,7 +253,7 @@ class LocalContext {
     return variable;
   }
 
-  findMetaTypeByMetaTypeName(metaTypeName) { return this.context.findMetaTypeByMetaTypeName(metaTypeName); }
+  findMetaTypeByMetaTypeNode(metaTypeNode) { return this.context.findMetaTypeByMetaTypeNode(metaTypeNode); }
 
   isVariablePresentByVariableNode(variableNode) {
     const variable = this.findVariableByVariableNode(variableNode),

package/src/context/release.js

@@ -198,6 +198,19 @@ export default class ReleaseContext {
     return theorems;
   }
 
+  getMetaLemmas(includeDependencies = true) {
+    const metaLemmas = [];
+
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextMetaLemmas = fileContext.getMetaLemmas(includeRelease);
+
+      push(metaLemmas, fileContextMetaLemmas);
+    });
+
+    return metaLemmas;
+  }
+
   getConjectures(includeDependencies = true) {
     const conjectures = [];
 
@@ -270,6 +283,30 @@ export default class ReleaseContext {
     return constructors;
   }
 
+  getMetatheorems(includeDependencies = true) {
+    const metatheorems = [];
+
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextMetatheorems = fileContext.getMetatheorems(includeRelease);
+
+      push(metatheorems, fileContextMetatheorems);
+    });
+
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextMetatheorems = releaseContext.getMetatheorems(includeDependencies);
+
+        push(metatheorems, releaseContextMetatheorems);
+      });
+    }
+
+    return metatheorems;
+  }
+
   addFileContext(fileContext) {
     this.fileContexts.push(fileContext);
   }

package/src/label.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import { nodeAsString } from "./utilities/string";
-import { labelNameFromLabelNode } from "./utilities/query";
+import { labelNameFromLabelNode } from "./utilities/name";
 import { labelNodeFromLabelString } from "./utilities/node";
 
 export default class Label {
@@ -13,12 +13,10 @@ export default class Label {
     return this.node;
   }
 
-  matchName(name) {
-    const labelNode = this.node,
-          labelName = labelNameFromLabelNode(labelNode),
-          matchesName = (labelName === name);
+  matchNode(node) {
+    const matches = this.node.match(node);
 
-    return matchesName;
+    return matches;
   }
 
   asString(tokens) {

package/src/metaConsequent.js

@@ -0,0 +1,58 @@
+"use strict";
+
+import metaLevelNodesVerifier from "./verifier/nodes/metaLevel";
+
+import { nodeAsString } from "./utilities/string";
+import { metastatementNodeFromMetastatementString } from "./utilities/node";
+
+export default class MetaConsequent {
+  constructor(metastatementNode) {
+    this.metastatementNode = metastatementNode;
+  }
+
+  getMetastatementNode() {
+    return this.metastatementNode;
+  }
+
+  matchMetastatementNode(metastatementNode, substitutions, localContext, metastatementLocalContext) {
+    const nonTerminalNodeA = this.metastatementNode,  ///
+          nonTerminalNodeB = metastatementNode,  ///
+          localContextA = localContext, ///
+          localContextB = metastatementLocalContext, ///
+          nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+            const verifiedAhead = true;
+
+            return verifiedAhead;
+          }),
+          metastatementNodeMatches = nonTerminalNodeVerified; ///
+
+    return metastatementNodeMatches;
+  }
+
+  toJSON(tokens) {
+    const metastatementString = nodeAsString(this.metastatementNode, tokens),
+          metastatement = metastatementString,  ///
+          json = {
+            metastatement
+          };
+
+    return json;
+  }
+
+  static fromMetastatementNode(metastatementNode) {
+    const metaConsequent = new MetaConsequent(metastatementNode);
+
+    return metaConsequent;
+  }
+
+  static fromJSONAndFileContext(json, fileContext) {
+    const { metastatement } = json,
+          metastatementString = metastatement,  ///
+          lexer = fileContext.getLexer(),
+          parser = fileContext.getParser(),
+          metastatementNode = metastatementNodeFromMetastatementString(metastatementString, lexer, parser),
+          metaConsequent = new MetaConsequent(metastatementNode);
+
+    return metaConsequent;
+  }
+}

package/src/metaLemma.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import MetalemmaMetatheorem from "./metalemmaMetatheorem";
+
+export default class MetaLemma extends MetalemmaMetatheorem {
+  static fromJSONAndFileContext(json, fileContext) { return MetalemmaMetatheorem.fromJSONAndFileContext(MetaLemma, json, fileContext); }
+
+  static fromLabelsMetaSuppositionsMetaConsequentAndLocalMetaContext(labels, suppositions, consequent, localMetaContext) { return MetalemmaMetatheorem.fromLabelsMetaSuppositionsMetaConsequentAndLocalMetaContext(MetaLemma, labels, suppositions, consequent, localMetaContext); }
+}