occam-verify-cli 1.0.768 → 1.0.781

package/src/utilities/string.js

@@ -108,8 +108,8 @@ export function suppositionsStringFromSuppositions(suppositions) {
     const suppositionString = supposition.getString();
 
     suppositionsString = (suppositionsString === null) ?
-                           suppositionString: ///
-                            `${suppositionsString}, ${suppositionString}`;
+                            suppositionString: ///
+                             `${suppositionsString}, ${suppositionString}`;
 
     return suppositionsString;
   }, null);
@@ -117,6 +117,20 @@ export function suppositionsStringFromSuppositions(suppositions) {
   return suppositionsString;
 }
 
+export function metaLevelSubstitutionsStringFromMetaLevelSubstitutions(metaLevelSubstitutions) {
+  const metaLevelSubstitutionsString = metaLevelSubstitutions.reduce((metaLevelSubstitutionsString, metaLevelSubstitution) => {
+    const metaLevelSubstitutionString = metaLevelSubstitution.getString();
+
+    metaLevelSubstitutionsString = (metaLevelSubstitutionsString === null) ?
+                                     metaLevelSubstitutionString: ///
+                                      `${metaLevelSubstitutionsString}, ${metaLevelSubstitutionString}`;
+
+    return metaLevelSubstitutionsString;
+  }, null);
+
+  return metaLevelSubstitutionsString;
+}
+
 export function signatureStringFromTerms(terms) {
   const termsString = termsStringFromTerms(terms),
         signatureString = `[${termsString}]`;

package/src/utilities/unification.js

@@ -4,11 +4,7 @@ import { arrayUtilities } from "necessary";
 
 import elements from "../elements";
 
-import { equalityFromStatement,
-         judgementFromStatement,
-         typeAssertionFromStatement,
-         propertyAssertionFromStatement,
-         satisfiesAssertionFromStatement } from "../utilities/statement";
+import { descend } from "./context";
 
 const { backwardsSome } = arrayUtilities;
 
@@ -49,7 +45,7 @@ async function unifyStatementWithReference(statement, reference, satisfiesAssert
 
     context.trace(`Unifying the '${statementString}' statement with the '${referenceString}' reference...`);
 
-    const topLevelAssertion = context.findTopLevelAssertionByReference(reference, context);
+    const topLevelAssertion = context.findTopLevelAssertionByReference(reference);
 
     if (topLevelAssertion !== null) {
       const subproofOrProofAssertions = context.getSubproofOrProofAssertions(),
@@ -84,16 +80,18 @@ async function unifyStatementWithReference(statement, reference, satisfiesAssert
 async function unifyStatementAsSatisfiesAssertion(statement, reference, satisfiesAssertion, context) {
   let statementUnifiesAsSatisfiesAssertion = false;
 
-  satisfiesAssertion = satisfiesAssertionFromStatement(statement, context);
+  const { SatisfiesAssertion } = elements;
+
+  satisfiesAssertion = SatisfiesAssertion.fromStatement(statement, context);
 
   if (satisfiesAssertion !== null) {
     const statementString = statement.getString();
 
     context.trace(`Unifying the '${statementString}' statement as a satisfies assertion...`);
 
-    const stated = true;
-
-    satisfiesAssertion.verifySignature(stated, context);
+    descend((context) => {
+      satisfiesAssertion.verifySignature(context);
+    }, context);
 
     if (reference === null) {
       const subproofOrProofAssertions = context.getSubproofOrProofAssertions();
@@ -106,7 +104,7 @@ async function unifyStatementAsSatisfiesAssertion(statement, reference, satisfie
         }
       });
     } else {
-      const topLevelAssertion = context.findTopLevelAssertionByReference(reference, context);
+      const topLevelAssertion = context.findTopLevelAssertionByReference(reference);
 
       if (topLevelAssertion !== null) {
         reference = satisfiesAssertion.getReference();
@@ -147,7 +145,7 @@ async function unifyStatementWithTopLevelAssertion(statement, reference, satisfi
   let statementUnifiesWithTopLevelAssertion = false;
 
   if (reference !== null) {
-    const topLevelAssertion = context.findTopLevelAssertionByReference(reference, context);
+    const topLevelAssertion = context.findTopLevelAssertionByReference(reference);
 
     if (topLevelAssertion !== null) {
       const statementString = statement.getString(),
@@ -175,7 +173,8 @@ async function unifyStatementAsEquality(statement, reference, satisfiesAssertion
   let statementUnifiesAEquality = false;
 
   if (reference === null) {
-    const equality = equalityFromStatement(statement, context);
+    const { Equality } = elements,
+          equality = Equality.fromStatement(statement, context);
 
     if (equality !== null) {
       const statementString = statement.getString();
@@ -201,7 +200,8 @@ async function unifyStatementAsJudgement(statement, reference, satisfiesAssertio
   let statementUnifiesAsJudgement = false;
 
   if (reference === null) {
-    const judgement = judgementFromStatement(statement, context);
+    const { Judgement } = elements,
+          judgement = Judgement.fromStatement(statement, context);
 
     if (judgement !== null) {
       const statementString = statement.getString();
@@ -223,7 +223,8 @@ async function unifyStatementAsTypeAssertion(statement, reference, satisfiesAsse
   let statementUnifiesAsTypeAssertion = false;
 
   if (reference === null) {
-    const typeAssertion = typeAssertionFromStatement(statement, context);
+    const { TypeAssertion } = elements,
+          typeAssertion = TypeAssertion.fromStatement(statement, context);
 
     if (typeAssertion !== null) {
       const statementString = statement.getString();
@@ -243,7 +244,8 @@ async function unifyStatementAsPropertyAssertion(statement, reference, satisfies
   let statementUnifiesAsPropertyAssertion = false;
 
   if (reference === null) {
-    const propertyAssertion = propertyAssertionFromStatement(statement, context);
+    const { PropertyAssertion } = elements,
+          propertyAssertion = PropertyAssertion.fromStatement(statement, context);
 
     if (propertyAssertion !== null) {
       const statementString = statement.getString();

package/src/utilities/validation.js

@@ -2,25 +2,17 @@
 
 import elements from "../elements";
 
-import { choose } from "./context";
-import { variableFromTerm } from "../utilities/term";
+import { choose, descend } from "./context";
 import { bracketedConstructorFromNothing, bracketedCombinatorFromNothing } from "../utilities/instance";
-import { equalityFromStatement,
-         judgementFromStatement,
-         metavariableFromStatement,
-         typeAssertionFromStatement,
-         definedAssertionFromStatement,
-         propertyAssertionFromStatement,
-         subproofAssertionFromStatement,
-         containedAssertionFromStatement,
-         satisfiesAssertionFromStatement } from "../utilities/statement";
 
 function validateTermAsVariable(term, context, validateForwards) {
   let termValidatesAsVariable = false;
 
+  const { Variable } = elements;
+
   let variable;
 
-  variable = variableFromTerm(term, context);
+  variable = Variable.fromTerm(term, context);
 
   if (variable !== null) {
     const termString = term.getString();
@@ -53,11 +45,11 @@ function validateTermAsVariable(term, context, validateForwards) {
 }
 
 function unifyTermWithConstructors(term, context, validateForwards) {
-  let termUnifiesWithConstructors;
+  let termUnifiesWithConstructors = false;
 
   const constructors = context.getConstructors();
 
-  termUnifiesWithConstructors = constructors.some((constructor) => {
+  constructors.some((constructor) => {
     let termUnifies;
 
     choose((context) => {
@@ -69,6 +61,8 @@ function unifyTermWithConstructors(term, context, validateForwards) {
     }, context);
 
     if (termUnifies) {
+      termUnifiesWithConstructors = true;
+
       return true;
     }
   });
@@ -86,12 +80,14 @@ function unifyTermWithBracketedConstructor(term, context, validateForwards) {
   return termUnifiesWithBracketedConstructor;
 }
 
-function validateStatementAsMetavariable(statement, stated, context) {
+function validateStatementAsMetavariable(statement, context) {
   let statementValidatesAsMetavariable = false;
 
+  const { Metavariable } = elements;
+
   let metavariable;
 
-  metavariable = metavariableFromStatement(statement, context);
+  metavariable = Metavariable.fromStatement(statement, context);
 
   if (metavariable !== null) {
     const statementString = statement.getString();
@@ -139,43 +135,53 @@ function validateStatementAsMetavariable(statement, stated, context) {
   return statementValidatesAsMetavariable;
 }
 
-function unifyStatementWithCombinators(statement, stated, context) {
-  stated = true;  ///
+function unifyStatementWithCombinators(statement, context) {
+  let statementUnifiesWithCombinators = false;
+
+  const combinators = context.getCombinators();
+
+  combinators.some((combinator) => {
+    let statementUnifies;
 
-  const combinators = context.getCombinators(),
-        statementUnifiesWithCombinators = combinators.some((combinator) => {
-          const unifiesWithCombinator = combinator.unifyStatement(statement, stated, context);
+    descend((context) => {
+      statementUnifies = combinator.unifyStatement(statement, context);
+    }, context);
+
+    if (statementUnifies) {
+      statementUnifiesWithCombinators = true;
 
-          if (unifiesWithCombinator) {
-            return true;
-          }
-        });
+      return true;
+    }
+  });
 
   return statementUnifiesWithCombinators;
 }
 
-function unifyStatementWithBracketedCombinator(statement, stated, context) {
-  stated = true;  ///
+function unifyStatementWithBracketedCombinator(statement, context) {
+  let statementUnifiesWithBracketedCombinator;
 
-  const bracketedCombinator = bracketedCombinatorFromNothing(),
-        statementUnifiesWithBracketedCombinator = bracketedCombinator.unifyStatement(statement, stated, context);
+  const bracketedCombinator = bracketedCombinatorFromNothing();
+
+  statementUnifiesWithBracketedCombinator = bracketedCombinator.unifyStatement(statement, context);
 
   return statementUnifiesWithBracketedCombinator;
 }
 
-function validateStatementAsEquality(statement, stated, context) {
+function validateStatementAsEquality(statement, context) {
   let statementValidatesAsEquality = false;
 
+  const { Equality } = elements;
+
   let equality;
 
-  equality = equalityFromStatement(statement, context);
+  equality = Equality.fromStatement(statement, context);
 
   if (equality !== null) {
     const statementString = statement.getString();
 
     context.trace(`Validating the '${statementString}' statement as an equality...`);
 
-    equality = equality.validate(stated, context);  ///
+    equality = equality.validate(context);  ///
 
     if (equality !== null) {
       statementValidatesAsEquality = true;
@@ -189,19 +195,21 @@ function validateStatementAsEquality(statement, stated, context) {
   return statementValidatesAsEquality;
 }
 
-function validateStatementAsJudgement(statement, stated, context) {
+function validateStatementAsJudgement(statement, context) {
   let validatesStatementAsJudgement = false;
 
   let judgement;
 
-  judgement = judgementFromStatement(statement, context);
+  const { Judgement } = elements;
+
+  judgement = Judgement.fromStatement(statement, context);
 
   if (judgement !== null) {
     const statementString = statement.getString();
 
     context.trace(`Validating the '${statementString}' statement as a judgement...`);
 
-    judgement = judgement.validate(stated, context);  ///
+    judgement = judgement.validate(context);  ///
 
     if (judgement !== null) {
       validatesStatementAsJudgement = true;
@@ -215,19 +223,21 @@ function validateStatementAsJudgement(statement, stated, context) {
   return validatesStatementAsJudgement;
 }
 
-function validateStatementAsTypeAssertion(statement, stated, context) {
+function validateStatementAsTypeAssertion(statement, context) {
   let validatesStatementAsTypeAssertion = false;
 
+  const { TypeAssertion } = elements;
+
   let typeAssertion;
 
-  typeAssertion = typeAssertionFromStatement(statement, context);
+  typeAssertion = TypeAssertion.fromStatement(statement, context);
 
   if (typeAssertion !== null) {
     const statementString = statement.getString();
 
     context.trace(`Validating the '${statementString}' statement as a type assertion...`);
 
-    typeAssertion = typeAssertion.validate(stated, context);  ///
+    typeAssertion = typeAssertion.validate(context);  ///
 
     if (typeAssertion !== null) {
       validatesStatementAsTypeAssertion = true;
@@ -241,19 +251,21 @@ function validateStatementAsTypeAssertion(statement, stated, context) {
   return validatesStatementAsTypeAssertion;
 }
 
-function validateStatementAsDefinedAssertion(statement, stated, context) {
+function validateStatementAsDefinedAssertion(statement, context) {
   let validatesStatementAsDefinedAssertion = false;
 
+  const { DefinedAssertion } = elements;
+
   let definedAssertion;
 
-  definedAssertion = definedAssertionFromStatement(statement, context);
+  definedAssertion = DefinedAssertion.fromStatement(statement, context);
 
   if (definedAssertion !== null) {
     const statementString = statement.getString();
 
     context.trace(`Validating the '${statementString}' statement as a defined assertion...`);
 
-    definedAssertion = definedAssertion.validate(stated, context);  ///
+    definedAssertion = definedAssertion.validate(context);  ///
 
     if (definedAssertion !== null) {
       validatesStatementAsDefinedAssertion = true;
@@ -267,19 +279,21 @@ function validateStatementAsDefinedAssertion(statement, stated, context) {
   return validatesStatementAsDefinedAssertion;
 }
 
-function validateStatementAsPropertyAssertion(statement, stated, context) {
+function validateStatementAsPropertyAssertion(statement, context) {
   let statementValidatesAsPropertyAssertion = false;
 
+  const { PropertyAssertion } = elements;
+
   let propertyAssertion;
 
-  propertyAssertion = propertyAssertionFromStatement(statement, context);
+  propertyAssertion = PropertyAssertion.fromStatement(statement, context);
 
   if (propertyAssertion !== null) {
     const statementString = statement.getString();
 
     context.trace(`Validating the '${statementString}' statement as a property assertion...`);
 
-    propertyAssertion = propertyAssertion.validate(stated, context);  ///
+    propertyAssertion = propertyAssertion.validate(context);  ///
 
     if (propertyAssertion !== null) {
       statementValidatesAsPropertyAssertion = true;
@@ -293,19 +307,21 @@ function validateStatementAsPropertyAssertion(statement, stated, context) {
   return statementValidatesAsPropertyAssertion;
 }
 
-function validateStatementAsSubproofAssertion(statement, stated, context) {
+function validateStatementAsSubproofAssertion(statement, context) {
   let statementValidatesAsSubproofAssertion = false;
 
+  const { SubproofAssertion } = elements;
+
   let subproofAssertion;
 
-  subproofAssertion = subproofAssertionFromStatement(statement, context);
+  subproofAssertion = SubproofAssertion.fromStatement(statement, context);
 
   if (subproofAssertion !== null) {
     const statementString = statement.getString();
 
     context.trace(`Validating the '${statementString}' statement as a subproof assertion...`);
 
-    subproofAssertion = subproofAssertion.validate(stated, context);  ///
+    subproofAssertion = subproofAssertion.validate(context);  ///
 
     if (subproofAssertion !== null) {
       statementValidatesAsSubproofAssertion = true;
@@ -319,19 +335,21 @@ function validateStatementAsSubproofAssertion(statement, stated, context) {
   return statementValidatesAsSubproofAssertion;
 }
 
-function validateStatementAsContainedAssertion(statement, stated, context) {
+function validateStatementAsContainedAssertion(statement, context) {
   let validatesStatementAsContainedAssertion = false;
 
+  const { ContainedAssertion } = elements;
+
   let containedAssertion;
 
-  containedAssertion = containedAssertionFromStatement(statement, context);
+  containedAssertion = ContainedAssertion.fromStatement(statement, context);
 
   if (containedAssertion !== null) {
     const statementString = statement.getString();
 
     context.trace(`Validating the '${statementString}' statement as a contained assertion...`);
 
-    containedAssertion = containedAssertion.validate(stated, context);  ///
+    containedAssertion = containedAssertion.validate(context);  ///
 
     if (containedAssertion !== null) {
       validatesStatementAsContainedAssertion = true;
@@ -345,19 +363,21 @@ function validateStatementAsContainedAssertion(statement, stated, context) {
   return validatesStatementAsContainedAssertion;
 }
 
-function validateStatementAsSatisfiesAssertion(statement, stated, context) {
+function validateStatementAsSatisfiesAssertion(statement, context) {
   let validatesAStatementsSatisfiesAssertion = false;
 
+  const { SatisfiesAssertion } = elements;
+
   let satisfiesAssertion;
 
-  satisfiesAssertion = satisfiesAssertionFromStatement(statement, context);
+  satisfiesAssertion = SatisfiesAssertion.fromStatement(statement, context);
 
   if (satisfiesAssertion !== null) {
     const statementString = statement.getString();
 
     context.trace(`Validating the '${statementString}' statement as a satisfies assertion...`);
 
-    satisfiesAssertion = satisfiesAssertion.validate(stated, context);  ///
+    satisfiesAssertion = satisfiesAssertion.validate(context);  ///
 
     if (satisfiesAssertion !== null) {
       validatesAStatementsSatisfiesAssertion = true;