occam-verify-cli 1.0.651 → 1.0.655

package/src/element/metavariable.js

@@ -5,10 +5,12 @@ import { Element } from "occam-languages";
 import elements from "../elements";
 
 import { define } from "../elements";
+import { literally } from "../utilities/context";
 import { EMPTY_STRING } from "../constants";
-import { typeToTypeJSON } from "../utilities/json";
 import { metaTypeToMetaTypeJSON } from "../utilities/json";
+import { instantiateMetavariable } from "../process/instantiate";
 import { unifyMetavariable, unifyMetavariableIntrinsically } from "../process/unify";
+import { nameFromJSON, typeFromJSON, nameToNameJSON, metaTypeFromJSON, typeToTypeJSON } from "../utilities/json";
 
 export default define(class Metavariable extends Element {
   constructor(context, string, node, name, type, metaType) {
@@ -438,11 +440,14 @@ export default define(class Metavariable extends Element {
   toJSON() {
     const metaTypeJSON = metaTypeToMetaTypeJSON(this.metaType),
           typeJSON = typeToTypeJSON(this.type),
+          nameJSON = nameToNameJSON(this.name),
           type = typeJSON,  ///
           metaType = metaTypeJSON,  ///
           string = this.getString(), ///
+          name = this.name,
           json = {
             string,
+            name,
             type,
             metaType
           };
@@ -453,6 +458,19 @@ export default define(class Metavariable extends Element {
   static name = "Metavariable";
 
   static fromJSON(json, context) {
-    debugger
+    const metavariable = literally((context) => {
+      const { string } = json,
+            metavariableNode = instantiateMetavariable(string, context),
+            node = metavariableNode,  ///
+            name = nameFromJSON(json, context),
+            type = typeFromJSON(json, context),
+            metaType = metaTypeFromJSON(json, context),
+            metavariable = new Metavariable(context, string, node, name, type, metaType);
+
+      return metavariable;
+
+    }, context);
+
+    return metavariable;
   }
 });

package/src/element/parameter.js

@@ -58,11 +58,6 @@ export default define(class Parameter extends Element {
   static name = "Parameter";
 
   static fromJSON(json, context) {
-    const { name, identifier } = json,
-          string = null,
-          node = null,
-          parameter = new Parameter(context, string, node, name, identifier);
-
-    return parameter;
+    debugger
   }
 });

package/src/element/procedureCall.js

@@ -126,12 +126,6 @@ export default define(class ProcedureCall extends Element {
   static name = "ProcedureCall";
 
   static fromJSON(json, context) {
-    const node = null,
-          parameters = parametersFromJSON(json, context),
-          procedureReference = procedureReferenceFromJSON(json, context),
-          string = stringFromProcedureReferenceAndParameters(procedureReference, parameters),
-          procedureCall = new ProcedureCall(context, string, node, parameters, procedureReference);
-
-    return procedureCall;
+    debugger
   }
 });

package/src/element/procedureReference.js

@@ -39,11 +39,6 @@ export default define(class ProcedureReference extends Element {
   static name = "ProcedureReference";
 
   static fromJSON(json, context) {
-    const { name } = json,
-          string = name,  ///
-          node = null,
-          procedureReference = new ProcedureReference(context, string, node, name);
-
-    return procedureReference;
+    debugger
   }
 });

package/src/element/proofAssertion/premise.js

@@ -3,8 +3,9 @@
 import ProofAssertion from "../proofAssertion";
 
 import { define } from "../../elements";
-import { attempt, liminally } from "../../utilities/context";
-import { statementFromJSON, procedureCallFromJSON, statementToStatementJSON, procedureCallToProcedureCallJSON } from "../../utilities/json";
+import { instantiatePremise } from "../../process/instantiate";
+import { attempt, liminally, literally } from "../../utilities/context";
+import { statementFromJSON, procedureCallFromJSON, statementToStatementJSON, ephemeralContextFromJSON, procedureCallToProcedureCallJSON } from "../../utilities/json";
 
 export default define(class Premise extends ProofAssertion {
   constructor(context, string, node, statement, procedureCall) {
@@ -30,6 +31,32 @@ export default define(class Premise extends ProofAssertion {
     return stated;
   }
 
+  async verify(context) {
+    let verifies = false;
+
+    await this.break(context);
+
+    const premiseString = this.getString();
+
+    context.trace(`Verifying the '${premiseString}' premise...`);
+
+    attempt((context) => {
+      const validates = this.validate(context);
+
+      if (validates) {
+        this.setContext(context);
+
+        verifies = true;
+      }
+    }, context);
+
+    if (verifies) {
+      context.debug(`...verified the '${premiseString}' premise.`);
+    }
+
+    return verifies;
+  }
+
   validate(context) {
     let validates = false;
 
@@ -194,32 +221,6 @@ export default define(class Premise extends ProofAssertion {
     return subproofUnifies;
   }
 
-  async verify(context) {
-    let verifies = false;
-
-    await this.break(context);
-
-    const premiseString = this.getString();
-
-    context.trace(`Verifying the '${premiseString}' premise...`);
-
-    attempt((context) => {
-      const validates = this.validate(context);
-
-      if (validates) {
-        this.setContext(context);
-
-        verifies = true;
-      }
-    }, context);
-
-    if (verifies) {
-      context.debug(`...verified the '${premiseString}' premise.`);
-    }
-
-    return verifies;
-  }
-
   async unifyIndependently(context) {
     let unifiesIndependently = false;
 
@@ -262,11 +263,22 @@ export default define(class Premise extends ProofAssertion {
   }
 
   toJSON() {
+    let context;
+
+    context = this.getContext();
+
+    const contextJSON = context.toJSON();
+
+    context = contextJSON;  ///
+
     const procedureCallJSON = procedureCallToProcedureCallJSON(this.procedureCall),
           statementJSON = statementToStatementJSON(this.statement),
           procedureCall = procedureCallJSON,  ///
           statement = statementJSON,  ///
+          string = this.getString(),
           json = {
+            context,
+            string,
             statement,
             procedureCall
           };
@@ -277,22 +289,25 @@ export default define(class Premise extends ProofAssertion {
   static name = "Premise";
 
   static fromJSON(json, context) {
-    const statement = statementFromJSON(json, context),
-          procedureCall = procedureCallFromJSON(json, context);
+    const premise = literally((context) => {
+      let { string } = json;
 
-    let string;
+      string = `${string}
+`;  ///
 
-    if (statement !== null) {
-      string = statement.getString();
-    }
+      const prmiseNode = instantiatePremise(string, context),
+            node = prmiseNode,  ///
+            statement = statementFromJSON(json, context),
+            procedureCall = procedureCallFromJSON(json, context),
+            ephemeralContext = ephemeralContextFromJSON(json, context);
 
-    if (procedureCall !== null) {
-      string = procedureCall.getString();
-    }
+      context = ephemeralContext; ///
+
+      const premise = new Premise(context, string, node, statement, procedureCall);
 
-    const node = null;
+      return premise;
 
-    const premise = new Premise(context, string, node, statement, procedureCall);
+    }, context);
 
     return premise;
   }

package/src/element/proofAssertion/step.js

@@ -66,6 +66,36 @@ export default define(class Step extends ProofAssertion {
     return comparesToTermAndPropertyRelation;
   }
 
+  async verify(context) {
+    let verifies = false;
+
+    await this.break(context);
+
+    const stepString = this.getString(); ///
+
+    context.trace(`Verifying the '${stepString}' step...`);
+
+    await asyncAttempt(async (context) => {
+      const validates = this.validate(context);
+
+      if (validates) {
+        const unifies = await this.unify(context);
+
+        if (unifies) {
+          this.setContext(context);
+
+          verifies = true;
+        }
+      }
+    }, context);
+
+    if (verifies) {
+      context.debug(`...verified the '${stepString}' step.`);
+    }
+
+    return verifies;
+  }
+
   validate(context) {
     let validates = false;
 
@@ -147,68 +177,6 @@ export default define(class Step extends ProofAssertion {
     return satisfiesAssertionValidates;
   }
 
-  unifyWithSatisfiesAssertion(satisfiesAssertion, context) {
-    let unifiesWithSatisfiesAssertion = false;
-
-    const stepString = this.getString(), ///
-          satisfiesAssertionString = satisfiesAssertion.getString();
-
-    context.trace(`Unifying the '${stepString}' step with the '${satisfiesAssertionString}' satisfies assertion...`);
-
-    const reference = satisfiesAssertion.getReference(),
-          axiom = context.findAxiomByReference(reference);
-
-    if (axiom !== null) {
-      const step = this,  ///
-            substitutions = [],
-            stepUnifies = axiom.unifyStep(step, substitutions, context);
-
-      if (stepUnifies) {
-        const substitutionsCompare = satisfiesAssertion.compareSubstitutions(substitutions, context);
-
-        if (substitutionsCompare) {
-          unifiesWithSatisfiesAssertion = true;
-        }
-      }
-    }
-
-    if (unifiesWithSatisfiesAssertion) {
-      context.debug(`...unified the '${stepString}' step with the '${satisfiesAssertionString}' satisfies assertion.`);
-    }
-
-    return unifiesWithSatisfiesAssertion;
-  }
-
-  async verify(context) {
-    let verifies = false;
-
-    await this.break(context);
-
-    const stepString = this.getString(); ///
-
-    context.trace(`Verifying the '${stepString}' step...`);
-
-    await asyncAttempt(async (context) => {
-      const validates = this.validate(context);
-
-      if (validates) {
-        const unifies = await this.unify(context);
-
-        if (unifies) {
-          this.setContext(context);
-
-          verifies = true;
-        }
-      }
-    }, context);
-
-    if (verifies) {
-      context.debug(`...verified the '${stepString}' step.`);
-    }
-
-    return verifies;
-  }
-
   async unify(context) {
     let unifies = false;
 
@@ -242,5 +210,37 @@ export default define(class Step extends ProofAssertion {
     return unifies;
   }
 
+  unifyWithSatisfiesAssertion(satisfiesAssertion, context) {
+    let unifiesWithSatisfiesAssertion = false;
+
+    const stepString = this.getString(), ///
+          satisfiesAssertionString = satisfiesAssertion.getString();
+
+    context.trace(`Unifying the '${stepString}' step with the '${satisfiesAssertionString}' satisfies assertion...`);
+
+    const reference = satisfiesAssertion.getReference(),
+          axiom = context.findAxiomByReference(reference);
+
+    if (axiom !== null) {
+      const step = this,  ///
+            substitutions = [],
+            stepUnifies = axiom.unifyStep(step, substitutions, context);
+
+      if (stepUnifies) {
+        const substitutionsCompare = satisfiesAssertion.compareSubstitutions(substitutions, context);
+
+        if (substitutionsCompare) {
+          unifiesWithSatisfiesAssertion = true;
+        }
+      }
+    }
+
+    if (unifiesWithSatisfiesAssertion) {
+      context.debug(`...unified the '${stepString}' step with the '${satisfiesAssertionString}' satisfies assertion.`);
+    }
+
+    return unifiesWithSatisfiesAssertion;
+  }
+
   static name = "Step";
 });

package/src/element/proofAssertion/supposition.js

@@ -30,6 +30,32 @@ export default define(class Supposition extends ProofAssertion {
     return stated;
   }
 
+  async verify(context) {
+    let verifies = false;
+
+    await this.break(context);
+
+    const suppositionString = this.getString(); ///
+
+    context.trace(`Verifying the '${suppositionString}' supposition...`);
+
+    attempt((context) => {
+      const validates = this.validate(context);
+
+      if (validates) {
+        this.setContext(context);
+
+        verifies = true;
+      }
+    }, context);
+
+    if (verifies) {
+      context.debug(`...verified the '${suppositionString}' supposition.`);
+    }
+
+    return verifies;
+  }
+
   validate(context) {
     let validates = false;
 
@@ -216,32 +242,6 @@ export default define(class Supposition extends ProofAssertion {
     return subproofUnifies;
   }
 
-  async verify(context) {
-    let verifies = false;
-
-    await this.break(context);
-
-    const suppositionString = this.getString(); ///
-
-    context.trace(`Verifying the '${suppositionString}' supposition...`);
-
-    attempt((context) => {
-      const validates = this.validate(context);
-
-      if (validates) {
-        this.setContext(context);
-
-        verifies = true;
-      }
-    }, context);
-
-    if (verifies) {
-      context.debug(`...verified the '${suppositionString}' supposition.`);
-    }
-
-    return verifies;
-  }
-
   async unifyIndependently(context) {
     let unifiesIndependently = false;
 
@@ -299,24 +299,7 @@ export default define(class Supposition extends ProofAssertion {
   static name = "Supposition";
 
   static fromJSON(json, context) {
-    const statement = statementFromJSON(json, context),
-          procedureCall = procedureCallFromJSON(json, context);
-
-    let string;
-
-    if (statement !== null) {
-      string = statement.getString();
-    }
-
-    if (procedureCall !== null) {
-      string = procedureCall.getString();
-    }
-
-    const node = null;
-
-    const supposition = new Supposition(context, string, node, statement, procedureCall);
-
-    return supposition;
+    debugger
   }
 });
 

package/src/element/property.js

@@ -53,11 +53,6 @@ export default define(class Property extends Element {
   static name = "Property";
 
   static fromJSON(json, context) {
-    const { name, nominalTypeName } = json,
-          string = name, ///
-          node = null,
-          property = new Property(context, string, node, name, nominalTypeName);
-
-    return property;
+    debugger
   }
 });

package/src/element/reference.js

@@ -304,11 +304,6 @@ export default define(class Reference extends Element {
   static name = "Reference";
 
   static fromJSON(json, context) {
-    const metavariable = metavariableFromJSON(json, context),
-          string = metavariable.getString(),
-          node = metavariable.getNode(),
-          reference = new Reference(context, string, node, metavariable);
-
-    return reference;
+    debugger
   }
 });

package/src/element/rule.js

@@ -5,12 +5,7 @@ import { Element, asynchronousUtilities } from "occam-languages";
 
 import { define } from "../elements";
 import { asyncScope } from "../utilities/context";
-import { labelsFromJSON,
-         premisesFromJSON,
-         conclusionFromJSON,
-         labelsToLabelsJSON,
-         premisesToPremisesJSON,
-         conclusionToConclusionJSON } from "../utilities/json";
+import { labelsFromJSON, premisesFromJSON, conclusionFromJSON, labelsToLabelsJSON, premisesToPremisesJSON, conclusionToConclusionJSON } from "../utilities/json";
 
 const { reverse, extract } = arrayUtilities,
       { asyncForwardsEvery, asyncBackwardsEvery } = asynchronousUtilities;
@@ -307,16 +302,13 @@ export default define(class Rule extends Element {
   static name = "Rule";
 
   static fromJSON(json, context) {
-    let rule;
-
     const node = null,
           proof = null,
+          string = null,
           labels = labelsFromJSON(json, context),
           premises = premisesFromJSON(json, context),
           conclusion = conclusionFromJSON(json, context),
-          string = stringFromLabelsPremisesAndConclusion(labels, premises, conclusion);
-
-    rule = new Rule(context, string, node, labels, premises, conclusion, proof);
+          rule = new Rule(context, string, node, proof, labels, premises, conclusion);
 
     return rule;
   }

package/src/element/section.js

@@ -42,18 +42,6 @@ export default define(class Section extends Element {
     return sectionNode;
   }
 
-  verifyHypotheses() {
-    const hypothesesVerify = this.hypotheses.every((hypothesis) => {
-      const hypothesisVerifies = hypothesis.verify(this.context);
-
-      if (hypothesisVerifies) {
-        return true;
-      }
-    });
-
-    return hypothesesVerify;
-  }
-
   async verify() {
     let verifies = false;
 
@@ -82,5 +70,17 @@ export default define(class Section extends Element {
     return verifies;
   }
 
+  verifyHypotheses() {
+    const hypothesesVerify = this.hypotheses.every((hypothesis) => {
+      const hypothesisVerifies = hypothesis.verify(this.context);
+
+      if (hypothesisVerifies) {
+        return true;
+      }
+    });
+
+    return hypothesesVerify;
+  }
+
   static name = "Section";
 });

package/src/element/signature.js

@@ -170,12 +170,6 @@ export default define(class Signature extends Element {
   static name = "Signature";
 
   static fromJSON(json, context) {
-    const terms = termsFromJSON(json, context),
-          signatureString = signatureStringFromTerms(terms),
-          string = signatureString, ///
-          node = null,
-          signature = new Signature(context, string, node, terms);
-
-    return signature;
+    debugger
   }
 });

package/src/element/statement.js

@@ -4,8 +4,10 @@ import { Element } from "occam-languages";
 import { arrayUtilities } from "necessary";
 
 import { define } from "../elements";
+import { literally } from "../utilities/context";
 import { unifyStatement } from "../process/unify";
 import { validateStatements } from "../utilities/validation";
+import { instantiateStatement } from "../process/instantiate";
 import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 
 const { match, backwardsSome } = arrayUtilities;
@@ -345,6 +347,16 @@ export default define(class Statement extends Element {
   static name = "Statement";
 
   static fromJSON(json, context) {
-    debugger
+    const statement = literally((context) => {
+      const { string } = json,
+            statementNode = instantiateStatement(string, context),
+            node = statementNode, ///
+            statement = new Statement(context, string, node);
+
+      return statement;
+
+    }, context);
+
+    return statement;
   }
 });

package/src/element/subproof.js

@@ -54,6 +54,12 @@ export default define(class Subproof extends Element {
     return proofAssertion;
   }
 
+  compareStatement(statement, context) {
+    const statementUnifies = false;
+
+    return statementUnifies;
+  }
+
   async verify(context) {
     let verifies = false;
 
@@ -84,12 +90,6 @@ export default define(class Subproof extends Element {
     return verifies;
   }
 
-  compareStatement(statement, context) {
-    const statementUnifies = false;
-
-    return statementUnifies;
-  }
-
   unifyWithSatisfiesAssertion(satisfiesAssertion, context) {
     let unifiesWithSatisfiesAssertion = false;
 

package/src/element/substitution/statement.js

@@ -338,7 +338,7 @@ export default define(class StatementSubstitution extends Substitution {
   static name = "StatementSubstitution";
 
   static fromJSON(json, context) {
-    ///
+    debugger
   }
 
   static fromStatementAndMetavariable(statement, metavariable, context) {