occam-verify-cli 1.0.388 → 1.0.396

package/src/ontology/assertion/type.js

@@ -1,21 +1,19 @@
 "use strict";
 
 import ontology from "../../ontology";
+import Assertion from "../assertion";
 import VariableAssignment from "../../assignment/variable";
 
 import { define } from "../../ontology";
 
-export default define(class TypeAssertion {
-  constructor(string, term, type) {
-    this.string = string;
+export default define(class TypeAssertion extends Assertion {
+  constructor(string, node, tokens, term, type) {
+    super(string, node, tokens);
+
     this.term = term;
     this.type = type;
   }
 
-  getString() {
-    return this.string;
-  }
-
   getTerm() {
     return this.term;
   }
@@ -27,7 +25,7 @@ export default define(class TypeAssertion {
   verify(assignments, stated, context) {
     let verifies = false;
 
-    let typeAssertionString = this.string;  ///
+    let typeAssertionString = this.getString();  ///
 
     context.trace(`Verifying the '${typeAssertionString}' type assertion...`);
 
@@ -89,7 +87,7 @@ export default define(class TypeAssertion {
   verifyWhenStated(assignments, context) {
     let verifiesWhenStated = false;
 
-    const typeAssertionString = this.string; ///
+    const typeAssertionString = this.getString(); ///
 
     context.trace(`Verifying the '${typeAssertionString}' stated type assertion...`);
 
@@ -120,7 +118,7 @@ export default define(class TypeAssertion {
   verifyWhenDerived(context) {
     let verifiesWhenDerived;
 
-    const typeAssertionString = this.string; ///
+    const typeAssertionString = this.getString(); ///
 
     context.trace(`Verifying the '${typeAssertionString}' derived type assertion...`);
 
@@ -191,11 +189,12 @@ export default define(class TypeAssertion {
     if (typeAssertionNode !== null) {
       const { Term, Type } = ontology,
             node = typeAssertionNode, ///
+            tokens = null,
             string = context.nodeAsString(node),
             term = Term.fromTypeAssertionNode(typeAssertionNode, context),
             type = Type.fromTypeAssertionNode(typeAssertionNode, context);
 
-      typeAssertion = new TypeAssertion(string, term, type);
+      typeAssertion = new TypeAssertion(string, node, tokens, term, type);
     }
 
     return typeAssertion;

package/src/ontology/assertion.js

@@ -0,0 +1,23 @@
+"use strict";
+
+export default class Assertion {
+  constructor(string, node, tokens) {
+    this.string = string;
+    this.node = node;
+    this.tokens = tokens;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getNode() {
+    return this.node;
+  }
+
+  getTokens() {
+    return this.tokens;
+  }
+
+  matchAssertionNode(assertionNode) { return this.node.match(assertionNode); }
+}

package/src/ontology/axiom.js

@@ -82,6 +82,8 @@ export default define(class Axiom extends TopLevelAssertion {
   unifyStep(step, substitutions, context) {
     let stepUnifies = false;
 
+    context = step.getContext();
+
     const node = this.getNode(),
           stepString = step.getString(),
           axiomString = this.getString();
@@ -94,12 +96,7 @@ export default define(class Axiom extends TopLevelAssertion {
       context.trace(`Cannot unify the '${stepString}' step with the '${axiomString}' axiom because the axiom is not unconditional.`, node);
     } else {
       const statement = step.getStatement(),
-            specificContext = context;  ///
-
-      context = this.getContext();
-
-      const generalContext = context,  ///
-            statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, generalContext, specificContext);
+            statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, context);
 
       if (statementUnifiesWithDeduction) {
         stepUnifies = true;
@@ -113,18 +110,17 @@ export default define(class Axiom extends TopLevelAssertion {
     return stepUnifies;
   }
 
-  unifyLastStep(lastStep, substitutions, generalContext, specificContext) {
+  unifyLastStep(lastStep, substitutions, context) {
     let lastStepUnifies = false;
 
     const node = this.getNode(),
-          context = specificContext,  ///
           axiomString = this.getString(),
           lastStepString = lastStep.getString();
 
     context.trace(`Unifying the '${lastStepString}' last step with the '${axiomString}' axiom...`, node)
 
     const statement = lastStep.getStatement(),
-          statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, generalContext, specificContext);
+          statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, context);
 
     if (statementUnifiesWithDeduction) {
       lastStepUnifies = true;
@@ -152,16 +148,11 @@ export default define(class Axiom extends TopLevelAssertion {
       context.trace(`Cannot unify the '${subproofString}' subproof with the '${axiomString}' axiom because the axiom is unconditional.`, node);
     } else {
       const lastStep = subproof.getLastStep(),
-            specificContext = context;  ///
-
-      context = this.getContext();
-
-      const generalContext = context,  ///
-            lastStepUnifies = this.unifyLastStep(lastStep, substitutions, generalContext, specificContext);
+            lastStepUnifies = this.unifyLastStep(lastStep, substitutions, context);
 
       if (lastStepUnifies) {
         const suppositions = subproof.getSuppositions(),
-              suppositionsUnify = this.unifySuppositions(suppositions, substitutions, generalContext, specificContext);
+              suppositionsUnify = this.unifySuppositions(suppositions, substitutions, context);
 
         if (suppositionsUnify) {
           subproofUnifies = true;

package/src/ontology/combinator/bracketed.js

@@ -23,6 +23,8 @@ export default define(class BracketedCombinator extends Combinator {
     return statementUnifies;
   }
 
+  static name = "BracketedCombinator";
+
   static fromNothing() {
     const { Statement } = ontology,
           bracketedStatementNode = combinatorBracketedContext.getBracketedStatementNode(),

package/src/ontology/combinator.js

@@ -53,6 +53,8 @@ export default define(class Combinator {
     return json;
   }
 
+  static name = "Combinator";
+
   static fromJSON(json, context) {
     const statement = statementFromJSON(json, context),
           combinator = new Combinator(statement);

package/src/ontology/conclusion.js

@@ -1,17 +1,23 @@
 "use strict";
 
 import ontology from "../ontology";
+import TemporaryContext from "../context/temporary";
 
 import { define } from "../ontology";
-import { statementFromJSON, statementToStatementJSON } from "../utilities/json";
+import { termsFromJSON, framesFromJSON, statementFromJSON, termsToTermsJSON, framesToFramesJSON, statementToStatementJSON } from "../utilities/json";
 
 export  default define(class Conclusion {
-  constructor(node, string, statement) {
+  constructor(context, node, string, statement) {
+    this.context = context;
     this.node = node;
     this.string = string;
     this.statement = statement;
   }
 
+  getContext() {
+    return this.context;
+  }
+
   getNode() {
     return this.node;
   }
@@ -27,6 +33,10 @@ export  default define(class Conclusion {
   verify(context) {
     let verifies = false;
 
+    const temporaryContext = TemporaryContext.fromNothing(context);
+
+    context = temporaryContext; ///
+
     const conclusionString = this.string;  ///
 
     context.trace(`Verifying the '${conclusionString}' conclusion...`, this.node);
@@ -43,35 +53,56 @@ export  default define(class Conclusion {
     }
 
     if (verifies) {
+      this.context = context;
+
       context.debug(`...verified the '${conclusionString}' conclusion.`, this.node);
     }
 
     return verifies;
   }
 
-  unifyStatement(statement, substitutions, generalContext, specificContext) {
+  unifyStatement(statement, substitutions, context) {
     let statementUnifies;
 
     const conclusion = this,  ///
           statementString = statement.getString(),
           conclusionString = conclusion.getString();
 
-    specificContext.trace(`Unifying the '${statementString}' statement with the '${conclusionString}' conclusion...`);
+    context.trace(`Unifying the '${statementString}' statement with the '${conclusionString}' conclusion...`);
+
+    const generalContext = this.context,  ///
+          specificContext = context;  ///
 
     statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
 
     if (statementUnifies) {
-      specificContext.debug(`...unified the '${statementString}' statement with the '${conclusionString}' conclusion.`);
+      context.debug(`...unified the '${statementString}' statement with the '${conclusionString}' conclusion.`);
     }
 
     return statementUnifies;
   }
 
   toJSON() {
+    let frames,
+        terms;
+
+    frames = this.context.getFrames();
+
+    terms = this.context.getTerms();
+
     const statementJSON = statementToStatementJSON(this.statement),
-          statement = statementJSON,  ///
+          framesJSON = framesToFramesJSON(frames),
+          termsJSON = termsToTermsJSON(terms);
+
+    frames = framesJSON;  ///
+
+    terms = termsJSON;  ///
+
+    const statement = statementJSON,  ///
           json = {
-            statement
+            statement,
+            frames,
+            terms
           };
 
     return json;
@@ -80,10 +111,16 @@ export  default define(class Conclusion {
   static name = "Conclusion";
 
   static fromJSON(json, context) {
-    const statement = statementFromJSON(json, context),
+    const terms = termsFromJSON(json, context),
+          frames = framesFromJSON(json, context),
+          statement = statementFromJSON(json, context),
           node = null,
           string = statement.getString(),
-          conclusion = new Conclusion(node, string, statement);
+          temporaryContext = TemporaryContext.fromTermsAndFrames(terms, frames, context);
+
+    context = temporaryContext; ///
+
+    const conclusion = new Conclusion(context, node, string, statement);
 
     return conclusion;
   }
@@ -93,7 +130,11 @@ export  default define(class Conclusion {
           node = conclusionNode,  ///
           string = context.nodeAsString(node),
           statement = Statement.fromConclusionNode(conclusionNode, context),
-          conclusion = new Conclusion(node, string, statement);
+          temporaryContext = null;
+
+    context = temporaryContext; ///
+
+    const conclusion = new Conclusion(context, node, string, statement);
 
     return conclusion;
   }

package/src/ontology/constructor/bracketed.js

@@ -52,6 +52,8 @@ export default define(class BracketedConstructor extends Constructor {
     return termUnifies;
   }
 
+  static name = "BracketedConstructor";
+
   static fromNothing() {
     const { Term } = ontology,
           bracketedTermNode = constructorBracketedContext.getBracketedTermNode(),

package/src/ontology/constructor.js

@@ -67,6 +67,8 @@ export default define(class Constructor {
     return json;
   }
 
+  static name = "Constructor";
+
   static fromJSON(json, context) {
     const term = termFromJSON(json, context),
           string = stringFromTerm(term),

package/src/ontology/declaration.js

@@ -5,6 +5,7 @@ import Substitutions from "../substitutions";
 
 import { define } from "../ontology";
 import { unifyStatementIntrinsically } from "../utilities/unification";
+import { metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
 
 export default define(class Declaration {
   constructor(string, node, statement, metavariable) {
@@ -310,14 +311,46 @@ export default define(class Declaration {
     }
 
     if (metaLemmaMetatheoremUnifies) {
+      context = generalContext; ///
+
       context.trace(`...unified the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${declarationString}' declaration...`);
     }
 
     return metaLemmaMetatheoremUnifies;
   }
 
+  toJSON() {
+    let json = null;
+
+    const simple = this.isSimple();
+
+    if (simple) {
+      const metavariable = this.getMetavariable(),
+            metavariableJSON = metavariableToMetavariableJSON(metavariable);
+
+      json = metavariableJSON;  ///
+    }
+
+    return json;
+  }
+
   static name = "Declaration";
 
+  static fromJSON(json, context) {
+    let declaration = null;
+
+    if (json !== null) {
+      const string = null,
+            node = null,
+            statement = null,
+            metavariable = metavariableFromJSON(json, context);
+
+      declaration = new Declaration(string, node, statement, metavariable)
+    }
+
+    return declaration;
+  }
+
   static fromJudgementNode(judgementNode, context) {
     const declarationNode = judgementNode.getDeclarationNode(),
           declaration = declarationFromDeclarationNode(declarationNode, context);
@@ -344,8 +377,8 @@ function declarationFromDeclarationNode(declarationNode, context) {
   const { Metavariable, Declaration, Statement } = ontology,
         node = declarationNode,  ///
         string = context.nodeAsString(node),
-        metavariable = Metavariable.fromDeclarationNode(declarationNode, context),
         statement = Statement.fromDeclarationNode(declarationNode, context),
+        metavariable = Metavariable.fromDeclarationNode(declarationNode, context),
         declaration = new Declaration(string, node, statement, metavariable);
 
   return declaration;

package/src/ontology/deduction.js

@@ -1,17 +1,23 @@
 "use strict";
 
 import ontology from "../ontology";
+import TemporaryContext from "../context/temporary";
 
 import { define } from "../ontology";
-import { statementFromJSON, statementToStatementJSON } from "../utilities/json";
+import { termsFromJSON, framesFromJSON, statementFromJSON, termsToTermsJSON, framesToFramesJSON, statementToStatementJSON } from "../utilities/json";
 
 export default define(class Deduction {
-  constructor(node, string, statement) {
+  constructor(context, node, string, statement) {
+    this.context = context;
     this.node = node;
     this.string = string;
     this.statement = statement;
   }
 
+  getContext() {
+    return this.context;
+  }
+
   getNode(node) {
     return this.node;
   }
@@ -27,6 +33,10 @@ export default define(class Deduction {
   verify(context) {
     let verifies = false;
 
+    const temporaryContext = TemporaryContext.fromNothing(context);
+
+    context = temporaryContext; ///
+
     const deductionString = this.string;  ///
 
     context.trace(`Verifying the '${deductionString}' deduction...`, this.node);
@@ -42,25 +52,30 @@ export default define(class Deduction {
     }
 
     if (verifies) {
+      this.context = context;
+
       context.debug(`...verified the '${deductionString}' deduction.`, this.node);
     }
 
     return verifies;
   }
 
-  unifyStatement(statement, substitutions, generalContext, specificContext) {
+  unifyStatement(statement, substitutions, context) {
     let statementUnifies;
 
     const deduction = this,  ///
           statementString = statement.getString(),
           deductionString = deduction.getString();
 
-    specificContext.trace(`Unifying the '${statementString}' statement with the '${deductionString}' deduction...`);
+    context.trace(`Unifying the '${statementString}' statement with the '${deductionString}' deduction...`);
+
+    const generalContext = this.context,  ///
+          specificContext = context;  ///
 
     statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
 
     if (statementUnifies) {
-      specificContext.debug(`...unified the '${statementString}' statement with the '${deductionString}' deduction.`);
+      context.debug(`...unified the '${statementString}' statement with the '${deductionString}' deduction.`);
     }
 
     return statementUnifies;
@@ -89,10 +104,26 @@ export default define(class Deduction {
   }
 
   toJSON() {
+    let frames,
+        terms;
+
+    frames = this.context.getFrames();
+
+    terms = this.context.getTerms();
+
     const statementJSON = statementToStatementJSON(this.statement),
-          statement = statementJSON,  ///
+          framesJSON = framesToFramesJSON(frames),
+          termsJSON = termsToTermsJSON(terms);
+
+    frames = framesJSON;  ///
+
+    terms = termsJSON;  ///
+
+    const statement = statementJSON,  ///
           json = {
-            statement
+            statement,
+            frames,
+            terms
           };
 
     return json;
@@ -101,10 +132,16 @@ export default define(class Deduction {
   static name = "Deduction";
 
   static fromJSON(json, context) {
-    const statement = statementFromJSON(json, context),
+    const terms = termsFromJSON(json, context),
+          frames = framesFromJSON(json, context),
+          statement = statementFromJSON(json, context),
           node = null,
           string = statement.getString(),
-          deduction = new Deduction(node, string, statement);
+          temporaryContext = TemporaryContext.fromTermsAndFrames(terms, frames, context);
+
+    context = temporaryContext; ///
+
+    const deduction = new Deduction(context, node, string, statement);
 
     return deduction;
   }
@@ -114,7 +151,11 @@ export default define(class Deduction {
           node = deductionNode,  ///
           string = context.nodeAsString(node),
           statement = Statement.fromDeductionNode(deductionNode, context),
-          deduction = new Deduction(node, string, statement);
+          temporaryContext = null;
+
+    context = temporaryContext;  ///
+
+    const deduction = new Deduction(context, node, string, statement);
 
     return deduction;
   }

package/src/ontology/frame.js

@@ -36,14 +36,27 @@ export default define(class Frame {
 
   getLength() { return this.declarations.length; }
 
+  getDeclaration() {
+    let declaration = null;
+
+    const length = this.getLength();
+
+    if (length === 1) {
+      const firstDeclaration = first(this.declarations);
+
+      declaration = firstDeclaration; ///
+    }
+
+    return declaration;
+  }
+
   getMetavariable() {
     let metavariable = null;
 
     const simple = this.isSimple();
 
     if (simple) {
-      const firstDeclaration = first(this.declarations),
-            declaration = firstDeclaration; ///
+      const declaration = this.getDeclaration();
 
       metavariable = declaration.getMetavariable();
     }
@@ -54,12 +67,9 @@ export default define(class Frame {
   isSimple() {
     let simple = false;
 
-    const length = this.getLength();
-
-    if (length === 1) {
-      const firstDeclaration = first(this.declarations),
-            declaration = firstDeclaration; ///
+    const declaration = this.getDeclaration();
 
+    if (declaration !== null) {
       simple = declaration.isSimple();
     }
 
@@ -73,6 +83,8 @@ export default define(class Frame {
     return equalTo;
   }
 
+  matchFrameNode(frameNode) { return this.node.match(frameNode); }
+
   matchSubstitution(substitution, context) {
     let substitutionMatches = false;
 
@@ -146,6 +158,10 @@ export default define(class Frame {
     }
 
     if (verifies) {
+      const frame = this; ///
+
+      context.addFrame(frame);
+
       context.debug(`...verified the '${frameString}' frame.`);
     }
 
@@ -244,8 +260,42 @@ export default define(class Frame {
     return verifiesGivenMetaType;
   }
 
+  toJSON() {
+    let json = null;
+
+    const simple = this.isSimple();
+
+    if (simple) {
+      const declaration = this.getDeclaration(),
+            declarationJSON = declaration.toJSON();
+
+      json = declarationJSON;  ///
+    }
+
+    return json;
+  }
+
   static name = "Frame";
 
+  static fromJSON(json, context) {
+    let frame = null;
+
+    if (json !== null) {
+      const { Declaration } =ontology,
+            declaration = Declaration.fromJSON(json, context),
+            declarations = [
+              declaration
+            ],
+            string = null,
+            node = null,
+            tokens = null;
+
+      frame = new Frame(string, node, tokens, declarations);
+    }
+
+    return frame;
+  }
+
   static fromFrameNode(frameNode, context) {
     let frame = null;
 
@@ -294,8 +344,7 @@ function frameFromFrameNode(frameNode, context) {
         string = context.nodeAsString(node),
         tokens = context.nodeAsTokens(node),
         declarations = declarationsFromFrameNode(frameNode, context),
-        metavariables = metavariablesFromFrameNode(frameNode, context),
-        frame = new Frame(string, node, tokens, declarations, metavariables);
+        frame = new Frame(string, node, tokens, declarations);
 
   return frame;
 }
@@ -312,18 +361,6 @@ function declarationsFromFrameNode(frameNode, context) {
   return declarations;
 }
 
-function metavariablesFromFrameNode(frameNode, context) {
-  const { Metavariable } = ontology,
-        metavariableNodes = frameNode.getMetavariableNodes(),
-        metavariables = metavariableNodes.map((metavariableNode) => {
-          const metavariable = Metavariable.fromMetavariableNode(metavariableNode, context);
-
-          return metavariable;
-        });
-
-  return metavariables;
-}
-
 function declarationsStringFromDeclarations(declarations) {
   const declarationsString = declarations.reduce((declarationsString, declaration) => {
     const declarationString = declaration.getString();