occam-verify-cli 0.0.921 → 0.0.923

package/src/conclusion.js

@@ -1,54 +1,28 @@
 "use strict";
 
-import MetaLevelLocalContext from "./context/local/metaLevel";
+import LocalContext from "./context/local";
 import metaLevelNodesVerifier from "./verifier/nodes/metaLevel";
-import intrinsicLevelAgainstMetaLevelNodesVerifier from "./verifier/nodes/intrinsicLevelAgainstMetaLevel";
 
 import { nodeAsString } from "./utilities/string";
-import { statementNodeFromStatementString, metastatementNodeFromMetastatementString } from "./utilities/node";
+import { statementNodeFromStatementString } from "./utilities/node";
 
 export default class Conclusion {
-  constructor(metastatementNode, statementNode) {
-    this.metastatementNode = metastatementNode;
+  constructor(statementNode) {
     this.statementNode = statementNode;
   }
 
-  getMetastatementNode() {
-    return this.metastatementNode;
-  }
-
   getStatementNode() {
     return this.statementNode;
   }
 
-  matchStatementNode(statementNode, substitutions, localContext, statementLocalContext) {
-    let matchesStatementNose = false;
+  matchStatementNode(statementNode, substitutions, fileContext, localContext) {
+    let matchesStatementNode = false;
 
-    if (this.metastatementNode !== null) {
-      const nonTerminalNodeA = this.metastatementNode,  ///
+    if (this.statementNode !== null) {
+      const fileContextA = fileContext, ///
+            nonTerminalNodeA = this.statementNode,  ///
             nonTerminalNodeB = statementNode,  ///
-            localContextA = localContext, ///
-            localContextB = statementLocalContext,  ///
-            nonTerminalNodeVerified = intrinsicLevelAgainstMetaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
-              const verifiedAhead = true;
-
-              return verifiedAhead;
-            });
-
-      matchesStatementNose = nonTerminalNodeVerified; ///
-    }
-
-    return matchesStatementNose;
-  }
-
-  matchMetastatementNode(metastatementNode, substitutions, fileContext, localContext) {
-    let matchesMetastatementNode = false;
-
-    if (this.metastatementNode !== null) {
-      const metaLevelLocalContext = MetaLevelLocalContext.fromFileContext(fileContext),
-            nonTerminalNodeA = this.metastatementNode,  ///
-            nonTerminalNodeB = metastatementNode,  ///
-            localContextA = metaLevelLocalContext,  ///
+            localContextA = LocalContext.fromFileContext(fileContextA),
             localContextB = localContext,  ///
             nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
               const verifiedAhead = true;
@@ -56,19 +30,16 @@ export default class Conclusion {
               return verifiedAhead;
             });
 
-      matchesMetastatementNode = nonTerminalNodeVerified; ///
+      matchesStatementNode = nonTerminalNodeVerified; ///
     }
 
-    return matchesMetastatementNode;
+    return matchesStatementNode;
   }
 
   toJSON(tokens) {
-    const metastatementString = nodeAsString(this.metastatementNode, tokens),
-          statementString = nodeAsString(this.statementNode, tokens),
-          metastatement = metastatementString,  ///
+    const statementString = nodeAsString(this.statementNode, tokens),
           statement = statementString,  ///
           json = {
-            metastatement,
             statement
           };
 
@@ -76,28 +47,18 @@ export default class Conclusion {
   }
 
   static fromStatementNode(statementNode) {
-    const metastatementNode = null,
-          conclusion = new Conclusion(metastatementNode, statementNode);
-
-    return conclusion;
-  }
-
-  static fromMetastatementNode(metastatementNode) {
-    const statementNode = null,
-          conclusion = new Conclusion(metastatementNode, statementNode);
+    const conclusion = new Conclusion(statementNode);
 
     return conclusion;
   }
 
   static fromJSONAndFileContext(json, fileContext) {
-    const { metastatement, statement } = json,
-          metastatementString = metastatement,  ///
+    const { statement } = json,
           statementString = statement,  ///
           lexer = fileContext.getLexer(),
           parser = fileContext.getParser(),
-          metastatementNode = metastatementNodeFromMetastatementString(metastatementString, lexer, parser),
           statementNode = statementNodeFromStatementString(statementString, lexer, parser),
-          conclusion = new Conclusion(metastatementNode, statementNode);
+          conclusion = new Conclusion(statementNode, statementNode);
 
     return conclusion;
   }

package/src/constants.js

@@ -6,4 +6,3 @@ export const DEFINED = "defined";
 export const CONTAINED = "contained";
 export const EMPTY_STRING = "";
 export const BRACKETED_STATEMENT_DEPTH = 2;
-export const BRACKETED_METASTATEMENT_DEPTH = 1;

package/src/context/{local/intrinsicLevel.js → local.js}

@@ -1,18 +1,20 @@
 "use strict";
 
-import Variable from "../../variable";
-import Equivalence from "../../equivalence";
-import contextMixins from "../../mixins/context";
+import Variable from "../variable";
+import Equivalence from "../equivalence";
+import contextMixins from "../mixins/context";
 
-import { last, reverse } from "../../utilities/array";
-import { mergeEquivalences, findEquivalenceByTerm, groundedTermsAndDefinedVariablesFromFromEquivalences } from "../../utilities/equivalences";
+import { last, reverse } from "../utilities/array";
+import { mergeEquivalences, findEquivalenceByTerm, groundedTermsAndDefinedVariablesFromFromEquivalences } from "../utilities/equivalences";
 
-class IntrinsicLevelLocalContext {
-  constructor(context, variables, proofSteps, equivalences) {
+class LocalContext {
+  constructor(context, variables, proofSteps, judgements, equivalences, metavariables) {
     this.context = context;
     this.variables = variables;
     this.proofSteps = proofSteps;
+    this.judgements = judgements;
     this.equivalences = equivalences;
+    this.metavariables = metavariables;
   }
 
   getContext() {
@@ -41,22 +43,38 @@ class IntrinsicLevelLocalContext {
     return proofSteps;
   }
 
+  getJudgements() {
+    let judgements = this.context.getJudgements();
+
+    judgements = [ ///
+      ...this.judgements,
+      ...judgements
+    ]
+
+    return judgements;
+  }
+
   getEquivalences() {
     let equivalences = this.context.getEquivalences();
 
     const equivalencesA = this.equivalences, ///
           equivalencesB = equivalences,
-          intrinsicLevelLocalContext = this;  ///
+          LocalContext = this;  ///
 
-    equivalences = mergeEquivalences(equivalencesA, equivalencesB, intrinsicLevelLocalContext); ///
+    equivalences = mergeEquivalences(equivalencesA, equivalencesB, LocalContext); ///
 
     return equivalences;
   }
 
-  isIntrinsicLevel() {
-    const intrinsicLevel = true;
+  getMetavariables() {
+    let metavariables = this.context.getMetavariables();
+
+    metavariables = [ ///
+      ...this.metavariables,
+      ...metavariables
+    ]
 
-    return intrinsicLevel;
+    return metavariables;
   }
 
   getLastProofStep() {
@@ -71,64 +89,6 @@ class IntrinsicLevelLocalContext {
     return lastProofStep;
   }
 
-  getTermType(term) {
-    let termType;
-
-    const equivalences = this.getEquivalences(),
-          equivalence = findEquivalenceByTerm(equivalences, term);
-
-    if (equivalence !== null) {
-      const intrinsicLevelLocalContext = this,  ///
-            equivalenceType = equivalence.getType(intrinsicLevelLocalContext);
-
-      termType = equivalenceType;  ///
-    } else {
-      termType = term.getType();
-    }
-
-    return termType;
-  }
-
-  isTermGrounded(term) {
-    const context = this,
-          equivalences = this.getEquivalences(),
-          groundedTerms = [],
-          definedVariables = [];
-
-    groundedTermsAndDefinedVariablesFromFromEquivalences(equivalences, groundedTerms, definedVariables, context);
-
-    const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
-            const termMatchesGroundedTerm = term.match(groundedTerm);
-
-            if (termMatchesGroundedTerm) {
-              return true;
-            }
-          }),
-          termGrounded = termMatchesGroundedTerm; ///
-
-    return termGrounded;
-  }
-
-  isVariableDefined(variable) {
-    const context = this,
-          equivalences = this.getEquivalences(),
-          groundedTerms = [],
-          definedVariables = [];
-
-    groundedTermsAndDefinedVariablesFromFromEquivalences(equivalences, groundedTerms, definedVariables, context);
-
-    const variableMatchesDefinedVariable = definedVariables.some((definedVariable) => {
-            const variableMatchesDefinedVariable = variable.match(definedVariable);
-
-            if (variableMatchesDefinedVariable) {
-              return true;
-            }
-          }),
-          variableDefined = variableMatchesDefinedVariable; ///
-
-    return variableDefined;
-  }
-
   addEquality(equality) {
     let equalityAdded;
 
@@ -221,6 +181,42 @@ class IntrinsicLevelLocalContext {
     this.equivalences.splice(start, deleteCount);
   }
 
+  addJudgement(judgement) {
+    let judgementAdded = false;
+
+    const metavariableNode = judgement.getMetavariableNode(),
+          judgementPresent = this.isJudgementPresentByMetavariableNode(metavariableNode);
+
+    if (!judgementPresent) {
+      this.judgements.push(judgement);
+
+      judgementAdded = true;
+    }
+
+    return judgementAdded;
+  }
+
+  addMetavariable(metavariable) {
+    let metavariableAdded = false;
+
+    const node = metavariable.getName(),
+          metavariablePresent = this.metavariables.some((metavariable) => {
+            const metavariableMatchesNode = metavariable.matchNode(node);
+
+            if (metavariableMatchesNode) {
+              return true;
+            }
+          });
+
+    if (!metavariablePresent) {
+      this.metavariables.push(metavariable);
+
+      metavariableAdded = true;
+    }
+
+    return metavariableAdded;
+  }
+
   matchStatementNode(statementNode) {
     let proofSteps = this.getProofSteps();
 
@@ -237,21 +233,63 @@ class IntrinsicLevelLocalContext {
     return matchesStatementNode;
   }
 
-  findVariableByVariableNode(variableNode) {
-    const node = variableNode,  ///
-          variables = this.getVariables(),
-          variable = variables.find((variable) => {
-            const matches = variable.matchNode(node);
+  getTermType(term) {
+    let termType;
 
-            if (matches) {
+    const equivalences = this.getEquivalences(),
+          equivalence = findEquivalenceByTerm(equivalences, term);
+
+    if (equivalence !== null) {
+      const LocalContext = this,  ///
+            equivalenceType = equivalence.getType(LocalContext);
+
+      termType = equivalenceType;  ///
+    } else {
+      termType = term.getType();
+    }
+
+    return termType;
+  }
+
+  isTermGrounded(term) {
+    const context = this,
+          equivalences = this.getEquivalences(),
+          groundedTerms = [],
+          definedVariables = [];
+
+    groundedTermsAndDefinedVariablesFromFromEquivalences(equivalences, groundedTerms, definedVariables, context);
+
+    const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
+            const termMatchesGroundedTerm = term.match(groundedTerm);
+
+            if (termMatchesGroundedTerm) {
               return true;
             }
-          }) || null;
+          }),
+          termGrounded = termMatchesGroundedTerm; ///
 
-    return variable;
+    return termGrounded;
   }
 
-  findMetaTypeByMetaTypeNode(metaTypeNode) { return this.context.findMetaTypeByMetaTypeNode(metaTypeNode); }
+  isVariableDefined(variable) {
+    const context = this,
+          equivalences = this.getEquivalences(),
+          groundedTerms = [],
+          definedVariables = [];
+
+    groundedTermsAndDefinedVariablesFromFromEquivalences(equivalences, groundedTerms, definedVariables, context);
+
+    const variableMatchesDefinedVariable = definedVariables.some((definedVariable) => {
+            const variableMatchesDefinedVariable = variable.match(definedVariable);
+
+            if (variableMatchesDefinedVariable) {
+              return true;
+            }
+          }),
+          variableDefined = variableMatchesDefinedVariable; ///
+
+    return variableDefined;
+  }
 
   isVariablePresentByVariableNode(variableNode) {
     const variable = this.findVariableByVariableNode(variableNode),
@@ -260,19 +298,59 @@ class IntrinsicLevelLocalContext {
     return variablePresent;
   }
 
-  toJSON(tokens) {
-    const variables = this.variables.map((variable) => {
-            const variableJSON = variable.toJSON(tokens);
+  isJudgementPresentByMetavariableNode(metavariableNode) {
+    const judgement = this.findJudgementByMetavariableNode(metavariableNode),
+          judgementPresent = (judgement !== null);
 
-            variable = variableJSON;
+    return judgementPresent;
+  }
 
-            return variable;
-          }),
-          json = {
-            variables
-          };
+  isMetavariablePresentByMetavariableNode(metavariableNode, localContext) {
+    const metavariable = this.findMetavariableByMetavariableNode(metavariableNode, localContext),
+          metavariablePresent = (metavariable !== null);
 
-    return json;
+    return metavariablePresent;
+  }
+
+  findVariableByVariableNode(variableNode) {
+    const node = variableNode,  ///
+      variables = this.getVariables(),
+      variable = variables.find((variable) => {
+        const matches = variable.matchNode(node);
+
+        if (matches) {
+          return true;
+        }
+      }) || null;
+
+    return variable;
+  }
+
+  findJudgementByMetavariableNode(metavariableNode) {
+    const judgements = this.getJudgements(),
+          judgement = judgements.find((judgement) => {
+            const judgementMatchesMetavariableNode = judgement.matchMetavariableNode(metavariableNode);
+
+            if (judgementMatchesMetavariableNode) {
+              return true;
+            }
+          }) || null;
+
+    return judgement;
+  }
+
+  findMetavariableByMetavariableNode(metavariableNode, localContext) {
+    const node = metavariableNode,  ///
+          metavariables = this.getMetavariables(),
+          metavariable = metavariables.find((metavariable) => {
+            const matches = metavariable.matchNode(node, localContext);
+
+            if (matches) {
+              return true;
+            }
+          }) || null;
+
+    return metavariable;
   }
 
   static fromFileContext(fileContext) {
@@ -280,9 +358,11 @@ class IntrinsicLevelLocalContext {
           variables = [],
           proofSteps = [],
           equivalences = [],
-          intrinsicLevelLocalContext = new IntrinsicLevelLocalContext(context, variables, proofSteps, equivalences);
+          judgements = [],
+          metavariables = [],
+          localContext = new LocalContext(context, variables, proofSteps, judgements, equivalences, metavariables);
 
-    return intrinsicLevelLocalContext;
+    return localContext;
   }
 
   static fromLocalContext(localContext) {
@@ -290,9 +370,12 @@ class IntrinsicLevelLocalContext {
           variables = [],
           proofSteps = [],
           equivalences = [],
-          intrinsicLevelLocalContext = new IntrinsicLevelLocalContext(context, variables, proofSteps, equivalences);
+          judgements = [],
+          metavariables = [];
+
+    localContext = new LocalContext(context, variables, proofSteps, judgements, equivalences, metavariables);  ///
 
-    return intrinsicLevelLocalContext;
+    return localContext;
   }
 
   static fromJSONAndFileContext(json, fileContext) {
@@ -310,12 +393,14 @@ class IntrinsicLevelLocalContext {
     const context = fileContext,  ///
           proofSteps = [],
           equivalences = [],
-          intrinsicLevelLocalContext = new IntrinsicLevelLocalContext(context, variables, proofSteps, equivalences);
+          judgements = [],
+          metavariables = [],
+          localContext = new LocalContext(context, variables, proofSteps, judgements, equivalences, metavariables);  ///
 
-    return intrinsicLevelLocalContext;
+    return localContext;
   }
 }
 
-Object.assign(IntrinsicLevelLocalContext.prototype, contextMixins);
+Object.assign(LocalContext.prototype, contextMixins);
 
-export default IntrinsicLevelLocalContext;
+export default LocalContext;

package/src/declaration.js

@@ -1,27 +1,27 @@
 "use strict";
 
-import { matchMetastatementModuloBrackets } from "./utilities/match";
+import { matchStatementModuloBrackets } from "./utilities/match";
 
 export default class Declaration {
-  constructor(metavariableNode, metastatementNode) {
+  constructor(metavariableNode, statementNode) {
     this.metavariableNode = metavariableNode;
-    this.metastatementNode = metastatementNode;
+    this.statementNode = statementNode;
   }
 
   getMetavariableNode() {
     return this.metavariableNode;
   }
 
-  getMetastatementNode() {
-    return this.metastatementNode;
+  getStatementNode() {
+    return this.statementNode;
   }
 
   matchSubstitution(substitution) {
-    const metavariableNode = substitution.getMetavariableNode(),
-          metastatementNode = substitution.getMetastatementNode(),
+    const statementNode = substitution.getStatementNode(),
+          metavariableNode = substitution.getMetavariableNode(),
+          matchesStatementNode = this.matchStatementNode(statementNode),
           matchesMetavariableNode = this.matchMetavariableNode(metavariableNode),
-          matchesMetastatementNode = this.matchMetastatementNode(metastatementNode),
-          matchesSubstitution = (matchesMetavariableNode && matchesMetastatementNode);
+          matchesSubstitution = (matchesMetavariableNode && matchesStatementNode);
 
     return matchesSubstitution;
   }
@@ -32,26 +32,26 @@ export default class Declaration {
     return matchesMetavariableNode;
   }
 
-  matchMetastatementNode(metastatementNode) {
-    const metastatementNodeA = metastatementNode, ///
-          metastatementNodeB = this.metastatementNode,  ///
-          metastatementMatches = matchMetastatementModuloBrackets(metastatementNodeA, metastatementNodeB),
-          matchesMetastatementNode = metastatementMatches;  ///
+  matchStatementNode(statementNode) {
+    const statementNodeA = statementNode, ///
+          statementNodeB = this.statementNode,  ///
+          statementMatches = matchStatementModuloBrackets(statementNodeA, statementNodeB),
+          matchesStatementNode = statementMatches;  ///
 
-    return matchesMetastatementNode;
+    return matchesStatementNode;
   }
 
   matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem) {
     const metaConsequent = metaLemmaMetatheorem.getMetaConsequent(),
-          metastatementNode = metaConsequent.getMetastatementNode(),
-          matches = this.metastatementNode.match(metastatementNode),
+          statementNode = metaConsequent.getStatementNode(),
+          matches = this.statementNode.match(statementNode),
           matchesMetaLemmaOrMetaTheorem = matches;  ///
 
     return matchesMetaLemmaOrMetaTheorem;
   }
 
-  static fromMetavariableNodeAndMetastatementNode(metavariableNode, metastatementNode) {
-    const declaration = new Declaration(metavariableNode, metastatementNode);
+  static fromMetavariableNodeAndStatementNode(metavariableNode, statementNode) {
+    const declaration = new Declaration(metavariableNode, statementNode);
 
     return declaration;
   }