occam-verify-cli 0.0.922 → 0.0.923

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.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;
 
@@ -404,8 +360,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 +371,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 +395,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/metaLemmaMetatheorem.js

@@ -1,17 +1,17 @@
 "use strict";
 
 import Label from "./label";
-import MetaConsequent from "./metaConsequent";
-import MetaSupposition from "./metaSupposition";
-import MetastatementForMetavariableSubstitution from "./substitution/metastatementForMetavariable";
+import Consequent from "./consequent";
+import Supposition from "./supposition";
+import StatementForMetavariableSubstitution from "./substitution/statementForMetavariable";
 
 import { reverse, correlate } from "./utilities/array";
 
 export default class MetaLemmaMetatheorem {
-  constructor(labels, metaSuppositions, metaConsequent, substitutions, fileContext) {
+  constructor(labels, suppositions, consequent, substitutions, fileContext) {
     this.labels = labels;
-    this.metaSuppositions = metaSuppositions;
-    this.metaConsequent = metaConsequent;
+    this.suppositions = suppositions;
+    this.consequent = consequent;
     this.substitutions = substitutions;
     this.fileContext = fileContext;
   }
@@ -20,12 +20,12 @@ export default class MetaLemmaMetatheorem {
     return this.labels;
   }
 
-  getMetaSuppositions() {
-    return this.metaSuppositions;
+  getSuppositions() {
+    return this.suppositions;
   }
 
-  getMetaConsequent() {
-    return this.metaConsequent;
+  getConsequent() {
+    return this.consequent;
   }
 
   getSubstitutions() {
@@ -36,20 +36,20 @@ export default class MetaLemmaMetatheorem {
     return this.fileContext;
   }
 
-  matchMetastatement(metastatementNode, localContext) {
-    let metastatementNatches = false;
+  matchStatement(statementNode, localContext) {
+    let statementNatches = false;
 
     const metaproofSteps = localContext.getProofSteps(),
           substitutions = [],
-          metaSuppositionsMatch = matchMetaSuppositions(this.metaSuppositions, metaproofSteps, substitutions, this.fileContext, localContext);
+          suppositionsMatch = matchSuppositions(this.suppositions, metaproofSteps, substitutions, this.fileContext, localContext);
 
-    if (metaSuppositionsMatch) {
-      const metaConsequentMatches = matchMetaConsequent(this.metaConsequent, metastatementNode, substitutions, this.fileContext, localContext);
+    if (suppositionsMatch) {
+      const consequentMatches = matchConsequent(this.consequent, statementNode, substitutions, this.fileContext, localContext);
 
-      metastatementNatches = metaConsequentMatches;  ///
+      statementNatches = consequentMatches;  ///
     }
 
-    return metastatementNatches;
+    return statementNatches;
   }
 
   matchMetavariableNode(metavariableNode) {
@@ -70,12 +70,12 @@ export default class MetaLemmaMetatheorem {
 
             return labelJSON;
           }),
-          metaSuppositionsJSON = this.metaSuppositions.map((metaSupposition) => {
-            const metaSuppositionJSON = metaSupposition.toJSON(tokens);
+          suppositionsJSON = this.suppositions.map((supposition) => {
+            const suppositionJSON = supposition.toJSON(tokens);
 
-            return metaSuppositionJSON;
+            return suppositionJSON;
           }),
-          metaConsequentJSON = this.metaConsequent.toJSON(tokens),
+          consequentJSON = this.consequent.toJSON(tokens),
           substitutionsJSON = this.substitutions.map((substitution) => {
             const substitutionJSON = substitution.toJSON();
 
@@ -83,14 +83,14 @@ export default class MetaLemmaMetatheorem {
           }),
           localContextJSON = this.fileContext.toJSON(tokens),
           labels = labelsJSON,  ///
-          metaSuppositions = metaSuppositionsJSON,  ///
-          metaConsequent = metaConsequentJSON,  ///
+          suppositions = suppositionsJSON,  ///
+          consequent = consequentJSON,  ///
           substitutions = substitutionsJSON,  ///
           fileContext = localContextJSON,  ///
           json = {
             labels,
-            metaSuppositions,
-            metaConsequent,
+            suppositions,
+            consequent,
             substitutions,
             fileContext
           };
@@ -110,79 +110,79 @@ export default class MetaLemmaMetatheorem {
       return label;
     });
 
-    let { metaSuppositions, metaConsequent, substitutions } = json;
+    let { suppositions, consequent, substitutions } = json;
 
-    const metaSuppositionsJSON = metaSuppositions;  ///
+    const suppositionsJSON = suppositions;  ///
 
-    metaSuppositions = metaSuppositionsJSON.map((metaSuppositionJSON) => {
-      const json = metaSuppositionJSON, ///
-            metaSupposition = MetaSupposition.fromJSONAndFileContext(json, fileContext);
+    suppositions = suppositionsJSON.map((suppositionJSON) => {
+      const json = suppositionJSON, ///
+            supposition = Supposition.fromJSONAndFileContext(json, fileContext);
 
-      return metaSupposition;
+      return supposition;
     });
 
-    const metaConsequentJSON = metaConsequent;  ///
+    const consequentJSON = consequent;  ///
 
-    json = metaConsequentJSON;  ///
+    json = consequentJSON;  ///
 
-    metaConsequent = MetaConsequent.fromJSONAndFileContext(json, fileContext);
+    consequent = Consequent.fromJSONAndFileContext(json, fileContext);
 
     const substitutionsJSON = substitutions;  ///
 
     substitutions = substitutionsJSON.map((substitutionJSON) => {
       const json = substitutionJSON,  ///
-            metastatementForMetavariableSubstitution = MetastatementForMetavariableSubstitution.fromJSONAndFileContext(json, fileContext),
-            substitution = metastatementForMetavariableSubstitution;  ///
+            statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromJSONAndFileContext(json, fileContext),
+            substitution = statementForMetavariableSubstitution;  ///
 
       return substitution;
     });
 
-    return new Class(labels, metaSuppositions, metaConsequent, substitutions, fileContext);  ///
+    return new Class(labels, suppositions, consequent, substitutions, fileContext);  ///
   }
 
-  static fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(Class, labels, metaSuppositions, metaConsequent, substitutions, fileContext) { return new Class(labels, metaSuppositions, metaConsequent, substitutions, fileContext); }
+  static fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(Class, labels, suppositions, consequent, substitutions, fileContext) { return new Class(labels, suppositions, consequent, substitutions, fileContext); }
 }
 
-function matchMetaSuppositions(metaSuppositions, metaproofSteps, substitutions, fileContext, localContext) {
-  metaSuppositions = reverse(metaSuppositions); ///
+function matchSuppositions(suppositions, metaproofSteps, substitutions, fileContext, localContext) {
+  suppositions = reverse(suppositions); ///
 
   metaproofSteps = reverse(metaproofSteps); ///
 
-  const metaSuppositionsMatch = correlate(metaSuppositions, metaproofSteps, (metaSupposition, metaproofStep) => {
-    const metaSuppositionMatches = matchMetaSupposition(metaSupposition, metaproofStep, substitutions, fileContext, localContext);
+  const suppositionsMatch = correlate(suppositions, metaproofSteps, (supposition, metaproofStep) => {
+    const suppositionMatches = matchSupposition(supposition, metaproofStep, substitutions, fileContext, localContext);
 
-    if (metaSuppositionMatches) {
+    if (suppositionMatches) {
       return true;
     }
   });
 
-  return metaSuppositionsMatch;
+  return suppositionsMatch;
 }
 
-function matchMetaSupposition(metaSupposition, metaproofStep, substitutions, fileContext, localContext) {
-  let matchesMetaSupposition = false;
+function matchSupposition(supposition, metaproofStep, substitutions, fileContext, localContext) {
+  let matchesSupposition = false;
 
-  const metaSubproofNode = metaproofStep.getMetaSubproofNode(),
-        metastatementNode = metaproofStep.getMetastatementNode();
+  const metaSubproofNode = metaproofStep.getSubproofNode(),
+        statementNode = metaproofStep.getStatementNode();
 
   if (metaSubproofNode !== null) {
-    const metaSuppositionMatchesMetaSubproofNode = metaSupposition.matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localContext);
+    const suppositionMatchesSubproofNode = supposition.matchSubproofNode(metaSubproofNode, substitutions, fileContext, localContext);
 
-    matchesMetaSupposition - metaSuppositionMatchesMetaSubproofNode; ///
+    matchesSupposition - suppositionMatchesSubproofNode; ///
   }
 
-  if (metastatementNode !== null) {
-    const metaSuppositionMatchesMetastatementNode = metaSupposition.matchMetastatementNode(metastatementNode, substitutions, fileContext, localContext);
+  if (statementNode !== null) {
+    const suppositionMatchesStatementNode = supposition.matchStatementNode(statementNode, substitutions, fileContext, localContext);
 
-    matchesMetaSupposition - metaSuppositionMatchesMetastatementNode; ///
+    matchesSupposition - suppositionMatchesStatementNode; ///
   }
 
-  return matchesMetaSupposition;
+  return matchesSupposition;
 }
 
-function matchMetaConsequent(metaConsequent, metastatementNode, substitutions, fileContext, localContext) {
-  const metaConsequentMatchesMetastatementNode = metaConsequent.matchMetastatementNode(metastatementNode, substitutions, fileContext, localContext),
-        metaConsequentMatches = metaConsequentMatchesMetastatementNode; ///
+function matchConsequent(consequent, statementNode, substitutions, fileContext, localContext) {
+  const consequentMatchesStatementNode = consequent.matchStatementNode(statementNode, substitutions, fileContext, localContext),
+        consequentMatches = consequentMatchesStatementNode; ///
 
-  return metaConsequentMatches;
+  return consequentMatches;
 }

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