occam-verify-cli 1.0.768 → 1.0.781

package/src/element/assertion/defined.js

@@ -3,10 +3,10 @@
 import Assertion from "../assertion";
 
 import { define } from "../../elements";
-import { instantiate } from "../../utilities/context";
+import { descend, instantiate } from "../../utilities/context";
 import { instantiateDefinedAssertion } from "../../process/instantiate";
 import { termFromTermAndSubstitutions, frameFromFrameAndSubstitutions } from "../../utilities/substitutions";
-import { termFromJDefinedAssertionNode, frameFromJDefinedAssertionNode, negatedFromJDefinedAssertionNode } from "../../utilities/element";
+import { termFromJDefinedAssertionNode, frameFromJDefinedAssertionNode, negatedFromJDefinedAssertionNode, definedAssertionFromStatementNode } from "../../utilities/element";
 
 export default define(class DefinedAssertion extends Assertion {
   constructor(context, string, node, term, frame, negated) {
@@ -36,7 +36,7 @@ export default define(class DefinedAssertion extends Assertion {
     return definedAssertionNode;
   }
 
-  validate(stated, context) {
+  validate(context) {
     let definedAssertion = null;
 
     const definedAssertionString = this.getString(); ///
@@ -52,20 +52,22 @@ export default define(class DefinedAssertion extends Assertion {
     } else {
       let validates = false;
 
-      const termValidates = this.validateTerm(stated, context),
-            frameValidates = this.validateFrame(stated, context);
+      const termValidates = this.validateTerm(context),
+            frameValidates = this.validateFrame(context);
 
       if (termValidates || frameValidates) {
-        let verifiesWhenStated = false,
-            verifiesWhenDerived = false;
+        const stated = context.isStated();
+
+        let validatesWhenStated = false,
+            validatesWhenDerived = false;
 
         if (stated) {
-          verifiesWhenStated = this.validateWhenStated(context);
+          validatesWhenStated = this.validateWhenStated(context);
         } else {
-          verifiesWhenDerived = this.validateWhenDerived(context);
+          validatesWhenDerived = this.validateWhenDerived(context);
         }
 
-        if (verifiesWhenStated || verifiesWhenDerived) {
+        if (validatesWhenStated || validatesWhenDerived) {
           validates = true;
         }
       }
@@ -84,7 +86,7 @@ export default define(class DefinedAssertion extends Assertion {
     return definedAssertion;
   }
 
-  validateTerm(stated, context) {
+  validateTerm(context) {
     let termValidates = false;
 
     if (this.term !== null) {
@@ -119,7 +121,7 @@ export default define(class DefinedAssertion extends Assertion {
     return termValidates;
   }
 
-  validateFrame(stated, context) {
+  validateFrame(context) {
     let frameValidates = false;
 
     if (this.frame !== null) {
@@ -130,22 +132,22 @@ export default define(class DefinedAssertion extends Assertion {
 
       const frameSingular = this.frame.isSingular();
 
-      if (!frameSingular) {
-        context.debug(`The '${frameString}' frame is not singular.`);
-      } else {
-        stated = true;  ///
-
-        const frame = this.frame.validate(stated, context);
+      if (frameSingular) {
+        descend((context) => {
+          const frame = this.frame.validate(context);
 
-        if (frame !== null) {
-          this.frame = frame;
+          if (frame !== null) {
+            this.frame = frame;
 
-          frameValidates = true;
-        }
+            frameValidates = true;
+          }
+        }, context);
+      } else {
+        context.debug(`The '${frameString}' frame is not singular.`);
+      }
 
-        if (frameValidates) {
-          context.debug(`...validates the'${definedAssertionString}' defined assertion's '${frameString}' frame.`);
-        }
+      if (frameValidates) {
+        context.debug(`...validates the'${definedAssertionString}' defined assertion's '${frameString}' frame.`);
       }
     }
 
@@ -153,23 +155,23 @@ export default define(class DefinedAssertion extends Assertion {
   }
 
   validateWhenStated(context) {
-    let verifiesWhenStated;
+    let validatesWhenStated;
 
     const definedAssertionString = this.getString(); ///
 
     context.trace(`Validating the '${definedAssertionString}' stated defined assertion...`);
 
-    verifiesWhenStated = true;
+    validatesWhenStated = true;
 
-    if (verifiesWhenStated) {
+    if (validatesWhenStated) {
       context.debug(`...validates the '${definedAssertionString}' stated defined assertion.`);
     }
 
-    return verifiesWhenStated;
+    return validatesWhenStated;
   }
 
   validateWhenDerived(context) {
-    let verifiesWhenDerived;
+    let validatesWhenDerived;
 
     const definedAssertionString = this.getString(); ///
 
@@ -178,17 +180,17 @@ export default define(class DefinedAssertion extends Assertion {
     const generalContext = null,
           specificContext = context;  ///
 
-    verifiesWhenDerived = validateWhenDerived(this.term, this.frame, this.negated, generalContext, specificContext);
+    validatesWhenDerived = validateWhenDerived(this.term, this.frame, this.negated, generalContext, specificContext);
 
-    if (verifiesWhenDerived) {
+    if (validatesWhenDerived) {
       context.debug(`...validates the '${definedAssertionString}' derived defined assertion.`);
     }
 
-    return verifiesWhenDerived;
+    return validatesWhenDerived;
   }
 
   unifyIndependently(generalContext, specificContext) {
-    let unifiesIndependently;
+    let unifiesIndependently = false;
 
     const context = specificContext, ///
           definedAssertionString = this.getString(); ///
@@ -197,9 +199,11 @@ export default define(class DefinedAssertion extends Assertion {
 
     const term = termFromTermAndSubstitutions(this.term, generalContext, specificContext),
           frame = frameFromFrameAndSubstitutions(this.frame, generalContext, specificContext),
-          verifiesWhenDerived = validateWhenDerived(term, frame, this.negated, generalContext, specificContext);
+          validatesWhenDerived = validateWhenDerived(term, frame, this.negated, generalContext, specificContext);
 
-    unifiesIndependently = verifiesWhenDerived; ///
+    if (validatesWhenDerived) {
+      unifiesIndependently = true;
+    }
 
     if (unifiesIndependently) {
       context.debug(`...unified the '${definedAssertionString}' defined assertion independently.`);
@@ -216,7 +220,7 @@ export default define(class DefinedAssertion extends Assertion {
     const { name } = json;
 
     if (this.name === name) {
-      definedAssertion = instantiate((context) => {
+      instantiate((context) => {
         const { string } = json,
               definedAssertionNode = instantiateDefinedAssertion(string, context),
               node = definedAssertionNode,  ///
@@ -226,18 +230,23 @@ export default define(class DefinedAssertion extends Assertion {
 
         context = null;
 
-        const definedAssertion = new DefinedAssertion(context, string, node, term, frame, negated);
-
-        return definedAssertion;
+        definedAssertion = new DefinedAssertion(context, string, node, term, frame, negated);
       }, context);
     }
 
     return definedAssertion;
   }
+
+  static fromStatement(statement, context) {
+    const statementNode = statement.getNode(),
+          definedAssertion = definedAssertionFromStatementNode(statementNode, context);
+
+    return definedAssertion;
+  }
 });
 
 function validateWhenDerived(term, frame, negated, generalContext, specificContext) {
-  let verifiesWhenDerived = false;
+  let validatesWhenDerived = false;
 
   const context = specificContext;  ///
 
@@ -247,11 +256,11 @@ function validateWhenDerived(term, frame, negated, generalContext, specificConte
           variableDefined = isVariableDefined(variable, context);
 
     if (!negated && variableDefined) {
-      verifiesWhenDerived = true;
+      validatesWhenDerived = true;
     }
 
     if (negated && !variableDefined) {
-      verifiesWhenDerived = true;
+      validatesWhenDerived = true;
     }
   }
 
@@ -261,15 +270,15 @@ function validateWhenDerived(term, frame, negated, generalContext, specificConte
           metavariableDefined = isMetavariableDefined(metavariable, context);
 
     if (!negated && metavariableDefined) {
-      verifiesWhenDerived = true;
+      validatesWhenDerived = true;
     }
 
     if (negated && !metavariableDefined) {
-      verifiesWhenDerived = true;
+      validatesWhenDerived = true;
     }
   }
 
-  return verifiesWhenDerived;
+  return validatesWhenDerived;
 }
 
 function isVariableDefined(variable, context) {

package/src/element/assertion/property.js

@@ -6,7 +6,7 @@ import { define } from "../../elements";
 import { instantiate } from "../../utilities/context";
 import { instantiatePropertyAssertion } from "../../process/instantiate";
 import { variableAssignmentFromPrepertyAssertion } from "../../process/assign";
-import { termFromPropertyAssertionNode, propertyRelationFromPropertyAssertionNode } from "../../utilities/element";
+import { termFromPropertyAssertionNode, propertyAssertionFromStatementNode, propertyRelationFromPropertyAssertionNode } from "../../utilities/element";
 
 export default define(class PropertyAssertion extends Assertion {
   constructor(context, string, node, term, propertyRelation) {
@@ -57,7 +57,7 @@ export default define(class PropertyAssertion extends Assertion {
     return comparesToTermAndPropertyRelation;
   }
 
-  validate(stated, context) {
+  validate(context) {
     let propertyAssertion = null;
 
     const propertyAssertionString = this.getString(); ///
@@ -73,12 +73,14 @@ export default define(class PropertyAssertion extends Assertion {
     } else {
       let validates = false;
 
-      const termValidates = this.validateTerm(stated, context);
+      const termValidates = this.validateTerm(context);
 
       if (termValidates) {
-        const propertyRelationVerifies = this.validatePropertyRelation(stated, context);
+        const propertyRelationVerifies = this.validatePropertyRelation(context);
 
         if (propertyRelationVerifies) {
+          const stated = context.isStated();
+
           let validatesWhenStated = false,
               validatesWhenDerived = false;
 
@@ -99,7 +101,7 @@ export default define(class PropertyAssertion extends Assertion {
 
         propertyAssertion = assertion;  ///
 
-        this.assign(stated, context);
+        this.assign(context);
 
         context.addAssertion(assertion);
 
@@ -110,7 +112,7 @@ export default define(class PropertyAssertion extends Assertion {
     return propertyAssertion;
   }
 
-  validateTerm(stated, context) {
+  validateTerm(context) {
     let termValidates = false;
 
     const termString = this.term.getString();
@@ -136,7 +138,7 @@ export default define(class PropertyAssertion extends Assertion {
     return termValidates;
   }
 
-  validatePropertyRelation(stated, context) {
+  validatePropertyRelation(context) {
     let propertyRelationValidates = false;
 
     const propertyRelationString = this.propertyRelation.getString();
@@ -188,16 +190,17 @@ export default define(class PropertyAssertion extends Assertion {
     return validatesWhenDerived;
   }
 
-  assign(stated, context) {
+  assign(context) {
+    const stated = context.isStated();
+
     if (!stated) {
       return;
     }
 
     const propertyAssertion = this, ///
-          variableAssigment = variableAssignmentFromPrepertyAssertion(propertyAssertion, context),
-          assignment = variableAssigment; ///
+          variableAssigment = variableAssignmentFromPrepertyAssertion(propertyAssertion, context);
 
-    context.addAssignment(assignment);
+    context.addAssignment(variableAssigment);
   }
 
   static name = "PropertyAssertion";
@@ -208,7 +211,7 @@ export default define(class PropertyAssertion extends Assertion {
     const { name } = json;
 
     if (this.name === name) {
-      propertyAssertion = instantiate((context) => {
+      instantiate((context) => {
         const { string } = json,
               propertyAssertionNode = instantiatePropertyAssertion(string, context),
               node = propertyAssertionNode,  ///
@@ -217,12 +220,17 @@ export default define(class PropertyAssertion extends Assertion {
 
         context = null;
 
-        const propertyAssertion = new PropertyAssertion(context, string, node, term, propertyRelation);
-
-        return propertyAssertion;
+        propertyAssertion = new PropertyAssertion(context, string, node, term, propertyRelation);
       }, context);
     }
 
     return propertyAssertion;
   }
+
+  static fromStatement(statement, context) {
+    const statementNode = statement.getNode(),
+          propertyAssertion = propertyAssertionFromStatementNode(statementNode, context);
+
+    return propertyAssertion;
+  }
 });

package/src/element/assertion/satisfies.js

@@ -5,7 +5,7 @@ import Assertion from "../assertion";
 import { define } from "../../elements";
 import { instantiate } from "../../utilities/context";
 import { instantiateSatisfiesAssertion } from "../../process/instantiate";
-import { signatureFromJSatisfiesAssertionNode, referenceFromJSatisfiesAssertionNode } from "../../utilities/element";
+import { signatureFromJSatisfiesAssertionNode, referenceFromJSatisfiesAssertionNode, satisfiesAssertionFromStatementNode } from "../../utilities/element";
 
 export default define(class SatisfiesAssertion extends Assertion {
   constructor(context, string, node, signature, reference) {
@@ -34,7 +34,7 @@ export default define(class SatisfiesAssertion extends Assertion {
 
   correlateSubstitutions(substitutions, context) { return this.signature.correlateSubstitutions(substitutions, context); }
 
-  validate(stated, context) {
+  validate(context) {
     let satisfiesAssertion = null;
 
     const satisfiesAssertionString = this.getString(); ///
@@ -50,10 +50,10 @@ export default define(class SatisfiesAssertion extends Assertion {
     } else {
       let validates = true;
 
-      const signatureVerifies = this.validateSignature(stated, context);
+      const signatureVerifies = this.validateSignature(context);
 
       if (signatureVerifies) {
-        const referenceVerifies = this.validateReference(stated, context);
+        const referenceVerifies = this.validateReference(context);
 
         if (referenceVerifies) {
           validates = true;
@@ -76,7 +76,7 @@ export default define(class SatisfiesAssertion extends Assertion {
     return satisfiesAssertion;
   }
 
-  validateSignature(stated, context) {
+  validateSignature(context) {
     let signatureValidates = false;
 
     const signature = this.signature.validate(context);
@@ -88,7 +88,7 @@ export default define(class SatisfiesAssertion extends Assertion {
     return signatureValidates;
   }
 
-  validateReference(stated, context) {
+  validateReference(context) {
     let referenceVerifies = false;
 
     const referenceString = this.reference.getString(),
@@ -165,7 +165,7 @@ export default define(class SatisfiesAssertion extends Assertion {
     const { name } = json;
 
     if (this.name === name) {
-      satisfiesAssertion = instantiate((context) => {const { string } = json,
+      instantiate((context) => {const { string } = json,
               definedAssertionNode = instantiateSatisfiesAssertion(string, context),
               node = definedAssertionNode,  ///
               signature = signatureFromJSatisfiesAssertionNode(definedAssertionNode, context),
@@ -173,12 +173,17 @@ export default define(class SatisfiesAssertion extends Assertion {
 
         context = null;
 
-        const satisfiesAssertion = new SatisfiesAssertion(context, string, node, signature, reference);
-
-        return satisfiesAssertion;
+        satisfiesAssertion = new SatisfiesAssertion(context, string, node, signature, reference);
       }, context);
     }
 
     return satisfiesAssertion;
   }
+
+  static fromStatement(statement, context) {
+    const statementNode = statement.getNode(),
+          satisfiesAssertion = satisfiesAssertionFromStatementNode(statementNode, context);
+
+    return satisfiesAssertion;
+  }
 });

package/src/element/assertion/subproof.js

@@ -6,8 +6,9 @@ import Assertion from "../assertion";
 
 import { define } from "../../elements";
 import { reconcile } from "../../utilities/context";
-import { join, instantiate } from "../../utilities/context";
+import { join, descend, instantiate } from "../../utilities/context";
 import { instantiateSubproofAssertion } from "../../process/instantiate";
+import { subproofAssertionFromStatementNode } from "../../utilities/element";
 
 const { last, front, backwardsEvery } = arrayUtilities;
 
@@ -49,7 +50,7 @@ export default define(class SubproofAssertion extends Assertion {
     return subproofAssertionNode;
   }
 
-  validate(stated, context) {
+  validate(context) {
     let subproofAssertion = null;
 
     const subproofAssertionString = this.getString();  ///
@@ -65,7 +66,7 @@ export default define(class SubproofAssertion extends Assertion {
     } else {
       let validates = false;
 
-      const statementsValidate = this.validateStatements(stated, context);
+      const statementsValidate = this.validateStatements(context);
 
       if (statementsValidate) {
         validates = true;
@@ -85,17 +86,17 @@ export default define(class SubproofAssertion extends Assertion {
     return subproofAssertion;
   }
 
-  validateStatements(stated, context) {
-    stated = true;  ///
-
-    const statementsValidate = this.statements.map((statement) => {
+  validateStatements(context) {
+    const statementsValidate = this.statements.every((statement) => {
       let statementValidates = false;
 
-      statement = statement.validate(stated, context);  ///
+      descend((context) => {
+        statement = statement.validate(context);  ///
 
-      if (statement !== null) {
-        statementValidates = true;
-      }
+        if (statement !== null) {
+          statementValidates = true;
+        }
+      }, context);
 
       if (statementValidates) {
         return true;
@@ -239,7 +240,7 @@ export default define(class SubproofAssertion extends Assertion {
     return suppositionUnifies;
   }
 
-  unifySuppositions(suppositions, generalContext, specificContext) {
+  unifySuppositions(suppositions, generalContxt, spsecificContext) {
     let suppositionsUnify = false;
 
     const supposedStatements = this.getSupposedStatements(),
@@ -248,7 +249,7 @@ export default define(class SubproofAssertion extends Assertion {
 
     if (suppositionsLength === supposedStatementsLength) {
       suppositionsUnify = backwardsEvery(suppositions, (supposition, index) => {
-        const suppositionUnifies = this.unifySupposition(supposition, index, generalContext, specificContext);
+        const suppositionUnifies = this.unifySupposition(supposition, index, generalContxt, spsecificContext);
 
         if (suppositionUnifies) {
           return true;
@@ -259,30 +260,27 @@ export default define(class SubproofAssertion extends Assertion {
     return suppositionsUnify;
   }
 
-  unifyTopLevelMetaAssertion(topLevelMetaAssertion, generalContext, specificContext) {
+  unifyTopLevelMetaAssertion(topLevelMetaAssertion, context) {
     let topLevelMetaAssertionUnifies = false;
 
-    const context = specificContext,  ///
+    const generalContext = context, ///
+          specificContext = context,  ///
           subproofAssertionString = this.getString(),  ///
           topLevelMetaAssertionString = topLevelMetaAssertion.getString();
 
     context.trace(`Unifying the '${topLevelMetaAssertionString}' top level meta-assertion with the '${subproofAssertionString}' subproof assertion...`);
 
-    reconcile((specificContext) => {
-      const deduction = topLevelMetaAssertion.getDeduction(),
-            deductionUnifies = this.unifyDeduction(deduction, generalContext, specificContext);
-
-      if (deductionUnifies) {
-        const suppositions = topLevelMetaAssertion.getSuppositions(),
-              suppositionsUnify = this.unifySuppositions(suppositions, generalContext, specificContext);
+    const deduction = topLevelMetaAssertion.getDeduction(),
+          deductionUnifies = this.unifyDeduction(deduction, generalContext, specificContext);
 
-        if (suppositionsUnify) {
-          specificContext.commit();
+    if (deductionUnifies) {
+      const suppositions = topLevelMetaAssertion.getSuppositions(),
+            suppositionsUnify = this.unifySuppositions(suppositions, generalContext, specificContext);
 
-          topLevelMetaAssertionUnifies = true;
-        }
+      if (suppositionsUnify) {
+        topLevelMetaAssertionUnifies = true;
       }
-    }, specificContext);
+    }
 
     if (topLevelMetaAssertionUnifies) {
       context.debug(`...unified the '${topLevelMetaAssertionString}' top level meta-assertion with the '${subproofAssertionString}' subproof assertion.`);
@@ -299,7 +297,7 @@ export default define(class SubproofAssertion extends Assertion {
     const { name } = json;
 
     if (this.name === name) {
-      subproorAssertion = instantiate((context) => {
+      instantiate((context) => {
         const { string } = json,
               subproofAssertionNode = instantiateSubproofAssertion(string, context),
               statements = statementsFromSubproofAssertionNode(subproofAssertionNode, context),
@@ -307,14 +305,19 @@ export default define(class SubproofAssertion extends Assertion {
 
         context = null;
 
-        const subproorAssertion = new SubproofAssertion(context, string, node, statements);
-
-        return subproorAssertion;
+        subproorAssertion = new SubproofAssertion(context, string, node, statements);
       }, context);
     }
 
     return subproorAssertion;
   }
+
+  static fromStatement(statement, context) {
+    const statementNode = statement.getNode(),
+          subproofAssertion = subproofAssertionFromStatementNode(statementNode, context);
+
+    return subproofAssertion;
+  }
 });
 
 function statementsFromSubproofAssertionNode(subproofAssertionNode, context) {

package/src/element/assertion/type.js

@@ -5,9 +5,9 @@ import Assertion from "../assertion";
 import { define } from "../../elements";
 import { instantiate } from "../../utilities/context";
 import { instantiateTypeAssertion } from "../../process/instantiate";
-import { termFromTypeAssertionNode } from "../../utilities/element";
 import { typeFromJSON, typeToTypeJSON } from "../../utilities/json";
 import { variableAssignmentFromTypeAssertion } from "../../process/assign";
+import { termFromTypeAssertionNode, typeAssertionFromStatementNode } from "../../utilities/element";
 
 export default define(class TypeAssertion extends Assertion {
   constructor(context, string, node, term, type) {
@@ -32,7 +32,7 @@ export default define(class TypeAssertion extends Assertion {
     return typeAssertionNode;
   }
 
-  validate(stated, context) {
+  validate(context) {
     let typeAssertion = null;
 
     const typeAssertionString = this.getString();  ///
@@ -51,6 +51,8 @@ export default define(class TypeAssertion extends Assertion {
       const typeValidates = this.validateType(context);
 
       if (typeValidates) {
+        const stated = context.isStated();
+
         let validatesWhenStated = false,
             validatesWhenDerived = false;
 
@@ -70,7 +72,7 @@ export default define(class TypeAssertion extends Assertion {
 
         typeAssertion = assertion;  ///
 
-        this.assign(stated, context);
+        this.assign(context);
 
         context.addAssertion(assertion);
 
@@ -177,7 +179,9 @@ export default define(class TypeAssertion extends Assertion {
     return validatesWhenDerived;
   }
 
-  assign(stated, context) {
+  assign(context) {
+    const stated = context.isStated();
+
     if (!stated) {
       return;
     }
@@ -185,11 +189,7 @@ export default define(class TypeAssertion extends Assertion {
     const typeAssertion = this, ///
           variableAssigment = variableAssignmentFromTypeAssertion(typeAssertion, context);
 
-    if (variableAssigment !== null) {
-      const assignment = variableAssigment;  ///
-
-      context.addAssignment(assignment);
-    }
+    context.addAssignment(variableAssigment);
   }
 
   toJSON() {
@@ -214,7 +214,7 @@ export default define(class TypeAssertion extends Assertion {
     const { name } = json;
 
     if (this.name === name) {
-      typeAssertion = instantiate((context) => {
+      instantiate((context) => {
         const { string } = json,
               typeAssertionNode = instantiateTypeAssertion(string, context),
               term = termFromTypeAssertionNode(typeAssertionNode, context),
@@ -223,12 +223,17 @@ export default define(class TypeAssertion extends Assertion {
 
         context = null;
 
-        const typeAssertion = new TypeAssertion(context, string, node, term, type);
-
-        return typeAssertion;
+        typeAssertion = new TypeAssertion(context, string, node, term, type);
       }, context);
     }
 
     return typeAssertion;
   }
+
+  static fromStatement(statement, context) {
+    const statementNode = statement.getNode(),
+          typeAssertion = typeAssertionFromStatementNode(statementNode, context);
+
+    return typeAssertion;
+  }
 });