occam-verify-cli 0.0.1229 → 0.0.1232

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,18 +62,33 @@ 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;
 }
 
+export function referenceFromJSON(json, fileContext) {
+  let { reference } = json;
+
+  const { Reference } = dom,
+        referenceJSON = reference;  ///
+
+  json = referenceJSON;  ///
+
+  reference = Reference.fromJSON(json, fileContext);
+
+  return reference;
+}
+
 export function conclusionFromJSON(json, fileContext) {
   let { conclusion } = json;
 
@@ -113,6 +128,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;
 
@@ -222,6 +252,22 @@ export function variablesFromJSON(json, fileContext) {
   return variables;
 }
 
+export function parametersFromJSON(json, fileContext) {
+  let { parameters } = json;
+
+  const { Parameter } = dom,
+        parametersJSON = parameters; ///
+
+  parameters = parametersJSON.map((parameterJSON) => {
+    const json = parameterJSON,  ///
+          parameter = Parameter.fromJSON(json, fileContext);
+
+    return (parameter);
+  });
+
+  return parameters;
+}
+
 export function conjecturesFromJSON(json, fileContext) {
   let { conjectures } = json;
 
@@ -372,7 +418,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 +445,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();
@@ -475,6 +535,18 @@ export function variablesToVariablesJSON(variables) {
   return variablesJSON;
 }
 
+export function parametersToParametersJSON(parameters) {
+  const parametersJSON = parameters.map((parameter) => {
+    const parameterJSON = parameter.toJSON();
+
+    parameter = parameterJSON;  ///
+
+    return parameter;
+  });
+
+  return parametersJSON;
+}
+
 export function conjecturesToConjecturesJSON(conjectures) {
   const conjecturesJSON = conjectures.map((conjecture) => {
     const conjectureJSON = conjecture.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); ///