occam-verify-cli 1.0.388 → 1.0.404

package/src/ontology/frame.js

@@ -11,11 +11,11 @@ import { FRAME_META_TYPE_NAME } from "../metaTypeNames";
 const { first } = arrayUtilities;
 
 export default define(class Frame {
-  constructor(string, node, tokens, declarations) {
+  constructor(string, node, tokens, assumptions) {
     this.string = string;
     this.node = node;
     this.tokens = tokens;
-    this.declarations = declarations;
+    this.assumptions = assumptions;
   }
 
   getString() {
@@ -30,42 +30,42 @@ export default define(class Frame {
     return this.tokens;
   }
 
-  getDeclarations() {
-    return this.declarations;
+  getAssumptions() {
+    return this.assumptions;
   }
 
-  getLength() { return this.declarations.length; }
+  getLength() { return this.assumptions.length; }
 
-  getMetavariable() {
-    let metavariable = null;
+  getAssumption() {
+    let assumption = null;
 
-    const simple = this.isSimple();
+    const length = this.getLength();
 
-    if (simple) {
-      const firstDeclaration = first(this.declarations),
-            declaration = firstDeclaration; ///
+    if (length === 1) {
+      const firstAssumption = first(this.assumptions);
 
-      metavariable = declaration.getMetavariable();
+      assumption = firstAssumption; ///
     }
 
-    return metavariable;
+    return assumption;
   }
 
-  isSimple() {
-    let simple = false;
+  getMetavariable() {
+    let metavariable = null;
 
-    const length = this.getLength();
+    const simple = this.isSimple();
 
-    if (length === 1) {
-      const firstDeclaration = first(this.declarations),
-            declaration = firstDeclaration; ///
+    if (simple) {
+      const assumption = this.getAssumption();
 
-      simple = declaration.isSimple();
+      metavariable = assumption.getMetavariable();
     }
 
-    return simple;
+    return metavariable;
   }
 
+  isSimple() { return this.node.isSimple();}
+
   isEqualTo(frame) {
     const frameString = frame.getString(),
           equalTo = (frameString === this.string);
@@ -73,6 +73,8 @@ export default define(class Frame {
     return equalTo;
   }
 
+  matchFrameNode(frameNode) { return this.node.match(frameNode); }
+
   matchSubstitution(substitution, context) {
     let substitutionMatches = false;
 
@@ -82,10 +84,10 @@ export default define(class Frame {
     context.trace(`Matching the '${substitutionString}' substitution against the '${frameString}' frame...`);
 
     if (!substitutionMatches) {
-      substitutionMatches = this.declarations.some((declaration) => {
-        const substitutionMatchesDeclaration = declaration.matchSubstitution(substitution, context);
+      substitutionMatches = this.assumptions.some((assumption) => {
+        const substitutionMatchesAssumption = assumption.matchSubstitution(substitution, context);
 
-        if (substitutionMatchesDeclaration) {
+        if (substitutionMatchesAssumption) {
           return true;
         }
       });
@@ -128,9 +130,9 @@ export default define(class Frame {
 
     context.trace(`Verifying the '${frameString}' frame...`);
 
-    const declarationsVerify = this.verifyDeclarations(assignments, stated, context);
+    const assumptionsVerify = this.verifyAssumptions(assignments, stated, context);
 
-    if (declarationsVerify) {
+    if (assumptionsVerify) {
       let verifiesWhenStated = false,
           verifiesWhenDerived = false;
 
@@ -146,6 +148,10 @@ export default define(class Frame {
     }
 
     if (verifies) {
+      const frame = this; ///
+
+      context.addFrame(frame);
+
       context.debug(`...verified the '${frameString}' frame.`);
     }
 
@@ -190,8 +196,8 @@ export default define(class Frame {
     return verifiesWhenDerived;
   }
 
-  verifyDeclarations(assignments, stated, context) {
-    let declarationsVerify = true;  ///
+  verifyAssumptions(assignments, stated, context) {
+    let assumptionsVerify = true;  ///
 
     const length = this.getLength();
 
@@ -199,26 +205,26 @@ export default define(class Frame {
       const sOrNothing = (length > 1) ?
                            S :
                              NOTHING,
-            declarationsString = declarationsStringFromDeclarations(this.declarations);
+            assumptionsString = assumptionsStringFromAssumptions(this.assumptions);
 
-      context.trace(`Verifying the '${declarationsString}' declaration${sOrNothing}...`);
+      context.trace(`Verifying the '${assumptionsString}' assumption${sOrNothing}...`);
 
       stated = true;  ///
 
       assignments = null; ///
 
-      declarationsVerify = this.declarations.every((declaration) => {
-        const declarationVerifies = declaration.verify(assignments, stated, context);
+      assumptionsVerify = this.assumptions.every((assumption) => {
+        const assumptionVerifies = assumption.verify(assignments, stated, context);
 
-        return declarationVerifies;
+        return assumptionVerifies;
       });
 
-      if (declarationsVerify) {
-        context.debug(`...verified the '${declarationsString}' declaration${sOrNothing}.`);
+      if (assumptionsVerify) {
+        context.debug(`...verified the '${assumptionsString}' assumption${sOrNothing}.`);
       }
     }
 
-    return declarationsVerify;
+    return assumptionsVerify;
   }
 
   verifyGivenMetaType(metaType, assignments, stated, context) {
@@ -244,8 +250,42 @@ export default define(class Frame {
     return verifiesGivenMetaType;
   }
 
+  toJSON() {
+    let json = null;
+
+    const simple = this.isSimple();
+
+    if (simple) {
+      const assumption = this.getAssumption(),
+            assumptionJSON = assumption.toJSON();
+
+      json = assumptionJSON;  ///
+    }
+
+    return json;
+  }
+
   static name = "Frame";
 
+  static fromJSON(json, context) {
+    let frame = null;
+
+    if (json !== null) {
+      const { Assumption } =ontology,
+            assumption = Assumption.fromJSON(json, context),
+            assumptions = [
+              assumption
+            ],
+            string = null,
+            node = null,
+            tokens = null;
+
+      frame = new Frame(string, node, tokens, assumptions);
+    }
+
+    return frame;
+  }
+
   static fromFrameNode(frameNode, context) {
     let frame = null;
 
@@ -293,47 +333,34 @@ function frameFromFrameNode(frameNode, context) {
         node = frameNode, ///
         string = context.nodeAsString(node),
         tokens = context.nodeAsTokens(node),
-        declarations = declarationsFromFrameNode(frameNode, context),
-        metavariables = metavariablesFromFrameNode(frameNode, context),
-        frame = new Frame(string, node, tokens, declarations, metavariables);
+        assumptions = assumptionsFromFrameNode(frameNode, context),
+        frame = new Frame(string, node, tokens, assumptions);
 
   return frame;
 }
 
-function declarationsFromFrameNode(frameNode, context) {
-  const { Declaration } = ontology,
-        declarationNodes = frameNode.getDeclarationNodes(),
-        declarations = declarationNodes.map((declarationNode) => {
-          const declaration = Declaration.fromDeclarationNode(declarationNode, context);
-
-          return declaration;
-        });
-
-  return declarations;
-}
-
-function metavariablesFromFrameNode(frameNode, context) {
-  const { Metavariable } = ontology,
-        metavariableNodes = frameNode.getMetavariableNodes(),
-        metavariables = metavariableNodes.map((metavariableNode) => {
-          const metavariable = Metavariable.fromMetavariableNode(metavariableNode, context);
+function assumptionsFromFrameNode(frameNode, context) {
+  const { Assumption } = ontology,
+        assumptionNodes = frameNode.getAssumptionNodes(),
+        assumptions = assumptionNodes.map((assumptionNode) => {
+          const assumption = Assumption.fromAssumptionNode(assumptionNode, context);
 
-          return metavariable;
+          return assumption;
         });
 
-  return metavariables;
+  return assumptions;
 }
 
-function declarationsStringFromDeclarations(declarations) {
-  const declarationsString = declarations.reduce((declarationsString, declaration) => {
-    const declarationString = declaration.getString();
+function assumptionsStringFromAssumptions(assumptions) {
+  const assumptionsString = assumptions.reduce((assumptionsString, assumption) => {
+    const assumptionString = assumption.getString();
 
-    declarationsString = (declarationsString === null) ?
-                           declarationString :
-                            `${declarationsString}, ${declarationString}`;
+    assumptionsString = (assumptionsString === null) ?
+                           assumptionString :
+                            `${assumptionsString}, ${assumptionString}`;
 
-    return declarationsString;
+    return assumptionsString;
   }, null);
 
-  return declarationsString;
+  return assumptionsString;
 }

package/src/ontology/hypothesis.js

@@ -7,20 +7,20 @@ import { assignAssignments } from "../utilities/assignments";
 import { statementFromJSON, statementToStatementJSON } from "../utilities/json";
 
 export default define(class Hypothesis {
-  constructor(node, string, statement) {
-    this.node = node;
+  constructor(string, node, statement) {
     this.string = string;
+    this.node = node;
     this.statement = statement;
   }
 
-  getNode() {
-    return this.node;
-  }
-
   getString() {
     return this.string;
   }
 
+  getNode() {
+    return this.node;
+  }
+
   getStatement() {
     return this.statement;
   }
@@ -107,7 +107,7 @@ export default define(class Hypothesis {
     }
 
     const node = null,
-          hypothesis = new Hypothesis(node, string, statement);
+          hypothesis = new Hypothesis(string, node, statement);
 
     return hypothesis;
   }
@@ -117,7 +117,7 @@ export default define(class Hypothesis {
           node = hypothesisNode, ///
           string = context.nodeAsString(node),
           statement = Statement.fromHypothesisNode(hypothesisNode, context),
-          hypothesis = new Hypothesis(node, string, statement);
+          hypothesis = new Hypothesis(string, node, statement);
 
     return hypothesis
   }

package/src/ontology/judgement.js

@@ -6,10 +6,10 @@ import JudgementAssignment from "../assignment/judgement";
 import { define } from "../ontology";
 
 export default define(class Judgement {
-  constructor(string, frame, declaration) {
+  constructor(string, frame, assumption) {
     this.string = string;
     this.frame = frame;
-    this.declaration = declaration;
+    this.assumption = assumption;
   }
 
   getString() {
@@ -21,7 +21,7 @@ export default define(class Judgement {
   }
 
   getDeclaration() {
-    return this.declaration;
+    return this.assumption;
   }
 
   isSimple() { return this.frame.isSimple(); }
@@ -88,7 +88,7 @@ export default define(class Judgement {
   verifyDeclaration(assignments, stated, context) {
     let declarationVerifies;
 
-    declarationVerifies = this.declaration.verify(assignments, stated, context);
+    declarationVerifies = this.assumption.verify(assignments, stated, context);
 
     return declarationVerifies;
   }
@@ -116,7 +116,7 @@ export default define(class Judgement {
 
     context.trace(`Verifying the '${judgementString}' derived judgement...`);
 
-    const metavariable = this.declaration.getMetavariable(),
+    const metavariable = this.assumption.getMetavariable(),
           reference = referenceFromMetavariable(metavariable, context),
           metaLemmaMetatheorem = context.findMetaLemmaMetatheoremByReference(reference),
           substitutions = metaLemmaMetatheorem.getSubstitutions(),
@@ -151,13 +151,13 @@ export default define(class Judgement {
     const judgementNode = statementNode.getJudgementNode();
 
     if (judgementNode !== null) {
-      const { Frame, Declaration} = ontology,
+      const { Frame, Assumption } = ontology,
             node = judgementNode, ///
             string = context.nodeAsString(node),
             frame = Frame.fromJudgementNode(judgementNode, context),
-            declaration = Declaration.fromJudgementNode(judgementNode, context);
+            assumption = Assumption.fromJudgementNode(judgementNode, context);
 
-      judgement = new Judgement(string, frame, declaration);
+      judgement = new Judgement(string, frame, assumption);
     }
 
     return judgement;

package/src/ontology/label.js

@@ -35,18 +35,13 @@ export default define(class Label {
 
   matchReference(reference) {
     const metavariable = reference.getMetavariable(),
-          metavariableEqualToMetavariable = this.isMetavariableEqualTo(metavariable),
+          metavariableEqualToMetavariable = this.isMetavariableEqualToMetavariable(metavariable),
           referenceMatches = metavariableEqualToMetavariable; ///
 
     return referenceMatches;
   }
 
-  isMetavariableEqualTo(metavariable) {
-    const equalTo = this.metavariable.isEqualTo(metavariable),
-          metavariableEqualTo = equalTo;  ///
-
-    return metavariableEqualTo;
-  }
+  isMetavariableEqualToMetavariable(metavariable) { return this.metavariable.isEqualTo(metavariable); }
 
   matchMetavariableName(metavariableName) { return this.metavariable.matchMetavariableName(metavariableName); }
 

package/src/ontology/metavariable.js

@@ -95,9 +95,7 @@ export default define(class Metavariable {
     context.trace(`Verifying the '${metavariableString}' metavariable...`);
 
     const metavariable = this, ///
-          generalContext = context,  ///
-          specificContext = context,  ///
-          metavariablePresent = generalContext.isMetavariablePresent(metavariable, generalContext, specificContext);
+          metavariablePresent = context.isMetavariablePresent(metavariable);
 
     verifies = metavariablePresent; ///
 
@@ -118,10 +116,7 @@ export default define(class Metavariable {
 
     let metavariable = this;  ///
 
-    const specificContext = context,  ///
-          generalContext = context; ///
-
-    metavariable = generalContext.findMetavariable(metavariable, generalContext, specificContext);
+    metavariable = context.findMetavariable(metavariable);
 
     if (metavariable !== null) {
       const metavariableMetaTypeEqualToMetaType = metavariable.isMetaTypeEqualTo(metaType);
@@ -155,7 +150,7 @@ export default define(class Metavariable {
       if (simpleSubstitutionPresent) {
         const simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariable(metavariable),
               substitution = simpleSubstitution,  ///
-              substitutionFrameEqualToFrame = substitution.isFrameEqualTo(frame);
+              substitutionFrameEqualToFrame = substitution.isFrameEqualToFrame(frame);
 
         if (substitutionFrameEqualToFrame) {
           frameUnifies = true;
@@ -167,7 +162,7 @@ export default define(class Metavariable {
               frameSubstitution = FrameSubstitution.fromFrameAndMetavariable(frame, metavariable, context),
               substitution = frameSubstitution;  ///
 
-        substitutions.addSubstitution(substitution, specificContext);
+        substitutions.addSubstitution(substitution, context);
 
         frameUnifies = true;
       }
@@ -200,7 +195,7 @@ export default define(class Metavariable {
       if (simpleSubstitutionPresent) {
         const simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariable(metavariable), ///
               substitution = simpleSubstitution,  ///
-              substitutionReferenceEqualToReference = substitution.isReferenceEqualTo(reference, context);
+              substitutionReferenceEqualToReference = substitution.isReferenceEqualToReference(reference, context);
 
         if (substitutionReferenceEqualToReference) {
           referenceUnifies = true;
@@ -211,7 +206,7 @@ export default define(class Metavariable {
               referenceSubstitution = ReferenceSubstitution.fromReferenceAndMetavariable(reference, metavariable, context),
               substitution = referenceSubstitution;  ///
 
-        substitutions.addSubstitution(substitution, specificContext);
+        substitutions.addSubstitution(substitution, context);
 
         referenceUnifies = true;
       }
@@ -247,7 +242,7 @@ export default define(class Metavariable {
       if (substitutionPresent) {
         substitution = substitutions.findSubstitutionByMetavariableAndSubstitution(metavariable, substitution); ///
 
-        const substitutionStatementEqualToStatement = substitution.isStatementEqualTo(statement, context);
+        const substitutionStatementEqualToStatement = substitution.isStatementEqualToStatement(statement, context);
 
         if (substitutionStatementEqualToStatement) {
           statementUnifies = true;
@@ -259,7 +254,7 @@ export default define(class Metavariable {
 
         substitution = statementSubstitution;  ///
 
-        substitutions.addSubstitution(substitution, specificContext);
+        substitutions.addSubstitution(substitution, context);
 
         statementUnifies = true;
       }
@@ -272,10 +267,12 @@ export default define(class Metavariable {
     return statementUnifies;
   }
 
-  unifyMetavariable(metavariable, generalContext, specificContext) {
+  unifyMetavariable(metavariable, context) {
     let metavariableUnifies;
 
-    const generalMetavariable = this, ///
+    const generalContext = context, ///
+          specificContext = context,  ///
+          generalMetavariable = this, ///
           specificMetavariable = metavariable,  ///
           generalMetavariableString = generalMetavariable.getString(),
           specificMetavariableString = specificMetavariable.getString();
@@ -477,8 +474,8 @@ export default define(class Metavariable {
     return metavariable;
   }
 
-  static fromDeclarationNode(declarationNode, context) {
-    const metavariableNode = declarationNode.getMetavariableNode(),
+  static fromAssumptionNode(assumptionNode, context) {
+    const metavariableNode = assumptionNode.getMetavariableNode(),
           metavariable = metavariableFromMetavariableNode(metavariableNode, context);
 
     return metavariable;