occam-verify-cli 1.0.792 → 1.0.799

package/src/context/proof.js

@@ -8,21 +8,17 @@ import elements from "../elements";
 const { last, filter } = arrayUtilities;
 
 class ProofContext extends Context {
-  constructor(context, assumptions, variables, judgements, assignments, equivalences, subproofOrProofAssertions) {
+  constructor(context, variables, judgements, assignments, equivalences, metaLevelAssumptions, subproofOrProofAssertions) {
     super(context);
 
-    this.assumptions = assumptions;
     this.variables = variables;
     this.judgements = judgements;
     this.assignments = assignments;
     this.equivalences = equivalences;
+    this.metaLevelAssumptions = metaLevelAssumptions;
     this.subproofOrProofAssertions = subproofOrProofAssertions;
   }
 
-  getAssumptions() {
-    return this.assumptions;
-  }
-
   getVariables() {
     let variables;
 
@@ -73,6 +69,10 @@ class ProofContext extends Context {
     return equivalences;
   }
 
+  getMetaLevelAssumptions() {
+    return this.metaLevelAssumptions;
+  }
+
   getSubproofOrProofAssertions() {
     let subproofOrProofAssertions;
 
@@ -119,7 +119,7 @@ class ProofContext extends Context {
   isMetaLevel() {
     let metaLevel = false;
 
-    if (this.assumptions !== null) {
+    if (this.metaLevelAssumptiona !== null) {
       metaLevel = true;
     } else {
       const context = this.getContext();
@@ -184,38 +184,34 @@ class ProofContext extends Context {
     });
   }
 
-  addAssumption(assumption, metaLevel = true) {
-    if (!metaLevel) {
-      return;
-    }
-
-    if (this.assumptions === null) {
-      super.addAssumption(assumption, metaLevel);
+  addMetaLevelAssumption(metaLevelAssumption) {
+    if (this.metaLevelAssumptions === null) {
+      super.addMetaLevelAssumption(metaLevelAssumption);
 
       return;
     }
 
     const context = this, ///
-          assumptionA = assumption, ///
-          assumptionString = assumption.getString();
+          metaLevelAssumptionA = metaLevelAssumption, ///
+          metaLevelAssumptionString = metaLevelAssumption.getString();
 
-    context.trace(`Adding the '${assumptionString}' assumption to the proof context...`);
+    context.trace(`Adding the '${metaLevelAssumptionString}' meta-level assumption to the proof context...`);
 
-    const assumptionB = this.assumptions.find((assumption) => {
-      const assumptionB = assumption, ///
-            assumptionAEqualToAssumptionB = assumptionA.isEqualTo(assumptionB);
+    const metaLevelAssumptionB = this.metaLevelAssumptions.find((metaLevelAssumption) => {
+      const metaLevelAssumptionB = metaLevelAssumption, ///
+            metaLevelAssumptionAEqualToAssumptionB = metaLevelAssumptionA.isEqualTo(metaLevelAssumptionB);
 
-      if (assumptionAEqualToAssumptionB) {
+      if (metaLevelAssumptionAEqualToAssumptionB) {
         return true;
       }
     }) || null;
 
-    if (assumptionB !== null) {
-      context.debug(`The '${assumptionString}' assumption has already been added to the proof context.`);
+    if (metaLevelAssumptionB !== null) {
+      context.debug(`The '${metaLevelAssumptionString}' metaLevelAssumption has already been added to the proof context.`);
     } else {
-      this.assumptions.push(assumption);
+      this.metaLevelAssumptions.push(metaLevelAssumption);
 
-      context.debug(`...added the '${assumptionString}' assumption to the proof context.`);
+      context.debug(`...added the '${metaLevelAssumptionString}' meta-level assumption to the proof context.`);
     }
   }
 
@@ -246,26 +242,6 @@ class ProofContext extends Context {
 
   findEquivalenceByTerm(term) { return this.equivalences.findEquivalenceByTerm(term); }
 
-  findAssumptionByAssumptionNode(assumptionNode, metaLevel = true) {
-    let assumption = null;
-
-    if (metaLevel) {
-      if (this.assumptions === null) {
-        assumption = super.findAssumptionByAssumptionNode(assumptionNode, metaLevel);
-      } else {
-        assumption = this.assumptions.find((assumption) => {
-          const assumptionNodeMatches = assumption.matchAssumptionNode(assumptionNode);
-
-          if (assumptionNodeMatches) {
-            return true;
-          }
-        }) || null;
-      }
-    }
-
-    return assumption;
-  }
-
   findJudgementByMetavariableName(metavariableName) {
     const judgements = this.getJudgements(),
           judgement = judgements.find((judgement) => {
@@ -306,6 +282,24 @@ class ProofContext extends Context {
     return judgements;
   }
 
+  findMetaLevelAssumptionByMetaLevelAssumptionNode(metaLevelAssumptionNode) {
+    let metaLevelAssumption;
+
+    if (this.metaLevelAssumptions === null) {
+      metaLevelAssumption = super.findMetaLevelAssumptionByMetaLevelAssumptionNode(metaLevelAssumptionNode);
+    } else {
+      metaLevelAssumption = this.metaLevelAssumptions.find((metaLevelAssumption) => {
+        const metaLevelAssumptionNodeMatches = metaLevelAssumption.matchMetaLevelAssumptionNode(metaLevelAssumptionNode);
+
+        if (metaLevelAssumptionNodeMatches) {
+          return true;
+        }
+      }) || null;
+    }
+
+    return metaLevelAssumption;
+  }
+
   isJudgementPresentByMetavariableName(metavariableName) {
     const judgement = this.findJudgementByMetavariableName(metavariableName),
           judgementPresent = (judgement !== null);
@@ -341,14 +335,14 @@ class ProofContext extends Context {
     return termGrounded;
   }
 
-  static fromAssumptions(assumptions, context) {
+  static fromMetaLevelAssumptions(metaLevelAssumptions, context) {
     const { Equivalences } = elements,
           variables = [],
           judgements = [],
           assignments = [],
           equivalences = Equivalences.fromNothing(context),
           subproofOrProofAssertions = [],
-          proofContext = new ProofContext(context, assumptions, variables, judgements, assignments, equivalences, subproofOrProofAssertions);
+          proofContext = new ProofContext(context, variables, judgements, assignments, equivalences, metaLevelAssumptions, subproofOrProofAssertions);
 
     return proofContext;
   }

package/src/context.js

@@ -246,6 +246,13 @@ export default class Context extends ContextBase {
     return judgement;
   }
 
+  findMetavariableByMetavariableNode(metavariableNode) {
+    const context = this.getContext(),
+          metavariable = context.findMetavariableByMetavariableNode(metavariableNode);
+
+    return metavariable;
+  }
+
   findSubstitutionBySubstitutionNode(substitutionNode) {
     const context = this.getContext(),
           substitution = context.findSubstitutionBySubstitutionNode(substitutionNode);
@@ -253,6 +260,13 @@ export default class Context extends ContextBase {
     return substitution;
   }
 
+  findMetaLevelAssumptionByMetaLevelAssumptionNode(metaLevelAssumptionNode) {
+    const context = this.getContext(),
+          metaLevelAssumption = context.findMetaLevelAssumptionByMetaLevelAssumptionNode(metaLevelAssumptionNode);
+
+    return metaLevelAssumption;
+  }
+
   findTypeByNominalTypeName(nominalTypeName) {
     const context = this.getContext(),
           type = context.findTypeByNominalTypeName(nominalTypeName);
@@ -419,6 +433,13 @@ export default class Context extends ContextBase {
     return metavariablePresent;
   }
 
+  isMetavariablePresentByMetavariableNode(metavariableNode) {
+    const context = this.getContext(),
+          metavariablePresent = context.isMetavariablePresentByMetavariableNode(metavariableNode);
+
+    return metavariablePresent;
+  }
+
   isSubstitutionPresentBySubstitutionNode(substitutionNode) {
     const context = this.getContext(),
           substitutionPresent = context.isSubstitutionPresentBySubstitutionNode(substitutionNode);
@@ -509,10 +530,10 @@ export default class Context extends ContextBase {
     context.addReference(reference);
   }
 
-  addAssumption(assumption, metaLevel = false) {
+  addAssumption(assumption) {
     const context = this.getContext();
 
-    context.addAssumption(assumption, metaLevel);
+    context.addAssumption(assumption);
   }
 
   addAssignment(assignment) {
@@ -521,12 +542,24 @@ export default class Context extends ContextBase {
     context.addAssignment(assignment);
   }
 
+  addMetavariable(metavariable) {
+    const context = this.getContext();
+
+    context.addMetavariable(metavariable);
+  }
+
   addSubstitution(substitution) {
     const context = this.getContext();
 
     context.addSubstitution(substitution);
   }
 
+  addMetaLevelAssumption(metaLevelAssumption) {
+    const context = this.getContext();
+
+    context.addMetaLevelAssumption(metaLevelAssumption);
+  }
+
   addSubproofOrProofAssertion(subproofOrProofAssertion) {
     const context = this.getContext();
 

package/src/element/assertion/contained.js

@@ -3,7 +3,7 @@
 import Assertion from "../assertion";
 
 import { define } from "../../elements";
-import { descend, instantiate } from "../../utilities/context";
+import { instantiate } from "../../utilities/context";
 import { instantiateContainedAssertion } from "../../process/instantiate";
 import { termFromTermAndSubstitutions, frameFromFrameAndSubstitutions, statementFromStatementAndSubstitutions } from "../../utilities/substitutions";
 import { termFromContainedAssertionNode,
@@ -143,15 +143,13 @@ export default define(class ContainedAssertion extends Assertion {
       const frameSingular = this.frame.isSingular();
 
       if (frameSingular) {
-        descend((context) => {
-          const frame = this.frame.validate(context);
+        const frame = this.frame.validate(context);
 
-          if (frame !== null) {
-            this.frame = frame;
+        if (frame !== null) {
+          this.frame = frame;
 
-            frameValidates = true;
-          }
-        }, context);
+          frameValidates = true;
+        }
       } else {
         context.debug(`The '${frameString}' frame is not singular.`);
       }
@@ -172,13 +170,11 @@ export default define(class ContainedAssertion extends Assertion {
 
       context.trace(`Validating the '${statementString}' statement...`);
 
-      descend((context) => {
-        const statement = this.statement.validate(context);
+      const statement = this.statement.validate(context);
 
-        if (statement !== null) {
-          statementValidates = true;
-        }
-      }, context);
+      if (statement !== null) {
+        statementValidates = true;
+      }
 
       if (statementValidates) {
         context.debug(`...validated the '${statementString}' statement.`);

package/src/element/assertion/defined.js

@@ -3,7 +3,7 @@
 import Assertion from "../assertion";
 
 import { define } from "../../elements";
-import { descend, instantiate } from "../../utilities/context";
+import { instantiate } from "../../utilities/context";
 import { instantiateDefinedAssertion } from "../../process/instantiate";
 import { termFromTermAndSubstitutions, frameFromFrameAndSubstitutions } from "../../utilities/substitutions";
 import { termFromJDefinedAssertionNode, frameFromJDefinedAssertionNode, negatedFromJDefinedAssertionNode, definedAssertionFromStatementNode } from "../../utilities/element";
@@ -133,15 +133,13 @@ export default define(class DefinedAssertion extends Assertion {
       const frameSingular = this.frame.isSingular();
 
       if (frameSingular) {
-        descend((context) => {
-          const frame = this.frame.validate(context);
+        const frame = this.frame.validate(context);
 
-          if (frame !== null) {
-            this.frame = frame;
+        if (frame !== null) {
+          this.frame = frame;
 
-            frameValidates = true;
-          }
-        }, context);
+          frameValidates = true;
+        }
       } else {
         context.debug(`The '${frameString}' frame is not singular.`);
       }

package/src/element/assumption/metaLevel.js

@@ -0,0 +1,263 @@
+"use strict";
+
+import { Element } from "occam-languages";
+
+import { define } from "../../elements";
+import { instantiateMetaLevelAssumption } from "../../process/instantiate";
+import { metaLevelAssumptionFromMetaLevelAssumptionNode } from "../../utilities/element";
+import { metaLevelAssumptionStringFromStatementAndReference } from "../../utilities/string";
+import { attempt, descend, serialise, unserialise, instantiate } from "../../utilities/context";
+
+export default define(class MetaLevelAssumption extends Element {
+  constructor(context, string, node, reference, statement) {
+    super(context, string, node);
+
+    this.reference = reference;
+    this.statement = statement;
+  }
+
+  getReference() {
+    return this.reference;
+  }
+
+  getStatement() {
+    return this.statement;
+  }
+
+  getMetaLevelAssumptionNode() {
+    const node = this.getNode(),
+          metaLevelAssumptionNode = node;  ///
+
+    return metaLevelAssumptionNode;
+  }
+
+  getMetavariable() { return this.reference.getMetavariable(); }
+
+  getTopLevelMetaAssertion() { return this.reference.getTopLevelMetaAssertion(); }
+
+  isEqualTo(metaLevelAssumption) {
+    const metaLevelAssumptionNode = metaLevelAssumption.getNode(),
+          metaLevelAssumptionNodeMatches = this.matchMetaLevelAssumptionNode(metaLevelAssumptionNode),
+          equalTo = metaLevelAssumptionNodeMatches;  ///
+
+    return equalTo;
+  }
+
+  matchMetaLevelAssumptionNode(metaLevelAssumptionNode) {
+    const node = metaLevelAssumptionNode, ///
+          nodeMatches = this.matchNode(node),
+          metaLevelAssumptionNodeMatches = nodeMatches; ///
+
+    return metaLevelAssumptionNodeMatches;
+  }
+
+  findValidMetaLevelAssumption(context) {
+    const metaLevelAssumptionNode = this.getMetaLevelAssumptionNode(),
+          metaLevelAssumption = context.findMetaLevelAssumptionByMetaLevelAssumptionNode(metaLevelAssumptionNode),
+          validMetaLevelAssumption = metaLevelAssumption;  ///
+
+    return validMetaLevelAssumption;
+  }
+
+  validate(context) {
+    let metaLevelAssumption = null;
+
+    const metaLevelAssumptionString = this.getString();  ///
+
+    context.trace(`Validating the '${metaLevelAssumptionString}' meta-lLevel assumption...`);
+
+    let validates = false;
+
+    const validMetaLevelAssumption = this.findValidMetaLevelAssumption(context);
+
+    if (validMetaLevelAssumption) {
+      metaLevelAssumption = validMetaLevelAssumption; ///
+
+      context.debug(`...the '${metaLevelAssumptionString}' meta-level assumption is already valid.`);
+    } else {
+      const context = this.getContext();
+
+      attempt((context) => {
+        const statementValidates = this.validateStatement(context);
+
+        if (statementValidates) {
+          const referenceValidates = this.validateReference(context);
+
+          if (referenceValidates) {
+            const stated = context.isStated();
+
+            let validatesWhenStated = false,
+                validatesWhenDerived = false;
+
+            if (stated) {
+              validatesWhenStated = this.validateWhenStated(context);
+            } else {
+              validatesWhenDerived = this.validateWhenDerived(context);
+            }
+
+            if (validatesWhenStated || validatesWhenDerived) {
+              validates = true;
+            }
+          }
+        }
+
+        if (validates) {
+          context.commit(this);
+        }
+      }, context);
+    }
+
+    if (validates) {
+      metaLevelAssumption = this;  ///
+
+      context.addMetaLevelAssumption(metaLevelAssumption);
+
+      context.debug(`...validated the '${metaLevelAssumptionString}' meta-level assumption.`);
+    }
+
+    return metaLevelAssumption;
+  }
+
+  validateReference(context) {
+    let referenceValidates = false;
+
+    const referenceString = this.reference.getString(),
+          metaLevelAssumptionString = this.getString();  ///
+
+    context.trace(`Validating the '${metaLevelAssumptionString}' metaLevelAssumption's '${referenceString}' reference...`);
+
+    const reference = this.reference.validate(context);
+
+    if (reference !== null) {
+      const metavariable = this.reference.getMetavariable(),
+            metavariablePresent = context.isMetavariablePresent(metavariable, context);
+
+      if (metavariablePresent) {
+        referenceValidates = true;
+      }
+    }
+
+    if (referenceValidates) {
+      context.debug(`...validated the '${metaLevelAssumptionString}' metaLevelAssumption's '${referenceString}' reference.`);
+    }
+
+    return referenceValidates;
+  }
+
+  validateStatement(context) {
+    let statementValidates = false;
+
+    const metaLevelAssumptionString = this.getString(),  ///
+          statementString = this.statement.getString();
+
+    context.trace(`Validating the '${metaLevelAssumptionString}' metaLevelAssumption's '${statementString}' statement...`);
+
+    descend((context) => {
+      const statement = this.statement.validate(context);
+
+      if (statement !== null) {
+        statementValidates = true;
+      }
+    }, context);
+
+    if (statementValidates) {
+      context.debug(`...validated the '${metaLevelAssumptionString}' metaLevelAssumption's '${statementString}' statement.`);
+    }
+
+    return statementValidates;
+  }
+
+  validateWhenStated(context) {
+    let validatesWhenStated;
+
+    const metaLevelAssumptionString = this.getString();  ///
+
+    context.trace(`Validating the '${metaLevelAssumptionString}' stated meta-level assumption...`);
+
+    validatesWhenStated = true
+
+    if (validatesWhenStated) {
+      context.debug(`...validated the '${metaLevelAssumptionString}' stated meta-level assumption.`);
+    }
+
+    return validatesWhenStated;
+  }
+
+  validateWhenDerived(context) {
+    let validatesWhenDerived;
+
+    const metaLevelAssumptionString = this.getString();  ///
+
+    context.trace(`Validating the '${metaLevelAssumptionString}' derived meta-level assumption...`);
+
+    validatesWhenDerived = true;
+
+    if (validatesWhenDerived) {
+      context.debug(`...validated the '${metaLevelAssumptionString}' derived meta-level assumption.`);
+    }
+
+    return validatesWhenDerived;
+  }
+
+  toJSON() {
+    const context = this.getContext();
+
+    return serialise((context) => {
+      const string = this.getString(),
+            json = {
+              context,
+              string
+            };
+
+      return json;
+    }, context);
+  }
+
+  static name = "MetaLevelAssumption";
+
+  static fromJSON(json, context) {
+    let metaLevelAssumption;
+
+    unserialise((json, context) => {
+      instantiate((context) => {
+        const { string } = json,
+              metaLevelAssumptionNode = instantiateMetaLevelAssumption(string, context),
+              node = metaLevelAssumptionNode,  ///
+              reference = referenceFromMetaLevelAssumptionNode(metaLevelAssumptionNode, context),
+              statement = statementFromMetaLevelAssumptionNode(metaLevelAssumptionNode, context);
+
+        metaLevelAssumption = new MetaLevelAssumption(context, string, node, reference, statement);
+      }, context);
+    }, json, context);
+
+    return metaLevelAssumption;
+  }
+
+  static fromStatementAndReference(statement, reference, context) {
+    let metaLevelAssumption;
+
+    instantiate((context) => {
+      const metaLevelAssumptionString = metaLevelAssumptionStringFromStatementAndReference(statement, reference),
+            string = metaLevelAssumptionString,  ///
+            metaLevelAssumptionNode = instantiateMetaLevelAssumption(string, context);
+
+      metaLevelAssumption = metaLevelAssumptionFromMetaLevelAssumptionNode(metaLevelAssumptionNode, context);
+    }, context);
+
+    return metaLevelAssumption;
+  }
+});
+
+function referenceFromMetaLevelAssumptionNode(metaLevelAssumptionNode, context) {
+  const referenceNode = metaLevelAssumptionNode.getReferenceNode(),
+        refernece = context.findReferenceByReferenceNode(referenceNode);
+
+  return refernece;
+}
+
+function statementFromMetaLevelAssumptionNode(metaLevelAssumptionNode, context) {
+  const statementNode = metaLevelAssumptionNode.getStatementNode(),
+        statement = context.findStatementByStatementNode(statementNode);
+
+  return statement;
+}