eproc, branch HEAD

release: v0.4.1

2026-07-04T18:59:31Z

commit 74e20bd89b53c21da1878c4a6bb9ef63c2b59c3e parent 54282d253042a7ec1891ef4fe72496f4908ffa52 Author: Jared Tobin Date: Sat, 4 Jul 2026 16:29:31 -0230 release: v0.4.1

fix: uncap the ConfSeq plug-in bet

2026-07-04T18:57:06Z

commit 54282d253042a7ec1891ef4fe72496f4908ffa52 parent 18a95aecce2a74ea6abd7b1a62adf07c927e4a9c Author: Jared Tobin Date: Sat, 4 Jul 2026 16:27:06 -0230 fix: uncap the ConfSeq plug-in bet Numeric.Eproc.ConfSeq pre-capped the shared predictable plug-in bet at the truncation level c = 1/2 before applying the candidate- specific truncations c/m and c/(1 - m). Since both exceed c on the interior grid, those truncations could never bind: a conservative deviation from the WSR (2024) eq. (26) bet that Theorem 3 and the module documentation describe, slowing rejection of extreme candidates early in the stream. Drop the pre-cap. The raw eq. (26) bet is now truncated only per- candidate, restoring the paper's construction and its early power; every capital factor retains the 1 - c floor via the truncations themselves, so coverage is unaffected. The update haddock, which carried the same pre-cap in its bet formula, and the module-header example output are corrected to match. Validated with and without -f+llvm.

release: v0.4.0

2026-07-03T17:39:21Z

commit 18a95aecce2a74ea6abd7b1a62adf07c927e4a9c parent fd9e56f36fadee3edca61961dbb558d8ce52546a Author: Jared Tobin Date: Fri, 3 Jul 2026 15:09:21 -0230 release: v0.4.0 Anytime-valid p-values and e-values on every test module, uniform convex mixtures of e-processes (Numeric.Eproc.Mixture), and time-uniform confidence sequences for bounded means (Numeric.Eproc.ConfSeq). README, CHANGELOG, and cabal description refreshed to match; the Mixture module example is now self-contained, with outputs verified against a live GHCi session.

Merge branch 'impl/confseq'

2026-07-03T17:09:09Z

commit fd9e56f36fadee3edca61961dbb558d8ce52546a parent e5232a884dd0c98ed00f8bd6611d353d24b614d4 Author: Jared Tobin Date: Fri, 3 Jul 2026 14:39:09 -0230 Merge branch 'impl/confseq' Numeric.Eproc.ConfSeq: anytime-valid confidence sequences for bounded means, via the hedged-capital construction of Waudby-Smith & Ramdas (2024), Theorem 3, over a finite grid of candidate means. The betting scheme is pinned by the theorem rather than reusing the library's Bettor strategies: a single m-free predictable plug-in bet (their eq. (26)) is computed once per update from running regularized statistics and shared across all candidates, with only the c/m and c/(1-m) truncations (c = 1/2) candidate-specific, and rejection decided by the max-hedge at theta = 1/2. This m-freeness is what makes the survivor set provably an interval (m-dependent bets like aGRAPA/ONS can produce non-interval survivor sets, their Section E.4), which in turn makes the sentinel-widened grid interval a sound superset of the continuum confidence sequence: whenever 'interval' reports Just, it covers the true mean uniformly over time with probability at least 1 - alpha. Nothing signals resolution below the grid; rerun with a larger grid. Rejected candidates are dropped permanently, so intervals are nested and per-update cost is O(live candidates): ~2.1 us per observation at g = 200, shrinking as evidence accumulates. Coverage verified by simulation at an off-grid truth, checked after every observation. Adds InvalidGridSize to ConfigError and the WSR paper under etc/. Validated with and without -f+llvm. Merge resolutions: union of the mixture- and confseq-side additions to ConfigError, exposed-modules, the test main list, and the bench suites.

bench: ConfSeq update and fold benchmarks

2026-07-03T17:00:42Z

commit b0fe75351d6a55ecbd90e4f95b7af53ebd58c5ef parent 5c12e9d87bdd71a96170381c6fceaefb371ce395 Author: Jared Tobin Date: Fri, 3 Jul 2026 14:30:42 -0230 bench: ConfSeq update and fold benchmarks One-step update and 1000-sample fold at g = 200, in both the criterion and weigh suites. The NFData orphan for ConfSeq.State relies on the module's invariant that the live-candidate list is fully forced on construction, so WHNF == NF.

test: confidence-sequence coverage, nesting, and safety tests

2026-07-03T17:00:42Z

commit 5c12e9d87bdd71a96170381c6fceaefb371ce395 parent 15f814b89fc95af7646eabf8330f3e611c1454c9 Author: Jared Tobin Date: Fri, 3 Jul 2026 14:30:42 -0230 test: confidence-sequence coverage, nesting, and safety tests Covers the initial full-range interval, interval nesting (unit and property forms), simulated time-uniform coverage at an off-grid Bernoulli mean, consistency/shrinkage onto the true mean, affine correctness on a shifted range, config validation, and endpoint well-formedness on arbitrary admissible streams.

Merge branch 'impl/mixture'

2026-07-03T16:58:21Z

commit e5232a884dd0c98ed00f8bd6611d353d24b614d4 parent 768d004f1949a588f2a8293e2c6ff42be15e7daf Author: Jared Tobin Date: Fri, 3 Jul 2026 14:28:21 -0230 Merge branch 'impl/mixture' Numeric.Eproc.Mixture: uniform K-way convex mixtures of e-processes. The arithmetic mean of K component e-processes adapted to a common filtration is itself an e-process, so a single Ville threshold log(K/alpha) tests the combined null with power against a union of qualitatively different alternatives, strictly dominating a Bonferroni union. Components stay caller-owned (they are typically heterogeneous); update consumes the per-step vector of component log e-values as exposed by the new log_evalue accessors. The rejection latch lives on the supremum of the mixture's own log-wealth -- latching per-component suprema combines peaks from different times and silently inflates alpha, the pitfall downstream consumers previously had to avoid by hand. Adds InvalidComponentCount to ConfigError. K=4 update measures ~31 ns and 32 bytes allocated per step. Validated with and without -f+llvm.

test,bench: Mixture coverage and measurement

2026-07-03T16:58:21Z

commit 662222b16d770527e35280b188fb92ca0b14bc14 parent ff6be8e3b2692d735be121efdf1486b2310852e0 Author: Jared Tobin Date: Fri, 3 Jul 2026 14:28:21 -0230 test,bench: Mixture coverage and measurement Tests pin the identity between a K-fold mixture of identical components and the component itself (shifted by log K), the mixture-sup latch against the per-component-sup alpha-inflation pitfall, decide/p_value agreement, monotonicity/latching, config validation, and simulated type-I error and power for a censor-style sign + magnitude hedge. Criterion and weigh entries measure the K=4 update: ~31 ns and 32 bytes per step.

api: anytime-valid confidence sequences via WSR Theorem 3

2026-07-03T16:55:17Z

commit 15f814b89fc95af7646eabf8330f3e611c1454c9 parent addadd93c816781d8f2ad32ca905efaa44d96198 Author: Jared Tobin Date: Fri, 3 Jul 2026 14:25:17 -0230 api: anytime-valid confidence sequences via WSR Theorem 3 Numeric.Eproc.ConfSeq estimates the conditional mean of bounded observations with a time-uniform confidence interval, running a grid of hedged-capital e-processes (Waudby-Smith & Ramdas (2024), Theorem 3) with the predictable plug-in bet of their eq. (26), max-hedge theta = 1/2, truncation c = 1/2. The bet is deliberately m-free (only the truncation depends on the candidate mean), which is what makes the survivor set provably an interval; the module therefore does not use the library's Bettor strategies. Rejected grid candidates are dropped permanently, so per-update cost shrinks as evidence accumulates and reported intervals are nested. Adds the InvalidGridSize constructor to ConfigError in Common.

api: Numeric.Eproc.Mixture, uniform convex mixtures of e-processes

2026-07-03T16:54:28Z

commit ff6be8e3b2692d735be121efdf1486b2310852e0 parent 768d004f1949a588f2a8293e2c6ff42be15e7daf Author: Jared Tobin Date: Fri, 3 Jul 2026 14:24:28 -0230 api: Numeric.Eproc.Mixture, uniform convex mixtures of e-processes A K-way arithmetic mean of component e-processes is itself an e-process, so a single Ville threshold log(K/alpha) tests the combined null with power against a union of alternatives, strictly dominating Bonferroni. The module consumes per-step vectors of component log e-values (the components stay caller-owned, since they are typically heterogeneous) and keeps the rejection latch on the supremum of the mixture's own log-wealth; latching per-component suprema would combine peaks from different times and silently inflate alpha, which is precisely the pitfall this module exists to absorb. Adds the InvalidComponentCount configuration error.

Merge branch 'impl/evalue-accessors'

2026-07-03T16:50:04Z

commit 768d004f1949a588f2a8293e2c6ff42be15e7daf parent 3b66da8d75aef92493c251a3b2e8039c86ad91fb Author: Jared Tobin Date: Fri, 3 Jul 2026 14:20:04 -0230 Merge branch 'impl/evalue-accessors' Calibrated evidence accessors across all four test modules: * log_evalue: current log e-value, normalized so a fresh state sits at zero (log_wealth less log 2 for the hedged modules, log_wealth itself for the one-sided Bernoulli test). Uniform across modules, and the natural input for convex combinations of e-processes. * log_evalue_sup: the running supremum of the above. * p_value: the anytime-valid p-value min 1 (exp (negate log_evalue_sup)); decide remains equivalent to comparing it against the configured alpha. Property tests pin the decide/p_value equivalence, monotonicity, normalization at fresh states, and the relation to log_wealth. Validated with and without -f+llvm.

test: coverage for the e-value accessors

2026-07-03T16:50:04Z

commit 8b371fff9c9653db5ac26a595d5dad8ca25888c5 parent e93692ea1a08ac732c15618f7c5e8fa9383478ef Author: Jared Tobin Date: Fri, 3 Jul 2026 14:20:04 -0230 test: coverage for the e-value accessors

api: log_evalue, log_evalue_sup, and p_value accessors

2026-07-03T16:48:28Z

commit e93692ea1a08ac732c15618f7c5e8fa9383478ef parent 3b66da8d75aef92493c251a3b2e8039c86ad91fb Author: Jared Tobin Date: Fri, 3 Jul 2026 14:18:28 -0230 api: log_evalue, log_evalue_sup, and p_value accessors Every test module now exposes its evidence in calibrated form: the log e-value (log-wealth normalized so a fresh state sits at zero, uniform across one-sided and hedged modules), its running supremum, and the anytime-valid p-value derived from that supremum. decide remains equivalent to comparing p_value against alpha.

etc: add WSR (2024) reference paper

2026-07-03T16:47:58Z

commit addadd93c816781d8f2ad32ca905efaa44d96198 parent 3b66da8d75aef92493c251a3b2e8039c86ad91fb Author: Jared Tobin Date: Fri, 3 Jul 2026 14:17:58 -0230 etc: add WSR (2024) reference paper

docs: rationale for the Newton accumulator-seed deviation from WSR

2026-07-03T16:43:05Z

commit 3b66da8d75aef92493c251a3b2e8039c86ad91fb parent 93246df3eb4bd63c4e970fe43fdfe1b0b439d2fd Author: Jared Tobin Date: Fri, 3 Jul 2026 14:13:05 -0230 docs: rationale for the Newton accumulator-seed deviation from WSR

release: v0.3.0

2026-07-02T21:55:01Z

commit 93246df3eb4bd63c4e970fe43fdfe1b0b439d2fd parent 709017518315c6d80df87492e7300e86abdb7a5e Author: Jared Tobin Date: Thu, 2 Jul 2026 19:25:01 -0230 release: v0.3.0

Merge branch 'impl/log-wealth-sup'

2026-07-02T19:53:55Z

commit 709017518315c6d80df87492e7300e86abdb7a5e parent 05542c668916429b9dd6b0ddafe42c88da145ffb Author: Jared Tobin Date: Thu, 2 Jul 2026 17:23:55 -0230 Merge branch 'impl/log-wealth-sup' Splits the log-wealth accessor, uniformly across Bounded, Paired, Bernoulli, and Bernoulli.TwoSided: log_wealth now returns the current log-wealth, and the latched supremum-so-far statistic that 'decide' monitors is exposed separately as log_wealth_sup. Internal state fields are renamed to match (st_sup_log_sum, st_sup_log_w); the stale Paired 'log_wealth s0' Haddock example (0.0 -> log 2) is fixed; property tests now target log_wealth_sup for monotonicity, cover both accessors for finiteness, and check that log_wealth is bounded above by log_wealth_sup pointwise; README and CHANGELOG updated. Breaking: callers that relied on log_wealth returning the supremum should switch to log_wealth_sup.

docs: README example and CHANGELOG for the log-wealth split

2026-07-02T19:53:08Z

commit 280df8abb83452f56f340e5b10e358210dfe2904 parent e13bae8f4a7ef5c918f1a38071281b1653a736ff Author: Jared Tobin Date: Thu, 2 Jul 2026 17:23:08 -0230 docs: README example and CHANGELOG for the log-wealth split The README GHCi session now shows both accessors at s10 (current 0.6187772969384595 vs supremum 0.916290731874155) and uses log_wealth_sup for the rejection at s300. CHANGELOG gains an unreleased entry noting the breaking rename.

api: log_wealth is now the current value; add log_wealth_sup

2026-07-02T19:52:58Z

commit e13bae8f4a7ef5c918f1a38071281b1653a736ff parent 05542c668916429b9dd6b0ddafe42c88da145ffb Author: Jared Tobin Date: Thu, 2 Jul 2026 17:22:58 -0230 api: log_wealth is now the current value; add log_wealth_sup Downstream wants to observe the running log-wealth, not just the latched supremum. Split the accessor, uniformly across Bounded, Paired, Bernoulli, and Bernoulli.TwoSided: - log_wealth now returns the current log-wealth: for the two-sided modules, log(K^+ + K^-) recomputed on demand via log_sum_exp; for the one-sided Bernoulli, the running field. - log_wealth_sup returns the supremum-so-far statistic that 'decide' monitors, i.e. what log_wealth returned previously. Internal fields renamed to match (st_max_log_sum -> st_sup_log_sum, st_max_log_w -> st_sup_log_w). Also fixes the stale Paired 'log_wealth s0' Haddock example, which claimed 0.0 but has started at log 2 since the switch to the convex-hedge combination. Property tests updated: monotonicity now targets log_wealth_sup, finiteness covers both accessors, and a new property checks that log_wealth is bounded above by log_wealth_sup along the whole stream (exact, since both derive from the same log_sum_exp values).

release: v0.2.2

2026-07-02T19:20:35Z

commit 05542c668916429b9dd6b0ddafe42c88da145ffb parent d9ce56dd4e90a053e8c8e67b1fa96d272ab42724 Author: Jared Tobin Date: Thu, 2 Jul 2026 16:50:35 -0230 release: v0.2.2

docs: refresh CHANGELOG and README for the unreleased work

2026-07-02T19:16:15Z

commit d9ce56dd4e90a053e8c8e67b1fa96d272ab42724 parent 1998344fea37369058a401bec35870a1347043de Author: Jared Tobin Date: Thu, 2 Jul 2026 16:46:15 -0230 docs: refresh CHANGELOG and README for the unreleased work - CHANGELOG unreleased entry now mentions the perf work (log1p + log_sum_exp fast-path) alongside the new Bernoulli.TwoSided module, and notes that TwoSided is a newtype wrapper over Bounded. - README performance section refreshed with current LLVM-enabled numbers, including a nod to the new Bernoulli and Bernoulli.TwoSided bench groups. - README GHCi example refreshed: 'log_wealth s10' had drifted because the two-sided combination switched from Bonferroni max to convex hedge and 'log_wealth' now reports sup log(K^+ + K^-), starting at log 2.

Bernoulli.TwoSided: newtype-wrap Bounded

2026-07-02T19:11:25Z

commit 1998344fea37369058a401bec35870a1347043de parent c35e2ca28eb847b2b556c5bc017723d88dc426bc Author: Jared Tobin Date: Thu, 2 Jul 2026 16:41:25 -0230 Bernoulli.TwoSided: newtype-wrap Bounded The two-sided Bernoulli rate test at p_0 is exactly the two-sided bounded-mean test on [0, 1] with m = p_0: same safe-bet ceilings (0.5/p_0 and 0.5/(1-p_0)), same convex-hedge construction, same log(2/alpha) threshold, same latched-max statistic. The prior implementation had all this machinery duplicated verbatim from Bounded, including the log_sum_exp fast-path skip that would otherwise need to be maintained in lockstep across two modules. Refactor along the same lines as Numeric.Eproc.Paired: newtype Config = Config Bounded.Config, newtype State = State Bounded.State, and each operation delegates. update maps the Bool observation to its numeric encoding and forwards. 'config' still emits InvalidBaselineRate for p_0 out of (0, 1) — that's the meaningful error for a Bernoulli-facing caller, not the Bounded-flavoured InvalidNullMean. 122 lines deleted, 31 added. INLINE pragmas make the wrapping transparent; the criterion fold numbers are unchanged or marginally better (14.84 us vs 15.65 us for the newton case). All 59 tests still pass.

perf: log1p for the per-step wealth factor, fast-path log_sum_exp

2026-07-02T19:05:05Z

commit c35e2ca28eb847b2b556c5bc017723d88dc426bc parent 4eddb4d8cf371b4fb2196183b3fca241021544bd Author: Jared Tobin Date: Thu, 2 Jul 2026 16:35:05 -0230 perf: log1p for the per-step wealth factor, fast-path log_sum_exp Two small changes to the per-observation work in the update functions: 1. Replace 'log (1 + lambda * z)' with 'log1p (lambda * z)' in all four update paths. Improves accuracy for small 'lambda * z' (the standard log1p rationale) and avoids the '1 + ...' add. 2. In the two-sided combinations (Bounded, BernTS), skip the 'log_sum_exp' call when the cheap upper bound 'max(logw_p, logw_n) + log 2' is already at or below the running max-log-sum. Under H_0 the wealth process is a supermartingale that stays near its early peak, so this fast-path fires on the vast majority of steps once the peak is set. Impact from criterion on a 1000-sample cycle at p = p_0: * Bernoulli.TwoSided fold newton: 25.62 us -> 15.65 us (-39%) * Bernoulli.TwoSided fold fixed: 16.21 us -> 8.27 us (-49%) * Bounded fold adaptive: 14.09 us -> 12.88 us (-9%) * Bounded fold newton: 14.83 us -> 14.57 us (-2%) The BernTS gap closes because its H_0 workload triggers the fast-path aggressively. Bounded is more modest because the input stream ('cycle [0.3, 0.7]') keeps both directional wealths active at similar magnitudes, so the log_sum_exp fires more often. Also moves 'log 2' to a shared 'log2_dbl' constant in Common (used both as the initial two-sided max-log-sum and as the fast-path slack). I checked GHC Core for the Newton fold specialisation question: the current bench's shared 'run_b' helper causes GHC to emit one worker taking 'Bettor' as an argument, with a per-iteration case dispatch. Rewriting the bench to inline the fold at each arm produces the specialised code, but the measurable difference is in the noise (<1 us on a 15 us fold). Left the library shape alone. All 59 tests still pass.

bench: add TwoSided groups

2026-07-02T18:53:35Z

commit 4eddb4d8cf371b4fb2196183b3fca241021544bd parent 0db7982a791fbcb5d61bb0d8f208a575c2780871 Author: Jared Tobin Date: Thu, 2 Jul 2026 16:23:35 -0230 bench: add TwoSided groups Adds 'Bernoulli.TwoSided.update (one step)' and 'Bernoulli.TwoSided.update (1000-sample fold)' to both the criterion and weigh benchmark suites (fixed / adaptive / newton each), plus the NFData orphan for 'BernTS.State'. Cost is roughly 2x the one-sided variant, matching the shape of the work (two per-direction bettors + log-sum-exp).

test: bring TwoSided coverage up to parity

2026-07-02T18:51:03Z

commit 0db7982a791fbcb5d61bb0d8f208a575c2780871 parent 3d8e7f8c1a33691e3d9b46e483a280f496a96817 Author: Jared Tobin Date: Thu, 2 Jul 2026 16:21:03 -0230 test: bring TwoSided coverage up to parity Adds the four QuickCheck safety properties the other test modules already have (log_wealth finiteness, monotonicity, Fixed-bettor safety under arbitrary lambdas, latched-rejection invariant) for 'Numeric.Eproc.Bernoulli.TwoSided', plus an Adaptive detection HUnit case so both non-baseline bettors are exercised on the new module. 54 -> 59.

Bernoulli: add two-sided variant via convex hedge

2026-07-02T18:48:01Z

commit 3d8e7f8c1a33691e3d9b46e483a280f496a96817 parent ffcd36e3be7a982e7e551e1173a2a69530280292 Author: Jared Tobin Date: Thu, 2 Jul 2026 16:18:01 -0230 Bernoulli: add two-sided variant via convex hedge Adds 'Numeric.Eproc.Bernoulli.TwoSided', a sibling module to 'Numeric.Eproc.Bernoulli' testing H_0: p = p_0 against p != p_0. The primary use case is the sign test at p_0 = 1/2, and more generally any comparison of Bernoulli rates where the shift direction isn't known in advance (which the existing one-sided variant can't handle). Construction is the convex hedge of Waudby-Smith & Ramdas (2024) §4, mirroring what 'Bounded' does: two per-direction Bernoulli capital processes K^+ (betting against p > p_0) and K^- (betting against p < p_0) are combined into the hedged e-process (K^+ + K^-) / 2 with E[K_0] = 1, and the test rejects when the supremum of log(K^+ + K^-) has ever crossed log(2/alpha). State carries per-direction log-wealths plus a single max-log-sum field, updated each step via log-sum-exp (moved from 'Bounded' into 'Common' so both consumers can use it). Rejection is latched. The sibling module keeps the same 'config' / 'initial' / 'update' / 'decide' / 'log_wealth' / 'samples' shape as the one-sided version, so downstream code just qualifies both and picks: import qualified Numeric.Eproc.Bernoulli as Bern import qualified Numeric.Eproc.Bernoulli.TwoSided as BernTS Seven new test cases cover upward/downward shift detection, null calibration, latched rejection, and config validation.

release: v0.2.1

2026-07-02T17:03:50Z

commit ffcd36e3be7a982e7e551e1173a2a69530280292 parent d2a8f8c31f770670a0c63ed51cc17e6fdd434b75 Author: Jared Tobin Date: Thu, 2 Jul 2026 14:33:50 -0230 release: v0.2.1

Bounded: switch two-sided combination to convex hedge

2026-06-29T23:29:53Z

commit d2a8f8c31f770670a0c63ed51cc17e6fdd434b75 parent 0356542ed038b607762dd9cfb414e3d96851eb65 Author: Jared Tobin Date: Mon, 29 Jun 2026 20:59:53 -0230 Bounded: switch two-sided combination to convex hedge Replace the Bonferroni union over the two one-sided e-processes (reject when max(K^+, K^-) >= 2/alpha) with the convex-hedge construction from Waudby-Smith & Ramdas (2024) §4 (reject when K^+ + K^- >= 2/alpha, monitored via the running supremum of the log-sum). Both are valid two-sided combinations under H_0, but the convex- hedge rejection region strictly contains Bonferroni's: where Bonferroni rejects (max >= 2/alpha), so does the hedge (since K^+ + K^- >= max(K^+, K^-) >= 2/alpha). Where one side is moderately large and the other contributes meaningfully, only the hedge fires. Same alpha guarantee via Ville on the averaged e-process K = (K^+ + K^-)/2 which has E[K_0] = 1. For one-sided alternatives — the common case in practice — the gap is small (the losing-direction bettor's wealth stays near 1). For genuinely two-sided alternatives it can be substantial. State is simplified: dropped the per-direction max fields, added a single max-log-sum field tracked via log-sum-exp. The decide threshold is unchanged at log(2/alpha). log_wealth now reports the max-log-sum directly (starts at log 2 rather than 0 since K^+_0 + K^-_0 = 2); documented in the haddock. Behaviour change is monotone: any stream that rejected under the old code also rejects under the new code, possibly with fewer samples. Bernoulli (one-sided) is unaffected. Paired wraps Bounded so inherits automatically.

release: v0.2.0

2026-06-29T00:01:18Z

commit 0356542ed038b607762dd9cfb414e3d96851eb65 parent 67999374211a038876017be1b90c74742ebc555e Author: Jared Tobin Date: Sun, 28 Jun 2026 21:31:18 -0230 release: v0.2.0

reject non-finite parameters in config constructors

2026-06-28T23:47:23Z

commit 67999374211a038876017be1b90c74742ebc555e parent b0a7a7cf7abdbae101d2efb87bcaf13a132b7501 Author: Jared Tobin Date: Sun, 28 Jun 2026 21:17:23 -0230 reject non-finite parameters in config constructors NaN and +/-Infinity were slipping past the existing range checks (NaN comparisons are False, and -Inf < +Inf passes 'lo < hi'), leaving the door open to e.g. infinite bounds that silently zeroed the safe-bet ceilings. Tighten each smart constructor to require finite m/lo/hi/alpha (Bounded), lo/hi/alpha (Paired), and p0/alpha (Bernoulli) via a shared 'finite' helper in Common.

tighten correctness and validation across the API

2026-06-28T23:27:37Z

commit b0a7a7cf7abdbae101d2efb87bcaf13a132b7501 parent 8c7d3c072dba28c933e84c15ddff14a8ded14509 Author: Jared Tobin Date: Sun, 28 Jun 2026 20:57:37 -0230 tighten correctness and validation across the API Acts on a code review of v0.1.0. The headline change is that 'decide' now reflects "ever crossed the threshold," not "currently above the threshold" -- this is the supremum-style event Ville's inequality actually bounds. State carries a running max log-wealth per direction (Bounded) or globally (Bernoulli), and 'log_wealth' returns the supremum so far. Other correctness fixes: * 'Fixed' bettor is now clipped to '[0, lambda_max]' like the other bettors. The Bounded module no longer needs the 'tiny' wealth-factor floor; that was hiding a violation rather than fixing one. * The Newton bettor uses the WSR (2024) Algorithm 2 learning rate '2 / (2 - log 3)', matching the paper. API hardening: * Config constructors return 'Either ConfigError Config' and reject invalid statistical parameters (alpha out of (0,1), lo >= hi, m outside (lo,hi), p0 outside (0,1)). * 'Numeric.Eproc.Bernoulli.config' argument order changed from (alpha, p0, bettor) to (p0, alpha, bettor) so alpha is second-to-last across all three test modules. Internal cleanup: * Bettor logic (BetState, init_bet, bet_lambda, step_bet) lives in 'Numeric.Eproc.Common'; Bounded and Bernoulli are thin consumers. Bench numbers unchanged. Docs: * Module headers reframe H_0 in conditional-expectation form, which is what anytime validity actually requires. * 'update' docstrings state the support precondition explicitly. Tests: 16 -> 41. Added latched-rejection cases, config-validation group, and QuickCheck properties for log-wealth finiteness, monotonicity, Fixed-bettor safety under arbitrary lambdas, and the latched-rejection invariant. Tightened null-FPR slack 0.10 -> 0.08. Added a Bernoulli Fixed-bettor smoke test. Benches: added Bernoulli update/fold groups.

release: v0.1.0

2026-06-04T21:06:33Z

commit 8c7d3c072dba28c933e84c15ddff14a8ded14509 parent 2a3196374cc7b58d3cd7ad1fd774a5cd914469aa Author: Jared Tobin Date: Thu, 4 Jun 2026 18:36:33 -0230 release: v0.1.0

extract Bettor and Verdict into Numeric.Eproc.Common

2026-06-04T19:31:51Z

commit 2a3196374cc7b58d3cd7ad1fd774a5cd914469aa parent dea08bd4741aa02cc1c0039090dca018c5aeedbd Author: Jared Tobin Date: Thu, 4 Jun 2026 17:01:51 -0230 extract Bettor and Verdict into Numeric.Eproc.Common Both types are now defined once in Numeric.Eproc.Common and re-exported from each test module (Bounded, Paired, Bernoulli). Single source of truth for the shared vocabulary; callers can still import any test module and get the full surface without a second import.

add Numeric.Eproc.Bernoulli; fix per-trial test seeding

2026-06-04T19:29:58Z

commit dea08bd4741aa02cc1c0039090dca018c5aeedbd parent 0a4b12ab29ad1259b97f3db16f47539af56449eb Author: Jared Tobin Date: Thu, 4 Jun 2026 16:59:58 -0230 add Numeric.Eproc.Bernoulli; fix per-trial test seeding Numeric.Eproc.Bernoulli is a one-sided Bernoulli rate test (H_0: E[x] <= p_0 vs H_1: E[x] > p_0). Single wealth process, so no Bonferroni adjustment; threshold is log(1 / alpha). Useful for fingerprint-style divergence detection where the per-observation quantity is a Bool, not a real. Bettors mirror Bounded: Fixed, Adaptive (aGRAPA), Newton (ONS). While adding tests for the new module, found that the existing gen_seq harness produced trial seeds one PRNG step apart, so consecutive trials shared all but one observation. Fine under a symmetric H_0 (rare streaks cancel) but catastrophic under a skewed one (rare streaks dominate every overlapping trial, producing FPR ~ 0.5). Replaced with independent seeds via a splitmix-style finalizer.

flake: add clang

2026-06-04T18:32:36Z

commit 0a4b12ab29ad1259b97f3db16f47539af56449eb parent 18bc2ced8ae223a05147151379439ce6818bf625 Author: Jared Tobin Date: Thu, 4 Jun 2026 16:02:36 -0230 flake: add clang

meta: description tweaks

2026-06-04T17:54:49Z

commit 18bc2ced8ae223a05147151379439ce6818bf625 parent e3b0b0b1a9e3c7f62bfbec57f24a603275cfcaa7 Author: Jared Tobin Date: Thu, 4 Jun 2026 15:24:49 -0230 meta: description tweaks

add module-level examples to Bounded and Paired

2026-06-04T17:52:29Z

commit e3b0b0b1a9e3c7f62bfbec57f24a603275cfcaa7 parent 01225b5275cdae0215412fc0704c88bfc2128dd6 Author: Jared Tobin Date: Thu, 4 Jun 2026 15:22:29 -0230 add module-level examples to Bounded and Paired

rename Agrapa to Adaptive, Ons to Newton

2026-06-04T17:26:18Z

commit 01225b5275cdae0215412fc0704c88bfc2128dd6 parent 55bab648d1e9a7b46ef8d51ff2b506dbb08dcc0c Author: Jared Tobin Date: Thu, 4 Jun 2026 14:56:18 -0230 rename Agrapa to Adaptive, Ons to Newton retains the aGRAPA acronym expansion in the Adaptive haddock.

lib: line lengths

2026-06-04T16:53:57Z

commit 55bab648d1e9a7b46ef8d51ff2b506dbb08dcc0c parent 6c09da6ddd72d3d29f7045d040dfb8ce15b6a075 Author: Jared Tobin Date: Thu, 4 Jun 2026 14:23:57 -0230 lib: line lengths

meta: refine text

2026-06-03T18:15:13Z

commit 6c09da6ddd72d3d29f7045d040dfb8ce15b6a075 parent 347be5310855537b93d034bbd5338ce6b5afeca9 Author: Jared Tobin Date: Wed, 3 Jun 2026 15:45:13 -0230 meta: refine text

fold Bettor into Bounded; drop Numeric.Eproc.Bettor

2026-06-03T14:10:29Z

commit 347be5310855537b93d034bbd5338ce6b5afeca9 parent dcd9754da35f9ded3faeef878fbf234497ed11c2 Author: Jared Tobin Date: Wed, 3 Jun 2026 11:40:29 -0230 fold Bettor into Bounded; drop Numeric.Eproc.Bettor The Bettor module was thin -- just a three-constructor enum and its documentation -- and the only module that actually case-analyzes on Bettor is Bounded (Paired delegates to Bounded internally). Moving the type to where it is used eliminates the thin module without duplicating across the two test families. * 'data Bettor' now lives in Numeric.Eproc.Bounded and is exported alongside Config / State / Verdict. * Numeric.Eproc.Paired re-exports Bettor(..) the same way it re-exports Verdict(..); no API change at the Paired call site. * Numeric.Eproc.Bettor deleted; removed from cabal exposed-modules. * Tests, benches, and the README drop the 'B' import; bettor constructors are referenced as Bounded.Ons / Bounded.Agrapa / Bounded.Fixed throughout (and as the bare constructors inside the library's own haddock examples). Tests pass.

rename Mean to Bounded

2026-06-03T13:58:29Z

commit dcd9754da35f9ded3faeef878fbf234497ed11c2 parent 8b73a8dc0a86c40d9e7845ce275580f9e87d083a Author: Jared Tobin Date: Wed, 3 Jun 2026 11:28:29 -0230 rename Mean to Bounded Module Numeric.Eproc.Mean -- which provides the two-sided bounded-mean test, not just mean calculation -- becomes Numeric.Eproc.Bounded. 'Bounded' parallels 'Paired' as a noun describing the test family. Import alias changes from 'M' to the spelled-out 'Bounded' (the natural single-letter 'B' is already in use by Bettor); call sites in Paired, tests, bench, and the README updated. Internal helpers and labels updated to match: local test helper 'run_mean_bernoulli' -> 'run_bounded_bernoulli'; benchmark bgroup labels 'Mean.update ...' / 'Mean.decide' -> 'Bounded.update ...' / 'Bounded.decide'; README's captured benchmark output relabeled. No semantic / API changes; tests pass.

rename Test to Paired

2026-06-03T12:59:16Z

commit 8b73a8dc0a86c40d9e7845ce275580f9e87d083a parent c8c70f93df09bbe173951220453ef661036d33e3 Author: Jared Tobin Date: Wed, 3 Jun 2026 10:29:16 -0230 rename Test to Paired 'Test' was overly generic given that Mean is itself a test (the two-sided bounded-mean test). 'Paired' more precisely names what the module provides: the paired two-sample mean-equality test. Module Numeric.Eproc.Test becomes Numeric.Eproc.Paired; import alias 'T' becomes 'P'; benchmark bgroup labels ('Test.update ...') updated to 'Paired.update ...'. No semantic / API changes; tests pass.

rename TwoSample to Test

2026-06-03T12:52:57Z

commit c8c70f93df09bbe173951220453ef661036d33e3 parent f84c84ac03843da025ad73533629af10e6867691 Author: Jared Tobin Date: Wed, 3 Jun 2026 10:22:57 -0230 rename TwoSample to Test Module Numeric.Eproc.TwoSample becomes Numeric.Eproc.Test. The 'TS' import alias becomes 'T' to match the single-letter M / B convention. Local test helpers ('run_ts_paired', 'ts_avg_rate') renamed to 'run_paired' and 'paired_avg_rate' for the same reason. Benchmark bgroup labels ('TwoSample.update ...') updated to 'Test.update ...'. No semantic / API changes; tests pass.

rename Statistics.EProcess.* to Numeric.Eproc.*

2026-06-03T12:50:37Z

commit f84c84ac03843da025ad73533629af10e6867691 parent e168b262bac7bd5ae011314dab46c37ffee12055 Author: Jared Tobin Date: Wed, 3 Jun 2026 10:20:37 -0230 rename Statistics.EProcess.* to Numeric.Eproc.* Module path rename only. Each library module moves to its new path (git tracks the renames), module declarations and internal cross-refs updated, Haddock cross-links ('Statistics.EProcess.Mean.config' etc.) follow. ppad-eproc.cabal exposed-modules, test/Main.hs imports, bench/Main.hs and bench/Weight.hs imports, and the README's GHCi example all updated in lockstep. No semantic / API changes; all 11 tests still pass.

docs: enrich haddocks with e-process framework context

2026-06-03T00:33:57Z

commit e168b262bac7bd5ae011314dab46c37ffee12055 parent f60ba344661745c8829cf46c4539694086c473c2 Author: Jared Tobin Date: Tue, 2 Jun 2026 22:03:57 -0230 docs: enrich haddocks with e-process framework context Expand the module-, type-, and function-level haddocks to give readers enough domain context to make sense of the API without needing the WSR paper in hand. * Bettor: module header now describes the wealth-process construction and Ville's-inequality justification; per-constructor docs explain the strategy (Fixed = baseline, Agrapa = Kelly plug-in with mu/sigma^2, Ons = online Newton on per-step log-wealth loss) and the role of lambda_max. * Mean: module header explains the two-direction (positive / negative) Bonferroni decomposition; Config and State get per-field haddocks (cfg_lam_max_pos / cfg_lam_max_neg / st_log_w_pos / ... so the reader knows what each field is for); 'config' derives the safe-bet ceilings from sample bounds explicitly; 'update' documents the wealth-update equation; 'decide' explains the anytime-valid stopping guarantee; 'log_wealth' framed as the test statistic. * TwoSample: module header explains the reduction (paired diffs feed the bounded-mean test); per-function docs refer back to the underlying mean test. No code or API changes; tests pass, haddock builds 14/14 in each module.

style: align library with ppad conventions

2026-06-03T00:09:33Z

commit f60ba344661745c8829cf46c4539694086c473c2 parent a230e6558be4050da6ecb1a799d9993a9c957152 Author: Jared Tobin Date: Tue, 2 Jun 2026 21:39:33 -0230 style: align library with ppad conventions Restyle the library to match the patterns used by ppad-fixed, ppad-script, ppad-bip32, etc. * snake_case for top-level functions ('log_wealth') and record fields ('cfg_bettor', 'st_n', 'cfg_lam_max_pos', 'st_log_w_pos', ...). * Aligned record-field syntax matching bip32's HDKey. * Section dividers ('-- types --------', '-- streaming --------', ...) organising each module. * '>>>' Haddock examples on every public binding; expanded haddocks on the Bettor constructors describing each strategy and where lambda_max comes from. Also drop the Statistics.EProcess umbrella module: its renamed camelCase exports ('meanConfig', 'updateMean', ...) existed only to disambiguate overlapping names from Mean/TwoSample/Bettor and fought the snake_case convention. Users now import the sub-modules directly, mirroring ppad-fixed's layout: import qualified Statistics.EProcess.Bettor as B import qualified Statistics.EProcess.Mean as M Tests and benches updated to the new imports and snake_case conventions; README's GHCi example rewritten accordingly. All 11 tests still pass; bench allocation and timing unchanged.

perf: close Bettor sum, fix per-step Rational conversion

2026-06-02T23:35:41Z

commit a230e6558be4050da6ecb1a799d9993a9c957152 parent f1318f8b4511eae8fe5cbe9af2ab6b988c091dd2 Author: Jared Tobin Date: Tue, 2 Jun 2026 21:05:41 -0230 perf: close Bettor sum, fix per-step Rational conversion Refactor Bettor from a record of strategy functions (init/step/bet) parameterised over an opaque state type to a closed sum type with three constructors (Fixed Double, Agrapa, Ons). Mean.update now case-dispatches on the bettor; with INLINE, GHC fully specialises each strategy at the call site. Per-direction bettor state lives in a separate closed BetState sum carried by Mean.State. Mean.Config and Mean.State lose their phantom 's' parameter; the re-exports in Statistics.EProcess drop AGRAPA/ONS/fixed/agrapa/ons in favour of Bettor(..). Breaking change to the (brand-new) public API. While here: replace 'tiny = 1.0e-300 :: Double' with the MagicHash form 'D# 1.0e-300##'. The fractional literal compiles as 'fromRational (1.0e-300 :: Rational)' and GHC was not folding the conversion, leaving a $wrationalToDouble call in every update step. This was the dominant cost once the closed-sum refactor unlocked inlining. Combined effect (LLVM, 1000-sample fold): Mean fold/fixed : 128.9 us -> 4.84 us (27x) Mean fold/agrapa : 142.4 us -> 15.67 us ( 9x) Mean fold/ons : 133.2 us -> 14.43 us ( 9x) TS fold/fixed : 129.2 us -> 5.33 us (24x) TS fold/agrapa : 155.7 us -> 9.92 us (16x) TS fold/ons : 136.9 us -> 16.31 us ( 8x) Allocation per 1000-step fold drops from ~850 KB to <33 KB; the fixed-bettor inner loop is fully fused (48 B total). All 11 tests pass.

bench: add suite

2026-06-02T23:17:24Z

commit f1318f8b4511eae8fe5cbe9af2ab6b988c091dd2 parent f47c6310e1bc44f8a0213beeac799ec75cc4d2b6 Author: Jared Tobin Date: Tue, 2 Jun 2026 20:47:24 -0230 bench: add suite

Initial release.

2026-05-31T23:45:11Z

commit f47c6310e1bc44f8a0213beeac799ec75cc4d2b6 Author: Jared Tobin Date: Sun, 31 May 2026 21:15:11 -0230 Initial release. Anytime-valid sequential testing via e-processes: bounded-mean and paired two-sample tests built on the WSR betting framework, with fixed-lambda, aGRAPA, and ONS bettor strategies.