occam-verify-cli 1.0.843 → 1.0.847

package/src/context/synoptic.js

@@ -4,215 +4,131 @@ import { arrayUtilities } from "necessary";
 
 import Context from "../context";
 
-const { push, last, compress } = arrayUtilities;
+import { compressTerms,
+         compressFrames,
+         compressEqualities,
+         compressJudgements,
+         compressAssertions,
+         compressStatements,
+         compressReferences,
+         compressAssumptions,
+         compressMetavariables,
+         compressSubstitutions,} from "../utilities/synoptic";
+
+const { push } = arrayUtilities;
 
 export default class SynopticContext extends Context {
-  constructor(context, contexts) {
+  constructor(context, terms, frames, equalities, judgements, assertions, statements, references, assumptions, metavariables, substitutions) {
     super(context);
 
-    this.contexts = contexts;
+    this.terms = terms;
+    this.frames = frames;
+    this.equalities = equalities;
+    this.judgements = judgements;
+    this.assertions = assertions;
+    this.statements = statements;
+    this.references = references;
+    this.assumptions = assumptions;
+    this.metavariables = metavariables;
+    this.substitutions = substitutions;
   }
 
-  getContexts() {
-    return this.contexts;
-  }
-
-  getTerms() {
-    const terms = [];
+  getTerms(terms = []) {
+    push(terms, this.terms);
 
-    this.contexts.forEach((context) => {
-      const contextTerms = context.getTerms();
+    this.context.getTerms(terms);
 
-      push(terms, contextTerms);
-    });
-    
-    compress(terms, (termA, termB) => {
-      const termAComparesToTermB = termA.compareTerm(termB);
-      
-      if (!termAComparesToTermB) {
-        return true;
-      }
-    });
+    compressTerms(terms);
 
     return terms;
   }
 
-  getFrames() {
-    const frames = [];
-
-    this.contexts.forEach((context) => {
-      const contextFrames = context.getFrames();
+  getFrames(frames = []) {
+    push(frames, this.frames);
 
-      push(frames, contextFrames);
-    });
+    this.context.getFrames(frames);
 
-    compress(frames, (frameA, frameB) => {
-      const frameAEqualToFrameB = frameA.isEqualTo(frameB);
-
-      if (!frameAEqualToFrameB) {
-        return true;
-      }
-    });
+    compressFrames(frames);
 
     return frames;
   }
 
-  getEqualities() {
-    const equalities = [];
-
-    this.contexts.forEach((context) => {
-      const contextEqualities = context.getEqualities();
+  getEqualities(equalities = []) {
+    push(equalities, this.equalities);
 
-      push(equalities, contextEqualities);
-    });
+    this.context.getEqualities(equalities);
 
-    compress(equalities, (equalityA, equalityB) => {
-      const equalityAEqualToEqualityB = equalityA.isEqualTo(equalityB);
-
-      if (!equalityAEqualToEqualityB) {
-        return true;
-      }
-    });
+    compressEqualities(equalities);
 
     return equalities;
   }
 
-  getJudgements() {
-    const judgements = [];
-
-    this.contexts.forEach((context) => {
-      const contextJudgements = context.getJudgements();
+  getJudgements(judgements = []) {
+    push(judgements, this.judgements);
 
-      push(judgements, contextJudgements);
-    });
+    this.context.getJudgements(judgements);
 
-    compress(judgements, (judgementA, judgementB) => {
-      const judgementAEqualToJudgementB = judgementA.isEqualTo(judgementB);
-
-      if (!judgementAEqualToJudgementB) {
-        return true;
-      }
-    });
+    compressJudgements(judgements);
 
     return judgements;
   }
 
-  getStatements() {
-    const statements = [];
-
-    this.contexts.forEach((context) => {
-      const contextStatements = context.getStatements();
+  getStatements(statements = []) {
+    push(statements, this.statements);
 
-      push(statements, contextStatements);
-    });
+    this.context.getStatements(statements);
 
-    compress(statements, (statementA, statementB) => {
-      const statementAEqualToStatementB = statementA.isEqualTo(statementB);
-
-      if (!statementAEqualToStatementB) {
-        return true;
-      }
-    });
+    compressStatements(statements);
 
     return statements;
   }
 
-  getAssertions() {
-    const assertions = [];
-
-    this.contexts.forEach((context) => {
-      const contextAssertions = context.getAssertions();
-
-      push(assertions, contextAssertions);
-    });
+  getAssertions(assertions = []) {
+    push(assertions, this.assertions);
 
-    compress(assertions, (assertionA, assertionB) => {
-      const assertionAEqualToAssertionB = assertionA.isEqualTo(assertionB);
+    this.context.getAssertions(assertions);
 
-      if (!assertionAEqualToAssertionB) {
-        return true;
-      }
-    });
+    compressAssertions(assertions);
 
     return assertions;
   }
 
-  getReferences() {
-    const references = [];
-
-    this.contexts.forEach((context) => {
-      const contextReferences = context.getReferences();
-
-      push(references, contextReferences);
-    });
+  getReferences(references = []) {
+    push(references, this.references);
 
-    compress(references, (referenceA, referenceB) => {
-      const referenceAEqualToReferenceB = referenceA.isEqualTo(referenceB);
+    this.context.getReferences(references);
 
-      if (!referenceAEqualToReferenceB) {
-        return true;
-      }
-    });
+    compressReferences(references);
 
     return references;
   }
 
-  getAssumptions() {
-    const assumptions = [];
+  getAssumptions(assumptions = []) {
+    push(assumptions, this.assumptions);
 
-    this.contexts.forEach((context) => {
-      const contextAssumptions = context.getAssumptions();
+    this.context.getAssumptions(assumptions);
 
-      push(assumptions, contextAssumptions);
-    });
-
-    compress(assumptions, (assumptionA, assumptionB) => {
-      const assumptionAEqualToAssumptionB = assumptionA.isEqualTo(assumptionB);
-
-      if (!assumptionAEqualToAssumptionB) {
-        return true;
-      }
-    });
+    compressAssumptions(assumptions);
 
     return assumptions;
   }
 
-  getMetavariables() {
-    const metavariables = [];
-
-    this.contexts.forEach((context) => {
-      const contextMetavariables = context.getMetavariables();
-
-      push(metavariables, contextMetavariables);
-    });
+  getMetavariables(metavariables = []) {
+    push(metavariables, this.metavariables);
 
-    compress(metavariables, (metavariableA, metavariableB) => {
-      const metavariableAEqualToMetavariableB = metavariableA.isEqualTo(metavariableB);
+    this.context.getMetavariables(metavariables);
 
-      if (!metavariableAEqualToMetavariableB) {
-        return true;
-      }
-    });
+    compressMetavariables(metavariables);
 
     return metavariables;
   }
 
-  getSubstitutions() {
-    const substitutions = [];
+  getSubstitutions(substitutions = []) {
+    push(substitutions, this.substitutions);
 
-    this.contexts.forEach((context) => {
-      const contextSubstitutions = context.getSubstitutions();
+    this.context.getSubstitutions(substitutions);
 
-      push(substitutions, contextSubstitutions);
-    });
-
-    compress(substitutions, (substitutionA, substitutionB) => {
-      const substitutionAEqualToSubstitutionB = substitutionA.isEqualTo(substitutionB);
-
-      if (!substitutionAEqualToSubstitutionB) {
-        return true;
-      }
-    });
+    compressSubstitutions(substitutions);
 
     return substitutions;
   }
@@ -361,10 +277,139 @@ export default class SynopticContext extends Context {
   }
 
   static fromContexts(...contexts) {
-    const lastContext = last(contexts),
-          context = lastContext,  ///
-          synopticContext = new SynopticContext(context, contexts);
+    const context = contexts.pop(),  ///
+          terms = termsFromContexts(contexts),
+          frames = framesFromContexts(contexts),
+          equalities = equalitiesFromContexts(contexts),
+          judgements = judgementsFromContexts(contexts),
+          assertions = assertionsFromContexts(contexts),
+          statements = statementsFromContexts(contexts),
+          references = referencesFromContexts(contexts),
+          assumptions = assumptionsFromContexts(contexts),
+          metavariables = metavariablesFromContexts(contexts),
+          substitutions = substitutionsFromContexts(contexts),
+          synopticContext = new SynopticContext(context, terms, frames, equalities, judgements, assertions, statements, references, assumptions, metavariables, substitutions);
 
     return synopticContext;
   }
 }
+
+function termsFromContexts(contexts) {
+  const terms = [];
+
+  contexts.forEach((context) => {
+    context.getTerms(terms);
+  });
+
+  compressTerms(terms);
+
+  return terms;
+}
+
+function framesFromContexts(contexts) {
+  const frames = [];
+
+  contexts.forEach((context) => {
+    context.getFrames(frames);
+  });
+
+  compressFrames(frames);
+
+  return frames;
+}
+
+function equalitiesFromContexts(contexts) {
+  const equalities = [];
+
+  contexts.forEach((context) => {
+    context.getEqualities(equalities);
+  });
+
+  compressEqualities(equalities);
+
+  return equalities;
+}
+
+function judgementsFromContexts(contexts) {
+  const judgements = [];
+
+  contexts.forEach((context) => {
+    context.getJudgements(judgements);
+  });
+
+  compressJudgements(judgements);
+
+  return judgements;
+}
+
+function assertionsFromContexts(contexts) {
+  const assertions = [];
+
+  contexts.forEach((context) => {
+    context.getAssertions(assertions);
+  });
+
+  compressAssertions(assertions);
+
+  return assertions;
+}
+
+function statementsFromContexts(contexts) {
+  const statements = [];
+
+  contexts.forEach((context) => {
+    context.getStatements(statements);
+  });
+
+  compressStatements(statements);
+
+  return statements;
+}
+
+function referencesFromContexts(contexts) {
+  const references = [];
+
+  contexts.forEach((context) => {
+    context.getReferences(references);
+  });
+
+  compressReferences(references);
+
+  return references;
+}
+
+function assumptionsFromContexts(contexts) {
+  const assumptions = [];
+
+  contexts.forEach((context) => {
+    context.getAssumptions(assumptions);
+  });
+
+  compressAssumptions(assumptions);
+
+  return assumptions;
+}
+
+function metavariablesFromContexts(contexts) {
+  const metavariables = [];
+
+  contexts.forEach((context) => {
+    context.getMetavariables(metavariables);
+  });
+
+  compressMetavariables(metavariables);
+
+  return metavariables;
+}
+
+function substitutionsFromContexts(contexts) {
+  const substitutions = [];
+
+  contexts.forEach((context) => {
+    context.getSubstitutions(substitutions);
+  });
+
+  compressSubstitutions(substitutions);
+
+  return substitutions;
+}

package/src/context.js

@@ -24,72 +24,82 @@ export default class Context extends ContextBase {
     return filePath;
   }
 
-  getTerms() {
-    const context = this.getContext(),
-          terms = context.getTerms();
+  getTerms(terms = []) {
+    const context = this.getContext();
+
+    context.getTerms(terms);
 
     return terms;
   }
 
-  getFrames() {
-    const context = this.getContext(),
-      frames = context.getFrames();
+  getFrames(frames = []) {
+    const context = this.getContext();
+
+    context.getFrames(frames);
 
     return frames;
   }
 
-  getJudgements() {
-    const context = this.getContext(),
-          judgements = context.getJudgements();
+  getJudgements(judgements = []) {
+    const context = this.getContext();
+
+    context.getJudgements(judgements);
 
     return judgements;
   }
 
-  getEqualities() {
-    const context = this.getContext(),
-          equalities = context.getEqualities();
+  getEqualities(equalities = []) {
+    const context = this.getContext();
+
+    context.getEqualities(equalities);
 
     return equalities;
   }
 
-  getStatements() {
-    const context = this.getContext(),
-          statements = context.getStatements();
+  getStatements(statements = []) {
+    const context = this.getContext();
+
+    context.getStatements(statements);
 
     return statements;
   }
 
-  getAssertions() {
-    const context = this.getContext(),
-          assertions = context.getAssertions();
+  getAssertions(assertions = []) {
+    const context = this.getContext();
+
+    context.getAssertions(assertions);
 
     return assertions;
   }
 
-  getReferences() {
-    const context = this.getContext(),
-          references = context.getReferences();
+  getReferences(references = []) {
+    const context = this.getContext();
+
+    context.getReferences(references);
 
     return references;
   }
 
-  getAssumptions() {
-    const context = this.getContext(),
-          assumptions = context.getAssumptions();
+  getAssumptions(assumptions = []) {
+    const context = this.getContext();
+
+    context.getAssumptions(assumptions);
 
     return assumptions;
   }
 
-  getMetavariables() {
-    const context = this.getContext(),
-          metavariables = context.getMetavariables();
+  getMetavariables(metavariables = []) {
+    const context = this.getContext();
+
+    context.getMetavariables(metavariables);
 
     return metavariables;
   }
 
-  getSubstitutions() {
-    const context = this.getContext(),
-      substitutions = context.getSubstitutions();
+  getSubstitutions(substitutions = []) {
+    const context = this.getContext();
+
+    context.getSubstitutions(substitutions);
 
     return substitutions;
   }
@@ -115,20 +125,27 @@ export default class Context extends ContextBase {
     return constructors;
   }
 
-  getDeclaredVariables(includeRelease) {
+  getDeclaredVariables() {
     const context = this.getContext(),
-          declaredVariables = context.getDeclaredVariables(includeRelease);
+          declaredVariables = context.getDeclaredVariables();
 
     return declaredVariables;
   }
 
-  getDeclaredMetavariables(includeRelease) {
+  getDeclaredMetavariables() {
     const context = this.getContext(),
-          declaredMetavariables = context.getDeclaredMetavariables(includeRelease);
+          declaredMetavariables = context.getDeclaredMetavariables();
 
     return declaredMetavariables;
   }
 
+  getDeclaredJudgements() {
+    const context = this.getContext(),
+          declaredJudgements = context.getDeclaredJudgements();
+
+    return declaredJudgements;
+  }
+
   getSubproofOrProofAssertions() {
     const context = this.getContext(),
           subproofOrProofAssertions = context.getSubproofOrProofAssertions();
@@ -260,6 +277,13 @@ export default class Context extends ContextBase {
     return substitution;
   }
 
+  findDeclaredJudgementsByMetavariableNode(metavariableNode) {
+    const context = this.getContext(),
+          declaredJudgements = context.findDeclaredJudgementsByMetavariableNode(metavariableNode);
+
+    return declaredJudgements;
+  }
+
   findMetaLevelAssumptionByMetaLevelAssumptionNode(metaLevelAssumptionNode) {
     const context = this.getContext(),
           metaLevelAssumption = context.findMetaLevelAssumptionByMetaLevelAssumptionNode(metaLevelAssumptionNode);
@@ -303,9 +327,9 @@ export default class Context extends ContextBase {
     return substitution;
   }
 
-  findTypeByTypeName(metaTypeName) {
+  findTypeByTypeName(typeName) {
     const context = this.getContext(),
-          type = context.findTypeByTypeName(metaTypeName);
+          type = context.findTypeByTypeName(typeName);
 
     return type;
   }
@@ -461,18 +485,18 @@ export default class Context extends ContextBase {
     return referencePresent;
   }
 
-  isJudgementPresentByMetavariableNode(metavariableNode) {
+  isSubstitutionPresentByMetavariableNode(metavariableNode) {
     const context = this.getContext(),
-          judgementPresent = context.isJudgementPresentByMetavariableNode(metavariableNode);
+          substitutionPresent = context.isSubstitutionPresentByMetavariableNode(metavariableNode);
 
-    return judgementPresent;
+    return substitutionPresent;
   }
 
-  isSubstitutionPresentByMetavariableNode(metavariableNode) {
+  isDeclaredJudgementPresentByMetavariableNode(metavariableNode) {
     const context = this.getContext(),
-          substitutionPresent = context.isSubstitutionPresentByMetavariableNode(metavariableNode);
+          declaredJudgementPresent = context.isDeclaredJudgementPresentByMetavariableNode(metavariableNode);
 
-    return substitutionPresent;
+    return declaredJudgementPresent;
   }
 
   isSubstitutionPresentByMetavariableNodeAndSubstitution(metavariableNode, substitution) {

package/src/element/assertion/contained.js

@@ -243,14 +243,19 @@ export default define(class ContainedAssertion extends Assertion {
     return unifiesIndependently;
   }
 
+  static name = "ContainedAssertion";
+
   toJSON() {
-    const json = super.toJSON();
+    const string = this.getString(),
+          lineIndex = this.getLineIndex(),
+          json = {
+            string,
+            lineIndex
+          };
 
     return json;
   }
 
-  static name = "ContainedAssertion";
-
   static fromJSON(json, context) {
     let containedAssertion = null;
 

package/src/element/assertion/defined.js

@@ -213,6 +213,17 @@ export default define(class DefinedAssertion extends Assertion {
 
   static name = "DefinedAssertion";
 
+  toJSON() {
+    const string = this.getString(),
+          lineIndex = this.getLineIndex(),
+          json = {
+            string,
+            lineIndex
+          };
+
+    return json;
+  }
+
   static fromJSON(json, context) {
     let definedAssertion = null;
 
@@ -220,7 +231,7 @@ export default define(class DefinedAssertion extends Assertion {
 
     if (this.name === name) {
       instantiate((context) => {
-        const { string } = json,
+        const { string, lineIndex } = json,
               definedAssertionNode = instantiateDefinedAssertion(string, context),
               node = definedAssertionNode,  ///
               term = termFromJDefinedAssertionNode(definedAssertionNode, context),
@@ -229,7 +240,7 @@ export default define(class DefinedAssertion extends Assertion {
 
         context = null;
 
-        definedAssertion = new DefinedAssertion(context, string, node, term, frame, negated);
+        definedAssertion = new DefinedAssertion(context, string, node, lineIndex, term, frame, negated);
       }, context);
     }
 
@@ -301,8 +312,8 @@ function isVariableDefined(variable, context) {
 
 function isMetavariableDefined(metavariable, context) {
   const metavariableNode = metavariable.getNode(),
-        judgementPresent = context.isJudgementPresentByMetavariableNode(metavariableNode),
-        metavariableDefined = judgementPresent; ///
+        declaredJudgementPresent = context.isDeclaredJudgementPresentByMetavariableNode(metavariableNode),
+        metavariableDefined = declaredJudgementPresent; ///
 
   return metavariableDefined
 }