@the-situation/collateral 0.5.0-alpha.0 → 0.8.0

package/dist/categorical/compute.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Off-chain collateral computation for categorical (multinoulli) distributions.
+ *
+ * Unlike normal distributions which require Newton-Raphson minimization,
+ * categorical distributions use exhaustive O(N) enumeration since outcomes
+ * are discrete.
+ *
+ * @module
+ */
+/**
+ * Computes L2 norm for a categorical distribution: sqrt(sum(pi^2))
+ *
+ * @param probs - The probability vector
+ * @returns The L2 norm of the probability vector
+ */
+export declare function computeCategoricalL2Norm(probs: readonly number[]): number;
+/**
+ * Computes lambda = k / L2Norm for a categorical distribution.
+ *
+ * @param probs - The probability vector
+ * @param k - The scaling parameter
+ * @returns The lambda value, or 0 if L2 norm is non-positive
+ */
+export declare function computeCategoricalLambda(probs: readonly number[], k: number): number;
+/**
+ * Result of categorical collateral computation.
+ */
+export interface CategoricalCollateralResult {
+    readonly lambdaF: number;
+    readonly lambdaG: number;
+    readonly minOutcomeIndex: number;
+    readonly minDifference: number;
+    readonly collateral: number;
+}
+/**
+ * Finds the outcome index that minimizes (lambda_g * gi - lambda_f * fi).
+ *
+ * This is the discrete analogue of the normal distribution's x* (infimum point).
+ *
+ * @param fProbs - Probability vector of the "from" distribution
+ * @param gProbs - Probability vector of the "to" distribution
+ * @param lambdaF - Lambda for the "from" distribution
+ * @param lambdaG - Lambda for the "to" distribution
+ * @returns The index and value of the minimum difference
+ */
+export declare function findMinimumOutcome(fProbs: readonly number[], gProbs: readonly number[], lambdaF: number, lambdaG: number): {
+    minIndex: number;
+    minValue: number;
+};
+/**
+ * Computes collateral for trading from distribution f to g in a multinoulli market.
+ *
+ * Uses exhaustive O(N) scan over all outcomes.
+ *
+ * @param fProbs - Probability vector of the "from" distribution
+ * @param gProbs - Probability vector of the "to" distribution
+ * @param k - The scaling parameter
+ * @returns The collateral result including lambdas, minimum outcome, and collateral amount
+ */
+export declare function computeCategoricalCollateral(fProbs: readonly number[], gProbs: readonly number[], k: number): CategoricalCollateralResult;
+/**
+ * Verifies that a claimed minimum outcome index is correct.
+ *
+ * Used to validate hints before submitting to contract.
+ *
+ * @param fProbs - Probability vector of the "from" distribution
+ * @param gProbs - Probability vector of the "to" distribution
+ * @param lambdaF - Lambda for the "from" distribution
+ * @param lambdaG - Lambda for the "to" distribution
+ * @param claimedMinIndex - The claimed minimum outcome index to verify
+ * @param tolerance - Numerical tolerance for comparison (default 1e-12)
+ * @returns True if the claimed index is the true minimum
+ */
+export declare function verifyCategoricalMinimum(fProbs: readonly number[], gProbs: readonly number[], lambdaF: number, lambdaG: number, claimedMinIndex: number, tolerance?: number): boolean;
+//# sourceMappingURL=compute.d.ts.map

package/dist/categorical/compute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute.d.ts","sourceRoot":"","sources":["../../src/categorical/compute.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAMzE;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAIpF;AAED;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACd;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAiBxC;AAED;;;;;;;;;GASG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,CAAC,EAAE,MAAM,GACR,2BAA2B,CAgB7B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,eAAe,EAAE,MAAM,EACvB,SAAS,GAAE,MAAc,GACxB,OAAO,CAWT"}

package/dist/categorical/compute.js

@@ -0,0 +1,110 @@
+/**
+ * Off-chain collateral computation for categorical (multinoulli) distributions.
+ *
+ * Unlike normal distributions which require Newton-Raphson minimization,
+ * categorical distributions use exhaustive O(N) enumeration since outcomes
+ * are discrete.
+ *
+ * @module
+ */
+/**
+ * Computes L2 norm for a categorical distribution: sqrt(sum(pi^2))
+ *
+ * @param probs - The probability vector
+ * @returns The L2 norm of the probability vector
+ */
+export function computeCategoricalL2Norm(probs) {
+    let sumSq = 0;
+    for (const p of probs) {
+        sumSq += p * p;
+    }
+    return Math.sqrt(sumSq);
+}
+/**
+ * Computes lambda = k / L2Norm for a categorical distribution.
+ *
+ * @param probs - The probability vector
+ * @param k - The scaling parameter
+ * @returns The lambda value, or 0 if L2 norm is non-positive
+ */
+export function computeCategoricalLambda(probs, k) {
+    const l2Norm = computeCategoricalL2Norm(probs);
+    if (l2Norm <= 0)
+        return 0;
+    return k / l2Norm;
+}
+/**
+ * Finds the outcome index that minimizes (lambda_g * gi - lambda_f * fi).
+ *
+ * This is the discrete analogue of the normal distribution's x* (infimum point).
+ *
+ * @param fProbs - Probability vector of the "from" distribution
+ * @param gProbs - Probability vector of the "to" distribution
+ * @param lambdaF - Lambda for the "from" distribution
+ * @param lambdaG - Lambda for the "to" distribution
+ * @returns The index and value of the minimum difference
+ */
+export function findMinimumOutcome(fProbs, gProbs, lambdaF, lambdaG) {
+    if (fProbs.length !== gProbs.length) {
+        throw new Error('Distributions must have same number of outcomes');
+    }
+    let minIdx = 0;
+    let minVal = lambdaG * gProbs[0] - lambdaF * fProbs[0];
+    for (let i = 1; i < fProbs.length; i++) {
+        const diff = lambdaG * gProbs[i] - lambdaF * fProbs[i];
+        if (diff < minVal) {
+            minVal = diff;
+            minIdx = i;
+        }
+    }
+    return { minIndex: minIdx, minValue: minVal };
+}
+/**
+ * Computes collateral for trading from distribution f to g in a multinoulli market.
+ *
+ * Uses exhaustive O(N) scan over all outcomes.
+ *
+ * @param fProbs - Probability vector of the "from" distribution
+ * @param gProbs - Probability vector of the "to" distribution
+ * @param k - The scaling parameter
+ * @returns The collateral result including lambdas, minimum outcome, and collateral amount
+ */
+export function computeCategoricalCollateral(fProbs, gProbs, k) {
+    const lambdaF = computeCategoricalLambda(fProbs, k);
+    const lambdaG = computeCategoricalLambda(gProbs, k);
+    const { minIndex, minValue } = findMinimumOutcome(fProbs, gProbs, lambdaF, lambdaG);
+    // Collateral = max(0, -minDifference)
+    const collateral = Math.max(0, -minValue);
+    return {
+        lambdaF,
+        lambdaG,
+        minOutcomeIndex: minIndex,
+        minDifference: minValue,
+        collateral,
+    };
+}
+/**
+ * Verifies that a claimed minimum outcome index is correct.
+ *
+ * Used to validate hints before submitting to contract.
+ *
+ * @param fProbs - Probability vector of the "from" distribution
+ * @param gProbs - Probability vector of the "to" distribution
+ * @param lambdaF - Lambda for the "from" distribution
+ * @param lambdaG - Lambda for the "to" distribution
+ * @param claimedMinIndex - The claimed minimum outcome index to verify
+ * @param tolerance - Numerical tolerance for comparison (default 1e-12)
+ * @returns True if the claimed index is the true minimum
+ */
+export function verifyCategoricalMinimum(fProbs, gProbs, lambdaF, lambdaG, claimedMinIndex, tolerance = 1e-12) {
+    if (claimedMinIndex < 0 || claimedMinIndex >= fProbs.length)
+        return false;
+    const claimedValue = lambdaG * gProbs[claimedMinIndex] - lambdaF * fProbs[claimedMinIndex];
+    for (let i = 0; i < fProbs.length; i++) {
+        const diff = lambdaG * gProbs[i] - lambdaF * fProbs[i];
+        if (diff < claimedValue - tolerance)
+            return false;
+    }
+    return true;
+}
+//# sourceMappingURL=compute.js.map

package/dist/categorical/compute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute.js","sourceRoot":"","sources":["../../src/categorical/compute.ts"],"names":[],"mappings":"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"}

package/dist/categorical/effect.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Effect-wrapped categorical collateral computation utilities.
+ *
+ * Lifts validation and computation failures into Effect's typed error channel.
+ *
+ * @module
+ */
+import { Effect } from 'effect';
+import { InvalidInputError, SolverFailedError } from '@the-situation/core';
+import { type CategoricalCollateralResult } from './compute';
+/**
+ * Effect-wrapped categorical collateral computation.
+ *
+ * Validates inputs and lifts failures into typed error channels:
+ * - `InvalidInputError` for mismatched sizes, empty vectors, or invalid k
+ * - `SolverFailedError` for unexpected computation failures
+ *
+ * @param fProbs - Probability vector of the "from" distribution
+ * @param gProbs - Probability vector of the "to" distribution
+ * @param k - The scaling parameter (must be positive)
+ * @returns Effect yielding a CategoricalCollateralResult or failing with a typed error
+ */
+export declare function computeCategoricalCollateralEffect(fProbs: readonly number[], gProbs: readonly number[], k: number): Effect.Effect<CategoricalCollateralResult, InvalidInputError | SolverFailedError>;
+//# sourceMappingURL=effect.d.ts.map

package/dist/categorical/effect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect.d.ts","sourceRoot":"","sources":["../../src/categorical/effect.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC3E,OAAO,EAAgC,KAAK,2BAA2B,EAAE,MAAM,WAAW,CAAC;AAE3F;;;;;;;;;;;GAWG;AACH,wBAAgB,kCAAkC,CAChD,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,CAAC,EAAE,MAAM,GACR,MAAM,CAAC,MAAM,CAAC,2BAA2B,EAAE,iBAAiB,GAAG,iBAAiB,CAAC,CA0BnF"}

package/dist/categorical/effect.js

@@ -0,0 +1,50 @@
+/**
+ * Effect-wrapped categorical collateral computation utilities.
+ *
+ * Lifts validation and computation failures into Effect's typed error channel.
+ *
+ * @module
+ */
+import { Effect } from 'effect';
+import { InvalidInputError, SolverFailedError } from '@the-situation/core';
+import { computeCategoricalCollateral } from './compute';
+/**
+ * Effect-wrapped categorical collateral computation.
+ *
+ * Validates inputs and lifts failures into typed error channels:
+ * - `InvalidInputError` for mismatched sizes, empty vectors, or invalid k
+ * - `SolverFailedError` for unexpected computation failures
+ *
+ * @param fProbs - Probability vector of the "from" distribution
+ * @param gProbs - Probability vector of the "to" distribution
+ * @param k - The scaling parameter (must be positive)
+ * @returns Effect yielding a CategoricalCollateralResult or failing with a typed error
+ */
+export function computeCategoricalCollateralEffect(fProbs, gProbs, k) {
+    return Effect.gen(function* () {
+        if (fProbs.length !== gProbs.length) {
+            return yield* new InvalidInputError({
+                message: `Distribution size mismatch: f has ${fProbs.length} outcomes, g has ${gProbs.length}`,
+            });
+        }
+        if (fProbs.length === 0) {
+            return yield* new InvalidInputError({
+                message: 'Empty probability vectors',
+            });
+        }
+        if (k <= 0) {
+            return yield* new InvalidInputError({
+                message: `Invalid k parameter: ${k}`,
+            });
+        }
+        try {
+            return computeCategoricalCollateral(fProbs, gProbs, k);
+        }
+        catch (e) {
+            return yield* new SolverFailedError({
+                message: `Categorical collateral computation failed: ${e instanceof Error ? e.message : String(e)}`,
+            });
+        }
+    });
+}
+//# sourceMappingURL=effect.js.map

package/dist/categorical/effect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect.js","sourceRoot":"","sources":["../../src/categorical/effect.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC3E,OAAO,EAAE,4BAA4B,EAAoC,MAAM,WAAW,CAAC;AAE3F;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,kCAAkC,CAChD,MAAyB,EACzB,MAAyB,EACzB,CAAS;IAET,OAAO,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QACzB,IAAI,MAAM,CAAC,MAAM,KAAK,MAAM,CAAC,MAAM,EAAE,CAAC;YACpC,OAAO,KAAK,CAAC,CAAC,IAAI,iBAAiB,CAAC;gBAClC,OAAO,EAAE,qCAAqC,MAAM,CAAC,MAAM,oBAAoB,MAAM,CAAC,MAAM,EAAE;aAC/F,CAAC,CAAC;QACL,CAAC;QACD,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACxB,OAAO,KAAK,CAAC,CAAC,IAAI,iBAAiB,CAAC;gBAClC,OAAO,EAAE,2BAA2B;aACrC,CAAC,CAAC;QACL,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YACX,OAAO,KAAK,CAAC,CAAC,IAAI,iBAAiB,CAAC;gBAClC,OAAO,EAAE,wBAAwB,CAAC,EAAE;aACrC,CAAC,CAAC;QACL,CAAC;QAED,IAAI,CAAC;YACH,OAAO,4BAA4B,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;QACzD,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,OAAO,KAAK,CAAC,CAAC,IAAI,iBAAiB,CAAC;gBAClC,OAAO,EAAE,8CAA8C,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE;aACpG,CAAC,CAAC;QACL,CAAC;IACH,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/categorical/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Categorical (multinoulli) collateral computation.
+ *
+ * @module
+ */
+export { computeCategoricalCollateral, computeCategoricalL2Norm, computeCategoricalLambda, findMinimumOutcome, verifyCategoricalMinimum, type CategoricalCollateralResult, } from './compute';
+export { computeCategoricalCollateralEffect } from './effect';
+//# sourceMappingURL=index.d.ts.map

package/dist/categorical/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/categorical/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,4BAA4B,EAC5B,wBAAwB,EACxB,wBAAwB,EACxB,kBAAkB,EAClB,wBAAwB,EACxB,KAAK,2BAA2B,GACjC,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAE,kCAAkC,EAAE,MAAM,UAAU,CAAC"}

package/dist/categorical/index.js

@@ -0,0 +1,8 @@
+/**
+ * Categorical (multinoulli) collateral computation.
+ *
+ * @module
+ */
+export { computeCategoricalCollateral, computeCategoricalL2Norm, computeCategoricalLambda, findMinimumOutcome, verifyCategoricalMinimum, } from './compute';
+export { computeCategoricalCollateralEffect } from './effect';
+//# sourceMappingURL=index.js.map

package/dist/categorical/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/categorical/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,4BAA4B,EAC5B,wBAAwB,EACxB,wBAAwB,EACxB,kBAAkB,EAClB,wBAAwB,GAEzB,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAE,kCAAkC,EAAE,MAAM,UAAU,CAAC"}

package/dist/index.d.ts

@@ -5,9 +5,11 @@
  *
  * @packageDocumentation
  */
-export { collateralFromMinimum, computeCollateral, computeL2Norm, computeLambda, computeScaledCollateral, DEFAULT_MAX_ITERATIONS, DEFAULT_TOLERANCE, defaultPolicy, findMinimum, getVerifiedMinimum, isOnCorrectSide, isVerified, pdfDifference, pdfDifferenceDerivative, pdfDifferenceSecondDerivative, relaxedPolicy, SQRT_PI, suggestInitialGuess, } from './compute';
+export { collateralFromMinimum, computeCollateral, computeL2Norm, computeL2NormNumber, computeLambda, computeLambdaNumber, computeScaledCollateral, DEFAULT_MAX_ITERATIONS, DEFAULT_TOLERANCE, defaultPolicy, findMinimum, getVerifiedMinimum, isOnCorrectSide, isVerified, pdfDifference, pdfDifferenceDerivative, pdfDifferenceSecondDerivative, relaxedPolicy, SQRT_PI, suggestInitialGuess, } from './compute';
 export type { CandidateMinimum, FindMinimumResult, MinimizationMethod, MinimizationPolicy, NotVerifiedReason, ScaledCollateralResult, VerifiedMinimum, } from './compute';
 export { computeCollateralAtPoint, isValid, quickVerify, verifyMinimum, } from './verify';
 export type { CollateralVerificationResult } from './verify';
 export { findMinimumEffect } from './effect';
+export { computeCategoricalCollateral, computeCategoricalL2Norm, computeCategoricalLambda, findMinimumOutcome, verifyCategoricalMinimum, type CategoricalCollateralResult, } from './categorical/compute';
+export { computeCategoricalCollateralEffect } from './categorical/effect';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EACL,qBAAqB,EACrB,iBAAiB,EACjB,aAAa,EACb,aAAa,EACb,uBAAuB,EACvB,sBAAsB,EACtB,iBAAiB,EACjB,aAAa,EACb,WAAW,EACX,kBAAkB,EAClB,eAAe,EACf,UAAU,EACV,aAAa,EACb,uBAAuB,EACvB,6BAA6B,EAC7B,aAAa,EACb,OAAO,EACP,mBAAmB,GACpB,MAAM,WAAW,CAAC;AAGnB,YAAY,EACV,gBAAgB,EAChB,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,iBAAiB,EACjB,sBAAsB,EACtB,eAAe,GAChB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,wBAAwB,EACxB,OAAO,EACP,WAAW,EACX,aAAa,GACd,MAAM,UAAU,CAAC;AAElB,YAAY,EAAE,4BAA4B,EAAE,MAAM,UAAU,CAAC;AAG7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EACL,qBAAqB,EACrB,iBAAiB,EACjB,aAAa,EACb,mBAAmB,EACnB,aAAa,EACb,mBAAmB,EACnB,uBAAuB,EACvB,sBAAsB,EACtB,iBAAiB,EACjB,aAAa,EACb,WAAW,EACX,kBAAkB,EAClB,eAAe,EACf,UAAU,EACV,aAAa,EACb,uBAAuB,EACvB,6BAA6B,EAC7B,aAAa,EACb,OAAO,EACP,mBAAmB,GACpB,MAAM,WAAW,CAAC;AAGnB,YAAY,EACV,gBAAgB,EAChB,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,iBAAiB,EACjB,sBAAsB,EACtB,eAAe,GAChB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,wBAAwB,EACxB,OAAO,EACP,WAAW,EACX,aAAa,GACd,MAAM,UAAU,CAAC;AAElB,YAAY,EAAE,4BAA4B,EAAE,MAAM,UAAU,CAAC;AAG7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7C,OAAO,EACL,4BAA4B,EAC5B,wBAAwB,EACxB,wBAAwB,EACxB,kBAAkB,EAClB,wBAAwB,EACxB,KAAK,2BAA2B,GACjC,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,kCAAkC,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/index.js

@@ -6,9 +6,12 @@
  * @packageDocumentation
  */
 // Computation
-export { collateralFromMinimum, computeCollateral, computeL2Norm, computeLambda, computeScaledCollateral, DEFAULT_MAX_ITERATIONS, DEFAULT_TOLERANCE, defaultPolicy, findMinimum, getVerifiedMinimum, isOnCorrectSide, isVerified, pdfDifference, pdfDifferenceDerivative, pdfDifferenceSecondDerivative, relaxedPolicy, SQRT_PI, suggestInitialGuess, } from './compute';
+export { collateralFromMinimum, computeCollateral, computeL2Norm, computeL2NormNumber, computeLambda, computeLambdaNumber, computeScaledCollateral, DEFAULT_MAX_ITERATIONS, DEFAULT_TOLERANCE, defaultPolicy, findMinimum, getVerifiedMinimum, isOnCorrectSide, isVerified, pdfDifference, pdfDifferenceDerivative, pdfDifferenceSecondDerivative, relaxedPolicy, SQRT_PI, suggestInitialGuess, } from './compute';
 // Verification
 export { computeCollateralAtPoint, isValid, quickVerify, verifyMinimum, } from './verify';
 // Effect-wrapped convenience exports
 export { findMinimumEffect } from './effect';
+// Categorical (multinoulli) collateral
+export { computeCategoricalCollateral, computeCategoricalL2Norm, computeCategoricalLambda, findMinimumOutcome, verifyCategoricalMinimum, } from './categorical/compute';
+export { computeCategoricalCollateralEffect } from './categorical/effect';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,cAAc;AACd,OAAO,EACL,qBAAqB,EACrB,iBAAiB,EACjB,aAAa,EACb,aAAa,EACb,uBAAuB,EACvB,sBAAsB,EACtB,iBAAiB,EACjB,aAAa,EACb,WAAW,EACX,kBAAkB,EAClB,eAAe,EACf,UAAU,EACV,aAAa,EACb,uBAAuB,EACvB,6BAA6B,EAC7B,aAAa,EACb,OAAO,EACP,mBAAmB,GACpB,MAAM,WAAW,CAAC;AAanB,eAAe;AACf,OAAO,EACL,wBAAwB,EACxB,OAAO,EACP,WAAW,EACX,aAAa,GACd,MAAM,UAAU,CAAC;AAIlB,qCAAqC;AACrC,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,cAAc;AACd,OAAO,EACL,qBAAqB,EACrB,iBAAiB,EACjB,aAAa,EACb,mBAAmB,EACnB,aAAa,EACb,mBAAmB,EACnB,uBAAuB,EACvB,sBAAsB,EACtB,iBAAiB,EACjB,aAAa,EACb,WAAW,EACX,kBAAkB,EAClB,eAAe,EACf,UAAU,EACV,aAAa,EACb,uBAAuB,EACvB,6BAA6B,EAC7B,aAAa,EACb,OAAO,EACP,mBAAmB,GACpB,MAAM,WAAW,CAAC;AAanB,eAAe;AACf,OAAO,EACL,wBAAwB,EACxB,OAAO,EACP,WAAW,EACX,aAAa,GACd,MAAM,UAAU,CAAC;AAIlB,qCAAqC;AACrC,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAE7C,uCAAuC;AACvC,OAAO,EACL,4BAA4B,EAC5B,wBAAwB,EACxB,wBAAwB,EACxB,kBAAkB,EAClB,wBAAwB,GAEzB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,kCAAkC,EAAE,MAAM,sBAAsB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@the-situation/collateral",
-  "version": "0.5.0-alpha.0",
+  "version": "0.8.0",
   "description": "Off-chain collateral computation for The Situation prediction markets",
   "type": "module",
   "main": "./dist/index.js",
@@ -11,7 +11,9 @@
       "types": "./dist/index.d.ts"
     }
   },
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build": "tsc -b",
     "typecheck": "tsc -b",
@@ -19,7 +21,7 @@
     "clean": "rm -rf dist tsconfig.tsbuildinfo"
   },
   "dependencies": {
-    "@the-situation/core": "0.5.0-alpha.0",
+    "@the-situation/core": "workspace:*",
     "effect": "^3.12.0"
   },
   "devDependencies": {