occam-verify-cli 1.0.564 → 1.0.570

package/src/node/assumption.js

@@ -5,18 +5,6 @@ import { NonTerminalNode } from "occam-languages";
 import { STATEMENT_RULE_NAME, METAVARIABLE_RULE_NAME } from "../ruleNames";
 
 export default class AssumptionpNode extends NonTerminalNode {
-  isSingular() {
-    let singular = false;
-
-    const statementNode = this.getStatementNode();
-
-    if (statementNode === null) {
-      singular = true;
-    }
-
-    return singular;
-  }
-
   getStatementNode() {
     const ruleName = STATEMENT_RULE_NAME,
           statementNode = this.getNodeByRuleName(ruleName);

package/src/node/frame.js

@@ -8,10 +8,10 @@ export default class FrameNode extends NonTerminalNode {
   isSingular() {
     let singular = false;
 
-    const singularAssumptionNode = this.getSingularAssumptionNode();
+    const metavariableNode = this.getMetavariableNode();
 
-    if (singularAssumptionNode !== null) {
-      singular = singularAssumptionNode.isSingular();
+    if (metavariableNode !== null) {
+      singular = true;
     }
 
     return singular;
@@ -29,27 +29,6 @@ export default class FrameNode extends NonTerminalNode {
     return metavariableName;
   }
 
-  getMetavariableNode() {
-    const singularMetavariableNode = this.getSingularMetavariableNode(),
-          metavariableNode = singularMetavariableNode;  ///
-
-    return metavariableNode;
-  }
-
-  getSingularMetavariableNode() {
-    let singularMetavariableNode = null;
-
-    const singularAssumptionNode = this.getSingularAssumptionNode();
-
-    if (singularAssumptionNode !== null) {
-      const metavariableNode = singularAssumptionNode.getMetavariableNode();
-
-      singularMetavariableNode = metavariableNode;  ///
-    }
-
-    return singularMetavariableNode;
-  }
-
   getAssumptionNodes() {
     const ruleName = ASSUMPTION_RULE_NAME,
           declarationNodes = this.getNodesByRuleName(ruleName);
@@ -57,18 +36,11 @@ export default class FrameNode extends NonTerminalNode {
     return declarationNodes;
   }
 
-  getMetavariableNodes() {
+  getMetavariableNode() {
     const ruleName = METAVARIABLE_RULE_NAME,
-          metavariableNodes = this.getNodesByRuleName(ruleName);
+          metavariableNode = this.getNodeByRuleName(ruleName);
 
-    return metavariableNodes;
-  }
-
-  getSingularAssumptionNode() {
-    const ruleName = ASSUMPTION_RULE_NAME,
-          singularAssumptionNode = this.getSingularNodeByRuleName(ruleName);
-
-    return singularAssumptionNode;
+    return metavariableNode;
   }
 
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(FrameNode, ruleName, childNodes, opacity, precedence); }

package/src/process/assign.js

@@ -1,14 +1,18 @@
 "use strict";
 
-export function judgementAssignmentFromJudgement(judgement) {
+export function variableAssignmentFromVariable(variable) {
   return function (context) {
-    const judgementString = judgement.getString(),
-          judgementAdded = context.addJudgement(judgement),
-          assigned = judgementAdded; ///
+    const nested = false;
+
+    context.addVariable(variable, nested);
+
+    const variableTypeString = variable.getTypeString(),
+          variableString = variable.getString(),
+          assigned = true;
 
     assigned ?
-      context.trace(`Assigned the '${judgementString}' judgement.`) :
-        context.debug(`Unable to assign the '${judgementString}' judgement.`);
+      context.trace(`Assigned the '${variableString}' variable with type '${variableTypeString}'.`) :
+        context.debug(`Unable to assign the '${variableString}' variable with type '${variableTypeString}'.`);
 
     return assigned;
   };
@@ -28,19 +32,15 @@ export function equalityAssignmentFromEquality(equality) {
   };
 }
 
-export function variableAssignmentFromVariable(variable) {
+export function judgementAssignmentFromJudgement(judgement) {
   return function (context) {
-    const nested = false;
-
-    context.addVariable(variable, nested);
-
-    const variableTypeString = variable.getTypeString(),
-          variableString = variable.getString(),
-          assigned = true;
+    const judgementString = judgement.getString(),
+          judgementAdded = context.addJudgement(judgement),
+          assigned = judgementAdded; ///
 
     assigned ?
-      context.trace(`Assigned the '${variableString}' variable with type '${variableTypeString}'.`) :
-        context.debug(`Unable to assign the '${variableString}' variable with type '${variableTypeString}'.`);
+      context.trace(`Assigned the '${judgementString}' judgement.`) :
+        context.debug(`Unable to assign the '${judgementString}' judgement.`);
 
     return assigned;
   };

package/src/process/instantiate.js

@@ -1,9 +1,7 @@
 "use strict";
 
 import { ruleFromRuleName } from "../utilities/bnf";
-import { TERM_RULE_NAME,
-         REFERENCE_RULE_NAME,
-         STATEMENT_RULE_NAME,
+import { REFERENCE_RULE_NAME,
          COMBINATOR_RULE_NAME,
          CONSTRUCTOR_RULE_NAME,
          EQUIVALENCE_RULE_NAME,
@@ -12,9 +10,7 @@ import { TERM_RULE_NAME,
          STATEMENT_SUBSTITUTION_RULE_NAME,
          REFERENCE_SUBSTITUTION_RULE_NAME } from "../ruleNames";
 
-const termPlaceholderRule = ruleFromRuleName(TERM_RULE_NAME),
-      referencePlaceholderRule = ruleFromRuleName(REFERENCE_RULE_NAME),
-      statementPlaceholderRule = ruleFromRuleName(STATEMENT_RULE_NAME),
+const referencePlaceholderRule = ruleFromRuleName(REFERENCE_RULE_NAME),
       combinatorPlaceholderRule = ruleFromRuleName(COMBINATOR_RULE_NAME),
       constructorPlaceholderRule = ruleFromRuleName(CONSTRUCTOR_RULE_NAME),
       equivalencePlaceholderRule = ruleFromRuleName(EQUIVALENCE_RULE_NAME),
@@ -23,12 +19,8 @@ const termPlaceholderRule = ruleFromRuleName(TERM_RULE_NAME),
       statementSubstitutionPlaceholderRule = ruleFromRuleName(STATEMENT_SUBSTITUTION_RULE_NAME),
       referenceSubstitutionPlaceholderRule = ruleFromRuleName(REFERENCE_SUBSTITUTION_RULE_NAME);
 
-export function instantiateTerm(string, context) { return instantiate(termPlaceholderRule, string, context); }
-
 export function instantiateReference(string, context) { return instantiate(referencePlaceholderRule, string, context); }
 
-export function instantiateStatement(string, context) { return instantiate(statementPlaceholderRule, string, context); }
-
 export function instantiateCombinator(string, context) { return instantiate(combinatorPlaceholderRule, string, context); }
 
 export function instantiateConstructor(string, context) { return instantiate(constructorPlaceholderRule, string, context); }

package/src/process/unify.js

@@ -13,16 +13,16 @@ const typeNodeQuery = nodeQuery("/type"),
       metaTypeNodeQuery = nodeQuery("/metaType"),
       statementNodeQuery = nodeQuery("/statement"),
       termVariableNodeQuery = nodeQuery("/term/variable!"),
+      frameAMetavariableNodeQuery = nodeQuery("/frame/metavariable!"),
       statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!"),
-      assumptionMetavariableNodeQuery = nodeQuery("/assumption/metavariable!"),
-      frameAssumptionMetavariableNodeQuery = nodeQuery("/frame/assumption!/metavariable!");
+      assumptionMetavariableNodeQuery = nodeQuery("/assumption/metavariable!");
 
 class MetaLevelPass extends ZipPass {
   static maps = [
     {
       generalNodeQuery: assumptionMetavariableNodeQuery,
       specificNodeQuery: assumptionMetavariableNodeQuery,
-      run: (generalAssumptionMetavariableNode, specificAssumptionMetavariableNode, substitutions, generalContext, specificContext) => {
+      run: (generalAssumptionMetavariableNode, specificAssumptionMetavariableNode, generalContext, specificContext) => {
         let success = false;
 
         let context,
@@ -40,7 +40,7 @@ class MetaLevelPass extends ZipPass {
         metavariableNode = specificAssumptionMetavariableNode; ///
 
         const reference = context.findReferenceByMetavariableNode(metavariableNode),
-              referenceUnifies = metavariable.unifyReference(reference, substitutions, generalContext, specificContext);
+              referenceUnifies = metavariable.unifyReference(reference, generalContext, specificContext);
 
         if (referenceUnifies) {
           success = true;
@@ -52,7 +52,7 @@ class MetaLevelPass extends ZipPass {
     {
       generalNodeQuery: statementMetavariableNodeQuery,
       specificNodeQuery: statementNodeQuery,
-      run: (generalStatementMetavariableNode, specificStatementNode, substitutions, generalContext, specificContext) => {
+      run: (generalStatementMetavariableNode, specificStatementNode, generalContext, specificContext) => {
         let success = false;
 
         let context,
@@ -79,7 +79,7 @@ class MetaLevelPass extends ZipPass {
         statementNode = specificStatementNode;  ///
 
         const statement = context.findStatementByStatementNode(statementNode),
-              statementUnifies = metavariable.unifyStatement(statement, substitution, substitutions, generalContext, specificContext);
+              statementUnifies = metavariable.unifyStatement(statement, substitution, generalContext, specificContext);
 
         if (statementUnifies) {
           success = true;
@@ -89,13 +89,13 @@ class MetaLevelPass extends ZipPass {
       }
     },
     {
-      generalNodeQuery: frameAssumptionMetavariableNodeQuery,
+      generalNodeQuery: frameAMetavariableNodeQuery,
       specificNodeQuery: frameNodeQuery,
-      run: (generalFrameAssumptionMetavariableNode, specificFrameNode, substitutions, generalContext, specificContext) => {
+      run: (generalFrameMetavariableNode, specificFrameNode, generalContext, specificContext) => {
         let success = false;
 
         const frameNode = specificFrameNode, ///
-              metavariableNode = generalFrameAssumptionMetavariableNode,  ///
+              metavariableNode = generalFrameMetavariableNode,  ///
               metavariableName = metavariableNode.getMetavariableName();
 
         let context;
@@ -107,7 +107,7 @@ class MetaLevelPass extends ZipPass {
         context = specificContext;  ///
 
         const frame = context.findFrameByFrameNode(frameNode),
-              frameUnifies = metavariable.unifyFrame(frame, substitutions, generalContext, specificContext);
+              frameUnifies = metavariable.unifyFrame(frame, generalContext, specificContext);
 
         if (frameUnifies) {
           success = true;
@@ -119,7 +119,7 @@ class MetaLevelPass extends ZipPass {
     {
       generalNodeQuery: termVariableNodeQuery,
       specificNodeQuery: termNodeQuery,
-      run: (generalTermVariableNode, specificTermNode, substitutions, generalContext, specificContext) => {
+      run: (generalTermVariableNode, specificTermNode, generalContext, specificContext) => {
         let success = false;
 
         const termNode = specificTermNode, ///
@@ -135,7 +135,7 @@ class MetaLevelPass extends ZipPass {
         context = specificContext;  ///
 
         const term = context.findTermByTermNode(termNode),
-              termUnifies = variable.unifyTerm(term, substitutions, generalContext, specificContext);
+              termUnifies = variable.unifyTerm(term, generalContext, specificContext);
 
         if (termUnifies) {
           success = true;
@@ -338,14 +338,14 @@ const metaLevelPass = new MetaLevelPass(),
       metavariablePass = new MetavariablePass(),
       intrinsicLevelPass = new IntrinsicLevelPass();
 
-export function unifyStatement(generalStatement, specificStatement, substitutions, generalContext, specificContext) {
+export function unifyStatement(generalStatement, specificStatement, generalContext, specificContext) {
   let statementUnifies = false;
 
   const generalStatementNode = generalStatement.getNode(),
         specificStatementNode = specificStatement.getNode(),
         generalNode = generalStatementNode, ///
         specificNode = specificStatementNode,  ///
-        success = metaLevelPass.run(generalNode, specificNode, substitutions, generalContext, specificContext);
+        success = metaLevelPass.run(generalNode, specificNode, generalContext, specificContext);
 
   if (success) {
     statementUnifies = true;

package/src/process/validate.js

@@ -17,7 +17,7 @@ class TermPass extends ForwardPass {
 
     const nonTerminalNode = statementNode,  ///
           childNodes = nonTerminalNode.getChildNodes(), ///
-          descended = this.descend(childNodes,context);
+          descended = this.descend(childNodes, context);
 
     if (descended) {
       success = true;
@@ -76,7 +76,7 @@ class StatementPass extends ForwardPass {
 
     const nonTerminalNode = statementNode,  ///
           childNodes = nonTerminalNode.getChildNodes(), ///
-          descended = this.descend(childNodes,context);
+          descended = this.descend(childNodes, context);
 
     if (descended) {
       success = true;

package/src/utilities/context.js

@@ -44,3 +44,20 @@ export function synthetically(innerFunction, generalContext, specificContext) {
 
   return innerFunction(context);
 }
+
+export async function asyncAttempt(innerFunction, context) {
+  const ephemeralContext = EphemeralContext.fromNothing(context);
+
+  context = ephemeralContext;  ///
+
+  return await innerFunction(context);
+}
+
+export async function asyncScope(innerFunction, context) {
+  const scopedContext = ScopedContext.fromNothing(context);
+
+  context = scopedContext;  ///
+
+  return await innerFunction(context);
+}
+

package/src/utilities/element.js

@@ -117,7 +117,8 @@ export function frameFromFrameNode(frameNode, context) {
         node = frameNode, ///
         string = context.nodeAsString(node),
         assumptions = assumptionsFromFrameNode(frameNode, context),
-        frame = new Frame(context, string, node, assumptions);
+        metavariable = metavariableFromFrameNode(frameNode, context),
+        frame = new Frame(context, string, node, assumptions, metavariable);
 
   return frame;
 }
@@ -380,9 +381,9 @@ export function assumptionFromAssumptionNode(assumptionNode, context) {
   const { Assumption } = elements,
         node = assumptionNode, ///
         string = context.nodeAsString(node),
-        statement = statementFromAssumptionNode(assumptionNode, context),
         reference = referenceFromAssumptionNode(assumptionNode, context),
-        assumption = new Assumption(context, string, node, statement, reference);
+        statement = statementFromAssumptionNode(assumptionNode, context),
+        assumption = new Assumption(context, string, node, reference, statement);
 
   return assumption;
 }
@@ -870,6 +871,18 @@ export function termsFromEquivalenceNode(equivalenceNode, context) {
   return terms;
 }
 
+export function metavariableFromFrameNode(frameNode, context) {
+  let metavariable = null;
+
+  const metavariableNode = frameNode.getMetavariableNode();
+
+  if (metavariableNode !== null) {
+    metavariable = metavariableFromMetavariableNode(metavariableNode, context);
+  }
+
+  return metavariable;
+}
+
 export function metavariableFromLabelNode(labelNode, context) {
   const metavariableNode = labelNode.getMetavariableNode(),
         metavariable = metavariableFromMetavariableNode(metavariableNode, context);
@@ -955,6 +968,13 @@ export function assumptionFromJudgementNode(judgementNode, context) {
   return assumption;
 }
 
+export function referenceFromAssumptionNode(assumptionNode, context) {
+  const metavariableNode = assumptionNode.getMetavariableNode(),
+        reference = referenceFromMetavariableNode(metavariableNode, context);
+
+  return reference;
+}
+
 export function statementFromCombinatorNode(combinatorNode, context) {
   const statementNode = combinatorNode.getStatementNode(),
         statement = statementFromStatementNode(statementNode, context);
@@ -986,13 +1006,6 @@ export function statementFromAssumptionNode(assumptionNode, context) {
   return statement;
 }
 
-export function referenceFromAssumptionNode(assumptionNode, context) {
-  const metavariableNode = assumptionNode.getMetavariableNode(),
-        reference = referenceFromMetavariableNode(metavariableNode, context);
-
-  return reference;
-}
-
 export function statementFromHypothesisNode(hypothesisNode, context) {
   let statement = null;
 

package/src/utilities/unification.js

@@ -110,8 +110,7 @@ function unifyStatementAsSatisfiesAssertion(statement, reference, satisfiesAsser
           const satisfiable = axiom.isSatisfiable();
 
           if (satisfiable) {
-            const { Substitutions } = elements,
-                  substitutions = Substitutions.fromNothing(context),
+            const substitutions = [],
                   topLevelAssertionUnifies = axiom.unifyTopLevelAssertion(topLevelAssertion, substitutions, context);
 
             if (topLevelAssertionUnifies) {
@@ -152,11 +151,8 @@ function unifyStatementWithTopLevelAssertion(statement, reference, satisfiesAsse
 
       context.trace(`Unifying the '${statementString}' statement with the '${topLevelAssertionString}' top level assertion...`);
 
-      const subproofOrProofAssertions = context.getSubproofOrProofAssertions();
-
-      substitutions = Substitutions.fromNothing(context);
-
-      const statementAndSubproofOrProofAssertionsUnify = topLevelAssertion.unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, substitutions, context);
+      const subproofOrProofAssertions = context.getSubproofOrProofAssertions(),
+            statementAndSubproofOrProofAssertionsUnify = topLevelAssertion.unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, context);
 
       if (statementAndSubproofOrProofAssertionsUnify) {
         const metavariable = reference.getMetavariable();