occam-verify-cli 1.0.651 → 1.0.655

package/src/context/ephemeral.js

@@ -2,6 +2,25 @@
 
 import Context from "../context";
 
+import { termsFromJSON,
+         framesFromJSON,
+         termsToTermsJSON,
+         framesToFramesJSON,
+         judgementsFromJSON,
+         equalitiesFromJSON,
+         statementsFromJSON,
+         assertionsFromJSON,
+         referencesFromJSON,
+         assumptionsFromJSON,
+         substitutionsFromJSON,
+         judgementsToJudgementsJSON,
+         equalitiesToEqualitiesJSON,
+         statementsToStatementsJSON,
+         assertionsToAssertionsJSON,
+         referencesToReferencesJSON,
+         assumptionsToAssumptionsJSON,
+         substitutionsToCSubstitutionsJSON } from "../utilities/json";
+
 export default class EphemeralContext extends Context {
   constructor(context, terms, frames, judgements, equalities, assertions, statements, references, assumptions, substitutions) {
     super(context);
@@ -449,6 +468,71 @@ export default class EphemeralContext extends Context {
     return substitutionPresent;
   }
 
+  initialise(json) {
+    const context = this; ///
+
+    this.terms = termsFromJSON(json, context);
+    this.frames = framesFromJSON(json, context);
+    this.judgements = judgementsFromJSON(json, context);
+    this.equalities = equalitiesFromJSON(json, context);
+    this.statements = statementsFromJSON(json, context);
+    this.assertions = assertionsFromJSON(json, context);
+    this.references = referencesFromJSON(json, context);
+    this.assumptions = assumptionsFromJSON(json, context);
+    this.substitutions = substitutionsFromJSON(json, context);
+  }
+
+  toJSON() {
+    const termsJSON = termsToTermsJSON(this.terms),
+          framesJSON = framesToFramesJSON(this.frames),
+          judgementsJSON = judgementsToJudgementsJSON(this.judgements),
+          equalitiesJSON = equalitiesToEqualitiesJSON(this.equalities),
+          statementsJSON = statementsToStatementsJSON(this.statements),
+          assertionsJSON = assertionsToAssertionsJSON(this.assertions),
+          referencesJSON = referencesToReferencesJSON(this.references),
+          assumptionsJSON = assumptionsToAssumptionsJSON(this.assumptions),
+          substitutionsJSON = substitutionsToCSubstitutionsJSON(this.substitutions),
+          terms = termsJSON, ///
+          frames = framesJSON, ///
+          judgements = judgementsJSON, ///
+          equalities = equalitiesJSON, ///
+          statements = statementsJSON, ///
+          assertions = assertionsJSON, ///
+          references = referencesJSON, ///
+          assumptions = assumptionsJSON, ///
+          substitutions = substitutionsJSON, ///
+          json = {
+            terms,
+            frames,
+            judgements,
+            equalities,
+            statements,
+            assertions,
+            references,
+            assumptions,
+            substitutions
+          };
+
+    return json;
+  }
+
+  static fromJSON(json, context) {
+    const terms = null,
+          frames = null,
+          judgements = null,
+          equalities = null,
+          statements = null,
+          assertions = null,
+          references = null,
+          assumptions = null,
+          substitutions = null,
+          emphemeralContext = new EphemeralContext(context, terms, frames, judgements, equalities, assertions, statements, references, assumptions, substitutions);
+
+    emphemeralContext.initialise(json);
+
+    return emphemeralContext;
+  }
+
   static fromNothing(context) {
     const terms = [],
           frames = [],

package/src/context/file/nominal.js

@@ -831,6 +831,28 @@ export default class NominalFileContext extends FileContext {
     return fileVerifies;
   }
 
+  initialise(json) {
+    const fileContext = this; ///
+
+    this.types = [];
+
+    typesFromJSON(json, this.types, fileContext);
+
+    this.lemmas = lemmasFromNothing();
+    this.metaLemmas = metaLemmasFromNothing();
+
+    this.metavariables = metavariablesFromJSON(json, fileContext);
+    this.variables = variablesFromJSON(json, fileContext);
+    this.rules = rulesFromJSON(json, fileContext);
+    this.axioms = axiomsFromJSON(json, fileContext);
+    this.theorems = theoremsFromJSON(json, fileContext);
+    this.conjectures = conjecturesFromJSON(json, fileContext);
+    this.combinators = combinatorsFromJSON(json, fileContext);
+    this.typePrefixes = typePrefixesFromJSON(json, fileContext);
+    this.constructors = constructorsFromJSON(json, fileContext);
+    this.metatheorems = metatheoremsFromJSON(json, fileContext);
+  }
+
   toJSON() {
     const typesJSON = typesToTypesJSON(this.types),
           rulesJSON = rulesToRulesJSON(this.rules),
@@ -899,31 +921,29 @@ export default class NominalFileContext extends FileContext {
   }
 
   static fromJSON(json, context) {
-    const fileContext = this, ///
-          releaseContext = context, ///
+    const releaseContext = context, ///
           combinedCustomGrammar = releaseContext.getCombinedCustomGrammar(),
           nominalLexer = nominalLexerFromCombinedCustomGrammar(NominalLexer, combinedCustomGrammar),
           nominalParser = nominalParserFromCombinedCustomGrammar(NominalParser, combinedCustomGrammar),
           lexer = nominalLexer, ///
           parser = nominalParser, ///
-          types = [];
-
-    typesFromJSON(json, types, fileContext);
-
-    const rules = rulesFromJSON(json, fileContext),
-          axioms = axiomsFromJSON(json, fileContext),
-          lemmas = lemmasFromNothing(),
-          theorems = theoremsFromJSON(json, fileContext),
-          variables = variablesFromJSON(json, fileContext),
-          metaLemmas = metaLemmasFromNothing(),
-          conjectures = conjecturesFromJSON(json, fileContext),
-          combinators = combinatorsFromJSON(json, fileContext),
-          typePrefixes = typePrefixesFromJSON(json, fileContext),
-          constructors = constructorsFromJSON(json, fileContext),
-          metatheorems = metatheoremsFromJSON(json, fileContext),
-          metavariables = metavariablesFromJSON(json, fileContext),
+          types = null,
+          rules = null,
+          axioms = null,
+          lemmas = null,
+          theorems = null,
+          variables = null,
+          metaLemmas = null,
+          conjectures = null,
+          combinators = null,
+          typePrefixes = null,
+          constructors = null,
+          metatheorems = null,
+          metavariables = null,
           nominalFileContext = FileContext.fromJSON(NominalFileContext, json, lexer, parser, types, rules, axioms, lemmas, theorems, variables, metaLemmas, conjectures, combinators, typePrefixes, constructors, metatheorems, metavariables, context);
 
+    nominalFileContext.initialise(json);
+
     return nominalFileContext;
   }
 }

package/src/element/assertion/contained.js

@@ -236,7 +236,32 @@ export default define(class ContainedAssertion extends Assertion {
     return unifiesIndependently;
   }
 
+  toJSON() {
+    debugger
+
+    const { name } = this.constructor,
+          string = this.getString(),
+          json = {
+            name,
+            string
+          };
+
+    return json;
+  }
+
   static name = "ContainedAssertion";
+
+  static fromJSON(json, context) {
+    let containedAssertion = null;
+
+    const { name } = json;
+
+    if (this.name === name) {
+      debugger
+    }
+
+    return containedAssertion;
+  }
 });
 
 function validateWhenDerived(term, frame, statement, negated, generalContext, specificContext) {

package/src/element/assertion/defined.js

@@ -205,7 +205,32 @@ export default define(class DefinedAssertion extends Assertion {
     return unifiesIndependently;
   }
 
+  toJSON() {
+    debugger
+
+    const { name } = this.constructor,
+          string = this.getString(),
+          json = {
+            name,
+            string
+          };
+
+    return json;
+  }
+
   static name = "DefinedAssertion";
+
+  static fromJSON(json, context) {
+    let definedAssertion = null;
+
+    const { name } = json;
+
+    if (this.name === name) {
+      debugger
+    }
+
+    return definedAssertion;
+  }
 });
 
 function validateWhenDerived(term, frame, negated, generalContext, specificContext) {

package/src/element/assertion/property.js

@@ -193,5 +193,30 @@ export default define(class PropertyAssertion extends Assertion {
     context.addAssignment(assignment);
   }
 
+  toJSON() {
+    debugger
+
+    const { name } = this.constructor,
+          string = this.getString(),
+          json = {
+            name,
+            string
+          };
+
+    return json;
+  }
+
   static name = "PropertyAssertion";
+
+  static fromJSON(json, context) {
+    let proopertyAssertion = null;
+
+    const { name } = json;
+
+    if (this.name === name) {
+      debugger
+    }
+
+    return proopertyAssertion;
+  }
 });

package/src/element/assertion/satisfies.js

@@ -154,5 +154,30 @@ export default define(class SatisfiesAssertion extends Assertion {
     return statementUnifies;
   }
 
+  toJSON() {
+    debugger
+
+    const { name } = this.constructor,
+          string = this.getString(),
+          json = {
+            name,
+            string
+          };
+
+    return json;
+  }
+
   static name = "SatisfiesAssertion";
+
+  static fromJSON(json, context) {
+    let satisfiesAssertion = null;
+
+    const { name } = json;
+
+    if (this.name === name) {
+      debugger
+    }
+
+    return satisfiesAssertion;
+  }
 });

package/src/element/assertion/subproof.js

@@ -5,7 +5,10 @@ import { arrayUtilities } from "necessary";
 import Assertion from "../assertion";
 
 import { define } from "../../elements";
+import { literally } from "../../utilities/context";
 import { unifyStatement } from "../../process/unify";
+import { statementsToStatementsJSON } from "../../utilities/json";
+import { instantiateSubproofAssertion } from "../../process/instantiate";
 
 const { match } = arrayUtilities;
 
@@ -111,6 +114,49 @@ export default define(class SubproofAssertion extends Assertion {
     return subproofUnifies;
   }
 
+  toJSON() {
+    const { name } = this.constructor,
+          statementJSON = statementsToStatementsJSON(this.statements),
+          statements = statementJSON, ///
+          string = this.getString(),
+          json = {
+            name,
+            string,
+            statements
+          };
+
+    return json;
+  }
+
   static name = "SubproofAssertion";
+
+  static fromJSON(json, context) {
+    let subproorAssertion = null;
+
+    const { name } = json;
+
+    if (this.name === name) {
+      subproorAssertion = literally((context) => {
+        const { string } = json,
+              subproofAssertionNode = instantiateSubproofAssertion(string, context),
+              statements = statementsFromSubproofAssertionNode(subproofAssertionNode, context),
+              node = subproofAssertionNode; ///
+
+        subproorAssertion = new SubproofAssertion(context, string, node, statements);
+      }, context);
+    }
+
+    return subproorAssertion;
+  }
 });
 
+function statementsFromSubproofAssertionNode(subproofAssertionNode, context) {
+  const statementNodes = subproofAssertionNode.getStatementNodes(),
+        statements = statementNodes.map((statemetNode) => {
+          const statement = context.findStatementByStatementNode(statemetNode);
+
+          return statement;
+        });
+
+  return statements;
+}

package/src/element/assertion/type.js

@@ -4,6 +4,7 @@ import Assertion from "../assertion";
 
 import { define } from "../../elements";
 import { variableAssignmentFromTypeAssertion } from "../../process/assign";
+import {termToTermJSON} from "../../utilities/json";
 
 export default define(class TypeAssertion extends Assertion {
   constructor(context, string, node, term, type) {
@@ -188,5 +189,36 @@ export default define(class TypeAssertion extends Assertion {
     }
   }
 
+  toJSON() {
+    debugger
+
+    const { name } = this.constructor,
+          termJSON = termToTermJSON(this.term),
+          typeJSON = typeToTypeJSON(this.type),
+          term = termJSON,  ///
+          type = typeJSON,  ///
+          string = this.getString(),
+          json = {
+            name,
+            term,
+            type,
+            string
+          };
+
+    return json;
+  }
+
   static name = "TypeAssertion";
+
+  static fromJSON(json, context) {
+    let typeAssertion = null;
+
+    const { name } = json;
+
+    if (this.name === name) {
+      debugger
+    }
+
+    return typeAssertion;
+  }
 });

package/src/element/assumption.js

@@ -336,17 +336,6 @@ export default define(class Assumption extends Element {
   static name = "Assumption";
 
   static fromJSON(json, context) {
-    let assumption = null;
-
-    if (json !== null) {
-      const string = null,
-            node = null,
-            statement = null,
-            reference = referenceFromJSON(json, context);
-
-      assumption = new Assumption(string, node, statement, reference)
-    }
-
-    return assumption;
+    debugger
   }
 });

package/src/element/combinator.js

@@ -3,10 +3,16 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { attempt } from "../utilities/context";
+import { attempt, literally } from "../utilities/context";
+import { instantiateCombinator } from "../process/instantiate";
 import { verifyStatementAsCombinator } from "../process/verify";
 import { unifyStatementWithCombinator } from "../process/unify";
-import { statementFromJSON, statementToStatementJSON } from "../utilities/json";
+import {
+  statementFromJSON,
+  ephemeralContextFromJSON,
+  statementToStatementJSON,
+  procedureCallToProcedureCallJSON
+} from "../utilities/json";
 
 export default define(class Combinator extends Element {
   constructor(context, string, node, statement) {
@@ -79,9 +85,20 @@ export default define(class Combinator extends Element {
   }
 
   toJSON() {
+    let context;
+
+    context = this.getContext();
+
+    const contextJSON = context.toJSON();
+
+    context = contextJSON;  ///
+
     const statementJSON = statementToStatementJSON(this.statement),
           statement = statementJSON,  ///
+          string = this.getString(),
           json = {
+            context,
+            string,
             statement
           };
 
@@ -91,7 +108,20 @@ export default define(class Combinator extends Element {
   static name = "Combinator";
 
   static fromJSON(json, context) {
-    debugger
+    const combinator = literally((context) => {
+      const { string } = json,
+            combinatorNode = instantiateCombinator(string, context),
+            node = combinatorNode,  ///
+            statement = statementFromJSON(json, context),
+            ephemeralContext = ephemeralContextFromJSON(json, context);
+
+      context = ephemeralContext; ///
+
+      const combinator = new Combinator(context, string, node, statement);
+
+      return combinator;
+    }, context);
 
+    return combinator;
   }
 });

package/src/element/conclusion.js

@@ -3,8 +3,9 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { attempt } from "../utilities/context";
-import { statementFromJSON, termsToTermsJSON, framesToFramesJSON, statementToStatementJSON } from "../utilities/json";
+import { attempt, literally } from "../utilities/context";
+import { instantiateConclusion } from "../process/instantiate";
+import { statementFromJSON, ephemeralContextFromJSON, statementToStatementJSON } from "../utilities/json";
 
 export  default define(class Conclusion extends Element {
   constructor(context, string, node, statement) {
@@ -87,9 +88,20 @@ export  default define(class Conclusion extends Element {
   }
 
   toJSON() {
+    let context;
+
+    context = this.getContext();
+
+    const contextJSON = context.toJSON();
+
+    context = contextJSON;  ///
+
     const statementJSON = statementToStatementJSON(this.statement),
           statement = statementJSON,  ///
+          string = this.getString(),
           json = {
+            context,
+            string,
             statement
           };
 
@@ -99,6 +111,24 @@ export  default define(class Conclusion extends Element {
   static name = "Conclusion";
 
   static fromJSON(json, context) {
-    debugger
+    const conclusion = literally((context) => {
+      let { string } = json;
+
+      string = `${string}
+`;  ///
+
+      const conclusionNode = instantiateConclusion(string, context),
+            node = conclusionNode,  ///
+            statement = statementFromJSON(json, context),
+            ephemeralContext = ephemeralContextFromJSON(json, context);
+
+      context = ephemeralContext; ///
+
+      const conclusion = new Conclusion(context, string, node, statement);
+
+      return conclusion;
+    }, context);
+
+    return conclusion;
   }
 });

package/src/element/constructor.js

@@ -3,10 +3,11 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { attempt } from "../utilities/context";
+import { attempt, literally } from "../utilities/context";
+import { instantiateConstructor } from "../process/instantiate";
 import { verifyTermAsConstructor } from "../process/verify";
 import { unifyTermWithConstructor } from "../process/unify";
-import { termFromJSON, termToTermJSON } from "../utilities/json";
+import { termFromJSON, termToTermJSON, ephemeralContextFromJSON } from "../utilities/json";
 
 export default define(class Constructor extends Element {
   constructor(context, string, node, term) {
@@ -124,8 +125,20 @@ export default define(class Constructor extends Element {
   static name = "Constructor";
 
   static fromJSON(json, context) {
-    const term = termFromJSON(json, context),
-          constructor = new Constructor(term);
+    const constructor = literally((context) => {
+      const { string } = json,
+            constructorNode = instantiateConstructor(string, context),
+            node = constructorNode, ///
+            term = termFromJSON(json, context),
+            ephemeralContext = ephemeralContextFromJSON(json, context);
+
+      context = ephemeralContext; ///
+
+      const constructor = new Constructor(context, string, node, term);
+
+      return constructor;
+
+    }, context);
 
     return constructor;
   }