occam-verify-cli 0.0.865 → 0.0.866

package/src/context/file.js

@@ -5,6 +5,8 @@ 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";
@@ -13,16 +15,11 @@ 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, metatheorems, 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;
@@ -33,6 +30,7 @@ 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;
@@ -200,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;
   }
@@ -264,27 +276,29 @@ export default class FileContext {
     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;
@@ -294,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;
@@ -308,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;
@@ -322,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;
@@ -336,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;
@@ -350,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(),
@@ -364,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;
@@ -377,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;
@@ -405,13 +447,13 @@ export default class FileContext {
     return metavariable;
   }
 
-  findMetatheoremByReferenceName(referenceName) {
-    const labelName = referenceName,  ///
+  findMetatheoremByReferenceNode(referenceNode) {
+    const labelNode = referenceNode,  ///
           metatheorems = this.getMetatheorems(),
           metatheorem = metatheorems.find((metatheorem) => {
-            const metatheoremMatchesLabelName = metatheorem.matchLabelName(labelName);
+            const metatheoremMatchesLabelNode = metatheorem.matchLabelNode(labelNode);
 
-            if (metatheoremMatchesLabelName) {
+            if (metatheoremMatchesLabelNode) {
               return true;
             }
           }) || null;
@@ -419,27 +461,22 @@ export default class FileContext {
     return metatheorem;
   }
 
-  isTermGrounded(term) {
-    const termGrounded = false; ///
-
-    return termGrounded;
-  }
-
-  isVariableDefined(variable) {
-    const variableDefined = false;  ///
+  isTypePresentByTypeName(typeName) {
+    const type = this.findTypeByTypeName(typeName),
+          typePresent = (type !== null);
 
-    return variableDefined;
+    return typePresent;
   }
 
-  isTypePresentByTypeName(typeName) {
-    const type = this.findTypeByTypeName(typeName),
+  isTypePresentByTypeNode(typeNode) {
+    const type = this.findTypeByTypeNode(typeNode),
           typePresent = (type !== null);
 
     return typePresent;
   }
 
-  isLabelPresentByLabelName(labelName) {
-    const label = this.findLabelByLabelName(labelName),
+  isLabelPresentByLabelNode(labelNode) {
+    const label = this.findLabelByLabelNode(labelNode),
           labelPresent = (label !== null);
 
     return labelPresent;
@@ -459,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;
 
@@ -518,6 +567,10 @@ export default class FileContext {
     return variableAdded;
   }
 
+  addMetaLemma(metaLemma) {
+    this.metaLemmas.push(metaLemma);
+  }
+
   addConjecture(conjecture) {
     this.conjectures.push(conjecture);
   }
@@ -611,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);
 
@@ -654,6 +714,7 @@ export default class FileContext {
             lemmas,
             theorems,
             variables,
+            metaLemmas,
             conjectures,
             combinators,
             constructors,
@@ -665,7 +726,7 @@ export default class FileContext {
   }
 
   initialise(json) {
-    const { types, rules, axioms, lemmas, theorems, variables, conjectures, combinators, constructors, metatheorems, metavariables } = json,
+    const { types, rules, axioms, lemmas, theorems, metaLemmas, variables, conjectures, combinators, constructors, metatheorems, metavariables } = json,
           fileContext = this, ///
           typesJSON = types,  ///
           rulesJSON = rules,  ///
@@ -673,10 +734,11 @@ export default class FileContext {
           lemmasJSON = lemmas,  ///
           theoremsJSON = theorems,  ///
           variablesJSON = variables,  ///
+          metaLemmasJSON = metaLemmas || [],  ///
           conjecturesJSON = conjectures,  ///
           combinatorsJSON = combinators,  ///
           constructorsJSON = constructors,  ///
-          metatheoremsJSON = metatheorems,  ///
+          metatheoremsJSON = metatheorems || [],  ///
           metavariablesJSON = metavariables;  ///
 
     typesJSON.forEach((typeJSON) => {
@@ -721,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);
@@ -767,12 +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, metatheorems, metavariables);
+          fileContext = new FileContext(releaseContext, filePath, tokens, node, types, rules, axioms, lemmas, metaLemmas, variables, theorems, conjectures, combinators, constructors, metatheorems, metavariables);
 
     fileContext.initialise(json);
 
@@ -790,12 +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, metatheorems, 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 = [];
 

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); }
+}