occam-verify-cli 1.0.768 → 1.0.781

package/src/element/term.js

@@ -41,40 +41,6 @@ export default define(class Term extends Element {
     return variableIdentifier;
   }
 
-  matchTermNode(termNode) {
-    const node = termNode, ///
-          nodeMatches = this.matchNode(node),
-          termNodeMatches = nodeMatches; ///
-
-    return termNodeMatches;
-  }
-
-  compareVariableIdentifier(variableIdentifier) {
-    let comparesToVariableIdentifier = false;
-
-    const singular = this.isSingular();
-
-    if (singular) {
-      const variableIdentifierA = variableIdentifier; ///
-
-      variableIdentifier = this.getVariableIdentifier();
-
-      const variableIdentifierB = variableIdentifier;
-
-      comparesToVariableIdentifier = (variableIdentifierA === variableIdentifierB);
-    }
-
-    return comparesToVariableIdentifier;
-  }
-
-  findValidTerm(context) {
-    const termNode = this.getTermNode(),
-          term = context.findTermByTermNode(termNode),
-          validTerm = term; ///
-
-    return validTerm;
-  }
-
   isEqualTo(term) {
     const termNode = term.getNode(),
           termNodeMatches = this.matchTermNode(termNode),
@@ -127,6 +93,22 @@ export default define(class Term extends Element {
     return implicitlyGrounded;
   }
 
+  matchTermNode(termNode) {
+    const node = termNode, ///
+          nodeMatches = this.matchNode(node),
+          termNodeMatches = nodeMatches; ///
+
+    return termNodeMatches;
+  }
+
+  compareTerm(term) {
+    const termNode = term.getNode(),
+          termNodeMatches = this.matchNode(termNode),
+          comparesTo = termNodeMatches; ///
+
+    return comparesTo;
+  }
+
   compareParameter(parameter) {
     let comparesToParamter = false;
 
@@ -147,6 +129,32 @@ export default define(class Term extends Element {
     return comparesToParamter;
   }
 
+  compareVariableIdentifier(variableIdentifier) {
+    let comparesToVariableIdentifier = false;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      const variableIdentifierA = variableIdentifier; ///
+
+      variableIdentifier = this.getVariableIdentifier();
+
+      const variableIdentifierB = variableIdentifier;
+
+      comparesToVariableIdentifier = (variableIdentifierA === variableIdentifierB);
+    }
+
+    return comparesToVariableIdentifier;
+  }
+
+  findValidTerm(context) {
+    const termNode = this.getTermNode(),
+          term = context.findTermByTermNode(termNode),
+          validTerm = term; ///
+
+    return validTerm;
+  }
+
   validate(context, validateForwards) {
     let term = null;
 

package/src/element/topLevelMetaAssertion.js

@@ -42,7 +42,7 @@ export default class TopLevelMetaAssertion extends Element {
     return this.proof;
   }
 
-  getSubstitutions() {
+  getMetaLevelSubstitutions() {
     return this.metaLevelSubstitutions;
   }
 

package/src/element/variable.js

@@ -7,8 +7,8 @@ import elements from "../elements";
 import { define } from "../elements";
 import { instantiate } from "../utilities/context";
 import { instantiateVariable } from "../process/instantiate";
-import {identifierFromVarialbeNode, variableFromVariableNode} from "../utilities/element";
 import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
+import { variableFromTermNode, identifierFromVarialbeNode } from "../utilities/element";
 
 export default define(class Variable extends Element {
   constructor(context, string, node, type, identifier) {
@@ -198,4 +198,11 @@ export default define(class Variable extends Element {
       return variable;
     }, context);
   }
+
+  static fromTerm(term, context) {
+    const termNode = term.getNode(),
+          variable = variableFromTermNode(termNode, context);
+
+    return variable;
+  }
 });

package/src/process/assign.js

@@ -23,7 +23,9 @@ export function judgementAssignmentFromJudgement(judgement, context) {
 }
 
 export function leftVariableAssignmentFromEquality(equality, context) {
-  let leftVariableAssignment = null;
+  let leftVariableAssignment = (contxt) => {
+    ///
+  };
 
   const leftTermNode = equality.getLeftTermNode(),
         singularVariableNode = leftTermNode.getSingularVariableNode();
@@ -39,7 +41,9 @@ export function leftVariableAssignmentFromEquality(equality, context) {
 }
 
 export function rightVariableAssignmentFromEquality(equality, context) {
-  let rightVariableAssignment = null;
+  let rightVariableAssignment = (context) => {
+    ///
+  };
 
   const rightTermNode = equality.getRightTermNode(),
         singularVariableNode = rightTermNode.getSingularVariableNode();
@@ -55,7 +59,9 @@ export function rightVariableAssignmentFromEquality(equality, context) {
 }
 
 export function variableAssignmentFromTypeAssertion(typeAssertion, context) {
-  let variableAssignment = null;
+  let variableAssignment = (context) => {
+    ///
+  };
 
   const term = typeAssertion.getTerm(),
         termSingular = term.isSingular();

package/src/process/unify.js

@@ -152,7 +152,7 @@ class CombinatorPass extends ZipPass {
     {
       generalNodeQuery: metaTypeNodeQuery,
       specificNodeQuery: statementNodeQuery,
-      run: (generalMetaTypeNode, specificStatementNode, stated, generalContext, specificContext) => {
+      run: (generalMetaTypeNode, specificStatementNode, generalContext, specificContext) => {
         let success = false;
 
         const metaTypeNode = generalMetaTypeNode, ///
@@ -167,7 +167,7 @@ class CombinatorPass extends ZipPass {
 
           statement = statementFromStatementNode(statementNode, context);
 
-          statement = statement.validate(stated, context);  ///
+          statement = statement.validate(context);  ///
 
           if (statement !== null) {
             success = true;
@@ -180,7 +180,7 @@ class CombinatorPass extends ZipPass {
     {
       generalNodeQuery: metaTypeNodeQuery,
       specificNodeQuery: frameNodeQuery,
-      run: (generalMetaTypeNode, specificFrameNode, stated, generalContext, specificContext) => {
+      run: (generalMetaTypeNode, specificFrameNode, generalContext, specificContext) => {
         let success = false;
 
         const metaTypeNode = generalMetaTypeNode, ///
@@ -195,7 +195,7 @@ class CombinatorPass extends ZipPass {
 
           frame = frameFromFrameNode(frameNode, context);
 
-          frame = frame.validate(stated, context);  ///
+          frame = frame.validate(context);  ///
 
           if (frame !== null) {
             success = true;
@@ -208,7 +208,7 @@ class CombinatorPass extends ZipPass {
     {
       generalNodeQuery: typeNodeQuery,
       specificNodeQuery: termNodeQuery,
-      run: (generalTypeNode, specificTermNode, stated, generalContext, specificContext) => {
+      run: (generalTypeNode, specificTermNode, generalContext, specificContext) => {
         let success = false;
 
         const typeNode = generalTypeNode, ///
@@ -466,13 +466,13 @@ export function unifyTermWithConstructor(term, constructor, generalContext, spec
   return termUnifiesWithConstructor;
 }
 
-export function unifyStatementWithCombinator(statement, combinator, stated, generalContext, specificContext) {
+export function unifyStatementWithCombinator(statement, combinator, generalContext, specificContext) {
   let statementUnifiesWithCombinator = false;
 
   const statementNode = statement.getNode(),
         combinatorStatement = combinator.getStatement(),
         combinatorStatementNode = combinatorStatement.getNode(),
-        success = combinatorPass.run(combinatorStatementNode, statementNode, stated, generalContext, specificContext);
+        success = combinatorPass.run(combinatorStatementNode, statementNode, generalContext, specificContext);
 
   if (success) {
     statementUnifiesWithCombinator = true;

package/src/process/validate.js

@@ -4,6 +4,7 @@ import { SimplePass } from "occam-languages";
 import { queryUtilities } from "occam-languages";
 
 import { termFromTermNode, statementFromStatementNode } from "../utilities/element";
+import {descend} from "../utilities/context";
 
 const { nodeQuery } = queryUtilities;
 
@@ -32,17 +33,17 @@ class CombinatorPass extends SimplePass {
       run: (statementNode, context) => {
         let success = false;
 
-        let statement;
+        descend((context) => {
+          let statement;
 
-        const stated = true;
+          statement = statementFromStatementNode(statementNode, context);
 
-        statement = statementFromStatementNode(statementNode, context);
+          statement = statement.validate(context);  ///
 
-        statement = statement.validate(stated, context);
-
-        if (statement !== null) {
-          success = true;
-        }
+          if (statement !== null) {
+            success = true;
+          }
+        }, context);
 
         return success;
       }

package/src/utilities/context.js

@@ -1,38 +1,53 @@
 "use strict";
 
-import ScopedContext from "../context/scoped";
+import ProofContext from "../context/proof";
+import NestedContext from "../context/nested";
+import TheticContext from "../context/thetic";
 import NominalContext from "../context/nominal";
 import LiteralContext from "../context/literal";
 import LiminalContext from "../context/liminal";
+import IllativeContext from "../context/illative";
 import EphemeralContext from "../context/ephemeral";
 import BranchingContext from "../context/branching";
 import SyntheticContext from "../context/synthetic";
 
-export function nominally(innerFunction) {
-  let context;
+import { ephemeralContextFromJSON, ephemeralContextToEphemeralContextJSON } from "../utilities/json";
 
-  const nominalContext = NominalContext.fromNothing();
+export function join(innerFunction, ...contexts) {
+  const syntheticContext = SyntheticContext.fromContexts(...contexts),
+        context = syntheticContext;  ///
 
-  context = nominalContext; ///
+  return innerFunction(context);
+}
 
-  const literalContext = LiteralContext.fromNothing(context);
+export function choose(innerFunction, context) {
+  const branchingContext = BranchingContext.fromNothing(context);
 
-  context = literalContext;  ///
+  context = branchingContext;  ///
 
   return innerFunction(context);
 }
 
-export function join(innerFunction, ...contexts) {
-  const syntheticContext = SyntheticContext.fromContexts(...contexts),
-        context = syntheticContext;  ///
+export function derive(innerFunction, context) {
+  const illativeContext = IllativeContext.fromNothing(context);
+
+  context = illativeContext;  ///
 
   return innerFunction(context);
 }
 
-export function choose(innerFunction, context) {
-  const branchingContext = BranchingContext.fromNothing(context);
+export function declare(innerFunction, context) {
+  const theticContext = TheticContext.fromNothing(context);
 
-  context = branchingContext;  ///
+  context = theticContext;  ///
+
+  return innerFunction(context);
+}
+
+export function descend(innerFunction, context) {
+  const nestedContext = NestedContext.fromNothing(context);
+
+  context = nestedContext;  ///
 
   return innerFunction(context);
 }
@@ -61,6 +76,54 @@ export function instantiate(innerFunction, context) {
   return innerFunction(context);
 }
 
+export function nominally(innerFunction) {
+  let context;
+
+  const nominalContext = NominalContext.fromNothing();
+
+  context = nominalContext; ///
+
+  const literalContext = LiteralContext.fromNothing(context);
+
+  context = literalContext;  ///
+
+  return innerFunction(context);
+}
+
+export function simplify(innerFunction, context) {
+  let contextExtraneousContext = isContextExtraneousContext(context);
+
+  while (contextExtraneousContext) {
+    context = context.getContext();
+
+    contextExtraneousContext = isContextExtraneousContext(context);
+  }
+
+  const ephemeralContext = EphemeralContext.fromNothing(context);
+
+  context = ephemeralContext; ///
+
+  return innerFunction(context);
+}
+
+export function serialise(innerFunction, context) {
+  const ephemeralContext = context, ///
+        ephemeralContextJSON = ephemeralContextToEphemeralContextJSON(ephemeralContext),
+        contextJSON = ephemeralContextJSON; ///
+
+  context = contextJSON;  ///
+
+  return innerFunction(context);
+}
+
+export function unserialise(innerFunction, json, context) {
+  const ephemeralContext = ephemeralContextFromJSON(json, context);
+
+  context = ephemeralContext; ///
+
+  return innerFunction(json, context);
+}
+
 export async function asyncRestrict(innerFunction, metaLevelSubstitutions, context) {
   if (context === undefined) {
     context = metaLevelSubstitutions;  ///
@@ -68,9 +131,9 @@ export async function asyncRestrict(innerFunction, metaLevelSubstitutions, conte
     metaLevelSubstitutions = null;
   }
 
-  const scopedContext = ScopedContext.fromMetaLevelSubstitutions(metaLevelSubstitutions, context);
+  const proofContext = ProofContext.fromMetaLevelSubstitutions(metaLevelSubstitutions, context);
 
-  context = scopedContext;  ///
+  context = proofContext;  ///
 
   return await innerFunction(context);
 }
@@ -83,27 +146,15 @@ export async function asyncReconcile(innerFunction, context) {
   return await innerFunction(context);
 }
 
-export function sanitisedContextFromContext(context) {
-  let contextExtraneousContext = isContextExtraneousContext(context);
-
-  while (contextExtraneousContext) {
-    context = context.getContext();
-
-    contextExtraneousContext = isContextExtraneousContext(context);
-  }
-
-  const ephemeralContext = EphemeralContext.fromNothing(context),
-        sanitisedContext = ephemeralContext; ///
-
-  return sanitisedContext;
-}
-
 function isContextExtraneousContext(context) {
   const contextLiminalContext = (context instanceof LiminalContext),
         contextEphemeralContext = (context instanceof EphemeralContext),
         contextBranchingContext = (context instanceof BranchingContext),
         contextSyntheticContext = (context instanceof SyntheticContext),
-        contextExtraneousContext = (contextLiminalContext || contextEphemeralContext || contextBranchingContext || contextSyntheticContext);
+        contextExtraneousContext = ( contextLiminalContext
+                                  || contextEphemeralContext
+                                  || contextBranchingContext
+                                  || contextSyntheticContext );
 
   return contextExtraneousContext;
 }

package/src/utilities/element.js

@@ -2,9 +2,9 @@
 
 import elements from "../elements";
 
-import { instantiate } from "../utilities/context";
 import { baseTypeFromNothing } from "../utilities/type";
-import { instantiateReference } from "../process/instantiate";
+import { simplify, instantiate,} from "../utilities/context";
+import { instantiateLabel, instantiateReference } from "../process/instantiate";
 import { equivalenceStringFromTerms,
          typeStringFromNominalTypeName,
          rulsStringFromLabelsPremisesAndConclusion,
@@ -13,7 +13,6 @@ import { equivalenceStringFromTerms,
          procedureCallStringFromProcedureReferenceAndParameters,
          topLevelAssertionStringFromLabelsSuppositionsAndDeduction,
          topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction } from "../utilities/string";
-import EphemeralContext from "../context/ephemeral";
 
 export function typeFromTypeNode(typeNode, context) {
   let type;
@@ -321,11 +320,9 @@ export function referenceFromReferenceNode(referenceNode, context) {
   const { Reference } = elements,
         node = referenceNode, ///
         string = context.nodeAsString(node),
-        metavariable = metavariableFromReferenceNode(referenceNode, context);
-
-  context = null;
-
-  const reference = new Reference(context, string, node, metavariable);
+        metavariable = metavariableFromReferenceNode(referenceNode, context),
+        topLevelMetaAssertion = topLevelMetaAssertionFromReferenceNode(referenceNode, context),
+        reference = new Reference(context, string, node, metavariable, topLevelMetaAssertion);
 
   return reference;
 }
@@ -509,13 +506,14 @@ export function suppositionFromSuppositionNode(suppositionNode, context) {
 export function equivalenceFromEquivalenceNode(equivalenceNode, context) {
   const { Equivalence } = elements,
         node = equivalenceNode, ///
+        type = typeFromEquivalenceNode(equivalenceNode, context),
         terms = termsFromEquivalenceNode(equivalenceNode, context),
         equivalenceString = equivalenceStringFromTerms(terms),
         string = equivalenceString; ///
 
   context = null;
 
-  const equivalence = new Equivalence(context, string, node, terms);
+  const equivalence = new Equivalence(context, string, node, type, terms);
 
   return equivalence;
 }
@@ -677,12 +675,6 @@ export function subproofAssertionFromSubproofAssertionNode(subproofAssertionNode
   return subproofAssertion;
 }
 
-export function substitutionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context) {
-  const substitutions = [];
-
-  return substitutions;
-}
-
 export function containedAssertionFromContainedAssertionNode(containedAssertionNode, context) {
   const { ContainedAssertion } = elements,
         node = containedAssertionNode,  ///
@@ -945,7 +937,9 @@ export function referenceFromStepNode(stepNode, context) {
   const referenceNode = stepNode.getReferenceNode();
 
   if (referenceNode !== null) {
-    reference = referenceFromReferenceNode(referenceNode, context);
+    const referenceString = context.nodeAsString(referenceNode);
+
+    reference = referenceFromReferenceString(referenceString, context);
   }
 
   return reference;
@@ -1042,6 +1036,12 @@ export function typeFromConstructorNode(ocnstructorNode, context) {
   return type;
 }
 
+export function typeFromEquivalenceNode(equivalenceNode, context) {
+  const type = null;
+
+  return type;
+}
+
 export function assumptionsFromFrameNode(frameNode, context) {
   const assumptionNodes = frameNode.getAssumptionNodes(),
         assumptions = assumptionsFromAssumptionNodes(assumptionNodes, context);
@@ -1361,16 +1361,11 @@ export function metavariableFromReferenceNode(referenceNode, context) {
 }
 
 export function referenceFromMetavariableNode(metavariableNode, context) {
-  const metavariableString = context.nodeAsString(metavariableNode);
+  const metavariableString = context.nodeAsString(metavariableNode),
+        referenceString = metavariableString, ///
+        reference = referenceFromReferenceString(referenceString, context);
 
-  return instantiate((context) => {
-    const referenceString = metavariableString, ///
-          string = referenceString,  ///
-          referenceNode = instantiateReference(string, context),
-          reference = referenceFromReferenceNode(referenceNode, context);
-
-    return reference;
-  }, context);
+  return reference;
 }
 
 export function termFromJDefinedAssertionNode(definedAssertionNode, context) {
@@ -1607,7 +1602,8 @@ export function proofFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, cont
 
 export function labelFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context) {
   const labelNode = metaLemmaMetathoremNode.getLabelNode(),
-        label = labelFromLabelNode(labelNode, context);
+        labelString = context.nodeAsString(labelNode),
+        label = labelFromLabelString(labelString, context);
 
   return label;
 }
@@ -1729,7 +1725,8 @@ export function signatureFromJSatisfiesAssertionNode(sasisfiesAssertionNode, con
 
 export function referenceFromJSatisfiesAssertionNode(sasisfiesAssertionNode, context) {
   const referenceNode = sasisfiesAssertionNode.getReferenceNode(),
-        reference = referenceFromReferenceNode(referenceNode, context);
+        referenceString = context.nodeAsString(referenceNode),
+        reference = referenceFromReferenceString(referenceString, context);
 
   return reference;
 }
@@ -1754,6 +1751,12 @@ export function resolvedFromStatementSubstitutionNode(statementSubstitutionNode,
   return resolved;
 }
 
+export function topLevelMetaAssertionFromReferenceNode(referenceNode, context) {
+  const topLevelMetaAssertion = null;
+
+  return topLevelMetaAssertion;
+}
+
 export function deductionFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context) {
   const deductionNode = metaLemmaMetathoremNode.getDeductionNode(),
         deduction = deductionFromDeductionNode(deductionNode, context);
@@ -1887,14 +1890,16 @@ export function metavariableFromMetavariableDeclarationNode(metavariableDeclarat
 
 export function targetReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context) {
   const targetReferenceNode = referenceSubstitutionNode.getTargetReferenceNode(),
-        targetRefernece = referenceFromReferenceNode(targetReferenceNode, context);
+        targetReferenceString = context.nodeAsString(targetReferenceNode),
+        targetRefernece = referenceFromReferenceString(targetReferenceString, context);
 
   return targetRefernece;
 }
 
 export function targetReferenceFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context) {
   const targetReferenceNode = metaLevelSubstitutionNode.getTargetReferenceNode(),
-        targetRefernece = referenceFromReferenceNode(targetReferenceNode, context);
+        targetReferenceString = context.nodeAsString(targetReferenceNode),
+        targetRefernece = referenceFromReferenceString(targetReferenceString, context);
 
   return targetRefernece;
 }
@@ -1932,7 +1937,8 @@ export function frameSubstitutionFromStatementSubstitutionNode(statementSubstitu
 
 export function replacementReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context) {
   const replacementReferenceNode = referenceSubstitutionNode.getReplacementReferenceNode(),
-        replacementReference = referenceFromReferenceNode(replacementReferenceNode, context);
+        replacementReferenceString = context.nodeAsString(replacementReferenceNode),
+        replacementReference = referenceFromReferenceString(replacementReferenceString, context);
 
   return replacementReference;
 }
@@ -1980,7 +1986,8 @@ export function typesFromTypesNode(typesNode, context) {
 
 export function labelsFromLabelNodes(labelNodes, context) {
   const labels = labelNodes.map((labelNode) => {
-    const label = labelFromLabelNode(labelNode, context);
+    const labelString = context.nodeAsString(labelNode),
+          label = labelFromLabelString(labelString, context);
 
     return label;
   });
@@ -2069,3 +2076,33 @@ export function stepsOrSubproofsFromSubDerivationNode(subDerivationNode, context
 
   return stepsOrSubproofs;
 }
+
+export function labelFromLabelString(labelString, context) {
+  let label;
+
+  simplify((context) => {
+    instantiate((context) => {
+      const string = labelString,  ///
+            labelNode = instantiateLabel(string, context);
+
+      label = labelFromLabelNode(labelNode, context);
+    }, context);
+  }, context);
+
+  return label;
+}
+
+export function referenceFromReferenceString(referenceString, context) {
+  let reference;
+
+  simplify((context) => {
+    instantiate((context) => {
+      const string = referenceString,  ///
+            referenceNode = instantiateReference(string, context);
+
+      reference = referenceFromReferenceNode(referenceNode, context);
+    }, context);
+  }, context);
+
+  return reference;
+}

package/src/utilities/json.js

@@ -56,6 +56,19 @@ export function typeFromJSON(json, context) {
   return type;
 }
 
+export function labelFromJSON(json, context) {
+  let { label } = json;
+
+  const { Label } = elements,
+    labelJSON = label;  ///
+
+  json = labelJSON; ///
+
+  label = Label.fromJSON(json, context);
+
+  return label;
+}
+
 export function frameFromJSON(json, context) {
   let { frame } = json;
 
@@ -270,19 +283,6 @@ export function rulesFromJSON(json, context) {
   return rules;
 }
 
-export function labelFromJSON(json, context) {
-  let { label } = json;
-
-  const { Label } = elements,
-        labelJSON = label;  ///
-
-  json = labelJSON; ///
-
-  label = Label.fromJSON(json, context);
-
-  return label;
-}
-
 export function framesFromJSON(json, context) {
   let { frames } = json;