occam-verify-cli 1.0.708 → 1.0.714

package/src/element/topLevelAssertion/axiom.js

@@ -19,7 +19,7 @@ export default define(class Axiom extends TopLevelAssertion {
     return satisfiable;
   }
 
-  compareSignature(signature, substitutions, context) {
+  compareSignature(signature, context) {
     let comparesToSignature = false;
 
     const satisfiable = this.isSatisfiable();
@@ -36,7 +36,7 @@ export default define(class Axiom extends TopLevelAssertion {
 
       const generalContext = context;  ///
 
-      comparesToSignature = signatureA.compare(signatureB, substitutions, generalContext, specificContext);
+      comparesToSignature = signatureA.compare(signatureB, generalContext, specificContext);
     }
 
     return comparesToSignature;
@@ -87,7 +87,7 @@ export default define(class Axiom extends TopLevelAssertion {
     return signatureVerifies;
   }
 
-  unifyStep(step, substitutions, context) {
+  unifyStep(step, context) {
     let stepUnifies = false;
 
     context = step.getContext();
@@ -103,7 +103,7 @@ export default define(class Axiom extends TopLevelAssertion {
       context.trace(`Unable to unify the '${stepString}' step with the '${axiomString}' axiom because the axiom is not unconditional.`);
     } else {
       const statement = step.getStatement(),
-            statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, context);
+            statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, context);
 
       if (statementUnifiesWithDeduction) {
         stepUnifies = true;
@@ -117,7 +117,7 @@ export default define(class Axiom extends TopLevelAssertion {
     return stepUnifies;
   }
 
-  unifySubproof(subproof, substitutions, context) {
+  unifySubproof(subproof, context) {
     let subproofUnifies = false;
 
     const axiomString = this.getString(),
@@ -131,11 +131,11 @@ export default define(class Axiom extends TopLevelAssertion {
       context.trace(`Unable to unify the '${subproofString}' subproof with the '${axiomString}' axiom because the axiom is unconditional.`);
     } else {
       const lastProofAssertion = subproof.getLastProofAssertion(),
-            lastProofAssertionUnifies = this.unifyLastProofAssertion(lastProofAssertion, substitutions, context);
+            lastProofAssertionUnifies = this.unifyLastProofAssertion(lastProofAssertion, context);
 
       if (lastProofAssertionUnifies) {
         const suppositions = subproof.getSuppositions(),
-              suppositionsUnify = this.unifySuppositions(suppositions, substitutions, context);
+              suppositionsUnify = this.unifySuppositions(suppositions, context);
 
         if (suppositionsUnify) {
           subproofUnifies = true;
@@ -150,7 +150,7 @@ export default define(class Axiom extends TopLevelAssertion {
     return subproofUnifies;
   }
 
-  unifyDeduction(deduction, substitutions, generalContext, specificContext) {
+  unifyDeduction(deduction, generalContext, specificContext) {
     let deductionUnifies;
 
     const specificDeduction = deduction;  ///
@@ -161,12 +161,12 @@ export default define(class Axiom extends TopLevelAssertion {
 
     deduction = specificDeduction;  ///
 
-    deductionUnifies = generalDeduction.unifyDeduction(deduction, substitutions, generalContext, specificContext);
+    deductionUnifies = generalDeduction.unifyDeduction(deduction, generalContext, specificContext);
 
     return deductionUnifies;
   }
 
-  unifySupposition(supposition, index, substitutions, generalContext, specificContext) {
+  unifySupposition(supposition, index, generalContext, specificContext) {
     let suppositionUnifies;
 
     const specificSupposition = supposition;  ///
@@ -177,12 +177,12 @@ export default define(class Axiom extends TopLevelAssertion {
 
     supposition = specificSupposition;  ///
 
-    suppositionUnifies = generalSupposition.unifySupposition(supposition, substitutions, generalContext, specificContext);
+    suppositionUnifies = generalSupposition.unifySupposition(supposition, generalContext, specificContext);
 
     return suppositionUnifies;
   }
 
-  unifySuppositions(suppositions, substitutions, generalContext, specificContext) {
+  unifySuppositions(suppositions, generalContext, specificContext) {
     let suppositionsUnify = false;
 
     const specificSuppositions = suppositions;  ///
@@ -197,7 +197,7 @@ export default define(class Axiom extends TopLevelAssertion {
       suppositions = specificSuppositions;  ///
 
       suppositionsUnify = suppositions.every((supposition, index) => {
-        const suppositionUnifies = this.unifySupposition(supposition, index, substitutions, generalContext, specificContext);
+        const suppositionUnifies = this.unifySupposition(supposition, index, generalContext, specificContext);
 
         if (suppositionUnifies) {
           return true;
@@ -208,7 +208,7 @@ export default define(class Axiom extends TopLevelAssertion {
     return suppositionsUnify;
   }
 
-  unifyLastProofAssertion(lastProofAssertion, substitutions, context) {
+  unifyLastProofAssertion(lastProofAssertion, context) {
     let lastProofAssertionUnifies = false;
 
     const axiomString = this.getString(),
@@ -217,7 +217,7 @@ export default define(class Axiom extends TopLevelAssertion {
     context.trace(`Unifying the '${lastProofAssertionString}' last proof assertion with the '${axiomString}' axiom...`)
 
     const statement = lastProofAssertion.getStatement(),
-          statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, context);
+          statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, context);
 
     if (statementUnifiesWithDeduction) {
       lastProofAssertionUnifies = true;
@@ -230,7 +230,7 @@ export default define(class Axiom extends TopLevelAssertion {
     return lastProofAssertionUnifies;
   }
 
-  unifyTopLevelAssertion(topLevelAssertion, substitutions, context) {
+  unifyTopLevelAssertion(topLevelAssertion, context) {
     let topLevelAssertionUnifies = false;
 
     const axiomString = this.getString(),
@@ -250,11 +250,11 @@ export default define(class Axiom extends TopLevelAssertion {
       context = specificContext;  ///
 
       const deduction = topLevelAssertion.getDeduction(),
-            deductionUnifies = this.unifyDeduction(deduction, substitutions, generalContext, specificContext);
+            deductionUnifies = this.unifyDeduction(deduction, generalContext, specificContext);
 
       if (deductionUnifies) {
         const suppositions = topLevelAssertion.getSuppositions(),
-              suppositionsUnify = this.unifySuppositions(suppositions, substitutions, generalContext, specificContext);
+              suppositionsUnify = this.unifySuppositions(suppositions, generalContext, specificContext);
 
         topLevelAssertionUnifies = suppositionsUnify; ///
       }

package/src/pass/zip.js

@@ -0,0 +1,19 @@
+"use strict";
+
+import { ZipPass as ZipPassBase } from "occam-languages";
+
+export default class ZipPass extends ZipPassBase {
+  run(generalNonTerminalNode, specificNonTerminalNode, ...remainingArguments) {
+    let success = false;
+
+    const specificChildNodes = specificNonTerminalNode.getChildNodes(), ///
+          generalChildNodes = generalNonTerminalNode.getChildNodes(), ///
+          descended = this.descend(generalChildNodes, specificChildNodes, ...remainingArguments);
+
+    if (descended) {
+      success = true;
+    }
+
+    return success;
+  }
+}

package/src/process/unify.js

@@ -1,6 +1,8 @@
 "use strict";
 
-import { ZipPass, queryUtilities } from "occam-languages";
+import { queryUtilities, ZipPass as ZipPassBase } from "occam-languages";
+
+import ZipPass from "../pass/zip";
 
 import { termFromTermNode, frameFromFrameNode, statementFromStatementNode } from "../utilities/element";
 
@@ -16,7 +18,7 @@ const typeNodeQuery = nodeQuery("/type"),
       statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!"),
       assumptionMetavariableNodeQuery = nodeQuery("/assumption/metavariable!");
 
-class MetaLevelPass extends ZipPass {
+class MetaLevelPass extends ZipPassBase {
   static maps = [
     {
       generalNodeQuery: assumptionMetavariableNodeQuery,
@@ -145,22 +147,6 @@ class MetaLevelPass extends ZipPass {
 }
 
 class CombinatorPass extends ZipPass {
-  run(combinatorStatementNode, statementNode, stated, generalContext, specificContext) {
-    let success = false;
-
-    const specificnonTerminalNode = statementNode,  ///
-          generalcnonTerminalNode = combinatorStatementNode,  ///
-          specificChildNodes = specificnonTerminalNode.getChildNodes(), ///
-          generalcChildNodes = generalcnonTerminalNode.getChildNodes(), ///
-          descended = this.descend(generalcChildNodes, specificChildNodes, stated, generalContext, specificContext);
-
-    if (descended) {
-      success = true;
-    }
-
-    return success;
-  }
-
   static maps = [
     {
       generalNodeQuery: metaTypeNodeQuery,
@@ -250,22 +236,6 @@ class CombinatorPass extends ZipPass {
 }
 
 class ConstructorPass extends ZipPass {
-  run(constructorTermNode, termNode, generalContext, specificContext) {
-    let success = false;
-
-    const specificnonTerminalNode = termNode,  ///
-          generalcnonTerminalNode = constructorTermNode,  ///
-          specificChildNodes = specificnonTerminalNode.getChildNodes(), ///
-          generalcChildNodes = generalcnonTerminalNode.getChildNodes(), ///
-          descended = this.descend(generalcChildNodes, specificChildNodes, generalContext, specificContext);
-
-    if (descended) {
-      success = true;
-    }
-
-    return success;
-  }
-
   static maps = [
     {
       generalNodeQuery: typeNodeQuery,

package/src/process/validate.js

@@ -149,8 +149,142 @@ class StatementPass extends SimplePass {
   ];
 }
 
+class ConbinatorPass extends SimplePass {
+  run(statementNode, context) {
+    let success = false;
+
+    const nonTerminalNode = statementNode,  ///
+          childNodes = nonTerminalNode.getChildNodes(), ///
+          descended = this.descend(childNodes, context);
+
+    if (descended) {
+      success = true;
+    }
+
+    return success;
+  }
+
+  static maps = [
+    {
+      nodeQuery: statementNodeQuery,
+      run: (statementNode, context) => {
+        let success = false;
+
+        let statement;
+
+        const stated = true;
+
+        statement = statementFromStatementNode(statementNode, context);
+
+        statement = statement.validate(stated, context);
+
+        if (statement !== null) {
+          success = true;
+        }
+
+        return success;
+      }
+    },
+    {
+      nodeQuery: termNodeQuery,
+      run: (termNode, context) => {
+        let success = false;
+
+        let term;
+
+        term = termFromTermNode(termNode, context);
+
+        term = term.validate(context, () => { ///
+          const validatesForwards = true;
+
+          return validatesForwards;
+        });
+
+        if (term !== null) {
+          success = true;
+        }
+
+        return success;
+      }
+    },
+    {
+      nodeQuery: typeNodeQuery,
+      run: (typeNode, context) => {
+        let success = false;
+
+        const nominalTypeName = typeNode.getNominalTypeName(),
+              typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
+
+        if (typePresent) {
+          success = true;
+        }
+
+        return success;
+      }
+    }
+  ];
+}
+
+class ConstructorPass extends SimplePass {
+  run(termNode, context) {
+    let success = false;
+
+    const nonTerminalNode = termNode,  ///
+          childNodes = nonTerminalNode.getChildNodes(), ///
+          descended = this.descend(childNodes, context);
+
+    if (descended) {
+      success = true;
+    }
+
+    return success;
+  }
+
+  static maps = [
+    {
+      nodeQuery: termNodeQuery,
+      run: (termNode, context) => {
+        let success = false;
+
+        let term;
+
+        term = termFromTermNode(termNode, context);
+
+        term = term.validate(context, () => { ///
+          const validatesForwards = true;
+
+          return validatesForwards;
+        });
+
+        if (term !== null) {
+          success = true;
+        }
+
+        return success;
+      }
+    },
+    {
+      nodeQuery: typeNodeQuery,
+      run: (typeNode, context) => {
+        let success = false;
+
+        const nominalTypeName = typeNode.getNominalTypeName(),
+              typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
+
+        if (typePresent) {
+          success = true;
+        }
+
+        return success;
+      }
+    }
+  ];
+}
+
 const termPass = new TermPass(),
-      statementPass = new StatementPass();
+      statementPass = new StatementPass(),
+      combinatorPass = new ConbinatorPass(),
+      constructorPass = new ConstructorPass();
 
 export function validateTerm(termNode, context, validateForwards) {
   let termValidates = false;
@@ -177,3 +311,29 @@ export function validateStatement(statementNode, context) {
 
   return statementValidates;
 }
+
+export function validateTermAsConstructor(term, context) {
+  let termValidatesAsConstructor = false;
+
+  const termNode = term.getNode(),
+        success = constructorPass.run(termNode, context);
+
+  if (success) {
+    termValidatesAsConstructor = true;
+  }
+
+  return termValidatesAsConstructor;
+}
+
+export function validateStatementAsCombinator(statement, context) {
+  let statementValidatesAsCombinator = false;
+
+  const statementNode = statement.getNode(),
+        success = combinatorPass.run(statementNode, context);
+
+  if (success) {
+    statementValidatesAsCombinator = true;
+  }
+
+  return statementValidatesAsCombinator;
+}

package/src/process/verify.js

@@ -1,8 +1,7 @@
 "use strict";
 
-import { AsyncPass, SimplePass, queryUtilities } from "occam-languages"
+import { AsyncPass, queryUtilities } from "occam-languages"
 
-import { termFromTermNode, statementFromStatementNode } from "../utilities/element";
 import { ruleFromRuleNode,
          errorFromErrorNode,
          axiomFromAxiomNode,
@@ -23,15 +22,12 @@ import { ruleFromRuleNode,
 const { nodeQuery } = queryUtilities;
 
 const ruleNodeQuery = nodeQuery("/rule"),
-      termNodeQuery = nodeQuery("/term"),
-      typeNodeQuery = nodeQuery("/type"),
       errorNodeQuery = nodeQuery("/error"),
       axiomNodeQuery = nodeQuery("/axiom"),
       lemmaNodeQuery = nodeQuery("/lemma"),
       sectionNodeQuery = nodeQuery("/section"),
       theoremNodeQuery = nodeQuery("/theorem"),
       metaLemmaNodeQuery = nodeQuery("/metaLemma"),
-      statementNodeQuery = nodeQuery("/statement"),
       conjectureNodeQuery = nodeQuery("/conjecture"),
       metatheoremNodeQuery = nodeQuery("/metatheorem"),
       variableDeclarationNodeQuery = nodeQuery("/variableDeclaration"),
@@ -287,141 +283,7 @@ class TopLevelPass extends AsyncPass {
   ];
 }
 
-class ConbinatorPass extends SimplePass {
-  run(statementNode, context) {
-    let success = false;
-
-    const nonTerminalNode = statementNode,  ///
-          childNodes = nonTerminalNode.getChildNodes(), ///
-          descended = this.descend(childNodes, context);
-
-    if (descended) {
-      success = true;
-    }
-
-    return success;
-  }
-
-  static maps = [
-    {
-      nodeQuery: statementNodeQuery,
-      run: (statementNode, context) => {
-        let success = false;
-
-        let statement;
-
-        const stated = true;
-
-        statement = statementFromStatementNode(statementNode, context);
-
-        statement = statement.validate(stated, context);
-
-        if (statement !== null) {
-          success = true;
-        }
-
-        return success;
-      }
-    },
-    {
-      nodeQuery: termNodeQuery,
-      run: (termNode, context) => {
-        let success = false;
-
-        let term;
-
-        term = termFromTermNode(termNode, context);
-
-        term = term.validate(context, () => { ///
-          const validatesForwards = true;
-
-          return validatesForwards;
-        });
-
-        if (term !== null) {
-          success = true;
-        }
-
-        return success;
-      }
-    },
-    {
-      nodeQuery: typeNodeQuery,
-      run: (typeNode, context) => {
-        let success = false;
-
-        const nominalTypeName = typeNode.getNominalTypeName(),
-              typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
-
-        if (typePresent) {
-          success = true;
-        }
-
-        return success;
-      }
-    }
-  ];
-}
-
-class ConstructorPass extends SimplePass {
-  run(termNode, context) {
-    let success = false;
-
-    const nonTerminalNode = termNode,  ///
-          childNodes = nonTerminalNode.getChildNodes(), ///
-          descended = this.descend(childNodes, context);
-
-    if (descended) {
-      success = true;
-    }
-
-    return success;
-  }
-
-  static maps = [
-    {
-      nodeQuery: termNodeQuery,
-      run: (termNode, context) => {
-        let success = false;
-
-        let term;
-
-        term = termFromTermNode(termNode, context);
-
-        term = term.validate(context, () => { ///
-          const validatesForwards = true;
-
-          return validatesForwards;
-        });
-
-        if (term !== null) {
-          success = true;
-        }
-
-        return success;
-      }
-    },
-    {
-      nodeQuery: typeNodeQuery,
-      run: (typeNode, context) => {
-        let success = false;
-
-        const nominalTypeName = typeNode.getNominalTypeName(),
-              typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
-
-        if (typePresent) {
-          success = true;
-        }
-
-        return success;
-      }
-    }
-  ];
-}
-
-const topLevelPass = new TopLevelPass(),
-      combinatorPass = new ConbinatorPass(),
-      constructorPass = new ConstructorPass();
+const topLevelPass = new TopLevelPass();
 
 export async function verifyFile(fileNode, context) {
   let fileVerifies = false;
@@ -435,29 +297,3 @@ export async function verifyFile(fileNode, context) {
 
   return fileVerifies;
 }
-
-export function verifyTermAsConstructor(term, context) {
-  let termVerifiesAsConstructor = false;
-
-  const termNode = term.getNode(),
-        success = constructorPass.run(termNode, context);
-
-  if (success) {
-    termVerifiesAsConstructor = true;
-  }
-
-  return termVerifiesAsConstructor;
-}
-
-export function verifyStatementAsCombinator(statement, context) {
-  let statementVerifiesAsCombinator = false;
-
-  const statementNode = statement.getNode(),
-        success = combinatorPass.run(statementNode, context);
-
-  if (success) {
-    statementVerifiesAsCombinator = true;
-  }
-
-  return statementVerifiesAsCombinator;
-}

package/src/utilities/context.js

@@ -46,14 +46,6 @@ export async function asyncScope(innerFunction, context) {
   return await innerFunction(context);
 }
 
-export async function asyncAttempt(innerFunction, context) {
-  const ephemeralContext = EphemeralContext.fromNothing(context);
-
-  context = ephemeralContext;  ///
-
-  return await innerFunction(context);
-}
-
 export async function asyncLiminally(innerFunction, context) {
   const liminalContext = LiminalContext.fromNothing(context);
 
@@ -61,4 +53,3 @@ export async function asyncLiminally(innerFunction, context) {
 
   return await innerFunction(context);
 }
-

package/src/utilities/unification.js

@@ -112,8 +112,7 @@ async function unifyStatementAsSatisfiesAssertion(statement, reference, satisfie
           const satisfiable = axiom.isSatisfiable();
 
           if (satisfiable) {
-            const substitutions = [],
-                  topLevelAssertionUnifies = axiom.unifyTopLevelAssertion(topLevelAssertion, substitutions, context);
+            const topLevelAssertionUnifies = axiom.unifyTopLevelAssertion(topLevelAssertion, context);
 
             if (topLevelAssertionUnifies) {
               const substitutionsCorrelates = satisfiesAssertion.correlateSubstitutions(substitutions, context);
@@ -155,19 +154,6 @@ async function unifyStatementWithTopLevelAssertion(statement, reference, satisfi
             statementAndSubproofOrProofAssertionsUnify = await topLevelAssertion.unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, context);
 
       if (statementAndSubproofOrProofAssertionsUnify) {
-        const metavariable = reference.getMetavariable();
-
-        debugger
-
-        // synthetically((context) => {
-        //   const { StatementSubstitution } = elements;
-        //
-        //   StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context);
-
-        // vaiddate
-        //
-        // }, generalContext, specificContext);
-
         statementUnifiesWithTopLevelAssertion = true;
       }
 

package/src/utilities/validation.js

@@ -73,7 +73,7 @@ function unifyTermWithBracketedConstructor(term, context, validateForwards) {
 }
 
 function validateStatementAsMetavariable(statement, stated, context) {
-  let statementValidatesAsMetavariableAndSubstitution = false;
+  let statementValidatesAsMetavariable = false;
 
   const statementNode = statement.getNode(),
         metavariableNode = statementNode.getMetavariableNode();
@@ -87,7 +87,7 @@ function validateStatementAsMetavariable(statement, stated, context) {
           metavariable = context.findMetavariableByMetavariableName(metavariableName);
 
     if (metavariable !== null) {
-      statementValidatesAsMetavariableAndSubstitution = true;
+      statementValidatesAsMetavariable = true;
 
       const { TermSubstitution, FrameSubstitution } = elements,
             frameSubstitution = FrameSubstitution.fromStatement(statement, context),
@@ -104,17 +104,17 @@ function validateStatementAsMetavariable(statement, stated, context) {
         substitution = substitution.validate(generalContext, specificContext);
 
         if (substitution === null) {
-          statementValidatesAsMetavariableAndSubstitution = false;
+          statementValidatesAsMetavariable = false;
         }
       }
     }
 
-    if (statementValidatesAsMetavariableAndSubstitution) {
+    if (statementValidatesAsMetavariable) {
       context.debug(`...validated the '${statementString}' statement as a metavariable.`);
     }
   }
 
-  return statementValidatesAsMetavariableAndSubstitution;
+  return statementValidatesAsMetavariable;
 }
 
 function unifyStatementWithCombinators(statement, stated, context) {