occam-verify-cli 0.0.1246 → 0.0.1248

package/src/dom/frame.js

@@ -70,93 +70,6 @@ export default domAssigned(class Frame {
     return equalTo;
   }
 
-  unifySubstitution(substitution, context) {
-    let substitutionUnified = false;
-
-    const frameString = this.string,  ///
-          substitutionString = substitution.getString();
-
-    context.trace(`Unifying the '${substitutionString}' substitution with the '${frameString}' frame...`)
-
-    if (!substitutionUnified) {
-      substitutionUnified = this.declarations.some((declaration) => {
-        const substitutionUnified = declaration.unifySubstitution(substitution, context);
-
-        if (substitutionUnified) {
-          return true;
-        }
-      });
-    }
-
-    if (!substitutionUnified) {
-      substitutionUnified = this.metavariables.some((metavariable) => {
-        const substitutionUnified = metavariable.unifySubstitution(substitution, context);
-
-        if (substitutionUnified) {
-          return true;
-        }
-      });
-    }
-
-    if (substitutionUnified) {
-      context.debug(`...unified the '${substitutionString}' substitution with the '${frameString}' frame...`)
-    }
-
-    return substitutionUnified;
-  }
-
-  unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context) {
-    let metaLemmaMetatheoremUnified;
-
-    const frameString = this.string,  ///
-          metaLemmaMetatheoremString = metaLemmaMetatheorem.getString();
-
-    context.trace(`Unifying the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${frameString}' frame...`);
-
-    const substitutions = metaLemmaMetatheorem.getSubstitutions(),
-          substitutionsUnified = substitutions.everySubstitution((substitution) => {
-            const substitutionUnified = this.unifySubstitution(substitution, context);
-
-            if (substitutionUnified) {
-              return true;
-            }
-          });
-
-    metaLemmaMetatheoremUnified = substitutionsUnified; ///
-
-    if (metaLemmaMetatheoremUnified) {
-      context.debug(`...unified the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${frameString}' frame.`);
-    }
-
-    return metaLemmaMetatheoremUnified;
-  }
-
-  unifyAxiomLemmaTheoremOrConjecture(axiomLemmaTheoremOrConjecture, context) {
-    let axiomLemmaTheoremOrConjectureUnified;
-
-    const frameString = this.string,  ///
-          axiomLemmaTheoremStringOrConjecture = axiomLemmaTheoremOrConjecture.getString();
-
-    context.trace(`Unifying the '${axiomLemmaTheoremStringOrConjecture}' axiom, lemma, theorem or conjecture with the '${frameString}' frame...`);
-
-    const substitutions = axiomLemmaTheoremOrConjecture.getSubstitutions(),
-          substitutionsUnified = substitutions.everySubstitution((substitution) => {
-            const substitutionUnified = this.unifySubstitution(substitution, context);
-
-            if (substitutionUnified) {
-              return true;
-            }
-          });
-
-    axiomLemmaTheoremOrConjectureUnified = substitutionsUnified; ///
-
-    if (axiomLemmaTheoremOrConjectureUnified) {
-      context.debug(`...unified the '${axiomLemmaTheoremStringOrConjecture}' axiom, lemma, theorem or conjecture with the '${frameString}' frame.`);
-    }
-
-    return axiomLemmaTheoremOrConjectureUnified;
-  }
-
   verify(assignments, stated, context) {
     let verified = false;
 
@@ -164,14 +77,10 @@ export default domAssigned(class Frame {
 
     context.trace(`Verifying the '${frameString}' frame...`);
 
-    const declarationsVerified = this.verifyDeclarations(this.declarations, assignments, stated, context);
+    const declarationsVerified = this.verifyDeclarations(assignments, stated, context);
 
     if (declarationsVerified) {
-      const  metavariablesVerified = this.metavariables.every((metavariable) => {
-        const metavariableVerified = metavariable.verify(context);
-
-        return metavariableVerified;
-      });
+      const  metavariablesVerified = this.verifyMetavariables(assignments, stated, context);
 
       if (metavariablesVerified) {
         let verifiedWhenStated = false,
@@ -196,21 +105,53 @@ export default domAssigned(class Frame {
     return verified;
   }
 
-  verifyDeclarations(declarations, assignments, stated, context) {
+  verifyDeclarations(assignments, stated, context) {
+    let declarationsVerified;
+
+    const frameString = this.string,  ///
+          declarationsString = declarationsStringFromDeclarations(this.declarations);
+
+    context.trace(`Verifying the '${frameString}' frame's '${declarationsString}' declarations...`);
+
     stated = true;  ///
 
     assignments = null; ///
 
-    const declarationsVerified = declarations.every((declaration) => {
+    declarationsVerified = this.declarations.every((declaration) => {
       const frame = null, ///
             declarationVerified = declaration.verify(frame, assignments, stated, context);
 
       return declarationVerified;
     });
 
+    if (declarationsVerified) {
+      context.debug(`...verified the '${frameString}' frame's '${declarationsString}' declarations.`);
+    }
+
     return declarationsVerified;
   }
 
+  verifyMetavariables(assignments, stated, context) {
+    let metavariablesVerified;
+
+    const frameString = this.string,  ///
+          metavariablesString = metavariablesStringFromDeclarations(this.metavariables);
+
+    context.trace(`Verifying the '${frameString}' frame's '${metavariablesString}' metavariables...`);
+
+    metavariablesVerified = this.metavariables.every((metavariable) => {
+      const metavariableVerified = metavariable.verify(context);
+
+      return metavariableVerified;
+    });
+
+    if (metavariablesVerified) {
+      context.debug(`...verified the '${frameString}' frame's '${metavariablesString}' metavariables.`);
+    }
+
+    return metavariablesVerified;
+  }
+
   verifyWhenStated(assignments, context) {
     let verifiedWhenStated = false;
 
@@ -278,6 +219,93 @@ export default domAssigned(class Frame {
     return verifiedGivenMetaType;
   }
 
+  unifySubstitution(substitution, context) {
+    let substitutionUnified = false;
+
+    const frameString = this.string,  ///
+          substitutionString = substitution.getString();
+
+    context.trace(`Unifying the '${substitutionString}' substitution with the '${frameString}' frame...`)
+
+    if (!substitutionUnified) {
+      substitutionUnified = this.declarations.some((declaration) => {
+        const substitutionUnified = declaration.unifySubstitution(substitution, context);
+
+        if (substitutionUnified) {
+          return true;
+        }
+      });
+    }
+
+    if (!substitutionUnified) {
+      substitutionUnified = this.metavariables.some((metavariable) => {
+        const substitutionUnified = metavariable.unifySubstitution(substitution, context);
+
+        if (substitutionUnified) {
+          return true;
+        }
+      });
+    }
+
+    if (substitutionUnified) {
+      context.debug(`...unified the '${substitutionString}' substitution with the '${frameString}' frame...`)
+    }
+
+    return substitutionUnified;
+  }
+
+  unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context) {
+    let metaLemmaMetatheoremUnified;
+
+    const frameString = this.string,  ///
+          metaLemmaMetatheoremString = metaLemmaMetatheorem.getString();
+
+    context.trace(`Unifying the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${frameString}' frame...`);
+
+    const substitutions = metaLemmaMetatheorem.getSubstitutions(),
+          substitutionsUnified = substitutions.everySubstitution((substitution) => {
+            const substitutionUnified = this.unifySubstitution(substitution, context);
+
+            if (substitutionUnified) {
+              return true;
+            }
+          });
+
+    metaLemmaMetatheoremUnified = substitutionsUnified; ///
+
+    if (metaLemmaMetatheoremUnified) {
+      context.debug(`...unified the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${frameString}' frame.`);
+    }
+
+    return metaLemmaMetatheoremUnified;
+  }
+
+  unifyAxiomLemmaTheoremOrConjecture(axiomLemmaTheoremOrConjecture, context) {
+    let axiomLemmaTheoremOrConjectureUnified;
+
+    const frameString = this.string,  ///
+          axiomLemmaTheoremStringOrConjecture = axiomLemmaTheoremOrConjecture.getString();
+
+    context.trace(`Unifying the '${axiomLemmaTheoremStringOrConjecture}' axiom, lemma, theorem or conjecture with the '${frameString}' frame...`);
+
+    const substitutions = axiomLemmaTheoremOrConjecture.getSubstitutions(),
+          substitutionsUnified = substitutions.everySubstitution((substitution) => {
+            const substitutionUnified = this.unifySubstitution(substitution, context);
+
+            if (substitutionUnified) {
+              return true;
+            }
+          });
+
+    axiomLemmaTheoremOrConjectureUnified = substitutionsUnified; ///
+
+    if (axiomLemmaTheoremOrConjectureUnified) {
+      context.debug(`...unified the '${axiomLemmaTheoremStringOrConjecture}' axiom, lemma, theorem or conjecture with the '${frameString}' frame.`);
+    }
+
+    return axiomLemmaTheoremOrConjectureUnified;
+  }
+
   static name = "Frame";
 
   static fromFrameNode(frameNode, context) {
@@ -369,3 +397,31 @@ function metavariablesFromFrameNode(frameNode, context) {
 
   return metavariables;
 }
+
+function declarationsStringFromDeclarations(declarations) {
+  const declarationsString = declarations.reduce((declarationsString, declaration) => {
+    const declarationString = declaration.getString();
+
+    declarationsString = (declarationsString === null) ?
+                           declarationString :
+                            `${declarationsString}, ${declarationString}`;
+
+    return declarationsString;
+  }, null);
+
+  return declarationsString;
+}
+
+function metavariablesStringFromDeclarations(metavariable) {
+  const metavariablesString = metavariable.reduce((metavariablesString, metavariable) => {
+    const metavariableString = metavariable.getString();
+
+    metavariablesString = (metavariablesString === null) ?
+                            metavariableString :
+                             `${metavariablesString}, ${metavariableString}`;
+
+    return metavariablesString;
+  }, null);
+
+  return metavariablesString;
+}

package/src/dom/judgement.js

@@ -38,10 +38,10 @@ export default domAssigned(class Judgement {
 
     context.trace(`Verifying the '${judgementString}' judgement...`);
 
-    const frameVerified = this.frame.verify(assignments, stated, context);
+    const frameVerified = this.verifyFrame(assignments, stated, context);
 
     if (frameVerified) {
-      const declarationVerified = this.declaration.verify(this.frame, assignments, stated, context);
+      const declarationVerified = this.verifyDeclaration(assignments, stated, context);
 
       if (declarationVerified) {
         let verifiedWhenStated = false,
@@ -64,6 +64,40 @@ export default domAssigned(class Judgement {
     return verified;
   }
 
+  verifyFrame(assignments, stated, context) {
+    let frameVerified;
+
+    const frameString = this.frame.getString(),
+          judgementString = this.string;  ///
+
+    context.trace(`Verifying the '${judgementString}' judgement's '${frameString}' frame...`);
+
+    frameVerified = this.frame.verify(assignments, stated, context);
+
+    if (frameVerified) {
+      context.debug(`...verified the '${judgementString}' judgement's '${frameString}' frame.`);
+    }
+
+    return frameVerified;
+  }
+
+  verifyDeclaration(assignments, stated, context) {
+    let declarationVerified;
+
+    const judgementString = this.string,  ///
+          declarationString = this.declaration.getString();
+
+    context.trace(`Verifying the '${judgementString}' judgement's '${declarationString}' declaration...`);
+
+    declarationVerified = this.declaration.verify(this.frame, assignments, stated, context);
+
+    if (declarationVerified) {
+      context.debug(`...verified the '${judgementString}' judgement's '${declarationString}' declaration.`);
+    }
+
+    return declarationVerified;
+  }
+
   verifyWhenStated(assignments, context) {
     let verifiedWhenStated;
 

package/src/dom/label.js

@@ -7,14 +7,19 @@ import { domAssigned } from "../dom";
 import { metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
 
 export default domAssigned(class Label {
-  constructor(metavariable) {
+  constructor(metavariable, fileContext) {
     this.metavariable = metavariable;
+    this.fileContext = fileContext;
   }
 
   getMetavariable() {
     return this.metavariable;
   }
 
+  getFileContext() {
+    return this.fileContext;
+  }
+
   getString() { return this.metavariable.getString(); }
 
   getMetavariableName() {
@@ -33,36 +38,36 @@ export default domAssigned(class Label {
 
   matchMetavariableNode(metavariableNode) { return this.metavariable.matchMetavariableNode(metavariableNode); }
 
-  verifyWhenDeclared(fileContext, nameOnly) {
-    let verifiedWhenDeclared = false;
+  verify(nameOnly) {
+    let verified = false;
 
     const labelString = this.getString(); ///
 
-    fileContext.trace(`Verifying the '${labelString}' label when declared...`);
+    this.fileContext.trace(`Verifying the '${labelString}' label...`);
 
     let labelPresent;
 
     if (nameOnly) {
       const metavariableName = this.getMetavariableName();
 
-      labelPresent = fileContext.isLabelPresentByMetavariableName(metavariableName);
+      labelPresent = this.fileContext.isLabelPresentByMetavariableName(metavariableName);
     } else {
       const metavariableNode = this.getMetavariableNode();
 
-      labelPresent = fileContext.isLabelPresentByMetavariableNode(metavariableNode);
+      labelPresent = this.fileContext.isLabelPresentByMetavariableNode(metavariableNode);
     }
 
     if (labelPresent) {
-      fileContext.debug(`The '${labelString}' label is already present.`);
+      this.fileContext.debug(`The '${labelString}' label is already present.`);
     } else {
-      verifiedWhenDeclared = true;
+      verified = true;
     }
 
-    if (verifiedWhenDeclared) {
-      fileContext.debug(`...verified the '${labelString}' label when declared.`);
+    if (verified) {
+      this.fileContext.debug(`...verified the '${labelString}' label.`);
     }
 
-    return verifiedWhenDeclared;
+    return verified;
   }
 
   toJSON() {
@@ -79,7 +84,7 @@ export default domAssigned(class Label {
 
   static fromJSON(json, fileContext) {
     const metavariable = metavariableFromJSON(json, fileContext),
-          label = new Label(metavariable);
+          label = new Label(metavariable, fileContext);
 
     return label;
   }
@@ -88,7 +93,7 @@ export default domAssigned(class Label {
     const { Metavariable } = dom,
           localContext = LocalContext.fromFileContext(fileContext),
           metavariable = Metavariable.fromLabelNode(labelNode, localContext),
-          label = new Label(metavariable);
+          label = new Label(metavariable, fileContext);
 
     return label;
   }

package/src/dom/metaLemma.js

@@ -1,72 +1,10 @@
 "use strict";
 
-import LocalContext from "../context/local";
-import TopLevelAssertion from "./topLevelAssertion";
+import TopLevelMetaAssertion from "./topLevelMetaAssertion";
 
 import { domAssigned } from "../dom";
 
-export default domAssigned(class MetaLemma extends TopLevelAssertion {
-  unifyReference(reference, substitutions, context) {
-    let referenceUnified;
-
-    const metaLemma = this, ///
-          referenceString = reference.getString(),
-          metaLemmaString = metaLemma.getString();
-
-    context.trace(`Unifying the '${referenceString}' reference with the '${metaLemmaString}' meta-lemma...`);
-
-    const fileContext = this.getFileContext(),
-          localContext = LocalContext.fromFileContext(fileContext),
-          generalContext = localContext,  ///
-          specificContext = context, ///
-          labelUnified = this.labels.some((label) => {
-            substitutions.clear();
-
-            const referenceUnified = reference.unifyLabel(label, substitutions, generalContext, specificContext);
-
-            if (referenceUnified) {
-              return true;
-            }
-          });
-
-    referenceUnified = labelUnified;  ///
-
-    if (referenceUnified) {
-      context.debug(`...unified the '${referenceString}' reference with the '${metaLemmaString}' meta-lemma.`);
-    }
-
-    return referenceUnified;
-  }
-
-  unifyStatement(statement, substitutions, context) {
-    let statementUnified;
-
-    const metaLemma = this, ///
-          statementString = statement.getString(),
-          metaLemmaString = metaLemma.getString();
-
-    context.trace(`Unifying the '${statementString}' statement with the '${metaLemmaString}' meta-lemma...`);
-
-    const suppositions = this.getSuppositions(),
-          suppositionsLength = suppositions.length;
-
-    if (suppositionsLength === 0) {
-      const fileContext = this.getFileContext(),
-            localContext = LocalContext.fromFileContext(fileContext),
-            generalContext = localContext,  ///
-            specificContext = context,  ///
-            statementUnifiedWithConsequent = this.unifyStatementWithConsequent(statement, substitutions, generalContext, specificContext);
-
-      statementUnified = statementUnifiedWithConsequent;  ///
-    }
-
-    if (statementUnified) {
-      context.debug(`...unified the '${statementString}' statement with the '${metaLemmaString}' meta-lemma.`);
-    }
-
-    return statementUnified;
-  }
-
+export default domAssigned(class MetaLemma extends TopLevelMetaAssertion {
   verify() {
     let verified;
 
@@ -89,20 +27,9 @@ export default domAssigned(class MetaLemma extends TopLevelAssertion {
     return verified;
   }
 
-  verifyLabels() {
-    const labelsVerified = this.labels.every((label) => {
-      const nameOnly = false,
-            labelVVerifiedWhenDeclared = label.verifyWhenDeclared(this.fileContext, nameOnly);
-
-      if (labelVVerifiedWhenDeclared) {
-        return true;
-      }
-    });
-
-    return labelsVerified;
-  }
-
   static name = "MetaLemma";
 
-  static fromMetaLemmaNode(metaLemmaNode, fileContext) { return TopLevelAssertion.fromNode(MetaLemma, metaLemmaNode, fileContext); }
+  static fromJSON(json, fileContext) { return TopLevelMetaAssertion.fromJSON(MetaLemma, json, fileContext); }
+
+  static fromMetaLemmaNode(axiomNode, fileContext) { return TopLevelMetaAssertion.fromNode(MetaLemma, axiomNode, fileContext); }
 });

package/src/dom/metatheorem.js

@@ -1,89 +1,18 @@
 "use strict";
 
-import LocalContext from "../context/local";
-import TopLevelAssertion from "./topLevelAssertion";
+import TopLevelMetaAssertion from "./topLevelMetaAssertion";
 
 import { domAssigned } from "../dom";
-import { stringFromLabels } from "./topLevelAssertion";
-import { labelsFromJSON,
-         labelsToLabelsJSON,
-         consequentFromJSON,
-         suppositionsFromJSON,
-         substitutionsFromJSON,
-         consequentToConsequentJSON,
-         suppositionsToSuppositionsJSON,
-         substitutionsToSubstitutionsJSON } from "../utilities/json";
-
-export default domAssigned(class Metatheorem extends TopLevelAssertion {
-  unifyReference(reference, substitutions, context) {
-    let referenceUnified;
-
-    const metatheorem = this, ///
-          referenceString = reference.getString(),
-          metatheoremString = metatheorem.getString();
-
-    context.trace(`Unifying the '${referenceString}' reference with the '${metatheoremString}' metatheorem...`);
-
-    const fileContext = this.getFileContext(),
-          localContext = LocalContext.fromFileContext(fileContext),
-          generalContext = localContext,  ///
-          specificContext = context, ///
-          labelUnified = this.labels.some((label) => {
-            substitutions.clear();
-
-            const referenceUnified = reference.unifyLabel(label, substitutions, generalContext, specificContext);
-
-            if (referenceUnified) {
-              return true;
-            }
-          });
-
-    referenceUnified = labelUnified;  ///
-
-    if (referenceUnified) {
-      context.debug(`...unified the '${referenceString}' reference with the '${metatheoremString}' metatheorem.`);
-    }
-
-    return referenceUnified;
-  }
-
-  unifyStatement(statement, substitutions, context) {
-    let statementUnified;
-
-    const metatheorem = this, ///
-          statementString = statement.getString(),
-          metatheoremString = metatheorem.getString();
-
-    context.trace(`Unifying the '${statementString}' statement with the '${metatheoremString}' metatheorem...`);
-
-    const suppositions = this.getSuppositions(),
-          suppositionsLength = suppositions.length;
-
-    if (suppositionsLength === 0) {
-      const fileContext = this.getFileContext(),
-            localContext = LocalContext.fromFileContext(fileContext),
-            generalContext = localContext,  ///
-            specificContext = context,  ///
-            statementUnifiedWithConsequent = this.unifyStatementWithConsequent(statement, substitutions, generalContext, specificContext);
-
-      statementUnified = statementUnifiedWithConsequent;  ///
-    }
-
-    if (statementUnified) {
-      context.debug(`...unified the '${statementString}' statement with the '${metatheoremString}' metatheorem.`);
-    }
-
-    return statementUnified;
-  }
 
+export default domAssigned(class Metatheorem extends TopLevelMetaAssertion {
   verify() {
     let verified;
 
-    const metatheorem = this, ///
+    const metaLemma = this, ///
           fileContext = this.getFileContext(),
-          metatheoremString = metatheorem.getString();
+          metaLemmaString = metaLemma.getString();
 
-    fileContext.trace(`Verifying the '${metatheoremString}' metatheorem...`);
+    fileContext.trace(`Verifying the '${metaLemmaString}' metatheorem...`);
 
     verified = super.verify();
 
@@ -92,57 +21,15 @@ export default domAssigned(class Metatheorem extends TopLevelAssertion {
 
       fileContext.addMetatheorem(metaTheorem);
 
-      fileContext.debug(`...verified the '${metatheoremString}' metatheorem.`);
+      fileContext.debug(`...verified the '${metaLemmaString}' metatheorem.`);
     }
 
     return verified;
   }
 
-  verifyLabels() {
-    const labelsVerified = this.labels.every((label) => {
-      const nameOnly = false,
-            labelVVerifiedWhenDeclared = label.verifyWhenDeclared(this.fileContext, nameOnly);
-
-      if (labelVVerifiedWhenDeclared) {
-        return true;
-      }
-    });
-
-    return labelsVerified;
-  }
-
-  toJSON() {
-    const labelsJSON = labelsToLabelsJSON(this.labels),
-          consequentJSON = consequentToConsequentJSON(this.consequent),
-          suppositionsJSON = suppositionsToSuppositionsJSON(this.suppositions),
-          substitutionsJSON = substitutionsToSubstitutionsJSON(this.substitutions),
-          labels = labelsJSON,  ///
-          consequent = consequentJSON,  ///
-          suppositions = suppositionsJSON,  ///
-          substitutions = substitutionsJSON,  ///
-          json = {
-            labels,
-            consequent,
-            suppositions,
-            substitutions
-          };
-
-    return json;
-  }
-
   static name = "Metatheorem";
 
-  static fromJSON(json, fileContext) {
-    const labels = labelsFromJSON(json, fileContext),
-          consequent = consequentFromJSON(json, fileContext),
-          suppositions = suppositionsFromJSON(json, fileContext),
-          substitutions = substitutionsFromJSON(json, fileContext),
-          string = stringFromLabels(labels),
-          proof = null,
-          topLevelAssertion = new Metatheorem(fileContext, string, labels, substitutions, suppositions, consequent, proof);
-
-    return topLevelAssertion;
-  }
+  static fromJSON(json, fileContext) { return TopLevelMetaAssertion.fromJSON(Metatheorem, json, fileContext); }
 
-  static fromMetatheoremNode(metatheoremNode, fileContext) { return TopLevelAssertion.fromNode(Metatheorem, metatheoremNode, fileContext); }
+  static fromMetatheoremNode(axiomNode, fileContext) { return TopLevelMetaAssertion.fromNode(Metatheorem, axiomNode, fileContext); }
 });