occam-verify-cli 1.0.448 → 1.0.472

package/src/element/{axiomLemmaTheoremConjecture.js → topLevelAssertion.js}

@@ -3,9 +3,8 @@
 import { arrayUtilities } from "necessary";
 
 import Element from "../element";
-import elements from "../elements";
-import LocalContext from "../context/local";
 
+import { scope, attempt } from "../utilities/context";
 import { labelsFromJSON,
          deductionFromJSON,
          signatureFromJSON,
@@ -19,7 +18,7 @@ import { labelsFromJSON,
 
 const { extract, reverse, correlate, backwardsEvery } = arrayUtilities;
 
-export default class AxiomLemmaTheoremConjecture extends Element {
+export default class TopLevelAssertion extends Element {
   constructor(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses) {
     super(context, string, node);
 
@@ -100,9 +99,9 @@ export default class AxiomLemmaTheoremConjecture extends Element {
 
     if (hypothetical) {
       const proofAssertions = context.getProofAssertions(),
-            axiomLemmaTheoremConjectureString = this.getString();  ///
+            topLevelAssertionString = this.getString();  ///
 
-      context.trace(`Correlating the hypotheses of the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture...`, this.node);
+      context.trace(`Correlating the hypotheses of the '${topLevelAssertionString}' top level assertion...`, this.node);
 
       correlatesToHypotheses = correlate(this.hypotheses, proofAssertions, (hypothesis, proofAssertion) => {
         const hypothesesComparesToStep = hypothesis.compareProofAssertion(proofAssertion, context);
@@ -113,7 +112,7 @@ export default class AxiomLemmaTheoremConjecture extends Element {
       });
 
       if (correlatesToHypotheses) {
-        context.debug(`...correlated the hypotheses of the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture.`, this.node);
+        context.debug(`...correlated the hypotheses of the '${topLevelAssertionString}' top level assertion.`, this.node);
       }
     } else {
       correlatesToHypotheses = true
@@ -125,25 +124,27 @@ export default class AxiomLemmaTheoremConjecture extends Element {
   verify() {
     let verifies = false;
 
-    const labelsVerify = this.verifyLabels();
+    const context = this.getContext();
 
-    if (labelsVerify) {
-      const localContext = LocalContext.fromNothing(this.context),
-            context = localContext, ///
-            suppositionsVerify = this.verifySuppositions(context);
+    scope((context) => {
+      const labelsVerify = this.verifyLabels();
 
-      if (suppositionsVerify) {
-        const deductionVerifies = this.verifyDeduction(context);
+      if (labelsVerify) {
+        const suppositionsVerify = this.verifySuppositions(context);
 
-        if (deductionVerifies) {
-          const proofVerifies = this.verifyProof(context);
+        if (suppositionsVerify) {
+          const deductionVerifies = this.verifyDeduction(context);
 
-          if (proofVerifies) {
-            verifies = true;
+          if (deductionVerifies) {
+            const proofVerifies = this.verifyProof(context);
+
+            if (proofVerifies) {
+              verifies = true;
+            }
           }
         }
       }
-    }
+    }, context);
 
     return verifies;
   }
@@ -186,15 +187,14 @@ export default class AxiomLemmaTheoremConjecture extends Element {
   }
 
   verifyProof(context) {
-    let proofVerifies;
+    let proofVerifies = true; ///
 
-    if (this.proof === null) {
-      proofVerifies = true;
-    } else {
-      const { Substitutions } = elements,
-            substitutions = Substitutions.fromNothing();
+    if (this.proof !== null) {
+      proofVerifies = attempt((context) => {
+        const proofVerifies = this.proof.verify(this.deduction, context);
 
-      proofVerifies = this.proof.verify(substitutions, this.deduction, context);
+        return proofVerifies;
+      }, context);
     }
 
     return proofVerifies;
@@ -239,12 +239,7 @@ export default class AxiomLemmaTheoremConjecture extends Element {
   unifyStepsOrSubproofsWithSupposition(subproofOrProofAssertions, supposition, substitutions, generalContext, specificContext) {
     let subproofOrProofAssertionsUnifiesWithSupposition = false;
 
-    const context = specificContext,  ///
-          suppositionUnifiesIndependently = supposition.unifyIndependently(substitutions, context);
-
-    if (suppositionUnifiesIndependently) {
-      subproofOrProofAssertionsUnifiesWithSupposition = true;
-    } else {
+    if (!subproofOrProofAssertionsUnifiesWithSupposition) {
       const subproofOrProofAssertion = extract(subproofOrProofAssertions, (subproofOrProofAssertion) => {
         const subproofOrProofAssertionUnifies = supposition.unifySubproofOrProofAssertion(subproofOrProofAssertion, substitutions, generalContext, specificContext);
 
@@ -258,6 +253,15 @@ export default class AxiomLemmaTheoremConjecture extends Element {
       }
     }
 
+    if (!subproofOrProofAssertionsUnifiesWithSupposition) {
+      const context = specificContext,  ///
+            suppositionUnifiesIndependently = supposition.unifyIndependently(substitutions, context);
+
+      if (suppositionUnifiesIndependently) {
+        subproofOrProofAssertionsUnifiesWithSupposition = true;
+      }
+    }
+
     return subproofOrProofAssertionsUnifiesWithSupposition;
   }
 
@@ -306,8 +310,8 @@ export default class AxiomLemmaTheoremConjecture extends Element {
           node = null,
           proof = null,
           string = stringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
-          axiomLemmaTheoremConjecture = new Class(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses);
+          topLevelAssertion = new Class(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses);
 
-    return axiomLemmaTheoremConjecture;
+    return topLevelAssertion;
   }
 }

package/src/element/{metaLemma.js → topLevelMetaAssertion/metaLemma.js}

@@ -1,17 +1,16 @@
 "use strict";
 
-import MetaLemmaMetatheorem from "./metaLemmaMetatheorem";
+import TopLevelMetaAssertion from "./../topLevelMetaAssertion";
 
-import { define } from "../elements";
+import { define } from "../../elements";
 
-export default define(class MetaLemma extends MetaLemmaMetatheorem {
+export default define(class MetaLemma extends TopLevelMetaAssertion {
   verify() {
     let verifies;
 
     const node = this.getNode(),
           context = this.getContext(),
-          metaLemma = this, ///
-          metaLemmaString = metaLemma.getString();
+          metaLemmaString = this.getString(); ///
 
     context.trace(`Verifying the '${metaLemmaString}' meta-lemma...`, node);
 
@@ -30,5 +29,5 @@ export default define(class MetaLemma extends MetaLemmaMetatheorem {
 
   static name = "MetaLemma";
 
-  static fromJSON(json, context) { return MetaLemmaMetatheorem.fromJSON(MetaLemma, json, context); }
+  static fromJSON(json, context) { return TopLevelMetaAssertion.fromJSON(MetaLemma, json, context); }
 });

package/src/element/{metatheorem.js → topLevelMetaAssertion/metatheorem.js}

@@ -1,17 +1,16 @@
 "use strict";
 
-import MetaLemmaMetatheorem from "./metaLemmaMetatheorem";
+import TopLevelMetaAssertion from "../topLevelMetaAssertion";
 
-import { define } from "../elements";
+import { define } from "../../elements";
 
-export default define(class Metatheorem extends MetaLemmaMetatheorem {
+export default define(class Metatheorem extends TopLevelMetaAssertion {
   verify() {
     let verifies;
 
     const node = this.getNode(),
           context = this.getContext(),
-          metaLemma = this, ///
-          metaLemmaString = metaLemma.getString();
+          metaLemmaString = this.getString(); ///
 
     context.trace(`Verifying the '${metaLemmaString}' metatheorem...`, node);
 
@@ -30,5 +29,5 @@ export default define(class Metatheorem extends MetaLemmaMetatheorem {
 
   static name = "Metatheorem";
 
-  static fromJSON(json, context) { return MetaLemmaMetatheorem.fromJSON(Metatheorem, json, context); }
+  static fromJSON(json, context) { return TopLevelMetaAssertion.fromJSON(Metatheorem, json, context); }
 });

package/src/element/{metaLemmaMetatheorem.js → topLevelMetaAssertion.js}

@@ -1,8 +1,8 @@
 "use strict";
 
 import Element from "../element";
-import LocalContext from "../context/local";
 
+import { scope } from "../utilities/context";
 import { labelFromJSON,
          labelToLabelJSON,
          deductionFromJSON,
@@ -12,7 +12,7 @@ import { labelFromJSON,
          suppositionsToSuppositionsJSON,
          substitutionsToSubstitutionsJSON } from "../utilities/json";
 
-export default class MetaLemmaMetatheorem extends Element {
+export default class TopLevelMetaAssertion extends Element {
   constructor(context, string, node, label, suppositions, deduction, proof, substitutions) {
     super(context, string, node);
 
@@ -56,25 +56,27 @@ export default class MetaLemmaMetatheorem extends Element {
   verify() {
     let verifies = false;
 
-    const labelVerifies = this.verifyLabel();
+    const context = this.getContext();
 
-    if (labelVerifies) {
-      const localContext = LocalContext.fromNothing(this.context),
-            context = localContext, ///
-            suppositionsVerify = this.verifySuppositions(context);
+    scope((context) => {
+      const labelVerifies = this.verifyLabel();
 
-      if (suppositionsVerify) {
-        const deductionVerifies = this.verifyDeduction(context);
+      if (labelVerifies) {
+        const suppositionsVerify = this.verifySuppositions(context);
 
-        if (deductionVerifies) {
-          const proofVerifies = this.verifyProof(context);
+        if (suppositionsVerify) {
+          const deductionVerifies = this.verifyDeduction(context);
 
-          if (proofVerifies) {
-            verifies = true;
+          if (deductionVerifies) {
+            const proofVerifies = this.verifyProof(context);
+
+            if (proofVerifies) {
+              verifies = true;
+            }
           }
         }
       }
-    }
+    }, context);
 
     return verifies;
   }
@@ -148,9 +150,9 @@ export default class MetaLemmaMetatheorem extends Element {
           substitutions = substitutionsFromJSON(json, context),
           node = null,
           proof = null,
-          string = metaLemmaMetatheoremStringFromLabelASuppositionsAndDeduction(label, suppositions, deduction),
-          metaLemmaMetatheorem = new Class(context, string, node, label, suppositions, deduction, proof, substitutions);
+          string = topLevelMetaAssertionStringFromLabelASuppositionsAndDeduction(label, suppositions, deduction),
+          topLevelMetaAssertion = new Class(context, string, node, label, suppositions, deduction, proof, substitutions);
 
-    return metaLemmaMetatheorem;
+    return topLevelMetaAssertion;
   }
 }

package/src/element/type.js

@@ -321,14 +321,12 @@ export default define(class Type extends Element {
     return type;
   }
 
-  static fromName(name) {
-    const context = null,
-          string = name,  ///
+  static fromNameAndProvisional(name, provisional, context) {
+    const string = name,  ///
           node = null,
           prefixName = null,
           superTypes = [],
           properties = [],
-          provisional = false,
           type = new Type(context, string, node, name, prefixName, superTypes, properties, provisional);
 
     return type;

package/src/element/variable.js

@@ -4,8 +4,8 @@ import Element from "../element";
 import elements from "../elements";
 
 import { define } from "../elements";
-import { instantiateVariable } from "../process/instantiate";
-import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
+import { synthetically } from "../utilities/context";
+import { typeToTypeJSON } from "../utilities/json";
 
 export default define(class Variable extends Element {
   constructor(context, string, node, type, identifier, propertyRelations) {
@@ -34,26 +34,34 @@ export default define(class Variable extends Element {
 
   getTypeString() { return this.type.getString(); }
 
-  compareParameter(parameter) {
-    const parameterName = parameter.getName(),
-          identifierParamterName = (this.identifier === parameterName),
-          comparesToParamter = identifierParamterName;  ///
+  isIdentifierEqualTo(identifier) {
+    const identifierEqualTo = (this.identifier === identifier);
+
+    return identifierEqualTo;
+  }
+
+  compareParamter(parameter) {
+    const identifier = parameter.getIdentifier(),
+          identifierEqualTo = this.isIdentifierEqualTo(identifier),
+          comparesToParamter = identifierEqualTo; ///
 
     return comparesToParamter;
   }
 
   compareVariableIdentifier(variableIdentifier) {
-    const comparesToVariablbeIdentifier = (this.identifier === variableIdentifier);
+    const identifier = variableIdentifier, ///
+          identifierEqualTo = this.isIdentifierEqualTo(identifier),
+          comparesToVariableIdentifier = identifierEqualTo; ///
 
-    return comparesToVariablbeIdentifier;
+    return comparesToVariableIdentifier;
   }
 
-  verify(context) {
-    let verifies;
+  validate(context) {
+    let validates;
 
-    const variableString = this.string; ///
+    const variableString = this.getString(); ///
 
-    context.trace(`Verifying the '${variableString}' variable...`);
+    context.trace(`Validating the '${variableString}' variable...`);
 
     const variableIdentifier = this.identifier,
           variable = context.findVariableByVariableIdentifier(variableIdentifier);
@@ -63,24 +71,24 @@ export default define(class Variable extends Element {
 
       this.type = type;
 
-      verifies = true;
+      validates = true;
     } else {
       context.debug(`The '${variableString}' variable is not present.`);
     }
 
-    if (verifies) {
-      context.debug(`...verified the '${variableString}' variable.`);
+    if (validates) {
+      context.debug(`...validated the '${variableString}' variable.`);
     }
 
-    return verifies;
+    return validates;
   }
 
-  verifyType(context) {
-    let typeVerifies = false;
+  validateType(context) {
+    let typeValidates = false;
 
     const typeString = this.type.getString();
 
-    context.trace(`Verifying the '${typeString}' type...`);
+    context.trace(`Validating the '${typeString}' type...`);
 
     const prefixedTypeName = this.type.getPrefixedName(),
           type = context.findTypeByPrefixedTypeName(prefixedTypeName);
@@ -90,40 +98,40 @@ export default define(class Variable extends Element {
     } else {
       this.type = type; ///
 
-      typeVerifies = true;
+      typeValidates = true;
     }
 
-    if (typeVerifies) {
-      context.debug(`...verified the '${typeString}' type.`);
+    if (typeValidates) {
+      context.debug(`...validated the '${typeString}' type.`);
     }
 
-    return typeVerifies;
+    return typeValidates;
   }
 
   unifyTerm(term, substitutions, generalContext, specificContext) {
     let termUnifies = false;
 
-    const termString = term.getString(),
-          variableString = this.string; ///
+    const context = specificContext,  ///
+          termString = term.getString(),
+          variableString = this.getString(); ///
 
-    specificContext.trace(`Unifying the '${termString}' term with the '${variableString}' variable...`);
+    context.trace(`Unifying the '${termString}' term with the '${variableString}' variable...`);
 
-    let context,
-        variable;
+    let variable;
 
     variable = this; ///
 
     const substitution = substitutions.findSubstitutionByVariable(variable);
 
     if (substitution !== null) {
-      context = specificContext;  ///
-
-      const substitutionTermEqualToTerm = substitution.isTermEqualToTerm(term, context);
+      const substitutionComparesToTerm = substitution.compareTerm(term, context);
 
-      if (substitutionTermEqualToTerm) {
+      if (substitutionComparesToTerm) {
         termUnifies = true;
       }
     } else {
+      let context;
+
       context = generalContext;  ///
 
       const variableIdentifier = variable.getIdentifier();
@@ -141,18 +149,18 @@ export default define(class Variable extends Element {
             termTypeEqualToOrSubTypeOfVariableType = termType.isEqualToOrSubTypeOf(variableType);
 
       if (termTypeEqualToOrSubTypeOfVariableType) {
-        const { TermSubstitution } = elements,
-              termSubstitution = TermSubstitution.fromTernAndVariable(term, variable, context),
-              substitution = termSubstitution;  ///
+        synthetically((context) => {
+          const { TermSubstitution } = elements;
 
-        substitutions.addSubstitution(substitution, context);
+          TermSubstitution.fromTermAndVariable(term, variable, context);
+        }, generalContext, specificContext);
 
         termUnifies = true;
       }
     }
 
     if (termUnifies) {
-      specificContext.debug(`...unified the '${termString}' term with the '${variableString}' variable.`);
+      context.debug(`...unified the '${termString}' term with the '${variableString}' variable.`);
     }
 
     return termUnifies;
@@ -160,7 +168,7 @@ export default define(class Variable extends Element {
 
   toJSON() {
     const typeJSON = typeToTypeJSON(this.type),
-          string = this.string, ///
+          string = this.getString(), ///
           type = typeJSON,  ///
           json = {
             type,
@@ -173,15 +181,6 @@ export default define(class Variable extends Element {
   static name = "Variable";
 
   static fromJSON(json, context) {
-    const { string } = json,
-          variableNode = instantiateVariable(string, context),
-          variableIdentifier = variableNode.getVariableIdentifier(),
-          node = variableNode,
-          identifier = variableIdentifier,  ///
-          type = typeFromJSON(json, context),
-          propertyRelations = [],
-          variable = new Variable(context, string, node, type, identifier, propertyRelations);
-
-    return variable;
+    ///
   }
 });

package/src/index.js

@@ -2,7 +2,8 @@
 
 import "./preamble";
 
-export { default as Log } from "./log";
+export { Log } from "occam-furtle";
+
 export { default as FileContext } from "./context/file";
 export { default as ReleaseContext } from "./context/release";
 export { default as releaseUtilities } from "./utilities/release";

package/src/main.js

@@ -1,6 +1,7 @@
 "use strict";
 
-import Log from "./log";
+import { Log } from "occam-furtle";
+
 import helpAction from "./action/help";
 import verifyAction from "./action/verify";
 import versionAction from "./action/version";

package/src/metaTypes.js

@@ -21,34 +21,50 @@ export function getMetaTypes() {
   return metaTypes;
 }
 
-export function frameMetaTypeFromNothing() {
+export function findMetaTypeByMetaTypeName(metaTypeName) {
+  const metaTypes = getMetaTypes(),
+        metaType = metaTypes.find((metaType) => {
+          const metaTypeComparesToMetaTypeName = metaType.compareMetaTypeName(metaTypeName);
+
+          if (metaTypeComparesToMetaTypeName) {
+            return true;
+          }
+        }) || null;
+
+  return metaType;
+}
+
+function frameMetaTypeFromNothing() {
   if (frameMetaType === null) {
     const { MetaType } = elements,
-          name = FRAME_META_TYPE_NAME;  ///
+          name = FRAME_META_TYPE_NAME,  ///
+          context = null;
 
-    frameMetaType = MetaType.fromName(name);
+    frameMetaType = MetaType.fromName(name, context);
   }
 
   return frameMetaType;
 }
 
-export function statementMetaTypeFromNothing() {
+function statementMetaTypeFromNothing() {
   if (statementMetaType === null) {
     const { MetaType } = elements,
-          name = STATEMENT_META_TYPE_NAME;  ///
+          name = STATEMENT_META_TYPE_NAME,  ///
+          context = null;
 
-    statementMetaType = MetaType.fromName(name);
+    statementMetaType = MetaType.fromName(name, context);
   }
 
   return statementMetaType;
 }
 
-export function referenceMetaTypeFromNothing() {
+function referenceMetaTypeFromNothing() {
   if (referenceMetaType === null) {
     const { MetaType } = elements,
-          name = REFERENCE_META_TYPE_NAME;  ///
+          name = REFERENCE_META_TYPE_NAME,  ///
+          context = null;
 
-    referenceMetaType = MetaType.fromName(name);
+    referenceMetaType = MetaType.fromName(name, context);
   }
 
   return referenceMetaType;

package/src/node/frame.js

@@ -22,7 +22,7 @@ export default class FrameNode extends NonTerminalNode {
 
     const metavariableNode = this.getMetavariableNode();
 
-    if (metavariableName !== null) {
+    if (metavariableNode !== null) {
       metavariableName = metavariableNode.getMetavariableName();
     }
 

package/src/node/metavariable.js

@@ -6,7 +6,7 @@ import { TERM_RULE_NAME, TYPE_RULE_NAME } from "../ruleNames";
 
 export default class MetavariableNode extends NonTerminalNode {
   getMetavariableName() {
-    let metaVariableName;
+    let metavariableName;
 
     this.someChildNode((childNode) => {
       const childNodeTerminalNode = childNode.isTerminalNode();
@@ -15,13 +15,13 @@ export default class MetavariableNode extends NonTerminalNode {
         const terminalNode = childNode, ///
               content = terminalNode.getContent();
 
-        metaVariableName = content; ///
+        metavariableName = content; ///
 
         return true;
       }
     });
 
-    return metaVariableName;
+    return metavariableName;
   }
 
   getTermNode() {

package/src/node/parameter.js

@@ -2,22 +2,49 @@
 
 import NonTerminalNode from "../nonTerminalNode";
 
+import { NAME_TOKEN_TYPE, IDENTIFIER_TOKEN_TYPE } from "../tokenTypes";
+
 export default class ParameterNode extends NonTerminalNode {
-  getParameterName() {
-    let parameterName;
+  getName() {
+    let name = null;
 
     this.someChildNode((childNode, index) => {
       const terminalNode = childNode, ///
-            content = terminalNode.getContent();
+            type = terminalNode.getType();
+
+      if (type === NAME_TOKEN_TYPE) {
+        const content = terminalNode.getContent();
+
+        name = content;  ///
+      }
+
+      if (index === 0) {
+        return true;
+      }
+    });
 
-      parameterName = content;  ///
+    return name;
+  }
+
+  getIdentifier() {
+    let identifier = null;
+
+    this.someChildNode((childNode, index) => {
+      const terminalNode = childNode, ///
+            type = terminalNode.getType();
+
+      if (type === IDENTIFIER_TOKEN_TYPE) {
+        const content = terminalNode.getContent();
+
+        identifier = content;  ///
+      }
 
       if (index === 0) {
         return true;
       }
     });
 
-    return parameterName;
+    return identifier;
   }
 
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ParameterNode, ruleName, childNodes, opacity, precedence); }

package/src/node/proofAssertion/premise.js

@@ -0,0 +1,16 @@
+"use strict";
+
+import ProofAssertionNode from "../../node/proofAssertion";
+
+import { PROCEDURE_CALL_RULE_NAME } from "../../ruleNames";
+
+export default class PremiseNode extends ProofAssertionNode {
+  getProcedureCallNode() {
+    const ruleName = PROCEDURE_CALL_RULE_NAME,
+          procedureCallNode = this.getNodeByRuleName(ruleName);
+
+    return procedureCallNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return ProofAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(PremiseNode, ruleName, childNodes, opacity, precedence); }
+}