occam-verify-cli 0.0.863 → 0.0.865

package/src/context/file.js

@@ -8,6 +8,7 @@ import Variable from "../variable";
 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";
@@ -21,7 +22,7 @@ const metaTypes = [
 ];
 
 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, conjectures, combinators, constructors, metatheorems, metavariables) {
     this.releaseContext = releaseContext;
     this.filePath = filePath;
     this.tokens = tokens;
@@ -35,6 +36,7 @@ export default class FileContext {
     this.conjectures = conjectures;
     this.combinators = combinators;
     this.constructors = constructors;
+    this.metatheorems = metatheorems;
     this.metavariables = metavariables;
   }
 
@@ -244,6 +246,20 @@ 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;
   }
@@ -389,6 +405,20 @@ export default class FileContext {
     return metavariable;
   }
 
+  findMetatheoremByReferenceName(referenceName) {
+    const labelName = referenceName,  ///
+          metatheorems = this.getMetatheorems(),
+          metatheorem = metatheorems.find((metatheorem) => {
+            const metatheoremMatchesLabelName = metatheorem.matchLabelName(labelName);
+
+            if (metatheoremMatchesLabelName) {
+              return true;
+            }
+          }) || null;
+
+    return metatheorem;
+  }
+
   isTermGrounded(term) {
     const termGrounded = false; ///
 
@@ -500,6 +530,10 @@ export default class FileContext {
     this.constructors.push(constructor);
   }
 
+  addMetatheorem(metatheorem) {
+    this.metatheorems.push(metatheorem);
+  }
+
   addMetavariable(metavariable) {
     let metavariableAdded = false;
 
@@ -598,6 +632,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);
 
@@ -616,6 +657,7 @@ export default class FileContext {
             conjectures,
             combinators,
             constructors,
+            metatheorems,
             metavariables
           };
 
@@ -623,27 +665,19 @@ 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, variables, conjectures, combinators, constructors, metatheorems, metavariables } = json,
+          fileContext = this, ///
+          typesJSON = types,  ///
+          rulesJSON = rules,  ///
+          axiomsJSON = axioms,  ///
+          lemmasJSON = lemmas,  ///
+          theoremsJSON = theorems,  ///
+          variablesJSON = variables,  ///
+          conjecturesJSON = conjectures,  ///
+          combinatorsJSON = combinators,  ///
+          constructorsJSON = constructors,  ///
+          metatheoremsJSON = metatheorems,  ///
+          metavariablesJSON = metavariables;  ///
 
     typesJSON.forEach((typeJSON) => {
       const json = typeJSON,  ///
@@ -708,6 +742,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);
@@ -729,8 +770,9 @@ export default class FileContext {
           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, theorems, conjectures, combinators, constructors, metatheorems, metavariables);
 
     fileContext.initialise(json);
 
@@ -751,8 +793,9 @@ export default class FileContext {
           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, theorems, conjectures, combinators, constructors, metatheorems, metavariables);
 
     return fileContext;
   }

package/src/context/release.js

@@ -270,6 +270,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/metatheorem.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import AxiomLemmaTheoremConjecture from "./axiomLemmaTheoremConjecture";
+
+export default class Metatheorem extends AxiomLemmaTheoremConjecture {
+  static fromJSONAndFileContext(json, fileContext) { return AxiomLemmaTheoremConjecture.fromJSONAndFileContext(Metatheorem, json, fileContext); }
+
+  static fromLabelsSuppositionsConsequentAndLocalContext(labels, suppositions, consequent, localContext) { return AxiomLemmaTheoremConjecture.fromLabelsSuppositionsConsequentAndLocalContext(Metatheorem, labels, suppositions, consequent, localContext); }
+}

package/src/ruleMetatheorem.js

@@ -0,0 +1,274 @@
+"use strict";
+
+import Label from "./label";
+import Premise from "./premise";
+import Conclusion from "./conclusion";
+
+import { prune } from "./utilities/array";
+import { someSubArray } from "./utilities/array";
+
+export default class RuleMetatheorem {
+  constructor(labels, premises, conclusion, fileContext) {
+    this.labels = labels;
+    this.premises = premises;
+    this.conclusion = conclusion;
+    this.fileContext = fileContext;
+  }
+
+  getLabels() {
+    return this.labels;
+  }
+
+  getPremises() {
+    return this.premises;
+  }
+
+  getConclusion() {
+    return this.conclusion;
+  }
+
+  getFileContext() {
+    return this.fileContext;
+  }
+
+  matchLabelName(labelName) {
+    const labelNameMatches = this.labels.some((label) => {
+      const name = labelName, ///
+            labelMatchesName = label.matchName(name);
+
+      if (labelMatchesName) {
+        return true;
+      }
+    });
+
+    return labelNameMatches;
+  }
+
+  matchStatement(statementNode, statementLocalContext) {
+    let statementNatches;
+
+    const premisesLength = this.premises.length;
+
+    if (premisesLength === 0) {
+      const substitutions = [],
+            conclusionMatches = matchConclusion(this.conclusion, statementNode, substitutions, this.fileContext, statementLocalContext);
+
+      statementNatches = conclusionMatches; ///
+    } else {
+      const proofSteps = statementLocalContext.getProofSteps();
+
+      statementNatches = someSubArray(proofSteps, premisesLength, (proofSteps) => {
+        let premisesMatchConclusion = false;
+
+        const substitutions = [],
+              premisesMatch = matchPremises(this.premises, proofSteps, substitutions, this.fileContext, statementLocalContext);
+
+        if (premisesMatch) {
+          const conclusionMatches = matchConclusion(this.conclusion, statementNode, substitutions, this.fileContext, statementLocalContext);
+
+          premisesMatchConclusion = conclusionMatches;  ///
+        }
+
+        if (premisesMatchConclusion) {
+          return true;
+        }
+      });
+    }
+
+    return statementNatches;
+  }
+
+  matchMetastatement(metastatementNode, metastatementLocalMetaContext) {
+    let metastatementNatches;
+
+    const premisesLength = this.premises.length;
+
+    if (premisesLength === 0) {
+      const substitutions = [],
+            conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, substitutions, this.fileContext, metastatementLocalMetaContext);
+
+      metastatementNatches = conclusionMatches; ///
+    } else {
+      const metaproofSteps = metastatementLocalMetaContext.getMetaproofSteps();
+
+      metastatementNatches = someSubArray(metaproofSteps, premisesLength, (metaproofSteps) => {
+        let premisesMatchConclusion = false;
+
+        const substitutions = [],
+              premisesMatch = metaMatchPremises(this.premises, metaproofSteps, substitutions, this.fileContext, metastatementLocalMetaContext);
+
+        if (premisesMatch) {
+          const conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, substitutions, this.fileContext, metastatementLocalMetaContext);
+
+          premisesMatchConclusion = conclusionMatches;  ///
+        }
+
+        if (premisesMatchConclusion) {
+          return true;
+        }
+      });
+    }
+
+    return metastatementNatches;
+  }
+
+  toJSON(tokens) {
+    const labelsJSON = this.labels.map((label) => {
+            const labelJSON = label.toJSON(tokens);
+
+            return labelJSON;
+          }),
+          premisesJSON = this.premises.map((premise) => {
+            const premiseJSON = premise.toJSON(tokens);
+
+            return premiseJSON;
+          }),
+          conclusionJSON = this.conclusion.toJSON(tokens),
+          labels = labelsJSON,  ///
+          premises = premisesJSON,  ///
+          conclusion = conclusionJSON,  ///
+          json = {
+            labels,
+            premises,
+            conclusion
+          };
+
+    return json;
+  }
+
+  static fromJSONAndFileContext(json, fileContext) {
+    let rule;
+
+    let { labels } = json;
+
+    const labelsJSON = labels;  ///
+
+    labels = labelsJSON.map((labelJSON) => {
+      const json = labelJSON, ///
+            label = Label.fromJSONAndFileContext(json, fileContext);
+
+      return label;
+    });
+
+    let { premises } = json;
+
+    const premisesJSON = premises;  ///
+
+    premises = premisesJSON.map((premiseJSON) => {
+      const json = premiseJSON, ///
+            premise = Premise.fromJSONAndFileContext(json, fileContext);
+
+      return premise;
+    });
+
+    let { conclusion } = json;
+
+    const conclusionJSON = conclusion;  ///
+
+    json = conclusionJSON;  ///
+
+    conclusion = Conclusion.fromJSONAndFileContext(json, fileContext);
+
+    rule = new Rule(labels, premises, conclusion, fileContext);
+
+    return rule;
+  }
+
+  static fromLabelsPremisesConclusionAndFileContext(labels, premises, conclusion, fileContext) {
+    const rule = new Rule(labels, premises, conclusion, fileContext);
+
+    return rule;
+  }
+}
+
+function matchPremise(premise, proofSteps, substitutions, fileContext, statementLocalContext) {
+  const proofStep = prune(proofSteps, (proofStep) => {
+    const subproofNode = proofStep.getSubproofNode(),
+          statementNode = proofStep.getStatementNode()
+
+    if (subproofNode !== null) {
+      const subProofNodeMatches = premise.matchSubproofNode(subproofNode, substitutions, fileContext, statementLocalContext);
+
+      if (!subProofNodeMatches) {  ///
+        return true;
+      }
+    }
+
+    if (statementNode !== null) {
+      const statementNodeMatches = premise.matchStatementNode(statementNode, substitutions, fileContext, statementLocalContext);
+
+      if (!statementNodeMatches) {  ///
+        return true;
+      }
+    }
+  }) || null;
+
+  const premiseMatches = (proofStep !== null);
+
+  return premiseMatches;
+}
+
+function matchPremises(premise, proofSteps, substitutions, fileContext, statementLocalContext) {
+  const premisesMatch = premise.every((premise) => {
+    const premiseMatches = matchPremise(premise, proofSteps, substitutions, fileContext, statementLocalContext);
+
+    if (premiseMatches) {
+      return true;
+    }
+  });
+
+  return premisesMatch;
+}
+
+function matchConclusion(conclusion, statementNode, substitutions, fileContext, statementLocalContext) {
+  const statementNodeMatches = conclusion.matchStatementNode(statementNode, substitutions, fileContext, statementLocalContext),
+        conclusionMatches = statementNodeMatches; ///
+
+  return conclusionMatches;
+}
+
+function metaMatchPremise(premise, metaproofSteps, substitutions, fileContext, metastatementLocalMetaContext) {
+  const metaproofStep = prune(metaproofSteps, (metaproofStep) => {
+    const ruleSubproofNode = metaproofStep.getRuleSubproofNode(),
+          metastatementNode = metaproofStep.getMetastatementNode()
+
+    if (ruleSubproofNode !== null) {
+      const ruleSubProofNodeMatches = premise.matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, metastatementLocalMetaContext);
+
+      if (!ruleSubProofNodeMatches) {  ///
+        return true;
+      }
+    }
+
+    if (metastatementNode !== null) {
+      const metastatementNodeMatches = premise.matchMetastatementNode(metastatementNode, substitutions, fileContext, metastatementLocalMetaContext);
+
+      if (!metastatementNodeMatches) {  ///
+        return true;
+      }
+    }
+  }) || null;
+
+  const premiseMatches = (metaproofStep !== null);
+
+  return premiseMatches;
+}
+
+function metaMatchPremises(premise, metaproofSteps, substitutions, fileContext, metastatementLocalMetaContext) {
+  const premisesMatch = premise.every((premise) => {
+    const premiseMatches = metaMatchPremise(premise, metaproofSteps, substitutions, fileContext, metastatementLocalMetaContext);
+
+    if (premiseMatches) {
+      return true;
+    }
+  });
+
+  return premisesMatch;
+}
+
+function metaMatchConclusion(conclusion, metastatementNode, substitutions, fileContext, metastatementLocalMetaContext) {
+  const metastatementNodeMatches = conclusion.matchMetastatementNode(metastatementNode, substitutions, fileContext, metastatementLocalMetaContext),
+        conclusionMatches = metastatementNodeMatches; ///
+
+  return conclusionMatches;
+}

package/src/verifier/nodes.js

@@ -31,7 +31,7 @@ export default class NodesVerifier {
   }
 
   verifyChildNodes(childNodesA, childNodesB, ...remainingArguments) {
-    let childNodesVerify = false;
+    let childNodesVerified = false;
 
     const childNodesALength = childNodesA.length,
           childNodesBLength = childNodesB.length;
@@ -45,11 +45,11 @@ export default class NodesVerifier {
         const index = 0,
               childNodesVerifyAhead = this.verifyChildNodesAhead(index, childNodesA, childNodesB, ...remainingArguments);
 
-        childNodesVerify = childNodesVerifyAhead; ///
+        childNodesVerified = childNodesVerifyAhead; ///
       }
     }
 
-    return childNodesVerify;
+    return childNodesVerified;
   }
 
   verifyTerminalNode(terminalNodeA, terminalNodeB, ...remainingArguments) { ///
@@ -74,16 +74,16 @@ export default class NodesVerifier {
             nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
             childNodesA = nonTerminalNodeAChildNodes, ///
             childNodesB = nonTerminalNodeBChildNodes, ///
-            childNodesVerify = this.verifyChildNodes(childNodesA, childNodesB, ...remainingArguments);
+            childNodesVerified = this.verifyChildNodes(childNodesA, childNodesB, ...remainingArguments);
 
-      nonTerminalNodeVerified = childNodesVerify; ///
+      nonTerminalNodeVerified = childNodesVerified; ///
     }
 
     return nonTerminalNodeVerified;
   }
 
   verifyChildNodesAhead(index, childNodesA, childNodesB, ...remainingArguments) {
-    let childNodesVerify;
+    let childNodesVerified;
 
     const verifyAhead = remainingArguments.pop(), ///
           childNodesALength = childNodesA.length;
@@ -91,7 +91,7 @@ export default class NodesVerifier {
     if (index === childNodesALength) {
       const verifiedAhead = verifyAhead();
 
-      childNodesVerify = verifiedAhead; ///
+      childNodesVerified = verifiedAhead; ///
     } else {
       const childNodeA = childNodesA[index],
             childNodeB = childNodesB[index],
@@ -106,9 +106,9 @@ export default class NodesVerifier {
               return childNodesVerifyAhead;
             });
 
-      childNodesVerify = nodeVerified;  ///
+      childNodesVerified = nodeVerified;  ///
     }
 
-    return childNodesVerify;
+    return childNodesVerified;
   }
 }

package/src/verify/declaration/metavariable.js

@@ -12,16 +12,17 @@ export default function verifyMetavariableDeclaration(metavariableDeclarationNod
 
   const metaTypeNode = metaTypeNodeQuery(metavariableDeclarationNode),
         metavariableNode = metavariableNodeQuery(metavariableDeclarationNode),
-        metavariableString = fileContext.nodeAsString(metaTypeNode);
+        metaTypeString = fileContext.nodeAsString(metaTypeNode),
+        metavariableString = fileContext.nodeAsString(metavariableNode);
 
-  fileContext.trace(`Verifying the '${metavariableString}' metavariable declaration...`, metavariableDeclarationNode);
+  fileContext.trace(`Verifying the '${metavariableString}:${metaTypeString}' metavariable declaration...`, metavariableDeclarationNode);
 
   const metavariableVVerified = verifyMetavariable(metavariableNode, metaTypeNode, fileContext);
 
   metavariableDeclarationVerified = metavariableVVerified;  ///
 
   if (metavariableDeclarationVerified) {
-    fileContext.debug(`...verified the '${metavariableString}' metavariable declaration.`, metavariableDeclarationNode);
+    fileContext.debug(`...verified the '${metavariableString}:${metaTypeString}' metavariable declaration.`, metavariableDeclarationNode);
   }
 
   return metavariableDeclarationVerified;