occam-verify-cli 0.0.1229 → 0.0.1231

package/src/dom/premise.js

@@ -5,12 +5,13 @@ import dom from "../dom";
 import { domAssigned } from "../dom";
 import { assignAssignments } from "../utilities/assignments";
 import { subproofAssertionFromStatement } from "../utilities/verification";
-import { statementFromJSON, statementToStatementJSON } from "../utilities/json";
+import { statementFromJSON, procedureCallFromJSON, statementToStatementJSON, procedureCallToProcedureCallJSON } from "../utilities/json";
 
 export default domAssigned(class Premise {
-  constructor(string, statement) {
+  constructor(string, statement, procedureCall) {
     this.string = string;
     this.statement = statement;
+    this.procedureCall = procedureCall;
   }
 
   getString() {
@@ -21,12 +22,24 @@ export default domAssigned(class Premise {
     return this.statement;
   }
 
+  getProcedureCall() {
+    return this.procedureCall;
+  }
+
   unifyIndependently(substitutions, generalContext, specificContext) {
     let unifiedIndependently;
 
-    const statementResolvedIndependently = this.statement.unifyIndependently(substitutions, generalContext, specificContext);
+    if (this.statesment !== null) {
+      const statementResolvedIndependently = this.statement.unifyIndependently(substitutions, generalContext, specificContext);
+
+      unifiedIndependently = statementResolvedIndependently;  ///
+    }
+
+    if (this.procedureCall !== null) {
+      const procedureCallResolvedIndependently = this.procedureCall.unifyIndependently(substitutions, generalContext, specificContext);
 
-    unifiedIndependently = statementResolvedIndependently;  ///
+      unifiedIndependently = procedureCallResolvedIndependently;  ///
+    }
 
     return unifiedIndependently;
   }
@@ -129,7 +142,9 @@ export default domAssigned(class Premise {
 
     context.trace(`Verifying the '${premiseString}' premise...`);
 
-    if (this.statement !== null) {
+    if (false) {
+      ///
+    } else if (this.statement !== null) {
       const stated = true,
             assignments = [],
             statementVerified = this.statement.verify(assignments, stated, context);
@@ -147,6 +162,14 @@ export default domAssigned(class Premise {
           verified = true;
         }
       }
+    } else if (this.procedureCall !== null) {
+      const stated = true,
+            assignments = null,
+            procedureCallVerified = this.procedureCall.verify(assignments, stated, context);
+
+      if (procedureCallVerified) {
+        verified = true;
+      }
     } else {
       context.debug(`Unable to verify the '${premiseString}' premise because it is nonsense.`);
     }
@@ -160,9 +183,12 @@ export default domAssigned(class Premise {
 
   toJSON() {
     const statementJSON = statementToStatementJSON(this.statement),
+          procedureCallJSON = procedureCallToProcedureCallJSON(this.procedureCall),
           statement = statementJSON,  ///
+          procedureCall = procedureCallJSON,  ///
           json = {
-            statement
+            statement,
+            procedureCall
           };
 
     return json;
@@ -172,18 +198,39 @@ export default domAssigned(class Premise {
 
   static fromJSON(json, fileContext) {
     const statement = statementFromJSON(json, fileContext),
-          string = statement.getString(),
-          premise = new Premise(string, statement);
+          procedureCall = procedureCallFromJSON(json, fileContext);
+
+    let string;
+
+    if (statement !== null) {
+      string = statement.getString();
+    }
+
+    if (procedureCall !== null) {
+      string = procedureCall.getString();
+    }
+
+    const premise = new Premise(string, statement, procedureCall);
 
     return premise;
   }
 
   static fromPremiseNode(premiseNode, fileContext) {
-    const { Statement } = dom,
+    const { Statement, ProcedureCall } = dom,
           statement = Statement.fromPremiseNode(premiseNode, fileContext),
-          statementString = statement.getString(),
-          string = statementString, ///
-          premise = new Premise(string, statement);
+          procedureCall = ProcedureCall.fromPremiseNode(premiseNode, fileContext);
+
+    let string;
+
+    if (statement !== null) {
+      string = statement.getString();
+    }
+
+    if (procedureCall !== null) {
+      string = procedureCall.getString();
+    }
+
+    const premise = new Premise(string, statement, procedureCall);
 
     return premise
   }

package/src/dom/procedureCall.js

@@ -8,7 +8,8 @@ import { domAssigned } from "../dom";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const parameterNodesQuery = nodesQuery("/procedureCall/parameter"),
-      procedureCallNodeQuery = nodeQuery("/statement/procedureCall");
+      premiseProcedureCallNodeQuery = nodeQuery("/premise/procedureCall"),
+      suppositionProcedureCallNodeQuery = nodeQuery("/supposition/procedureCall");
 
 export default domAssigned(class ProcedureCall {
   constructor(string, reference, parameters) {
@@ -93,13 +94,32 @@ export default domAssigned(class ProcedureCall {
 
   static name = "ProcedureCall";
 
-  static fromStatementNode(statementNode, context) {
+  static fromPremiseNode(premiseNode, context) {
     let procedureCall = null;
 
-    const procedureCallNode = procedureCallNodeQuery(statementNode);
+    const premiseProcedureCallNode = premiseProcedureCallNodeQuery(premiseNode);
 
-    if (procedureCallNode !== null) {
+    if (premiseProcedureCallNode !== null) {
       const { Reference } = dom,
+            procedureCallNode = premiseProcedureCallNode, ///
+            parameters = parametersFromProcedureCallNode(procedureCallNode, context),
+            reference = Reference.fromProcedureCallNode(procedureCallNode, context),
+            string = stringFromReferenceAndParameters(reference, parameters);
+
+      procedureCall = new ProcedureCall(string, reference, parameters);
+    }
+
+    return procedureCall;
+  }
+
+  static fromSuppositionNode(suppositionNode, context) {
+    let procedureCall = null;
+
+    const suppositionProcedureCallNode = suppositionProcedureCallNodeQuery(suppositionNode);
+
+    if (suppositionProcedureCallNode !== null) {
+      const { Reference } = dom,
+            procedureCallNode = suppositionProcedureCallNode, ///
             parameters = parametersFromProcedureCallNode(procedureCallNode, context),
             reference = Reference.fromProcedureCallNode(procedureCallNode, context),
             string = stringFromReferenceAndParameters(reference, parameters);

package/src/dom/statement.js

@@ -12,7 +12,7 @@ import { domAssigned } from "../dom";
 import { unifyStatement } from "../utilities/unification";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
-import { procedureCallFromStatement, definedAssertionFromStatement, subproofAssertionFromStatement, containedAssertionFromStatement } from "../utilities/verification";
+import { definedAssertionFromStatement, subproofAssertionFromStatement, containedAssertionFromStatement } from "../utilities/verification";
 
 const { match, backwardsSome } = arrayUtilities;
 
@@ -170,21 +170,14 @@ export default domAssigned(class Statement {
     const context = specificContext,  ///
           statement = this; ///
 
-    const procedureCall = procedureCallFromStatement(statement, context),
-          definedAssertion = definedAssertionFromStatement(statement, context),
+    const definedAssertion = definedAssertionFromStatement(statement, context),
           containedAssertion = containedAssertionFromStatement(statement, context);
 
-    if ((procedureCall !== null) || (definedAssertion !== null) || (containedAssertion !== null)) {
+    if ((definedAssertion !== null) || (containedAssertion !== null)) {
       const statementString = this.string;
 
       specificContext.trace(`Unifying the '${statementString}' statement independently...`);
 
-      if (procedureCall !== null) {
-        const procedureCallUnifiedIndependently = procedureCall.unifyIndependently(substitutions, context);
-
-        unifiedIndependently = procedureCallUnifiedIndependently; ///
-      }
-
       if (definedAssertion !== null) {
         const definedAssertionUnifiedIndependently = definedAssertion.unifyIndependently(substitutions, context);
 

package/src/dom/supposition.js

@@ -5,12 +5,13 @@ import dom from "../dom";
 import { domAssigned } from "../dom";
 import { assignAssignments } from "../utilities/assignments";
 import { subproofAssertionFromStatement } from "../utilities/verification";
-import { statementFromJSON, statementToStatementJSON } from "../utilities/json";
+import { statementFromJSON, procedureCallFromJSON, statementToStatementJSON, procedureCallToProcedureCallJSON } from "../utilities/json";
 
 export default domAssigned(class Supposition {
-  constructor(string, statement) {
+  constructor(string, statement, procedureCall) {
     this.string = string;
     this.statement = statement;
+    this.procedureCall = procedureCall;
   }
 
   getString() {
@@ -21,12 +22,24 @@ export default domAssigned(class Supposition {
     return this.statement;
   }
 
+  getProcedureCall() {
+    return this.procedureCall;
+  }
+
   unifyIndependently(substitutions, generalContext, specificContext) {
     let unifiedIndependently;
 
-    const statementResolvedIndependently = this.statement.unifyIndependently(substitutions, generalContext, specificContext);
+    if (this.statesment !== null) {
+      const statementResolvedIndependently = this.statement.unifyIndependently(substitutions, generalContext, specificContext);
+
+      unifiedIndependently = statementResolvedIndependently;  ///
+    }
+
+    if (this.procedureCall !== null) {
+      const procedureCallResolvedIndependently = this.procedureCall.unifyIndependently(substitutions, generalContext, specificContext);
 
-    unifiedIndependently = statementResolvedIndependently;  ///
+      unifiedIndependently = procedureCallResolvedIndependently;  ///
+    }
 
     return unifiedIndependently;
   }
@@ -129,7 +142,9 @@ export default domAssigned(class Supposition {
 
     context.trace(`Verifying the '${suppositionString}' supposition...`);
 
-    if (this.statement !== null) {
+    if (false) {
+      ///
+    } else if (this.statement !== null) {
       const stated = true,
             assignments = [],
             statementVerified = this.statement.verify(assignments, stated, context);
@@ -147,6 +162,14 @@ export default domAssigned(class Supposition {
           verified = true;
         }
       }
+    } else if (this.procedureCall !== null) {
+      const stated = true,
+            assignments = null,
+            procedureCallVerified = this.procedureCall.verify(assignments, stated, context);
+
+      if (procedureCallVerified) {
+        verified = true;
+      }
     } else {
       context.debug(`Unable to verify the '${suppositionString}' supposition because it is nonsense.`);
     }
@@ -160,9 +183,12 @@ export default domAssigned(class Supposition {
 
   toJSON() {
     const statementJSON = statementToStatementJSON(this.statement),
+          procedureCallJSON = procedureCallToProcedureCallJSON(this.procedureCall),
           statement = statementJSON,  ///
+          procedureCall = procedureCallJSON,  ///
           json = {
-            statement
+            statement,
+            procedureCall
           };
 
     return json;
@@ -172,18 +198,39 @@ export default domAssigned(class Supposition {
 
   static fromJSON(json, fileContext) {
     const statement = statementFromJSON(json, fileContext),
-          string = statement.getString(),
-          supposition = new Supposition(string, statement);
+          procedureCall = procedureCallFromJSON(json, fileContext);
+
+    let string;
+
+    if (statement !== null) {
+      string = statement.getString();
+    }
+
+    if (procedureCall !== null) {
+      string = procedureCall.getString();
+    }
+
+    const supposition = new Supposition(string, statement, procedureCall);
 
     return supposition;
   }
 
   static fromSuppositionNode(suppositionNode, fileContext) {
-    const { Statement } = dom,
+    const { Statement, ProcedureCall } = dom,
           statement = Statement.fromSuppositionNode(suppositionNode, fileContext),
-          statementString = statement.getString(),
-          string = statementString, ///
-          supposition = new Supposition(string, statement);
+          procedureCall = ProcedureCall.fromSuppositionNode(suppositionNode, fileContext);
+
+    let string;
+
+    if (statement !== null) {
+      string = statement.getString();
+    }
+
+    if (procedureCall !== null) {
+      string = procedureCall.getString();
+    }
+
+    const supposition = new Supposition(string, statement, procedureCall);
 
     return supposition
   }

package/src/mixins/statement/verify.js

@@ -5,7 +5,6 @@ import BracketedCombinator from "../../combinator/bracketed";
 import { equalityFromStatement,
          judgementFromStatement,
          metavariableFromStatement,
-         procedureCallFromStatement,
          typeAssertionFromStatement,
          definedAssertionFromStatement,
          subproofAssertionFromStatement,
@@ -77,28 +76,6 @@ function verifyAsJudgement(statement, assignments, stated, context) {
   return verifiedAsJudgement;
 }
 
-function verifyAsProcedureCall(statement, assignments, stated, context) {
-  let verifiedAsProcedureCall = false;
-
-  const procedureCall = procedureCallFromStatement(statement, context);
-
-  if (procedureCall !== null) {
-    const statementString = statement.getString();
-
-    context.trace(`Verifying the '${statementString}' statement as a procedure call...`);
-
-    const procedureCallVerified = procedureCall.verify(assignments, stated, context);
-
-    verifiedAsProcedureCall = procedureCallVerified; ///
-
-    if (verifiedAsProcedureCall) {
-      context.debug(`...verified the '${statementString}' statement as a procedure call.`);
-    }
-  }
-
-  return verifiedAsProcedureCall;
-}
-
 function verifyAsTypeAssertion(statement, assignments, stated, context) {
   let verifiedAsTypeAssertion = false;
 
@@ -220,7 +197,6 @@ const verifyMixins = [
   verifyAsEquality,
   verifyAsJudgement,
   verifyAsTypeAssertion,
-  verifyAsProcedureCall,
   verifyAsDefinedAssertion,
   verifyAsSubproofAssertion,
   verifyAsContainedAssertion,

package/src/utilities/json.js

@@ -62,14 +62,16 @@ export function superTypeFromJSON(json, fileContext) {
 }
 
 export function statementFromJSON(json, fileContext) {
-  let { statement } = json;
+  let { statement = null } = json;
 
-  const { Statement } = dom,
-        statementJSON = statement;  ///
+  if (statement !== null) {
+    const { Statement } = dom,
+      statementJSON = statement;  ///
 
-  json = statementJSON; ///
+    json = statementJSON; ///
 
-  statement = Statement.fromJSON(json, fileContext);
+    statement = Statement.fromJSON(json, fileContext);
+  }
 
   return statement;
 }
@@ -113,6 +115,21 @@ export function metavariableFromJSON(json, fileContext) {
   return metavariable;
 }
 
+export function procedureCallFromJSON(json, fileContext) {
+  let { procedureCall = null } = json;
+
+  if (procedureCall !== null) {
+    const { ProcedureCall } = dom,
+          procedureCallJSON = procedureCall;  ///
+
+    json = procedureCallJSON; ///
+
+    procedureCall = ProcedureCall.fromJSON(json, fileContext);
+  }
+
+  return procedureCall;
+}
+
 export function typesFromJSON(json, types, fileContext) {
   const { types: typesJSON } = json;
 
@@ -372,7 +389,11 @@ export function superTypeToSuperTypeJSON(superType) {
 }
 
 export function statementToStatementJSON(statement) {
-  const statementJSON = statement.toJSON();
+  let statementJSON = null;
+
+  if (statement !== null) {
+    statementJSON = statement.toJSON();
+  }
 
   return statementJSON;
 }
@@ -395,6 +416,16 @@ export function metavariableToMetavariableJSON(metavariable) {
   return metavariableJSON;
 }
 
+export function procedureCallToProcedureCallJSON(procedureCall) {
+  let procedureCallJSON = null;
+
+  if (procedureCall !== null) {
+    procedureCallJSON = procedureCall.toJSON();
+  }
+
+  return procedureCallJSON;
+}
+
 export function typesToTypesJSON(types) {
   const typesJSON = types.map((type) => {
     const typeJSON = type.toJSON();

package/src/utilities/verification.js

@@ -43,16 +43,6 @@ export function metavariableFromStatement(statement, context) {
   return metavariable;
 }
 
-export function procedureCallFromStatement(statement, context) {
-  context = contextFromStatement(statement, context); ///
-
-  const { ProcedureCall } = dom,
-        statementNode = statement.getNode(),
-        procedureCall = ProcedureCall.fromStatementNode(statementNode, context);
-
-  return procedureCall;
-}
-
 export function typeAssertionFromStatement(statement, context) {
   context = contextFromStatement(statement, context); ///