diffcb 0.1.4__tar.gz → 0.1.5__tar.gz

diffcb-0.1.5/LICENSE

@@ -0,0 +1,186 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship made available under
+      the License, as indicated by a copyright notice that is included in
+      or attached to the work (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean, as submitted to the Licensor for inclusion
+      in the Work by the copyright owner or by an individual or Legal Entity
+      authorized to submit on behalf of the copyright owner. For the purposes
+      of this definition, "submitted" means any form of electronic, verbal,
+      or written communication sent to the Licensor or its representatives,
+      including but not limited to communication on electronic mailing lists,
+      source code control systems, and issue tracking systems that are managed
+      by, or on behalf of, the Licensor for the purpose of discussing and
+      improving the Work, but excluding communication that is conspicuously
+      marked or designated in writing by the copyright owner as "Not a
+      Contribution."
+
+      "Contributor" shall mean Licensor and any Legal Entity on behalf of
+      whom a Contribution has been received by the Licensor and included
+      within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a cross-claim
+      or counterclaim in a lawsuit) alleging that the Work or any
+      Contribution embodied within the Work constitutes direct or
+      contributory patent infringement, then any patent licenses granted
+      to You under this License for that Work shall terminate as of the
+      date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or Derivative
+          Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, You must include a readable copy of the
+          attribution notices contained within such NOTICE file, in
+          at least one of the following places: within a NOTICE text
+          file distributed as part of the Derivative Works; within
+          the Source form or documentation, if provided along with the
+          Derivative Works; or, within a display generated by the
+          Derivative Works, if and wherever such third-party notices
+          normally appear. The contents of the NOTICE file are for
+          informational purposes only and do not modify the License.
+          You may add Your own attribution notices within Derivative
+          Works that You distribute, alongside or as an addendum to
+          the NOTICE text from the Work, provided that such additional
+          attribution notices cannot be construed as modifying the
+          License.
+
+      You may add Your own license statement for Your modifications and
+      may provide additional grant of rights to use, copy, modify, merge,
+      publish, distribute, sublicense, and/or sell copies of Your
+      modifications, and to permit persons to whom Your modifications are
+      furnished to do so, as long as such licensing does not conflict with
+      the terms of this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or reproducing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or exemplary damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or all other
+      commercial damages or losses), even if such Contributor has been
+      advised of the possibility of such damages.
+
+   9. Accepting Warranty or Liability. While redistributing the Work or
+      Derivative Works thereof, You may choose to offer, and charge a fee
+      for, acceptance of support, warranty, indemnity, or other liability
+      obligations and/or rights consistent with this License. However, in
+      accepting such obligations, You may offer such obligations only on
+      Your own behalf and on Your sole responsibility, not on behalf of
+      any other Contributor, and only if You agree to indemnify, defend,
+      and hold each Contributor harmless for any liability incurred by,
+      or claims asserted against, such Contributor by reason of your
+      accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 Ruiyu Zhang
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

diffcb-0.1.5/PKG-INFO

@@ -0,0 +1,317 @@
+Metadata-Version: 2.4
+Name: diffcb
+Version: 0.1.5
+Summary: Differentiable Critical Bandwidth: Silverman's modality test as a differentiable PyTorch layer with IFT backward pass.
+Project-URL: Homepage, https://github.com/ryZhangHason/differentiable-critical-bandwidth
+Project-URL: Repository, https://github.com/ryZhangHason/differentiable-critical-bandwidth
+Project-URL: Documentation, https://github.com/ryZhangHason/differentiable-critical-bandwidth#readme
+Project-URL: Bug Tracker, https://github.com/ryZhangHason/differentiable-critical-bandwidth/issues
+Author-email: Ruiyu Zhang <dhhhason@gmail.com>
+License:                                  Apache License
+                                   Version 2.0, January 2004
+                                http://www.apache.org/licenses/
+        
+           TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+        
+           1. Definitions.
+        
+              "License" shall mean the terms and conditions for use, reproduction,
+              and distribution as defined by Sections 1 through 9 of this document.
+        
+              "Licensor" shall mean the copyright owner or entity authorized by
+              the copyright owner that is granting the License.
+        
+              "Legal Entity" shall mean the union of the acting entity and all
+              other entities that control, are controlled by, or are under common
+              control with that entity. For the purposes of this definition,
+              "control" means (i) the power, direct or indirect, to cause the
+              direction or management of such entity, whether by contract or
+              otherwise, or (ii) ownership of fifty percent (50%) or more of the
+              outstanding shares, or (iii) beneficial ownership of such entity.
+        
+              "You" (or "Your") shall mean an individual or Legal Entity
+              exercising permissions granted by this License.
+        
+              "Source" form shall mean the preferred form for making modifications,
+              including but not limited to software source code, documentation
+              source, and configuration files.
+        
+              "Object" form shall mean any form resulting from mechanical
+              transformation or translation of a Source form, including but
+              not limited to compiled object code, generated documentation,
+              and conversions to other media types.
+        
+              "Work" shall mean the work of authorship made available under
+              the License, as indicated by a copyright notice that is included in
+              or attached to the work (an example is provided in the Appendix below).
+        
+              "Derivative Works" shall mean any work, whether in Source or Object
+              form, that is based on (or derived from) the Work and for which the
+              editorial revisions, annotations, elaborations, or other modifications
+              represent, as a whole, an original work of authorship. For the purposes
+              of this License, Derivative Works shall not include works that remain
+              separable from, or merely link (or bind by name) to the interfaces of,
+              the Work and Derivative Works thereof.
+        
+              "Contribution" shall mean, as submitted to the Licensor for inclusion
+              in the Work by the copyright owner or by an individual or Legal Entity
+              authorized to submit on behalf of the copyright owner. For the purposes
+              of this definition, "submitted" means any form of electronic, verbal,
+              or written communication sent to the Licensor or its representatives,
+              including but not limited to communication on electronic mailing lists,
+              source code control systems, and issue tracking systems that are managed
+              by, or on behalf of, the Licensor for the purpose of discussing and
+              improving the Work, but excluding communication that is conspicuously
+              marked or designated in writing by the copyright owner as "Not a
+              Contribution."
+        
+              "Contributor" shall mean Licensor and any Legal Entity on behalf of
+              whom a Contribution has been received by the Licensor and included
+              within the Work.
+        
+           2. Grant of Copyright License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              copyright license to reproduce, prepare Derivative Works of,
+              publicly display, publicly perform, sublicense, and distribute the
+              Work and such Derivative Works in Source or Object form.
+        
+           3. Grant of Patent License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              (except as stated in this section) patent license to make, have made,
+              use, offer to sell, sell, import, and otherwise transfer the Work,
+              where such license applies only to those patent claims licensable
+              by such Contributor that are necessarily infringed by their
+              Contribution(s) alone or by combination of their Contribution(s)
+              with the Work to which such Contribution(s) was submitted. If You
+              institute patent litigation against any entity (including a cross-claim
+              or counterclaim in a lawsuit) alleging that the Work or any
+              Contribution embodied within the Work constitutes direct or
+              contributory patent infringement, then any patent licenses granted
+              to You under this License for that Work shall terminate as of the
+              date such litigation is filed.
+        
+           4. Redistribution. You may reproduce and distribute copies of the
+              Work or Derivative Works thereof in any medium, with or without
+              modifications, and in Source or Object form, provided that You
+              meet the following conditions:
+        
+              (a) You must give any other recipients of the Work or Derivative
+                  Works a copy of this License; and
+        
+              (b) You must cause any modified files to carry prominent notices
+                  stating that You changed the files; and
+        
+              (c) You must retain, in the Source form of any Derivative Works
+                  that You distribute, all copyright, patent, trademark, and
+                  attribution notices from the Source form of the Work,
+                  excluding those notices that do not pertain to any part of
+                  the Derivative Works; and
+        
+              (d) If the Work includes a "NOTICE" text file as part of its
+                  distribution, You must include a readable copy of the
+                  attribution notices contained within such NOTICE file, in
+                  at least one of the following places: within a NOTICE text
+                  file distributed as part of the Derivative Works; within
+                  the Source form or documentation, if provided along with the
+                  Derivative Works; or, within a display generated by the
+                  Derivative Works, if and wherever such third-party notices
+                  normally appear. The contents of the NOTICE file are for
+                  informational purposes only and do not modify the License.
+                  You may add Your own attribution notices within Derivative
+                  Works that You distribute, alongside or as an addendum to
+                  the NOTICE text from the Work, provided that such additional
+                  attribution notices cannot be construed as modifying the
+                  License.
+        
+              You may add Your own license statement for Your modifications and
+              may provide additional grant of rights to use, copy, modify, merge,
+              publish, distribute, sublicense, and/or sell copies of Your
+              modifications, and to permit persons to whom Your modifications are
+              furnished to do so, as long as such licensing does not conflict with
+              the terms of this License.
+        
+           5. Submission of Contributions. Unless You explicitly state otherwise,
+              any Contribution intentionally submitted for inclusion in the Work
+              by You to the Licensor shall be under the terms and conditions of
+              this License, without any additional terms or conditions.
+              Notwithstanding the above, nothing herein shall supersede or modify
+              the terms of any separate license agreement you may have executed
+              with Licensor regarding such Contributions.
+        
+           6. Trademarks. This License does not grant permission to use the trade
+              names, trademarks, service marks, or product names of the Licensor,
+              except as required for reasonable and customary use in describing the
+              origin of the Work and reproducing the content of the NOTICE file.
+        
+           7. Disclaimer of Warranty. Unless required by applicable law or
+              agreed to in writing, Licensor provides the Work (and each
+              Contributor provides its Contributions) on an "AS IS" BASIS,
+              WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+              implied, including, without limitation, any warranties or conditions
+              of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+              PARTICULAR PURPOSE. You are solely responsible for determining the
+              appropriateness of using or reproducing the Work and assume any
+              risks associated with Your exercise of permissions under this License.
+        
+           8. Limitation of Liability. In no event and under no legal theory,
+              whether in tort (including negligence), contract, or otherwise,
+              unless required by applicable law (such as deliberate and grossly
+              negligent acts) or agreed to in writing, shall any Contributor be
+              liable to You for damages, including any direct, indirect, special,
+              incidental, or exemplary damages of any character arising as a
+              result of this License or out of the use or inability to use the
+              Work (including but not limited to damages for loss of goodwill,
+              work stoppage, computer failure or malfunction, or all other
+              commercial damages or losses), even if such Contributor has been
+              advised of the possibility of such damages.
+        
+           9. Accepting Warranty or Liability. While redistributing the Work or
+              Derivative Works thereof, You may choose to offer, and charge a fee
+              for, acceptance of support, warranty, indemnity, or other liability
+              obligations and/or rights consistent with this License. However, in
+              accepting such obligations, You may offer such obligations only on
+              Your own behalf and on Your sole responsibility, not on behalf of
+              any other Contributor, and only if You agree to indemnify, defend,
+              and hold each Contributor harmless for any liability incurred by,
+              or claims asserted against, such Contributor by reason of your
+              accepting any such warranty or additional liability.
+        
+           END OF TERMS AND CONDITIONS
+        
+           Copyright 2026 Ruiyu Zhang
+        
+           Licensed under the Apache License, Version 2.0 (the "License");
+           you may not use this file except in compliance with the License.
+           You may obtain a copy of the License at
+        
+               http://www.apache.org/licenses/LICENSE-2.0
+        
+           Unless required by applicable law or agreed to in writing, software
+           distributed under the License is distributed on an "AS IS" BASIS,
+           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+           See the License for the specific language governing permissions and
+           limitations under the License.
+License-File: LICENSE
+Keywords: PyTorch,anomaly detection,critical bandwidth,differentiable programming,generative models,kernel density estimation,mode counting,nonparametric statistics
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.9
+Requires-Dist: matplotlib>=3.7.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: scikit-learn>=1.3.0
+Requires-Dist: scipy>=1.10.0
+Requires-Dist: torch>=2.0.0
+Provides-Extra: dev
+Requires-Dist: black>=23.0.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.1.0; extra == 'dev'
+Requires-Dist: pytest>=7.4.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Provides-Extra: notebooks
+Requires-Dist: ipywidgets>=8.0.0; extra == 'notebooks'
+Requires-Dist: jupyter>=1.0.0; extra == 'notebooks'
+Description-Content-Type: text/markdown
+
+# DCB — Differentiable Critical Bandwidth
+
+[![PyPI](https://img.shields.io/pypi/v/diffcb.svg)](https://pypi.org/project/diffcb/)
+[![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/)
+
+A PyTorch package that makes **Silverman's critical bandwidth test (1981)** fully differentiable, enabling end-to-end gradient-based optimization over the modal structure of continuous distributions.
+
+## Overview
+
+The critical bandwidth `h_crit` is the minimum KDE bandwidth at which a distribution appears to have at most `m` modes — a classical nonparametric statistic for modality testing. DCB replaces every non-differentiable operation in its computation with a smooth surrogate, then uses the **Implicit Function Theorem** to compute exact gradients through the root-finding step at O(1) memory cost.
+
+```python
+import torch
+from dcb import DCBLayer
+
+X = torch.randn(1000, requires_grad=True)   # 1D samples
+layer = DCBLayer(target_modes=1)
+h_crit = layer(X)                           # differentiable scalar
+h_crit.backward()                           # exact IFT gradients
+```
+
+## Installation
+
+```bash
+pip install diffcb
+```
+
+Or from source:
+
+```bash
+git clone https://github.com/ryZhangHason/differentiable-critical-bandwidth
+cd differentiable-critical-bandwidth
+pip install -e ".[dev]"
+```
+
+## Accuracy vs R's `bw.crit`
+
+DCB is validated against R's `multimode::bw.crit(data, mod0=1)` — the standard reference implementation of Hall & York (2001). On **identical data**:
+
+| n | DCB vs R (same sample) | DCB vs R (independent samples) |
+|---|---|---|
+| 100K | **0.004%** | ~0.5% (MC noise from independent RNG) |
+| 1M | **0.005%** | ~0.2% |
+| 10M | **0.004%** | ~0.1% |
+
+The independent-sample figures reflect natural sampling variability (two unbiased estimators drawing different data), not algorithmic error. On identical data, DCB agrees with R to within **0.005%** at all tested n. DCB is 43× faster than R at n=100M (1.1 s vs 50 s) and handles n=2B in 24 s while R OOMs.
+
+## Key Parameters
+
+```python
+DCBLayer(
+    target_modes=1,       # target number of modes
+    G=512,                # IFT evaluation grid points
+    use_fft=True,         # FFT forward (default); eliminates subsampling bias for n>50K
+    max_n_exact=1_000_000,# sketch to sketch_size when n exceeds this (None = always exact)
+    sketch_size=500_000,  # sketch target; 500K matches full-n accuracy (O(n^{-2/9}) rate)
+    safe_backward=False,  # clamp IFT denominator near bifurcations
+)
+```
+
+## Confirmed Experimental Results
+
+All GPU results produced on Kaggle (T4 / P100) — see `experiments/` and `outputs/`.
+
+| Experiment | Result | Criterion |
+|---|---|---|
+| **Accuracy vs R (same data, n=100K)** | **0.004%** | < 0.01% ✓ |
+| **Validation (m≥2, Marron-Wand)** | R²=0.91, MAE=0.07, ρ=0.89 | R²≥0.85 ✓ |
+| **Speedup vs scipy (CUDA T4, n=8192)** | **10.5×** | ≥3× ✓ |
+| **GAN mode preservation** | h_crit=1.232 >> 0.3 | h_crit>0.3 ✓ |
+| **Anomaly AUC (KDDCup99)** | DCB=**0.9982** vs IF=0.9867 | DCB≥IF ✓ |
+
+## Repository Structure
+
+```
+dcb/            Core PyTorch package
+  layer.py        DCBLayer nn.Module + DCBFunction autograd
+  solver.py       IFT root-finder and backward pass
+  fft_kde.py      FFT-based mode counter (MPS-safe, float64, G=16384)
+  kde.py          Direct KDE derivatives (small-n path)
+  utils.py        Grid, Silverman bandwidth, sg() stabilizer
+experiments/    Reproduction scripts for all paper figures and tables
+  phase1_*.py     Validation, speedup, ablation (Figures 1–2, S1–S2)
+  phase2_gan.py   GAN mode-collapse prevention (Figure 3)
+  phase3_anomaly.py  Anomaly detection (Table 2, Figure 5)
+  round20_*.py    Large-n R comparison and streaming benchmarks
+  round21_*.py    Accuracy improvement experiments
+tests/          Unit tests (pytest, 45 passed, 1 xfailed)
+outputs/        All generated figures and tables (PDFs, PNGs, CSVs)
+```
+
+## License
+
+Apache 2.0 — see [LICENSE](LICENSE).

{diffcb-0.1.4 → diffcb-0.1.5}/README.md

@@ -1,7 +1,7 @@
 # DCB — Differentiable Critical Bandwidth
 
 [![PyPI](https://img.shields.io/pypi/v/diffcb.svg)](https://pypi.org/project/diffcb/)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
 [![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/)
 
 A PyTorch package that makes **Silverman's critical bandwidth test (1981)** fully differentiable, enabling end-to-end gradient-based optimization over the modal structure of continuous distributions.
@@ -71,18 +71,6 @@ All GPU results produced on Kaggle (T4 / P100) — see `experiments/` and `outpu
 | **GAN mode preservation** | h_crit=1.232 >> 0.3 | h_crit>0.3 ✓ |
 | **Anomaly AUC (KDDCup99)** | DCB=**0.9982** vs IF=0.9867 | DCB≥IF ✓ |
 
-## Changelog
-
-### v0.1.1 (2026-05-29)
-- **MPS fix:** `torch.histc` on MPS allocated an n×bins intermediate (OOM at n≥5M). Replaced with `bucketize+bincount` on CPU — MPS-safe and numerically identical.
-- **Sketch API:** `DCBLayer(max_n_exact=1_000_000, sketch_size=500_000)` — silently sketches to 500K when n exceeds threshold. Justified by O(n⁻²/⁹) convergence of h_crit; 500K sketch matches full-n accuracy.
-- **Consistent bisection domain:** Pre-computed domain passed to all `fft_mode_count` calls in a single bisection, eliminating per-step drift.
-- **Bias warning direction:** Corrected "expected upward bias" to "expected downward bias" on legacy `use_fft=False` path.
-- **Test fixes:** Updated 8 pre-existing test failures (tuple unpacking, bounds, deprecation API).
-
-### v0.1.0 (2026-05-28)
-- Initial PyPI release. FFT forward (O(n + G log G)), IFT backward, MPS support.
-
 ## Repository Structure
 
 ```
@@ -102,28 +90,6 @@ tests/          Unit tests (pytest, 45 passed, 1 xfailed)
 outputs/        All generated figures and tables (PDFs, PNGs, CSVs)
 ```
 
-## Reproducing Paper Results
-
-```bash
-# Phase 1: validation, speedup, ablation
-python experiments/phase1_validation.py
-python experiments/phase1_speedup.py
-
-# Phase 2: GAN mode collapse experiment
-python experiments/phase2_gan.py
-
-# Phase 3: anomaly detection benchmark
-python experiments/phase3_anomaly.py
-```
-
-For GPU runs use the Kaggle kernels:
-- Phase 1–2: `hsingle/dcb-full-experiments`
-- Phase 3: `hsingle/dcb-phase-3-anomaly-detection`
-
-## Paper
-
-> Ruiyu Zhang. "Differentiable Critical Bandwidth: Making Silverman's Modality Test End-to-End Trainable." *Journal of Machine Learning Research*, 2026 (in preparation).
-
 ## License
 
-MIT — see [LICENSE](LICENSE).
+Apache 2.0 — see [LICENSE](LICENSE).

{diffcb-0.1.4 → diffcb-0.1.5}/dcb/__init__.py

@@ -19,4 +19,4 @@ __all__ = [
     "DCBLayer", "DifferentiableCriticalBandwidth",
     "anneal_eps_tau", "soft_mode_count_cross", "soft_mode_count",
 ]
-__version__ = "0.1.4"
+__version__ = "0.1.5"

{diffcb-0.1.4 → diffcb-0.1.5}/dcb/fft_kde.py

@@ -138,16 +138,55 @@ def mode_count_from_C(
         return 1  # degenerate single-point distribution
 
     K_deriv = 1j * omega * torch.exp(-0.5 * (omega * h) ** 2)
-    f_prime_padded = torch.fft.irfft(C * K_deriv, n=N).real
-    f_prime = f_prime_padded[:G]
+    f_prime = torch.fft.irfft(C * K_deriv, n=N).real[:G]
+    # Exact zeros are measure-zero for smooth KDE on non-degenerate data; strict
+    # inequalities match the masked path in all practical cases while avoiding
+    # one host sync (.any()) and two allocations (nonzero_mask, s) per call.
+    return int(((f_prime[:-1] > 0) & (f_prime[1:] < 0)).sum().item())
 
-    nonzero_mask = f_prime != 0
-    if not nonzero_mask.any():
-        return 0
 
-    s = f_prime[nonzero_mask]
-    transitions = int(((s[:-1] > 0) & (s[1:] < 0)).sum().item())
-    return transitions
+def mode_count_from_C_batch(
+    C: Tensor,
+    omega: Tensor,
+    h_batch: list,
+    G: int,
+    N: int,
+) -> list:
+    """Evaluate mode count for B bandwidths in one batched irfft — O(B × G log G).
+
+    Stacks B kernel vectors into a (B, N//2+1) complex tensor and calls a
+    single batched irfft, amortising per-call dispatch overhead across the
+    batch.  Used by the trisection bisection loop to evaluate two interior
+    points per round, cutting the number of Python dispatches by ~35 %.
+
+    Parameters
+    ----------
+    C : Tensor, shape (N//2+1,), complex
+        rfft of the zero-padded histogram (from `precompute_fft`).
+    omega : Tensor, shape (N//2+1,), float
+        Frequency grid (from `precompute_fft`).
+    h_batch : list of float, length B
+        Bandwidths to evaluate.
+    G, N : int
+        Histogram bin count and padded FFT length.
+
+    Returns
+    -------
+    list of int, length B
+        Mode counts for each bandwidth in h_batch.
+    """
+    if C.numel() == 0:
+        return [1] * len(h_batch)
+
+    B = len(h_batch)
+    h_t = torch.tensor(h_batch, dtype=omega.dtype, device=omega.device)  # (B,)
+    # Build (B, M) kernel matrix in one vectorised op
+    omega_h = omega.unsqueeze(0) * h_t.unsqueeze(1)                       # (B, M)
+    K_batch = 1j * omega.unsqueeze(0) * torch.exp(-0.5 * omega_h ** 2)    # (B, M)
+    # One batched irfft dispatch instead of B separate calls
+    f_prime_batch = torch.fft.irfft(C.unsqueeze(0) * K_batch, n=N)[:, :G]  # (B, G)
+    counts = ((f_prime_batch[:, :-1] > 0) & (f_prime_batch[:, 1:] < 0)).sum(dim=1)
+    return counts.tolist()
 
 
 def fft_mode_count(
@@ -202,6 +241,8 @@ def _refine_hcrit(
     domain: tuple[float, float],
     target_modes: int = 1,
     pad_factor: int = 2,  # Worker 5: pad_factor=2 (was 4) — safe for h ≤ 3σ, halves irfft size
+    C_external: Tensor | None = None,
+    omega_external: Tensor | None = None,
 ) -> float:
     """Sub-bin quadratic refinement of h_crit after bisection converges.
 
@@ -223,6 +264,13 @@ def _refine_hcrit(
     h_lo, h_hi : float  — final bisection bracket; fft_mode_count(X,h_lo) > target,
                           fft_mode_count(X,h_hi) <= target
     G, domain, target_modes, pad_factor — same as fft_mode_count
+    C_external : Tensor or None
+        If provided, reuse the rfft of the zero-padded histogram from the
+        bisection step (Worker 23-4: avoids a duplicate O(n) histogram + rfft).
+        Must be the same G and pad_factor as the bisection.
+    omega_external : Tensor or None
+        Frequency grid matching C_external.  Must be provided together with
+        C_external or both left as None.
 
     Returns
     -------
@@ -240,19 +288,24 @@ def _refine_hcrit(
     N = pad_factor * G
     bw = bin_width  # histogram bin width
 
-    # Pre-compute histogram once; reuse C (FFT of counts) for all h evaluations.
-    with torch.no_grad():
-        counts = _histogram_on_device(X, G, lo_d, hi_d).cpu()
-        counts_padded = torch.zeros(N, dtype=torch.float64)
-        counts_padded[:G] = counts.double()
-        C = torch.fft.rfft(counts_padded)
-        k = torch.arange(N // 2 + 1, dtype=torch.float64)
-        omega_base = 2 * math.pi * k / (N * bw)
+    if C_external is not None and omega_external is not None:
+        # Reuse the bisection's precomputed C and omega — no extra O(n) histogram.
+        C_ref = C_external
+        omega_base = omega_external
+    else:
+        # Fallback: build float64 histogram + rfft (original behaviour).
+        with torch.no_grad():
+            counts = _histogram_on_device(X, G, lo_d, hi_d).cpu()
+            counts_padded = torch.zeros(N, dtype=torch.float64)
+            counts_padded[:G] = counts.double()
+            C_ref = torch.fft.rfft(counts_padded)
+            k = torch.arange(N // 2 + 1, dtype=torch.float64)
+            omega_base = 2 * math.pi * k / (N * bw)
 
     def fprime(h: float) -> Tensor:
-        """Compute f′ array (shape G,) for bandwidth h using cached C (float64)."""
+        """Compute f′ array (shape G,) for bandwidth h using cached C."""
         K_deriv = 1j * omega_base * torch.exp(-0.5 * (omega_base * h) ** 2)
-        return torch.fft.irfft(C * K_deriv, n=N).float()[:G]
+        return torch.fft.irfft(C_ref * K_deriv, n=N).real[:G]
 
     with torch.no_grad():
         # If the bracket is tighter than bin_width, expand it so that the

{diffcb-0.1.4 → diffcb-0.1.5}/dcb/layer.py

@@ -36,13 +36,14 @@ class DCBFunction(torch.autograd.Function):
     @staticmethod
     def forward(ctx, X, grid, eps, tau, target_modes, delta, formula, chunk_size,
                 brentq_n_max, g_brentq, use_hard_bisection, safe_backward, use_fft, fft_G_min,
-                fft_dtype):
+                fft_dtype, use_richardson):
         """Locate h_crit and save state for the backward pass."""
         h_crit, cond_num = find_h_crit(
             X, grid, eps, tau, target_modes,
             formula=formula, brentq_n_max=brentq_n_max, chunk_size=chunk_size,
             g_brentq=g_brentq, use_hard_bisection=use_hard_bisection,
             use_fft=use_fft, G_min=fft_G_min, fft_dtype=fft_dtype,
+            use_richardson=use_richardson,
         )
         ctx.save_for_backward(X, grid)
         ctx.h_crit = h_crit
@@ -68,8 +69,8 @@ class DCBFunction(torch.autograd.Function):
         ctx.denom_abs       = ift_gradient.last_denom_abs
         # Gradients for: X, grid, eps, tau, target_modes, delta, formula,
         #                chunk_size, brentq_n_max, g_brentq, use_hard_bisection,
-        #                safe_backward, use_fft, fft_G_min, fft_dtype
-        return grad_X, None, None, None, None, None, None, None, None, None, None, None, None, None, None
+        #                safe_backward, use_fft, fft_G_min, fft_dtype, use_richardson
+        return grad_X, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None
 
 
 class DCBLayer(nn.Module):
@@ -172,6 +173,7 @@ class DCBLayer(nn.Module):
         sketch_size: int = 500_000,
         fft_G_min: int = 16384,
         fft_dtype: torch.dtype = torch.float32,
+        use_richardson: bool = True,
     ):
         super().__init__()
         self.target_modes = target_modes
@@ -192,6 +194,7 @@ class DCBLayer(nn.Module):
         self.sketch_size = sketch_size
         self.fft_G_min = fft_G_min
         self.fft_dtype = fft_dtype
+        self.use_richardson = use_richardson
         if use_fft and brentq_n_max != 50_000:
             raise TypeError(
                 f"brentq_n_max={brentq_n_max} is meaningless when use_fft=True: the FFT path "
@@ -263,6 +266,7 @@ class DCBLayer(nn.Module):
             X, grid, eps_eff, tau_eff, self.target_modes, self.delta, self.formula,
             self.chunk_size, self.brentq_n_max, self.g_brentq, self.use_hard_bisection,
             self.safe_backward, self.use_fft, self.fft_G_min, self.fft_dtype,
+            self.use_richardson,
         )
 
 

{diffcb-0.1.4 → diffcb-0.1.5}/dcb/solver.py

@@ -37,7 +37,10 @@ from dcb.kde import (
     soft_mode_count_cross_from_derivs,
     kde_derivatives_chunked,
 )
-from dcb.fft_kde import fft_mode_count, adaptive_fft_G, precompute_fft, mode_count_from_C
+from dcb.fft_kde import (
+    fft_mode_count, adaptive_fft_G, precompute_fft,
+    mode_count_from_C, mode_count_from_C_batch,
+)
 
 _AUTO_FFT_THRESHOLD = 50_000  # n above which FFT bisection activates (use_fft_effective)
 
@@ -76,6 +79,7 @@ def find_h_crit_hard(
     use_fft: bool = False,
     G_min: int = 16384,
     fft_dtype: torch.dtype = torch.float32,
+    use_richardson: bool = True,
 ) -> tuple[float, float]:
     """Find h_crit via hard-mode-count bisection (monotone, no false roots).
 
@@ -184,32 +188,104 @@ def find_h_crit_hard(
                     if mode_count_from_C(C, omega, h_hi, G_fft, N) <= target_modes:
                         break
 
-            # Adaptive bisection: stop when bracket is localised (relative width < 1e-3)
-            # _refine_hcrit provides sub-bin precision afterwards — no need to over-bisect.
+            # Trisection with batched irfft (Worker 23-3): evaluate two interior
+            # h-values per round in one batched irfft call, shrinking the bracket
+            # by 3× per round instead of 2× per step.  This cuts the number of
+            # Python dispatch calls by ~35 % (≈15 rounds vs ≈22 bisection steps
+            # to reach relative width 1e-7) while each batched round costs only
+            # marginally more than a single bisection step.
             lo, hi = h_lo, h_hi
-            for _ in range(50):
-                mid = (lo + hi) / 2.0
-                count = mode_count_from_C(C, omega, mid, G_fft, N)
-                if count <= target_modes:
-                    hi = mid
-                else:
-                    lo = mid
+            for _ in range(32):
                 if (hi - lo) < tol:
                     break
-                # Worker 4: adaptive termination — stop when relative bracket width
-                # is small enough that further bisection cannot meaningfully shift
-                # _refine_hcrit's quadratic fit. Empirically 1e-7 preserves h_crit
-                # to within 1e-6 of the 50-step tol=1e-6 baseline while saving ~10
-                # bisection steps in typical cases.
                 if hi > 0 and (hi - lo) / hi < 1e-7:
                     break
+                width = hi - lo
+                h1 = lo + width / 3.0
+                h2 = lo + 2.0 * width / 3.0
+                c1, c2 = mode_count_from_C_batch(C, omega, [h1, h2], G_fft, N)
+                if c1 <= target_modes:
+                    hi = h1
+                elif c2 <= target_modes:
+                    lo = h1
+                    hi = h2
+                else:
+                    lo = h2
 
             h_crit = float(hi)  # smallest h with count <= target_modes
 
             # Sub-bin refinement: quadratic interpolation on the disappearing f′ lobe
             # to locate h_crit below the bin-width precision limit.
+            # Worker 23-4: pass C and omega from bisection to avoid duplicate O(n)
+            # histogram + rfft inside _refine_hcrit (saves ~80 ms at n=10M).
             from dcb.fft_kde import _refine_hcrit
-            h_crit = _refine_hcrit(X, lo, hi, G_fft, _domain, target_modes)
+            h_crit = _refine_hcrit(
+                X, lo, hi, G_fft, _domain, target_modes,
+                C_external=C, omega_external=omega,
+            )
+
+            # Worker 5: Richardson extrapolation on h_crit.
+            # h_crit(G) = h_crit_true + C·(data_range/G)² + O(G⁻⁴), so
+            # h_rich = (4·h_crit(G) − h_crit(G/2)) / 3 cancels the leading
+            # O(G⁻²) bin-discretisation error, dropping the same-sample R-vs-DCB
+            # discrepancy from ~0.004% to ~0.001% (R's noise floor).
+            if use_richardson:
+                G_half = G_fft // 2
+                if G_half >= 4096:
+                    try:
+                        C_half, omega_half, _ = precompute_fft(
+                            X, G=G_half, domain=_domain,
+                            pad_factor=pad_factor, fft_dtype=fft_dtype,
+                        )
+                        N_half = pad_factor * G_half
+
+                        # Narrow bracket around the fine-grid h_crit.
+                        h_lo_r = h_crit * 0.95
+                        h_hi_r = h_crit * 1.05
+
+                        def _bracket_valid(lo_r, hi_r):
+                            c_lo = mode_count_from_C(C_half, omega_half, lo_r, G_half, N_half)
+                            c_hi = mode_count_from_C(C_half, omega_half, hi_r, G_half, N_half)
+                            return (c_lo > target_modes) and (c_hi <= target_modes)
+
+                        valid = _bracket_valid(h_lo_r, h_hi_r)
+                        if not valid:
+                            h_lo_r = h_crit * 0.80
+                            h_hi_r = h_crit * 1.20
+                            valid = _bracket_valid(h_lo_r, h_hi_r)
+
+                        if valid:
+                            lo_r, hi_r = h_lo_r, h_hi_r
+                            for _ in range(12):
+                                if hi_r > 0 and (hi_r - lo_r) / hi_r < 1e-5:
+                                    break
+                                width = hi_r - lo_r
+                                h1 = lo_r + width / 3.0
+                                h2 = lo_r + 2.0 * width / 3.0
+                                c1, c2 = mode_count_from_C_batch(
+                                    C_half, omega_half, [h1, h2], G_half, N_half,
+                                )
+                                if c1 <= target_modes:
+                                    hi_r = h1
+                                elif c2 <= target_modes:
+                                    lo_r = h1
+                                    hi_r = h2
+                                else:
+                                    lo_r = h2
+
+                            h_crit_half = _refine_hcrit(
+                                X, lo_r, hi_r, G_half, _domain, target_modes,
+                                C_external=C_half, omega_external=omega_half,
+                            )
+
+                            h_rich = (4.0 * h_crit - h_crit_half) / 3.0
+                            # Sanity guard: reject implausible extrapolations.
+                            if h_crit * 0.5 < h_rich < h_crit * 1.5:
+                                h_crit = h_rich
+                    except Exception:
+                        # If the Richardson pass fails for any reason, keep the
+                        # pre-Richardson estimate — never degrade the baseline.
+                        pass
 
     else:
         with torch.no_grad():
@@ -318,6 +394,7 @@ def find_h_crit(
     use_fft: bool = True,
     G_min: int = 16384,
     fft_dtype: torch.dtype = torch.float32,
+    use_richardson: bool = True,
 ) -> tuple[float, float]:
     """Find h_crit and return (h_crit, condition_number).
 
@@ -372,6 +449,7 @@ def find_h_crit(
             X, grid, target_modes, chunk_size, brentq_n_max,
             h_lo, h_hi, formula=formula, eps=eps, tau=tau,
             use_fft=use_fft, G_min=G_min, fft_dtype=fft_dtype,
+            use_richardson=use_richardson,
         )
 
     from scipy.optimize import brentq

{diffcb-0.1.4 → diffcb-0.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "diffcb"
-version = "0.1.4"
+version = "0.1.5"
 description = "Differentiable Critical Bandwidth: Silverman's modality test as a differentiable PyTorch layer with IFT backward pass."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -25,7 +25,7 @@ keywords = [
 classifiers = [
     "Development Status :: 3 - Alpha",
     "Intended Audience :: Science/Research",
-    "License :: OSI Approved :: MIT License",
+    "License :: OSI Approved :: Apache Software License",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",

diffcb-0.1.4/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Ruiyu Zhang
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

diffcb-0.1.4/PKG-INFO

@@ -1,186 +0,0 @@
-Metadata-Version: 2.4
-Name: diffcb
-Version: 0.1.4
-Summary: Differentiable Critical Bandwidth: Silverman's modality test as a differentiable PyTorch layer with IFT backward pass.
-Project-URL: Homepage, https://github.com/ryZhangHason/differentiable-critical-bandwidth
-Project-URL: Repository, https://github.com/ryZhangHason/differentiable-critical-bandwidth
-Project-URL: Documentation, https://github.com/ryZhangHason/differentiable-critical-bandwidth#readme
-Project-URL: Bug Tracker, https://github.com/ryZhangHason/differentiable-critical-bandwidth/issues
-Author-email: Ruiyu Zhang <dhhhason@gmail.com>
-License: MIT License
-        
-        Copyright (c) 2026 Ruiyu Zhang
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-        SOFTWARE.
-License-File: LICENSE
-Keywords: PyTorch,anomaly detection,critical bandwidth,differentiable programming,generative models,kernel density estimation,mode counting,nonparametric statistics
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Classifier: Topic :: Scientific/Engineering :: Mathematics
-Requires-Python: >=3.9
-Requires-Dist: matplotlib>=3.7.0
-Requires-Dist: numpy>=1.24.0
-Requires-Dist: scikit-learn>=1.3.0
-Requires-Dist: scipy>=1.10.0
-Requires-Dist: torch>=2.0.0
-Provides-Extra: dev
-Requires-Dist: black>=23.0.0; extra == 'dev'
-Requires-Dist: pytest-cov>=4.1.0; extra == 'dev'
-Requires-Dist: pytest>=7.4.0; extra == 'dev'
-Requires-Dist: ruff>=0.1.0; extra == 'dev'
-Provides-Extra: notebooks
-Requires-Dist: ipywidgets>=8.0.0; extra == 'notebooks'
-Requires-Dist: jupyter>=1.0.0; extra == 'notebooks'
-Description-Content-Type: text/markdown
-
-# DCB — Differentiable Critical Bandwidth
-
-[![PyPI](https://img.shields.io/pypi/v/diffcb.svg)](https://pypi.org/project/diffcb/)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
-[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/)
-
-A PyTorch package that makes **Silverman's critical bandwidth test (1981)** fully differentiable, enabling end-to-end gradient-based optimization over the modal structure of continuous distributions.
-
-## Overview
-
-The critical bandwidth `h_crit` is the minimum KDE bandwidth at which a distribution appears to have at most `m` modes — a classical nonparametric statistic for modality testing. DCB replaces every non-differentiable operation in its computation with a smooth surrogate, then uses the **Implicit Function Theorem** to compute exact gradients through the root-finding step at O(1) memory cost.
-
-```python
-import torch
-from dcb import DCBLayer
-
-X = torch.randn(1000, requires_grad=True)   # 1D samples
-layer = DCBLayer(target_modes=1)
-h_crit = layer(X)                           # differentiable scalar
-h_crit.backward()                           # exact IFT gradients
-```
-
-## Installation
-
-```bash
-pip install diffcb
-```
-
-Or from source:
-
-```bash
-git clone https://github.com/ryZhangHason/differentiable-critical-bandwidth
-cd differentiable-critical-bandwidth
-pip install -e ".[dev]"
-```
-
-## Accuracy vs R's `bw.crit`
-
-DCB is validated against R's `multimode::bw.crit(data, mod0=1)` — the standard reference implementation of Hall & York (2001). On **identical data**:
-
-| n | DCB vs R (same sample) | DCB vs R (independent samples) |
-|---|---|---|
-| 100K | **0.004%** | ~0.5% (MC noise from independent RNG) |
-| 1M | **0.005%** | ~0.2% |
-| 10M | **0.004%** | ~0.1% |
-
-The independent-sample figures reflect natural sampling variability (two unbiased estimators drawing different data), not algorithmic error. On identical data, DCB agrees with R to within **0.005%** at all tested n. DCB is 43× faster than R at n=100M (1.1 s vs 50 s) and handles n=2B in 24 s while R OOMs.
-
-## Key Parameters
-
-```python
-DCBLayer(
-    target_modes=1,       # target number of modes
-    G=512,                # IFT evaluation grid points
-    use_fft=True,         # FFT forward (default); eliminates subsampling bias for n>50K
-    max_n_exact=1_000_000,# sketch to sketch_size when n exceeds this (None = always exact)
-    sketch_size=500_000,  # sketch target; 500K matches full-n accuracy (O(n^{-2/9}) rate)
-    safe_backward=False,  # clamp IFT denominator near bifurcations
-)
-```
-
-## Confirmed Experimental Results
-
-All GPU results produced on Kaggle (T4 / P100) — see `experiments/` and `outputs/`.
-
-| Experiment | Result | Criterion |
-|---|---|---|
-| **Accuracy vs R (same data, n=100K)** | **0.004%** | < 0.01% ✓ |
-| **Validation (m≥2, Marron-Wand)** | R²=0.91, MAE=0.07, ρ=0.89 | R²≥0.85 ✓ |
-| **Speedup vs scipy (CUDA T4, n=8192)** | **10.5×** | ≥3× ✓ |
-| **GAN mode preservation** | h_crit=1.232 >> 0.3 | h_crit>0.3 ✓ |
-| **Anomaly AUC (KDDCup99)** | DCB=**0.9982** vs IF=0.9867 | DCB≥IF ✓ |
-
-## Changelog
-
-### v0.1.1 (2026-05-29)
-- **MPS fix:** `torch.histc` on MPS allocated an n×bins intermediate (OOM at n≥5M). Replaced with `bucketize+bincount` on CPU — MPS-safe and numerically identical.
-- **Sketch API:** `DCBLayer(max_n_exact=1_000_000, sketch_size=500_000)` — silently sketches to 500K when n exceeds threshold. Justified by O(n⁻²/⁹) convergence of h_crit; 500K sketch matches full-n accuracy.
-- **Consistent bisection domain:** Pre-computed domain passed to all `fft_mode_count` calls in a single bisection, eliminating per-step drift.
-- **Bias warning direction:** Corrected "expected upward bias" to "expected downward bias" on legacy `use_fft=False` path.
-- **Test fixes:** Updated 8 pre-existing test failures (tuple unpacking, bounds, deprecation API).
-
-### v0.1.0 (2026-05-28)
-- Initial PyPI release. FFT forward (O(n + G log G)), IFT backward, MPS support.
-
-## Repository Structure
-
-```
-dcb/            Core PyTorch package
-  layer.py        DCBLayer nn.Module + DCBFunction autograd
-  solver.py       IFT root-finder and backward pass
-  fft_kde.py      FFT-based mode counter (MPS-safe, float64, G=16384)
-  kde.py          Direct KDE derivatives (small-n path)
-  utils.py        Grid, Silverman bandwidth, sg() stabilizer
-experiments/    Reproduction scripts for all paper figures and tables
-  phase1_*.py     Validation, speedup, ablation (Figures 1–2, S1–S2)
-  phase2_gan.py   GAN mode-collapse prevention (Figure 3)
-  phase3_anomaly.py  Anomaly detection (Table 2, Figure 5)
-  round20_*.py    Large-n R comparison and streaming benchmarks
-  round21_*.py    Accuracy improvement experiments
-tests/          Unit tests (pytest, 45 passed, 1 xfailed)
-outputs/        All generated figures and tables (PDFs, PNGs, CSVs)
-```
-
-## Reproducing Paper Results
-
-```bash
-# Phase 1: validation, speedup, ablation
-python experiments/phase1_validation.py
-python experiments/phase1_speedup.py
-
-# Phase 2: GAN mode collapse experiment
-python experiments/phase2_gan.py
-
-# Phase 3: anomaly detection benchmark
-python experiments/phase3_anomaly.py
-```
-
-For GPU runs use the Kaggle kernels:
-- Phase 1–2: `hsingle/dcb-full-experiments`
-- Phase 3: `hsingle/dcb-phase-3-anomaly-detection`
-
-## Paper
-
-> Ruiyu Zhang. "Differentiable Critical Bandwidth: Making Silverman's Modality Test End-to-End Trainable." *Journal of Machine Learning Research*, 2026 (in preparation).
-
-## License
-
-MIT — see [LICENSE](LICENSE).