occam-verify-cli 0.0.1245 → 0.0.1247

package/src/context/local.js

@@ -165,9 +165,9 @@ class LocalContext {
     let variableAdded = false;
 
     const variableName = variable.getNode(),
-          variableDeclared = this.isVariableDeclaredByVariableName(variableName, nested);
+          variablePresent = this.isVariablePresentByVariableName(variableName, nested);
 
-    if (!variableDeclared) {
+    if (!variablePresent) {
       this.variables.push(variable);
 
       variableAdded = true;
@@ -217,75 +217,23 @@ class LocalContext {
     return termType;
   }
 
-  isTermGrounded(term) {
-    const context = this, ///
-          equivalences = this.getEquivalences(),
-          groundedTerms = [],
-          definedVariables = [];
-
-    equivalences.separateGroundedTermsAndDefinedVariables(groundedTerms, definedVariables, context);
-
-    const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
-            const groundedTermNode = groundedTerm.getNode(),
-                  groundedTermNodeMatches = term.matchTermNode(groundedTermNode);
-
-            if (groundedTermNodeMatches) {
-              return true;
-            }
-          }),
-          termGrounded = termMatchesGroundedTerm; ///
-
-    return termGrounded;
-  }
-
-  isVariableDefined(variable) {
-    const context = this, ///
-          equivalences = this.getEquivalences(),
-          groundedTerms = [],
-          definedVariables = [];
-
-    equivalences.separateGroundedTermsAndDefinedVariables(groundedTerms, definedVariables, context);
-
-    const variableMatchesDefinedVariable = definedVariables.some((definedVariable) => {
-            const definedVariableEqualToVariable = definedVariable.isEqualTo(variable);
-
-            if (definedVariableEqualToVariable === variable) {
-              return true;
-            }
-          }),
-          variableDefined = variableMatchesDefinedVariable; ///
-
-    return variableDefined;
-  }
-
-  isMetavariableDefined(metavariable) {
-    const judgementPresent = this.isJudgementPresentByMetavariable(metavariable),
-      metavariableDefined = judgementPresent; ///
-
-    return metavariableDefined
-  }
+  findLabelByReference(reference, context) { return this.context.findLabelByReference(reference, context); }
 
-  isMetavariableDeclared(metavariable, generalContext, specificContext) { return this.context.isMetavariableDeclared(metavariable, generalContext, specificContext); }
+  findRuleByReference(reference) { return this.context.findRuleByReference(reference); }
 
-  isTypeDeclaredByTypeName(typeName) { return this.context.isTypeDeclaredByTypeName(typeName); }
+  findAxiomByReference(reference) { return this.context.findAxiomByReference(reference); }
 
-  isLabelPresentByMetavariableName(metavariableName) { return this.context.isLabelPresentByMetavariableName(metavariableName); }
+  findLemmaByReference(reference) { return this.context.findLemmaByReference(reference); }
 
-  isLabelPresentByMetavariableNode(metavariableNode) { return this.context.isLabelPresentByMetavariableNode(metavariableNode); }
+  findTheoremByReference(reference) { return this.context.findTheoremByReference(reference); }
 
-  isVariableDeclaredByVariableName(variableName, nested = true) {
-    const variable = this.findVariableByVariableName(variableName, nested),
-          variableDeclared = (variable !== null);
+  findProcedureByReference(reference) { return this.context.findProcedureByReference(reference); }
 
-    return variableDeclared;
-  }
+  findConjectureByReference(reference) { return this.context.findConjectureByReference(reference); }
 
-  isJudgementPresentByMetavariable(metavariable) {
-    const judgement = this.findJudgementByMetavariable(metavariable),
-          judgementPresent = (judgement !== null);
+  findMetaLemmasByReference(reference) { return this.context.findMetaLemmasByReference(reference); }
 
-    return judgementPresent;
-  }
+  findMetatheoremsByReference(reference) { return this.context.findMetatheoremsByReference(reference); }
 
   findVariableByVariableName(variableName, nested = true) {
     const variables = this.getVariables(nested),
@@ -321,49 +269,91 @@ class LocalContext {
 
   findTypeByTypeName(typeName) { return this.context.findTypeByTypeName(typeName); }
 
+  findLabelByMetavariable(metavariable) { return this.context.findLabelByMetavariable(metavariable); }
+
   findMetaTypeByMetaTypeName(metaTypeName) { return this.context.findMetaTypeByMetaTypeName(metaTypeName); }
 
   findMetavariableByMetavariableName(metavariableName) { return this.context.findMetavariableByMetavariableName(metavariableName); }
 
-  findLabelByMetavariable(metavariable) { return this.context.findLabelByMetavariable(metavariable); }
+  isLabelPresentByReference(reference) { return this.context.isLabelPresentByReference(reference); }
 
-  findRuleByReference(reference) { return this.context.findRuleByReference(reference); }
+  isProcedurePresentByReference(reference) { return this.context.isProcedurePresentByReference(reference); }
 
-  findAxiomByReference(reference) { return this.context.findAxiomByReference(reference); }
+  isMetavariablePresentByReference(reference) { return this.context.isMetavariablePresentByReference(reference); }
 
-  findLemmaByReference(reference) { return this.context.findLemmaByReference(reference); }
+  findAxiomLemmaTheoremConjectureByReference(reference) { return this.context.findAxiomLemmaTheoremConjectureByReference(reference); }
 
-  findTheoremByReference(reference) { return this.context.findTheoremByReference(reference); }
+  isMetavariablePresent(metavariable, generalContext, specificContext) { return this.context.isMetavariablePresent(metavariable, generalContext, specificContext); }
 
-  findProcedureByReference(reference) { return this.context.findProcedureByReference(reference); }
+  isTypePresentByTypeName(typeName) { return this.context.isTypePresentByTypeName(typeName); }
 
-  findConjectureByReference(reference) { return this.context.findConjectureByReference(reference); }
+  isVariablePresentByVariableName(variableName, nested = true) {
+    const variable = this.findVariableByVariableName(variableName, nested),
+          variablePresent = (variable !== null);
 
-  findMetaLemmasByReference(reference) { return this.context.findMetaLemmasByReference(reference); }
+    return variablePresent;
+  }
 
-  findMetatheoremsByReference(reference) { return this.context.findMetatheoremsByReference(reference); }
+  isLabelPresentByMetavariableName(metavariableName) { return this.context.isLabelPresentByMetavariableName(metavariableName); }
 
-  findAxiomLemmaTheoremConjectureByReference(reference) { return this.context.findAxiomLemmaTheoremConjectureByReference(reference); }
+  isLabelPresentByMetavariableNode(metavariableNode) { return this.context.isLabelPresentByMetavariableNode(metavariableNode); }
 
-  isRulePresentByReference(reference) { return this.context.isRulePresentByReference(reference); }
+  isMetavariablePresentByMetavariableName(metavariableNode) { return this.context.isMetavariablePresentByMetavariableName(metavariableNode); }
 
-  isAxiomPresentByReference(reference) { return this.context.isAxiomPresentByReference(reference); }
+  isJudgementPresentByMetavariable(metavariable) {
+    const judgement = this.findJudgementByMetavariable(metavariable),
+          judgementPresent = (judgement !== null);
 
-  isLemmaPresentByReference(reference) { return this.context.isLemmaPresentByReference(reference); }
+    return judgementPresent;
+  }
 
-  isTheoremPresentByReference(reference) { return this.context.isTheoremPresentByReference(reference); }
+  isTermGrounded(term) {
+    const context = this, ///
+          equivalences = this.getEquivalences(),
+          groundedTerms = [],
+          definedVariables = [];
 
-  isProcedurePresentByReference(reference) { return this.context.isProcedurePresentByReference(reference); }
+    equivalences.separateGroundedTermsAndDefinedVariables(groundedTerms, definedVariables, context);
 
-  isConjecturePresentByReference(reference) { return this.context.isConjecturePresentByReference(reference); }
+    const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
+        const groundedTermNode = groundedTerm.getNode(),
+              groundedTermNodeMatches = term.matchTermNode(groundedTermNode);
 
-  areMetaLemmasPresentByReference(reference) { return this.context.areMetaLemmasPresentByReference(reference); }
+            if (groundedTermNodeMatches) {
+              return true;
+            }
+          }),
+          termGrounded = termMatchesGroundedTerm; ///
+
+    return termGrounded;
+  }
+
+  isVariableDefined(variable) {
+    const context = this, ///
+          equivalences = this.getEquivalences(),
+          groundedTerms = [],
+          definedVariables = [];
+
+    equivalences.separateGroundedTermsAndDefinedVariables(groundedTerms, definedVariables, context);
 
-  areMetatheoremsPresentByReference(reference) { return this.context.areMetatheoremsPresentByReference(reference); }
+    const variableMatchesDefinedVariable = definedVariables.some((definedVariable) => {
+            const definedVariableEqualToVariable = definedVariable.isEqualTo(variable);
 
-  areMetaLemmasMetaTheoremsPresentByReference(reference) { return this.context.areMetaLemmasMetaTheoremsPresentByReference(reference); }
+            if (definedVariableEqualToVariable === variable) {
+              return true;
+            }
+          }),
+          variableDefined = variableMatchesDefinedVariable; ///
 
-  isAxiomLemmaTheoremConjecturePresentByReference(reference) { return this.context.isAxiomLemmaTheoremConjecturePresentByReference(reference) }
+    return variableDefined;
+  }
+
+  isMetavariableDefined(metavariable) {
+    const judgementPresent = this.isJudgementPresentByMetavariable(metavariable),
+          metavariableDefined = judgementPresent; ///
+
+    return metavariableDefined
+  }
 
   nodeAsString(node, tokens = null) {
     if (tokens === null) {

package/src/dom/assertion/contained.js

@@ -57,25 +57,9 @@ export default domAssigned(class ContainedAssertion {
 
     context.trace(`Verifying the '${containedAssertionString}' contained assertion...`);
 
-    let termVerified = false,
-        frameVerified = false,
-        statementVerified = false;
-
-    if (this.term !== null) {
-      termVerified = this.term.verify(context, () => {
-        const verifiedAhead = true;
-
-        return verifiedAhead;
-      });
-    }
-
-    if (this.frame !== null) {
-      frameVerified = this.verifyFrame(this.frame, assignments, stated, context);
-    }
-
-    if (this.statement !== null) {
-      statementVerified = this.verifyStatement(this.statement, assignments, stated, context);
-    }
+    const termVerified = this.verifyTerm(assignments, stated, context),
+          frameVerified = this.verifyFrame(assignments, stated, context),
+          statementVerified = this.verifyStatement(assignments, stated, context)
 
     if (termVerified || frameVerified || statementVerified) {
       let verifiedWhenStated = false,
@@ -99,22 +83,71 @@ export default domAssigned(class ContainedAssertion {
     return verified;
   }
 
-  verifyFrame(frame, assignments, stated, context) {
-    stated = true;  ///
+  verifyTerm(assignments, stated, context) {
+    let termVerified = false;
 
-    assignments = null; ///
+    if (this.term !== null) {
+      const termString = this.term.getString(),
+            containedAssertionString = this.string; ///
 
-    const frameVerified = frame.verify(assignments, stated, context);
+      context.trace(`Verifying the '${containedAssertionString}' contained assertion's '${termString}' term...`);
+
+      termVerified = this.term.verify(context, () => {
+        const verifiedAhead = true;
+
+        return verifiedAhead;
+      });
+
+      if (termVerified) {
+        context.trace(`...verified the '${containedAssertionString}' contained assertion's '${termString}' term.`);
+      }
+    }
+
+    return termVerified;
+  }
+
+  verifyFrame(assignments, stated, context) {
+    let frameVerified = false;
+
+    if (this.frame !== null) {
+      const frameString = this.frame.getString(),
+            containedAssertionString = this.string; ///
+
+      context.trace(`Verifying the '${containedAssertionString}' contained assertion's '${frameString}' frame...`);
+
+      stated = true;  ///
+
+      assignments = null; ///
+
+      frameVerified = this.frame.verify(assignments, stated, context);
+
+      if (frameVerified) {
+        context.trace(`...verified the '${containedAssertionString}' contained assertion's '${frameString}' frame.`);
+      }
+    }
 
     return frameVerified;
   }
 
-  verifyStatement(statement, assignments, stated, context) {
-    stated = true;  ///
+  verifyStatement(assignments, stated, context) {
+    let statementVerified = false;
+
+    if (this.statement !== null) {
+      const statementString = this.statement.getString(),
+            containedAssertionString = this.string; ///
+
+      context.trace(`Verifying the '${containedAssertionString}' contained assertion's '${statementString}' statement...`);
+
+      stated = true;  ///
+
+      assignments = null; ///
 
-    assignments = null; ///
+      statementVerified = this.statement.verify(assignments, stated, context);
 
-    const statementVerified = statement.verify(assignments, stated, context);
+      if (statementVerified) {
+        context.trace(`...verified the '${containedAssertionString}' contained assertion's '${statementString}' statement.`);
+      }
+    }
 
     return statementVerified;
   }

package/src/dom/assertion/defined.js

@@ -52,27 +52,15 @@ export default domAssigned(class DefinedAssertion {
 
     context.trace(`Verifying the '${definedAssertionString}' defined assertion...`);
 
-    let termVerified = false,
-        frameVerified = false;
-
-    if (this.term !== null) {
-      termVerified = this.term.verify(context, () => {
-        const verifiedAhead = true;
-
-        return verifiedAhead;
-      });
-    }
-
-    if (this.frame!== null) {
-      frameVerified = this.verifyFrame(this.frame, assignments, stated, context);
-    }
+    const termVerified = this.verifyTerm(assignments, stated, context),
+          frameVerified = this.verifyFrame(assignments, stated, context);
 
     if (termVerified || frameVerified) {
       let verifiedWhenStated = false,
           verifiedWhenDerived = false;
 
       if (stated) {
-        verifiedWhenStated = this.verifyWhenStated(context);
+        verifiedWhenStated = this.verifyWhenStated(assignments, context);
       } else {
         verifiedWhenDerived = this.verifyWhenDerived(context);
       }
@@ -89,17 +77,53 @@ export default domAssigned(class DefinedAssertion {
     return verified;
   }
 
-  verifyFrame(frame, assignments, stated, context) {
-    stated = true;  ///
+  verifyTerm(assignments, stated, context) {
+    let termVerified = false;
+
+    if (this.term !== null) {
+      const termString = this.term.getString(),
+            definedAssertionString = this.string; ///
+
+      context.trace(`Verifying the '${definedAssertionString}' defined assertion's '${termString}' term...`);
 
-    assignments = null; ///
+      termVerified = this.term.verify(context, () => {
+        const verifiedAhead = true;
 
-    const frameVerified = frame.verify(assignments, stated, context);
+        return verifiedAhead;
+      });
+
+      if (termVerified) {
+        context.debug(`...verified the '${definedAssertionString}' defined assertion's '${termString}' term.`);
+      }
+    }
+
+    return termVerified;
+  }
+
+  verifyFrame(assignments, stated, context) {
+    let frameVerified = false;
+
+    if (this.frame !== null) {
+      const frameString = this.frame.getString(),
+            definedAssertionString = this.string; ///
+
+      context.trace(`Verifying the '${definedAssertionString}' defined assertion's '${frameString}' frame...`);
+
+      stated = true;  ///
+
+      assignments = null; ///
+
+      frameVerified = this.frame.verify(assignments, stated, context);
+
+      if (frameVerified) {
+        context.debug(`...verified the '${definedAssertionString}' defined assertion's '${frameString}' frame.`);
+      }
+    }
 
     return frameVerified;
   }
 
-  verifyWhenStated(context) {
+  verifyWhenStated(assignments, context) {
     let verifiedWhenStated;
 
     const definedAssertionString = this.string; ///

package/src/{combinator → dom/combinator}/bracketed.js

@@ -1,12 +1,13 @@
 "use strict";
 
-import dom from "../dom";
+import dom from "../../dom";
 import Combinator from "../combinator";
-import combinatorBracketedContext from "../context/bracketed/combinator";
+import combinatorBracketedContext from "../../context/bracketed/combinator";
 
-import { unifyStatementWithCombinator } from "../utilities/unification";
+import { domAssigned } from "../../dom";
+import { unifyStatementWithCombinator } from "../../utilities/unification";
 
-export default class BracketedCombinator extends Combinator {
+export default domAssigned(class BracketedCombinator extends Combinator {
   unifyStatement(statement, assignments, stated, context) {
     let statementUnified;
 
@@ -37,4 +38,4 @@ export default class BracketedCombinator extends Combinator {
 
     return bracketedCombinator;
   }
-}
+});

package/src/{combinator.js → dom/combinator.js}

@@ -1,15 +1,16 @@
 "use strict";
 
-import dom from "./dom";
-import LocalContext from "./context/local";
+import dom from "../dom";
+import LocalContext from "../context/local";
 
-import { nodeQuery } from "./utilities/query";
-import { unifyStatementWithCombinator } from "./utilities/unification";
-import { statementFromJSON, statementToStatementJSON } from "./utilities/json";
+import { nodeQuery } from "../utilities/query";
+import { domAssigned } from "../dom";
+import { unifyStatementWithCombinator } from "../utilities/unification";
+import { statementFromJSON, statementToStatementJSON } from "../utilities/json";
 
 const statementNodeQuery = nodeQuery("/combinatorDeclaration/statement");
 
-export default class Combinator {
+export default domAssigned(class Combinator {
   constructor(statement) {
     this.statement = statement;
   }
@@ -91,4 +92,4 @@ export default class Combinator {
 
     return combinator;
   }
-}
+});

package/src/{constructor → dom/constructor}/bracketed.js

@@ -1,15 +1,16 @@
 "use strict";
 
-import dom from "../dom";
+import dom from "../../dom";
 import Constructor from "../constructor";
-import constructorBracketedContext from "../context/bracketed/constructor";
+import constructorBracketedContext from "../../context/bracketed/constructor";
 
-import { nodeQuery } from "../utilities/query";
+import { nodeQuery } from "../../utilities/query";
+import { domAssigned } from "../../dom";
 import { stringFromTermAndType } from "../constructor";
 
 const termNodeQuery = nodeQuery("/term/argument/term");
 
-export default class BracketedConstructor extends Constructor {
+export default domAssigned(class BracketedConstructor extends Constructor {
   unifyTerm(term, context, verifyAhead) {
     let termUnified;
 
@@ -65,4 +66,4 @@ export default class BracketedConstructor extends Constructor {
 
     return bracketedConstructor;
   }
-}
+});

package/src/{constructor.js → dom/constructor.js}

@@ -1,16 +1,17 @@
 "use strict";
 
-import dom from "./dom";
-import LocalContext from "./context/local";
+import dom from "../dom";
+import LocalContext from "../context/local";
 
-import { nodeQuery } from "./utilities/query";
-import { unifyTermWithConstructor } from "./utilities/unification";
-import { termFromJSON, termToTermJSON } from "./utilities/json";
+import { nodeQuery } from "../utilities/query";
+import { domAssigned } from "../dom";
+import { unifyTermWithConstructor } from "../utilities/unification";
+import { termFromJSON, termToTermJSON } from "../utilities/json";
 
 const termNodeQuery = nodeQuery("/constructorDeclaration/term"),
       typeNodeQuery = nodeQuery("/constructorDeclaration/type");
 
-export default class Constructor {
+export default domAssigned(class Constructor {
   constructor(string, term) {
     this.string = string;
     this.term = term;
@@ -108,7 +109,7 @@ export default class Constructor {
 
     return constructor;
   }
-}
+});
 
 export function stringFromTermAndType(term, type) {
   let string;

package/src/dom/declaration/combinator.js

@@ -1,7 +1,5 @@
 "use strict";
 
-import Combinator from "../../combinator";
-
 import { domAssigned } from "../../dom";
 
 export default domAssigned(class CombinatorDeclaration {
@@ -45,7 +43,8 @@ export default domAssigned(class CombinatorDeclaration {
   static name = "CombinatorDeclaration";
 
   static fromCombinatorDeclarationNode(combinatorDeclarationNode, fileContext) {
-    const combinator = Combinator.fromCombinatorDeclarationNode(combinatorDeclarationNode, fileContext),
+    const { Combinator } = dom,
+          combinator = Combinator.fromCombinatorDeclarationNode(combinatorDeclarationNode, fileContext),
           combinatorDeclaration = new CombinatorDeclaration(fileContext, combinator);
 
     return combinatorDeclaration;

package/src/dom/declaration/constructor.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import Constructor from "../../constructor";
+import dom from "../../dom";
 
 import { domAssigned } from "../../dom";
 
@@ -45,7 +45,8 @@ export default domAssigned(class ConstructorDeclaration {
   static name = "ConstructorDeclaration";
 
   static fromConstructorDeclarationNode(constructorDeclarationNode, fileContext) {
-    const constructor = Constructor.fromConstructorDeclarationNode(constructorDeclarationNode, fileContext),
+    const { Constructor } = dom,
+          constructor = Constructor.fromConstructorDeclarationNode(constructorDeclarationNode, fileContext),
           constructorDeclaration = new ConstructorDeclaration(fileContext, constructor);
 
     return constructorDeclaration;