occam-verify-cli 0.0.922 → 0.0.924

package/src/conclusion.js

@@ -2,52 +2,26 @@
 
 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;
-
-    if (this.metastatementNode !== null) {
-      const nonTerminalNodeA = this.metastatementNode,  ///
-            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;
+  matchStatementNode(statementNode, substitutions, fileContext, localContext) {
+    let matchesStatementNode = false;
 
-    if (this.metastatementNode !== null) {
+    if (this.statementNode !== null) {
       const fileContextA = fileContext, ///
-            nonTerminalNodeA = this.metastatementNode,  ///
-            nonTerminalNodeB = metastatementNode,  ///
+            nonTerminalNodeA = this.statementNode,  ///
+            nonTerminalNodeB = statementNode,  ///
             localContextA = LocalContext.fromFileContext(fileContextA),
             localContextB = localContext,  ///
             nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
@@ -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/conjecture.js

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

package/src/constants.js

@@ -2,8 +2,5 @@
 
 export const NOT = "not";
 export const COMMA = ",";
-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/file.js

@@ -513,8 +513,8 @@ export default class FileContext {
     return labelPresent;
   }
 
-  isMetavariablePresentByMetavariableNode(metavariableNode, localContext) {
-    const metavariable = this.findMetavariableByMetavariableNode(metavariableNode, localContext),
+  isMetavariablePresentByMetavariableNode(metavariableNode) {
+    const metavariable = this.findMetavariableByMetavariableNode(metavariableNode),
           metavariablePresent = (metavariable !== null);
 
     return metavariablePresent;

package/src/context/local.js

@@ -8,14 +8,13 @@ import { last, reverse } from "../utilities/array";
 import { mergeEquivalences, findEquivalenceByTerm, groundedTermsAndDefinedVariablesFromFromEquivalences } from "../utilities/equivalences";
 
 class LocalContext {
-  constructor(context, variables, proofSteps, equivalences, judgements, metavariables, metaproofSteps) {
+  constructor(context, variables, proofSteps, judgements, equivalences, metavariables) {
     this.context = context;
     this.variables = variables;
     this.proofSteps = proofSteps;
-    this.equivalences = equivalences;
     this.judgements = judgements;
+    this.equivalences = equivalences;
     this.metavariables = metavariables;
-    this.metaproofSteps = metaproofSteps;
   }
 
   getContext() {
@@ -44,6 +43,17 @@ class LocalContext {
     return proofSteps;
   }
 
+  getJudgements() {
+    let judgements = this.context.getJudgements();
+
+    judgements = [ ///
+      ...this.judgements,
+      ...judgements
+    ]
+
+    return judgements;
+  }
+
   getEquivalences() {
     let equivalences = this.context.getEquivalences();
 
@@ -56,17 +66,6 @@ class LocalContext {
     return equivalences;
   }
 
-  getJudgements() {
-    let judgements = this.context.getJudgements();
-
-    judgements = [ ///
-      ...this.judgements,
-      ...judgements
-    ]
-
-    return judgements;
-  }
-
   getMetavariables() {
     let metavariables = this.context.getMetavariables();
 
@@ -78,17 +77,6 @@ class LocalContext {
     return metavariables;
   }
 
-  getMetaproofSteps() {
-    let metaproofSteps = this.context.getMetaproofSteps();
-
-    metaproofSteps = [  ///
-      ...metaproofSteps,
-      ...this.metaproofSteps
-    ];
-
-    return metaproofSteps;
-  }
-
   getLastProofStep() {
     let lastProofStep = null;
 
@@ -101,18 +89,6 @@ class LocalContext {
     return lastProofStep;
   }
 
-  getLastMetaproofStep() {
-    let lastMetaproofStep = null;
-
-    const metaproofStepsLength = this.metaproofSteps.length;
-
-    if (metaproofStepsLength > 0) {
-      lastMetaproofStep = last(this.metaproofSteps);
-    }
-
-    return lastMetaproofStep;
-  }
-
   addEquality(equality) {
     let equalityAdded;
 
@@ -241,10 +217,6 @@ class LocalContext {
     return metavariableAdded;
   }
 
-  addMetaproofStep(metaproofStep) {
-    this.metaproofSteps.push(metaproofStep);
-  }
-
   matchStatementNode(statementNode) {
     let proofSteps = this.getProofSteps();
 
@@ -261,22 +233,6 @@ class LocalContext {
     return matchesStatementNode;
   }
 
-  matchMetastatementNode(metastatementNode) {
-    let metaproofSteps = this.getMetaproofSteps();
-
-    metaproofSteps = reverse(metaproofSteps); ///
-
-    const matchesMetastatementNode = metaproofSteps.some((metaproofStep) => {
-      const metaproofStepMatchesMetastatementNode = metaproofStep.matchMetastatementNode(metastatementNode);
-
-      if (metaproofStepMatchesMetastatementNode) {
-        return true;
-      }
-    });
-
-    return matchesMetastatementNode;
-  }
-
   getTermType(term) {
     let termType;
 
@@ -349,8 +305,8 @@ class LocalContext {
     return judgementPresent;
   }
 
-  isMetavariablePresentByMetavariableNode(metavariableNode, localContext) {
-    const metavariable = this.findMetavariableByMetavariableNode(metavariableNode, localContext),
+  isMetavariablePresentByMetavariableNode(metavariableNode) {
+    const metavariable = this.findMetavariableByMetavariableNode(metavariableNode),
           metavariablePresent = (metavariable !== null);
 
     return metavariablePresent;
@@ -383,8 +339,9 @@ class LocalContext {
     return judgement;
   }
 
-  findMetavariableByMetavariableNode(metavariableNode, localContext) {
+  findMetavariableByMetavariableNode(metavariableNode) {
     const node = metavariableNode,  ///
+          localContext = this,  ///
           metavariables = this.getMetavariables(),
           metavariable = metavariables.find((metavariable) => {
             const matches = metavariable.matchNode(node, localContext);
@@ -404,8 +361,7 @@ class LocalContext {
           equivalences = [],
           judgements = [],
           metavariables = [],
-          metaproofSteps = [],
-          localContext = new LocalContext(context, variables, proofSteps, equivalences, judgements, metavariables, metaproofSteps);
+          localContext = new LocalContext(context, variables, proofSteps, judgements, equivalences, metavariables);
 
     return localContext;
   }
@@ -416,10 +372,9 @@ class LocalContext {
           proofSteps = [],
           equivalences = [],
           judgements = [],
-          metavariables = [],
-          metaproofSteps = [];
+          metavariables = [];
 
-    localContext = new LocalContext(context, variables, proofSteps, equivalences, judgements, metavariables, metaproofSteps);  ///
+    localContext = new LocalContext(context, variables, proofSteps, judgements, equivalences, metavariables);  ///
 
     return localContext;
   }
@@ -441,8 +396,7 @@ class LocalContext {
           equivalences = [],
           judgements = [],
           metavariables = [],
-          metaproofSteps = [],
-          localContext = new LocalContext(context, variables, proofSteps, equivalences, judgements, metavariables, metaproofSteps);  ///
+          localContext = new LocalContext(context, variables, proofSteps, judgements, equivalences, metavariables);  ///
 
     return 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;
   }

package/src/lemma.js

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

package/src/metaLemma.js

@@ -1,9 +1,9 @@
 "use strict";
 
-import MetalemmaMetatheorem from "./metalemmaMetatheorem";
+import TopLevelAssertion from "./topLevelAssertion";
 
-export default class MetaLemma extends MetalemmaMetatheorem {
-  static fromJSONAndFileContext(json, fileContext) { return MetalemmaMetatheorem.fromJSONAndFileContext(MetaLemma, json, fileContext); }
+export default class MetaLemma extends TopLevelAssertion {
+  static fromJSONAndFileContext(json, fileContext) { return TopLevelAssertion.fromJSONAndFileContext(MetaLemma, json, fileContext); }
 
-  static fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(labels, metaSuppositions, metaConsequent, substitutions, fileContext) { return MetalemmaMetatheorem.fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(MetaLemma, labels, metaSuppositions, metaConsequent, substitutions, fileContext); }
+  static fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(labels, metaSuppositions, metaConsequent, substitutions, fileContext) { return TopLevelAssertion.fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(MetaLemma, labels, metaSuppositions, metaConsequent, substitutions, fileContext); }
 }

package/src/metatheorem.js

@@ -1,9 +1,9 @@
 "use strict";
 
-import MetaLemmaMetatheorem from "./metaLemmaMetatheorem";
+import TopLevelAssertion from "./topLevelAssertion";
 
-export default class Metatheorem extends MetaLemmaMetatheorem {
-  static fromJSONAndFileContext(json, fileContext) { return MetaLemmaMetatheorem.fromJSONAndFileContext(Metatheorem, json, fileContext); }
+export default class Metatheorem extends TopLevelAssertion {
+  static fromJSONAndFileContext(json, fileContext) { return TopLevelAssertion.fromJSONAndFileContext(Metatheorem, json, fileContext); }
 
-  static fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, fileContext) { return MetaLemmaMetatheorem.fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(Metatheorem, labels, suppositions, consequent, fileContext); }
+  static fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, fileContext) { return TopLevelAssertion.fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(Metatheorem, labels, suppositions, consequent, fileContext); }
 }

package/src/metavariable.js

@@ -36,6 +36,12 @@ export default class Metavariable {
     return this.metaType;
   }
 
+  getMetaTypeName() {
+    const metaTypeName = this.metaType.getName();
+
+    return metaTypeName;
+  }
+
   matchName(name) {
     const matchesName = (this.name === name);
 

package/src/mixins/nodesVerifier/metaLevel.js

@@ -1,8 +1,8 @@
 "use strict";
 
-import MetastatementForMetavariableSubstitution from "../../substitution/metastatementForMetavariable";
+import StatementForMetavariableSubstitution from "../../substitution/statementForMetavariable";
 
-function verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions, localContextA, localMetaContextB, verifyAhead) {
+function verifyMetavariableNode(metavariableNodeA, statementNodeB, substitutions, localContextA, localMetaContextB, verifyAhead) {
   let metavariableNodeVerified;
 
   const substitution = substitutions.find((substitution) => {
@@ -14,15 +14,15 @@ function verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitut
   }) || null;
 
   if (substitution !== null) {
-    const metastatementNode = metastatementNodeB, ///
-          substitutionMetastatementNode = substitution.matchMetastatementNode(metastatementNode);
+    const statementNode = statementNodeB, ///
+          substitutionStatementNode = substitution.matchStatementNode(statementNode);
 
-    metavariableNodeVerified = substitutionMetastatementNode;  ///
+    metavariableNodeVerified = substitutionStatementNode;  ///
   } else {
     const metavariableNode = metavariableNodeA, ///
-          metastatementNode = metastatementNodeB, ///
-          metastatementForMetavariableSubstitution = MetastatementForMetavariableSubstitution.fromMetavariableNodeAndMetastatementNode(metavariableNode, metastatementNode),
-          substitution = metastatementForMetavariableSubstitution;  ///
+          statementNode = statementNodeB, ///
+          statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromMetavariableNodeAndStatementNode(metavariableNode, statementNode),
+          substitution = statementForMetavariableSubstitution;  ///
 
     substitutions.push(substitution);