From a00d0357242ceb439c1d064db5ad6dda912c059f Mon Sep 17 00:00:00 2001
From: Till Hoffmann <tillahoffmann@gmail.com>
Date: Tue, 25 Feb 2025 15:42:55 -0500
Subject: [PATCH 01/12] Add `CirculantNormal` distribution.

---
 docs/source/distributions.rst        |   8 ++
 numpyro/distributions/__init__.py    |   2 +
 numpyro/distributions/constraints.py |  15 ++++
 numpyro/distributions/continuous.py  | 113 ++++++++++++++++++++++++++-
 test/test_distributions.py           |  15 +++-
 5 files changed, 150 insertions(+), 3 deletions(-)

diff --git a/docs/source/distributions.rst b/docs/source/distributions.rst
index 7288faa44..0e13f2b5c 100644
--- a/docs/source/distributions.rst
+++ b/docs/source/distributions.rst
@@ -136,6 +136,14 @@ Chi2
     :show-inheritance:
     :member-order: bysource
 
+CirculantNormal
+^^^^^^^^^^^^^^^
+.. autoclass:: numpyro.distributions.continuous.CirculantNormal
+    :members:
+    :undoc-members:
+    :show-inheritance:
+    :member-order: bysource
+
 Dirichlet
 ^^^^^^^^^
 .. autoclass:: numpyro.distributions.continuous.Dirichlet
diff --git a/numpyro/distributions/__init__.py b/numpyro/distributions/__init__.py
index 864d2cfb2..50fe50983 100644
--- a/numpyro/distributions/__init__.py
+++ b/numpyro/distributions/__init__.py
@@ -19,6 +19,7 @@
     BetaProportion,
     Cauchy,
     Chi2,
+    CirculantNormal,
     Dirichlet,
     EulerMaruyama,
     Exponential,
@@ -132,6 +133,7 @@
     "CategoricalProbs",
     "Cauchy",
     "Chi2",
+    "CirculantNormal",
     "Delta",
     "Dirichlet",
     "DirichletMultinomial",
diff --git a/numpyro/distributions/constraints.py b/numpyro/distributions/constraints.py
index 56075078f..37fc08333 100644
--- a/numpyro/distributions/constraints.py
+++ b/numpyro/distributions/constraints.py
@@ -47,6 +47,7 @@
     "nonnegative_integer",
     "positive",
     "positive_definite",
+    "positive_definite_circulant_vector",
     "positive_semidefinite",
     "positive_integer",
     "real",
@@ -642,6 +643,19 @@ def feasible_like(self, prototype):
         )
 
 
+class _PositiveDefiniteCirculantVector(_SingletonConstraint):
+    event_dim = 1
+
+    def __call__(self, x):
+        jnp = np if isinstance(x, (np.ndarray, np.generic)) else jax.numpy
+        tol = 10 * jnp.finfo(x.dtype).eps
+        rfft = jnp.fft.rfft(x)
+        return (jnp.abs(rfft.imag) < tol) & (rfft.real > tol)
+
+    def feasible_like(self, prototype):
+        return jnp.zeros_like(prototype).at[..., 0].set(1.0)
+
+
 class _PositiveSemiDefinite(_SingletonConstraint):
     event_dim = 2
 
@@ -792,6 +806,7 @@ def tree_flatten(self):
 ordered_vector = _OrderedVector()
 positive = _Positive()
 positive_definite = _PositiveDefinite()
+positive_definite_circulant_vector = _PositiveDefiniteCirculantVector()
 positive_semidefinite = _PositiveSemiDefinite()
 positive_integer = _IntegerPositive()
 positive_ordered_vector = _PositiveOrderedVector()
diff --git a/numpyro/distributions/continuous.py b/numpyro/distributions/continuous.py
index db3b43084..d5589db30 100644
--- a/numpyro/distributions/continuous.py
+++ b/numpyro/distributions/continuous.py
@@ -33,7 +33,7 @@
 import jax.nn as nn
 import jax.numpy as jnp
 import jax.random as random
-from jax.scipy.linalg import cho_solve, solve_triangular
+from jax.scipy.linalg import cho_solve, solve_triangular, toeplitz
 from jax.scipy.special import (
     betaln,
     digamma,
@@ -3068,3 +3068,114 @@ def entropy(self) -> ArrayLike:
         return jnp.broadcast_to(
             0.5 + 1.5 * jnp.euler_gamma + 0.5 * jnp.log(16 * jnp.pi), self.batch_shape
         ) + jnp.log(self.scale)
+
+
+class CirculantNormal(Distribution):
+    """
+    Multivariate normal distribution with circulant covariance matrix.
+
+    Args:
+        loc: Mean of the distribution.
+        covariance_row: First row of the circulant covariance matrix.
+        covariance_rfft: Real part of the Fourier transform of :code:`covariance_row`.
+    """
+
+    arg_constraints = {
+        "loc": constraints.real_vector,
+        "covariance_row": constraints.positive_definite_circulant_vector,
+        "covariance_rfft": constraints.independent(constraints.positive, 1),
+    }
+    support = constraints.real_vector
+    pytree_data_fields = ("base_dist", "loc", "covariance_rfft")
+
+    def __init__(
+        self,
+        loc: jnp.ndarray,
+        covariance_row: jnp.ndarray = None,
+        covariance_rfft: jnp.ndarray = None,
+        *,
+        validate_args=None,
+    ) -> None:
+        # We demand a one-dimensional input, because we cannot determine the event shape
+        # if only the covariance_rfft is given.
+        assert jnp.ndim(loc) > 0, "Location parameter must be at least one-dimensional."
+        n = jnp.shape(loc)[-1]
+        assert_one_of(covariance_row=covariance_row, covariance_rfft=covariance_rfft)
+
+        # Evaluate covariance_rfft if not provided and validate.
+        if covariance_rfft is None:
+            assert covariance_row.shape[-1] == n
+            covariance_rfft = jnp.fft.rfft(covariance_row).real
+            self.covariance_row = covariance_row
+        assert covariance_rfft.shape[-1] == n // 2 + 1
+
+        self.loc = loc
+        self.covariance_rfft = covariance_rfft
+        var_rfft = (n * covariance_rfft / 2).at[..., 0].mul(2)
+        if n % 2 == 0:
+            var_rfft = var_rfft.at[..., -1].mul(2)
+        self.base_dist = Normal(scale=jnp.sqrt(var_rfft))
+
+        batch_shape = jnp.broadcast_shapes(loc.shape[:-1], covariance_rfft.shape[:-1])
+        super().__init__(
+            batch_shape=batch_shape, event_shape=(n,), validate_args=validate_args
+        )
+
+    @validate_sample
+    def log_prob(self, value: jnp.ndarray) -> jnp.ndarray:
+        n = value.shape[-1]
+        last_complex = (n + 1) // 2
+        value_rfft = jnp.fft.rfft(value - self.loc)
+        return (
+            self.base_dist.log_prob(value_rfft.real).sum(axis=-1)
+            + self.base_dist.log_prob(value_rfft.imag)[..., 1:last_complex].sum(axis=-1)
+            + n / 2 * jnp.log(n)
+            - jnp.log(2) * ((n - 1) // 2)
+        )
+
+    def sample(self, key, sample_shape=()) -> jnp.ndarray:
+        key1, key2 = random.split(key)
+        z_real = self.base_dist.sample(key1, sample_shape)
+        z_imag = self.base_dist.sample(key2, sample_shape)
+        return jnp.fft.irfft(z_real + 1j * z_imag, n=self.event_shape[-1]) + self.loc
+
+    @property
+    def mean(self) -> jnp.ndarray:
+        return self.loc
+
+    @lazy_property
+    def covariance_row(self) -> jnp.ndarray:
+        return jnp.fft.irfft(self.covariance_rfft, n=self.event_shape[-1])
+
+    @lazy_property
+    def covariance_matrix(self) -> jnp.ndarray:
+        if self.batch_shape:
+            # toeplitz flattens the input, and we need to broadcast manually.
+            return vmap(toeplitz, range(len(self.batch_shape)))(self.covariance_row)
+        else:
+            return toeplitz(self.covariance_row)
+
+    @lazy_property
+    def variance(self) -> jnp.ndarray:
+        return jnp.broadcast_to(self.covariance_row[..., 0, None], self.shape())
+
+    @staticmethod
+    def infer_shapes(
+        loc: tuple = (), covariance_row: tuple = None, covariance_rfft: tuple = None
+    ):
+        assert_one_of(covariance_row=covariance_row, covariance_rfft=covariance_rfft)
+        for cov in [covariance_rfft, covariance_row]:
+            if cov is not None:
+                batch_shape = jnp.broadcast_shapes(loc[:-1], cov[:-1])
+                event_shape = loc[-1:]
+                return batch_shape, event_shape
+
+    def entropy(self):
+        (n,) = self.event_shape
+        last_complex = (n + 1) // 2
+        half_log_det = jnp.log(self.covariance_rfft[0]) / 2 + jnp.log(
+            self.covariance_rfft[1:last_complex]
+        ).sum(axis=-1)
+        if n % 2 == 0:
+            half_log_det += +jnp.log(self.covariance_rfft[-1]) / 2
+        return n * (jnp.log(2 * np.pi) + 1) / 2 + half_log_det
diff --git a/test/test_distributions.py b/test/test_distributions.py
index 03ffbf869..bca283df9 100644
--- a/test/test_distributions.py
+++ b/test/test_distributions.py
@@ -138,6 +138,11 @@ def _wishart_to_scipy(conc, scale, rate, tril):
     return osp.wishart(float(jax_dist.concentration), jax_dist.scale_matrix)
 
 
+def _circulant_to_scipy(loc, covariance_row, covariance_rfft):
+    jax_dist = dist.CirculantNormal(loc, covariance_row, covariance_rfft)
+    return osp.multivariate_normal(mean=loc, cov=jax_dist.covariance_matrix)
+
+
 def _TruncatedNormal(loc, scale, low, high):
     return dist.TruncatedNormal(loc=loc, scale=scale, low=low, high=high)
 
@@ -414,6 +419,7 @@ def __init__(
     ),
     dist.Cauchy: lambda loc, scale: osp.cauchy(loc=loc, scale=scale),
     dist.Chi2: lambda df: osp.chi2(df),
+    dist.CirculantNormal: _circulant_to_scipy,
     dist.Dirichlet: lambda conc: osp.dirichlet(conc),
     dist.DiscreteUniform: lambda low, high: osp.randint(low, high + 1),
     dist.Exponential: lambda rate: osp.expon(scale=jnp.reciprocal(rate)),
@@ -487,6 +493,8 @@ def get_sp_dist(jax_dist):
     T(dist.Cauchy, 0.0, 1.0),
     T(dist.Cauchy, 0.0, np.array([1.0, 2.0])),
     T(dist.Cauchy, np.array([0.0, 1.0]), np.array([[1.0], [2.0]])),
+    T(dist.CirculantNormal, np.zeros(4), np.array([0.9, 0.2, 0.1, 0.2]), None),
+    T(dist.CirculantNormal, np.zeros(5), np.array([0.9, 0.2, 0.1, 0.1, 0.2]), None),
     T(dist.Dirichlet, np.array([1.7])),
     T(dist.Dirichlet, np.array([0.2, 1.1])),
     T(dist.Dirichlet, np.array([[0.2, 1.1], [2.0, 2.0]])),
@@ -1141,7 +1149,8 @@ def gen_values_within_bounds(constraint, size, key=random.PRNGKey(11)):
         for axis in zero_sum_axes:
             x -= x.mean(axis)
         return x
-
+    elif constraint is constraints.positive_definite_circulant_vector:
+        return jnp.fft.irfft(random.gamma(key, 10, size) / 10, n=size[-1])
     else:
         raise NotImplementedError("{} not implemented.".format(constraint))
 
@@ -1213,6 +1222,8 @@ def gen_values_outside_bounds(constraint, size, key=random.PRNGKey(11)):
     elif isinstance(constraint, constraints.zero_sum):
         x = random.normal(key, size)
         return x
+    elif constraint is constraints.positive_definite_circulant_vector:
+        return random.normal(key, size)
     else:
         raise NotImplementedError("{} not implemented.".format(constraint))
 
@@ -2953,7 +2964,7 @@ def f(x):
         actual_arg = getattr(actual_dist, name)
         assert actual_arg is not None, f"arg {name} is None"
         if np.issubdtype(np.asarray(expected_arg).dtype, np.number):
-            assert_allclose(actual_arg, expected_arg)
+            assert_allclose(actual_arg, expected_arg, atol=1e-7)
         else:
             assert (
                 actual_arg.shape == expected_arg.shape

From 76a04d5579915ab7ec5c53f0bd0d284afb2d175f Mon Sep 17 00:00:00 2001
From: Till Hoffmann <tillahoffmann@gmail.com>
Date: Tue, 25 Feb 2025 20:14:52 -0500
Subject: [PATCH 02/12] Fix Jacobian of `RealFastFourierTransform`.

---
 numpyro/distributions/transforms.py | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/numpyro/distributions/transforms.py b/numpyro/distributions/transforms.py
index 0cbb0aa4b..10e087642 100644
--- a/numpyro/distributions/transforms.py
+++ b/numpyro/distributions/transforms.py
@@ -1311,10 +1311,15 @@ def inverse_shape(self, shape: tuple) -> tuple:
     def log_abs_det_jacobian(
         self, x: jnp.ndarray, y: jnp.ndarray, intermediates: None = None
     ) -> jnp.ndarray:
-        shape = jnp.broadcast_shapes(
+        batch_shape = jnp.broadcast_shapes(
             x.shape[: -self.transform_ndims], y.shape[: -self.transform_ndims]
         )
-        return jnp.zeros_like(x, shape=shape)
+        event_shape = x.shape[-self.transform_ndims :]
+        size = math.prod(event_shape)
+        q = math.prod(2 - size % 2 for size in event_shape)
+        return jnp.broadcast_to(
+            (size * jnp.log(size) - jnp.log(2) * (size - q)) / 2, batch_shape
+        )
 
     def tree_flatten(self):
         aux_data = {

From a3fce169ac6f88fdec4661858539da6d7af49094 Mon Sep 17 00:00:00 2001
From: Till Hoffmann <tillahoffmann@gmail.com>
Date: Tue, 25 Feb 2025 20:16:39 -0500
Subject: [PATCH 03/12] Add transform to pack and unpack Fourier coefficients.

---
 docs/source/distributions.rst       |  8 ++++
 numpyro/distributions/transforms.py | 69 +++++++++++++++++++++++++++++
 test/test_transforms.py             |  5 +++
 3 files changed, 82 insertions(+)

diff --git a/docs/source/distributions.rst b/docs/source/distributions.rst
index 0e13f2b5c..9ea8f1f1f 100644
--- a/docs/source/distributions.rst
+++ b/docs/source/distributions.rst
@@ -1006,6 +1006,14 @@ OrderedTransform
     :show-inheritance:
     :member-order: bysource
 
+PackRealFastFourierCoefficientsTransform
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+.. autoclass:: numpyro.distributions.transforms.PackRealFastFourierCoefficientsTransform
+    :members:
+    :undoc-members:
+    :show-inheritance:
+    :member-order: bysource
+
 PermuteTransform
 ^^^^^^^^^^^^^^^^
 .. autoclass:: numpyro.distributions.transforms.PermuteTransform
diff --git a/numpyro/distributions/transforms.py b/numpyro/distributions/transforms.py
index 10e087642..4a75ae2ff 100644
--- a/numpyro/distributions/transforms.py
+++ b/numpyro/distributions/transforms.py
@@ -40,6 +40,7 @@
     "LowerCholeskyTransform",
     "ScaledUnitLowerCholeskyTransform",
     "LowerCholeskyAffine",
+    "PackRealFastFourierCoefficientsTransform",
     "PermuteTransform",
     "PowerTransform",
     "RealFastFourierTransform",
@@ -1344,6 +1345,74 @@ def __eq__(self, other):
         )
 
 
+class PackRealFastFourierCoefficientsTransform(Transform):
+    """
+    Transform a real vector to complex coefficients of a real fast Fourier transform.
+
+    :param transform_shape: Shape of the real vector, defaults to the input size.
+    """
+
+    domain = constraints.real_vector
+    codomain = constraints.independent(constraints.complex, 1)
+
+    def __init__(self, transform_shape: tuple = None) -> None:
+        assert transform_shape is None or len(transform_shape) == 1, (
+            "Packing Fourier coefficients is only implemented for vectors."
+        )
+        self.shape = transform_shape
+
+    def tree_flatten(self):
+        return (), ((), {"shape": self.shape})
+
+    def forward_shape(self, shape: tuple) -> tuple:
+        *batch_shape, n = shape
+        assert self.shape is None or self.shape == (n,), (
+            f"`shape` must be `None` or `{self.shape}. Got `{shape}`."
+        )
+        n_rfft = n // 2 + 1
+        return (*batch_shape, n_rfft)
+
+    def inverse_shape(self, shape: tuple) -> tuple:
+        *batch_shape, n_rfft = shape
+        assert self.shape is not None, (
+            "Shape must be specified in `__init__` for inverse transform."
+        )
+        (n,) = self.shape
+        assert n_rfft == n // 2 + 1
+        return (*batch_shape, n)
+
+    def log_abs_det_jacobian(
+        self, x: jnp.ndarray, y: jnp.ndarray, intermediates: None = None
+    ) -> jnp.ndarray:
+        shape = jnp.broadcast_shapes(x.shape[:-1], y.shape[:-1])
+        return jnp.zeros_like(x, shape=shape)
+
+    def __call__(self, x: jnp.ndarray) -> jnp.ndarray:
+        assert self.shape is None or self.shape == x.shape[-1:]
+        n = x.shape[-1]
+        n_real = n // 2 + 1
+        n_imag = n - n_real
+        complex_dtype = jnp.result_type(x.dtype, jnp.complex64)
+        return (
+            x[..., :n_real]
+            .astype(complex_dtype)
+            .at[..., 1 : 1 + n_imag]
+            .add(1j * x[..., n_real:])
+        )
+
+    def _inverse(self, y: jnp.ndarray) -> jnp.ndarray:
+        (n,) = self.shape
+        n_real = n // 2 + 1
+        n_imag = n - n_real
+        return jnp.concatenate([y.real, y.imag[..., 1 : n_imag + 1]], axis=-1)
+
+    def __eq__(self, other) -> bool:
+        return (
+            isinstance(other, PackRealFastFourierCoefficientsTransform)
+            and self.shape == other.shape
+        )
+
+
 class RecursiveLinearTransform(Transform):
     """
     Apply a linear transformation recursively such that
diff --git a/test/test_transforms.py b/test/test_transforms.py
index bea2c768a..54c6e9449 100644
--- a/test/test_transforms.py
+++ b/test/test_transforms.py
@@ -32,6 +32,7 @@
     LowerCholeskyAffine,
     LowerCholeskyTransform,
     OrderedTransform,
+    PackRealFastFourierCoefficientsTransform,
     PermuteTransform,
     PowerTransform,
     RealFastFourierTransform,
@@ -81,6 +82,8 @@ class T(namedtuple("TestCase", ["transform_cls", "params", "kwargs"])):
     "lower_cholesky_affine": T(
         LowerCholeskyAffine, (np.array([1.0, 2.0]), np.eye(2)), dict()
     ),
+    "pack_rfft_odd": T(PackRealFastFourierCoefficientsTransform, (), dict(shape=(7,))),
+    "pack_rfft_even": T(PackRealFastFourierCoefficientsTransform, (), dict(shape=(7,))),
     "permute": T(PermuteTransform, (np.array([1, 0]),), dict()),
     "power": T(
         PowerTransform,
@@ -285,6 +288,8 @@ def test_real_fast_fourier_transform(input_shape, shape, ndims):
         (OrderedTransform(), (5,)),
         (PermuteTransform(np.roll(np.arange(7), 2)), (7,)),
         (PowerTransform(2.5), ()),
+        (PackRealFastFourierCoefficientsTransform((7,)), (7,)),
+        (PackRealFastFourierCoefficientsTransform((8,)), (8,)),
         (RealFastFourierTransform(7), (7,)),
         (RealFastFourierTransform((8, 9), 2), (8, 9)),
         (

From 72804c5c0ed6d5c9b695e692dc384a3ecb0d85d3 Mon Sep 17 00:00:00 2001
From: Till Hoffmann <tillahoffmann@gmail.com>
Date: Tue, 25 Feb 2025 20:17:02 -0500
Subject: [PATCH 04/12] Implement `CirculantNormal` using transformations.

---
 numpyro/distributions/continuous.py | 54 +++++++++++------------------
 1 file changed, 21 insertions(+), 33 deletions(-)

diff --git a/numpyro/distributions/continuous.py b/numpyro/distributions/continuous.py
index d5589db30..655da6a74 100644
--- a/numpyro/distributions/continuous.py
+++ b/numpyro/distributions/continuous.py
@@ -59,7 +59,9 @@
     CholeskyTransform,
     CorrMatrixCholeskyTransform,
     ExpTransform,
+    PackRealFastFourierCoefficientsTransform,
     PowerTransform,
+    RealFastFourierTransform,
     RecursiveLinearTransform,
     SigmoidTransform,
     ZeroSumTransform,
@@ -3070,7 +3072,7 @@ def entropy(self) -> ArrayLike:
         ) + jnp.log(self.scale)
 
 
-class CirculantNormal(Distribution):
+class CirculantNormal(TransformedDistribution):
     """
     Multivariate normal distribution with circulant covariance matrix.
 
@@ -3086,7 +3088,6 @@ class CirculantNormal(Distribution):
         "covariance_rfft": constraints.independent(constraints.positive, 1),
     }
     support = constraints.real_vector
-    pytree_data_fields = ("base_dist", "loc", "covariance_rfft")
 
     def __init__(
         self,
@@ -3098,7 +3099,7 @@ def __init__(
     ) -> None:
         # We demand a one-dimensional input, because we cannot determine the event shape
         # if only the covariance_rfft is given.
-        assert jnp.ndim(loc) > 0, "Location parameter must be at least one-dimensional."
+        assert jnp.ndim(loc) > 0, "Location parameter must have at least one dimension."
         n = jnp.shape(loc)[-1]
         assert_one_of(covariance_row=covariance_row, covariance_rfft=covariance_rfft)
 
@@ -3107,38 +3108,30 @@ def __init__(
             assert covariance_row.shape[-1] == n
             covariance_rfft = jnp.fft.rfft(covariance_row).real
             self.covariance_row = covariance_row
-        assert covariance_rfft.shape[-1] == n // 2 + 1
-
         self.loc = loc
         self.covariance_rfft = covariance_rfft
+
+        # Construct the base distribution.
+        n_real = n // 2 + 1
+        n_imag = n - n_real
+        assert self.covariance_rfft.shape[-1] == n_real
         var_rfft = (n * covariance_rfft / 2).at[..., 0].mul(2)
         if n % 2 == 0:
             var_rfft = var_rfft.at[..., -1].mul(2)
-        self.base_dist = Normal(scale=jnp.sqrt(var_rfft))
+        var_rfft = jnp.concatenate([var_rfft, var_rfft[..., 1 : 1 + n_imag]], axis=-1)
+        assert var_rfft.shape[-1] == n
+        base_distribution = Normal(scale=jnp.sqrt(var_rfft)).to_event(1)
 
-        batch_shape = jnp.broadcast_shapes(loc.shape[:-1], covariance_rfft.shape[:-1])
         super().__init__(
-            batch_shape=batch_shape, event_shape=(n,), validate_args=validate_args
-        )
-
-    @validate_sample
-    def log_prob(self, value: jnp.ndarray) -> jnp.ndarray:
-        n = value.shape[-1]
-        last_complex = (n + 1) // 2
-        value_rfft = jnp.fft.rfft(value - self.loc)
-        return (
-            self.base_dist.log_prob(value_rfft.real).sum(axis=-1)
-            + self.base_dist.log_prob(value_rfft.imag)[..., 1:last_complex].sum(axis=-1)
-            + n / 2 * jnp.log(n)
-            - jnp.log(2) * ((n - 1) // 2)
+            base_distribution,
+            [
+                PackRealFastFourierCoefficientsTransform((n,)),
+                RealFastFourierTransform((n,)).inv,
+                AffineTransform(loc, scale=1.0),
+            ],
+            validate_args=validate_args,
         )
 
-    def sample(self, key, sample_shape=()) -> jnp.ndarray:
-        key1, key2 = random.split(key)
-        z_real = self.base_dist.sample(key1, sample_shape)
-        z_imag = self.base_dist.sample(key2, sample_shape)
-        return jnp.fft.irfft(z_real + 1j * z_imag, n=self.event_shape[-1]) + self.loc
-
     @property
     def mean(self) -> jnp.ndarray:
         return self.loc
@@ -3172,10 +3165,5 @@ def infer_shapes(
 
     def entropy(self):
         (n,) = self.event_shape
-        last_complex = (n + 1) // 2
-        half_log_det = jnp.log(self.covariance_rfft[0]) / 2 + jnp.log(
-            self.covariance_rfft[1:last_complex]
-        ).sum(axis=-1)
-        if n % 2 == 0:
-            half_log_det += +jnp.log(self.covariance_rfft[-1]) / 2
-        return n * (jnp.log(2 * np.pi) + 1) / 2 + half_log_det
+        log_abs_det_jacobian = 2 * jnp.log(2) * ((n - 1) // 2) - jnp.log(n) * n
+        return self.base_dist.entropy() + log_abs_det_jacobian / 2

From 881a5a7498b4c3ef885cb6f65902700f89173f1f Mon Sep 17 00:00:00 2001
From: Till Hoffmann <tillahoffmann@gmail.com>
Date: Tue, 25 Feb 2025 20:17:45 -0500
Subject: [PATCH 05/12] Fix typo in skip reason for
 `test_generated_sample_distribution`.

---
 test/test_distributions.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/test_distributions.py b/test/test_distributions.py
index bca283df9..f1f78d11b 100644
--- a/test/test_distributions.py
+++ b/test/test_distributions.py
@@ -2759,7 +2759,7 @@ def test_generated_sample_distribution(
 
     if jax_dist not in [dist.Gumbel]:
         pytest.skip(
-            "{} sampling method taken from upstream, no need to"
+            "{} sampling method taken from upstream, no need to "
             "test generated samples.".format(jax_dist.__name__)
         )
 

From 394846c243c2a8244c4b02c52e3285a0dbc636fb Mon Sep 17 00:00:00 2001
From: Till Hoffmann <tillahoffmann@gmail.com>
Date: Wed, 26 Feb 2025 11:55:19 -0500
Subject: [PATCH 06/12] Add `CirculantNormal` example notebook.

---
 docs/source/index.rst               |   1 +
 notebooks/source/circulant_gp.ipynb | 286 ++++++++++++++++++++++++++++
 2 files changed, 287 insertions(+)
 create mode 100644 notebooks/source/circulant_gp.ipynb

diff --git a/docs/source/index.rst b/docs/source/index.rst
index 367cb45e0..4e956aaed 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -39,6 +39,7 @@ NumPyro documentation
    tutorials/censoring
    tutorials/hsgp_example
    tutorials/other_samplers
+   tutorials/circulant_gp
 
 .. nbgallery::
    :maxdepth: 1
diff --git a/notebooks/source/circulant_gp.ipynb b/notebooks/source/circulant_gp.ipynb
new file mode 100644
index 000000000..d64a5b76c
--- /dev/null
+++ b/notebooks/source/circulant_gp.ipynb
@@ -0,0 +1,286 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Fast Gaussian Process Inference Using Circulant Normal Distributions\n",
+    "\n",
+    "[Gaussian processes](https://en.wikipedia.org/wiki/Gaussian_process) (GPs) are powerful distributions for modeling functional data, but using them is computationally challenging except for small datasets. [Fast Fourier](https://en.wikipedia.org/wiki/Fast_Fourier_transform) methods can evaluate the likelihood efficiently if data lie on a regular grid. In this notebook, we use the `CirculantNormal` distribution to infer a latent GP with binary observations and compare with the standard `MultivariateNormal`.\n",
+    "\n",
+    "**tl;dr**: Using a `CirculantNormal` gives at least a ~10x speed up in terms of effective number of samples per second even for a small GP of 64 elements. \n",
+    "\n",
+    "We consider a latent Gaussian process $z(x)$ on a regular grid $x$ which encodes the log odds of binary outcomes $y$. More formally, the model is defined as\n",
+    "$$\\begin{aligned}\n",
+    "z&\\sim\\mathsf{MultivariateNormal}\\left(0, K\\right)\\\\\n",
+    "y&\\sim\\mathsf{Bernoulli}\\left(\\mathrm{expit} (z)\\right),\n",
+    "\\end{aligned}$$\n",
+    "where $\\mathrm{expit}(z) = 1/\\left(1 + \\exp(-z)\\right)$ denotes the [logistic sigmoid](https://en.wikipedia.org/wiki/Sigmoid_function) and $K$ is the covariance matrix between elements of the Gaussian process evaluated on the grid. We use a [squared exponential kernel](https://www.cs.toronto.edu/~duvenaud/cookbook/) $k$ such that\n",
+    "$$\\begin{aligned}\n",
+    "K_{ij}&=k\\left(x_i,x_j\\right) + \\epsilon \\delta_{ij}\\\\\n",
+    "&=\\sigma^2\\exp\\left(-\\frac{d\\left(x_i, x_j\\right)}{2\\ell^2}\\right) \\epsilon \\delta_{ij},\n",
+    "\\end{aligned}$$\n",
+    "where $\\sigma$ is the marginal scale of the Gaussian process, $d\\left(x_i, x_j\\right)$ is the distance between $x_i$ and $x_j$, and $\\ell$ is the correlation length of the kernel. We add a so-called \"nugget variance\" $\\epsilon={10}^{-4}$ to the diagonal of the covariance matrix to ensure it is numerically positive definite.\n",
+    "\n",
+    "The `CirculantNormal` distribution requires a [circulant](https://en.wikipedia.org/wiki/Circulant_matrix) covariance, i.e., one with periodic boundary conditions. Not all kernels can be represented, but the effect of boundary can be mitigated by [padding the domain](https://gptools-stan.readthedocs.io/docs/padding/padding.html)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install -q numpyro@git+https://github.com/pyro-ppl/numpyro matplotlib"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Generating Synthetic Data\n",
+    "\n",
+    "In this example, we consider $n=64$ regularly spaced observations, correlation length $\\ell=5$, and marginal scale $\\sigma=2$. Depending on the `method` argument in the model below, a `CirculantNormal` or `MultivariateNormal` is used to sample $z$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from time import time\n",
+    "\n",
+    "from matplotlib import pyplot as plt\n",
+    "\n",
+    "import jax\n",
+    "from jax import numpy as jnp, random\n",
+    "from jax.scipy.special import expit\n",
+    "\n",
+    "import numpyro\n",
+    "from numpyro import distributions as dist\n",
+    "\n",
+    "\n",
+    "def model(x: jnp.ndarray, y: jnp.ndarray = None, *, method: str):\n",
+    "    \"\"\"\n",
+    "    Latent Gaussian process model with binary outcomes.\n",
+    "\n",
+    "    Args:\n",
+    "        x: Observation grid.\n",
+    "        y: Binary outcomes.\n",
+    "        method: Likelihood evaluation method.\n",
+    "    \"\"\"\n",
+    "    n = x.size\n",
+    "\n",
+    "    # Sample parameters and evaluate the kernel.\n",
+    "    sigma = numpyro.sample(\"sigma\", dist.HalfCauchy())\n",
+    "    length_scale = numpyro.sample(\"length_scale\", dist.InverseGamma(5, 25))\n",
+    "    eps = 1e-4\n",
+    "\n",
+    "    if method == \"circulant\":\n",
+    "        # We can evaluate the rfft of the covariance matrix directly. This both saves us\n",
+    "        # some computation and is more numerically stable.\n",
+    "        nrfft = n // 2 + 1\n",
+    "        k = jnp.arange(nrfft)\n",
+    "        covariance_rfft = (\n",
+    "            sigma**2\n",
+    "            * length_scale\n",
+    "            * jnp.sqrt(2 * jnp.pi)\n",
+    "            * jnp.exp(-2 * (jnp.pi * k * length_scale / n) ** 2)\n",
+    "        ) + eps\n",
+    "        zdist = dist.CirculantNormal(jnp.zeros(n), covariance_rfft=covariance_rfft)\n",
+    "    elif method == \"cholesky\":\n",
+    "        # Evaluate the covariance matrix.\n",
+    "        distance = jnp.abs(x[:, None] - x)\n",
+    "        distance = jnp.minimum(distance, n - distance)\n",
+    "        covariance_matrix = sigma ** 2 * jnp.exp(- distance ** 2 / (2 * length_scale ** 2)) + eps * jnp.eye(n)\n",
+    "        zdist = dist.MultivariateNormal(covariance_matrix=covariance_matrix)\n",
+    "    z = numpyro.sample(\"z\", zdist)\n",
+    "\n",
+    "    with numpyro.plate(\"n\", n):\n",
+    "        numpyro.sample(\"y\", dist.BernoulliLogits(z), obs=y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Having defined the model, we use a `substitute` handler to specify the parameters for synthetic data, initialize a random number key with a `seed` handler, record the model execution with a `trace` handler, and visualize the synthetic data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 921.6x691.2 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Sample from the prior predictive.\n",
+    "with (\n",
+    "    numpyro.handlers.trace() as trace,\n",
+    "    numpyro.handlers.substitute(data={\"sigma\": 2, \"length_scale\": 5}),\n",
+    "    numpyro.handlers.seed(rng_seed=9),\n",
+    "):\n",
+    "    x = jnp.arange(64)\n",
+    "    model(x, method=\"circulant\")\n",
+    "y = trace[\"y\"][\"value\"]\n",
+    "\n",
+    "# Plot the synthetic data.\n",
+    "def plot_data(x, trace, ax):\n",
+    "    ax.plot(\n",
+    "        x, expit(trace[\"z\"][\"value\"]), label=\"latent Gaussian process $z(x)$\", color=\"k\"\n",
+    "    )\n",
+    "    ax.scatter(\n",
+    "        x,  y,  label=\"binary observations $y$\", alpha=0.5, edgecolor=\"none\", color=\"k\"\n",
+    "    )\n",
+    "    ax.set_xlabel(\"covariate $x$\")\n",
+    "\n",
+    "fig, ax = plt.subplots()\n",
+    "plot_data(x, trace, ax=ax)\n",
+    "ax.legend()\n",
+    "fig.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Sampling From the Posterior\n",
+    "\n",
+    "We use a [No-U-Turn-Sampler (NUTS)](https://www.jmlr.org/papers/volume15/hoffman14a/hoffman14a.pdf) to draw samples from the posterior using each of the two methods. We also record the effective number of samples per second, a common metric for evaluating the performance of samplers."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "sample: 100%|█████████████████████████████████████████████████████████████████████| 600/600 [00:03<00:00, 186.99it/s, 1023 steps of size 4.98e-03. acc. prob=0.81]\n",
+      "sample: 100%|██████████████████████████████████████████████████████████████████████| 600/600 [01:59<00:00,  5.03it/s, 1023 steps of size 4.17e-03. acc. prob=0.86]\n"
+     ]
+    }
+   ],
+   "source": [
+    "samples_by_method = {}\n",
+    "n_eff_per_second_by_method = {}\n",
+    "for method in [\"circulant\", \"cholesky\"]:\n",
+    "    # Sample from the posterior using the NUTS kernel and record the duration.\n",
+    "    kernel = numpyro.infer.NUTS(model)\n",
+    "    mcmc = numpyro.infer.MCMC(kernel, num_warmup=500, num_samples=100)\n",
+    "    start = time()\n",
+    "    mcmc.run(random.key(9), x, trace[\"y\"][\"value\"], method=method)\n",
+    "    duration = time() - start\n",
+    "\n",
+    "    # Calculate the number of effective samples per second.\n",
+    "    samples_by_method[method] = mcmc.get_samples()\n",
+    "    n_eff_per_second_by_method[method] = {\n",
+    "        name: site[\"n_eff\"] / duration\n",
+    "        for name, site\n",
+    "        in numpyro.diagnostics.summary(mcmc.get_samples(group_by_chain=True)).items()\n",
+    "    }"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Having drawn posterior samples, we visualize them and compare with the synthetic data we fit the model to. The plot below shows the posterior median as a line and a band from the 5th to 95th percentile."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 921.6x691.2 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots()\n",
+    "plot_data(x, trace, ax=ax)\n",
+    "for method, samples in samples_by_method.items():\n",
+    "    lower, median, upper = jnp.percentile(expit(samples[\"z\"]), jnp.array([5, 50.0, 95]), axis=0)\n",
+    "    (line,) = ax.plot(x, median, label=method)\n",
+    "    ax.fill_between(x, lower, upper, color=line.get_color(), alpha=0.2)\n",
+    "\n",
+    "ax.legend(loc=\"center left\", bbox_to_anchor=(0, 0.7))\n",
+    "fig.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "So how well did we do? The runtime is about 40x faster using the `CirculantNormal`. The number of effective samples per second varies between parameters, but we observe a 15x to 140x improvement depending on the parameter. Experiments were run on a 2020 Macbook Pro with M1 chip."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "speedup for `length_scale`: min = 10.97, mean = 10.97, max = 10.97\n",
+      "speedup for `sigma`: min = 63.37, mean = 63.37, max = 63.37\n",
+      "speedup for `z`: min = 16.27, mean = 51.68, max = 140.84\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Report the speed up due to using the `CirculantNormal`.\n",
+    "speedups = jax.tree.map(jnp.divide, *n_eff_per_second_by_method.values())\n",
+    "for site, speedup in speedups.items():\n",
+    "    print(\n",
+    "        f\"speedup for `{site}`: min = {speedup.min():.2f}, \"\n",
+    "        f\"mean = {speedup.mean():.2f}, max = {speedup.max():.2f}\"\n",
+    "    )"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

From c3e286fba7aefe62d20bc6a43175b0d931398f60 Mon Sep 17 00:00:00 2001
From: Till Hoffmann <tillahoffmann@gmail.com>
Date: Wed, 26 Feb 2025 12:13:02 -0500
Subject: [PATCH 07/12] Fix `noqa` comment.

---
 notebooks/source/conf.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/notebooks/source/conf.py b/notebooks/source/conf.py
index 39567245b..f040361b1 100644
--- a/notebooks/source/conf.py
+++ b/notebooks/source/conf.py
@@ -78,7 +78,7 @@
 
 if "READTHEDOCS" not in os.environ:
     # if developing locally, use numpyro.__version__ as version
-    from numpyro import __version__  # noqaE402
+    from numpyro import __version__  # noqa: E402
 
     version = __version__
 

From 19677ddcf222f779b313e8d16c77e955f7f43fd3 Mon Sep 17 00:00:00 2001
From: Till Hoffmann <tillahoffmann@gmail.com>
Date: Wed, 26 Feb 2025 12:15:25 -0500
Subject: [PATCH 08/12] Reformat `circulant_gp` example notebook.

---
 notebooks/source/circulant_gp.ipynb | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

diff --git a/notebooks/source/circulant_gp.ipynb b/notebooks/source/circulant_gp.ipynb
index d64a5b76c..8cd091d16 100644
--- a/notebooks/source/circulant_gp.ipynb
+++ b/notebooks/source/circulant_gp.ipynb
@@ -93,7 +93,9 @@
     "        # Evaluate the covariance matrix.\n",
     "        distance = jnp.abs(x[:, None] - x)\n",
     "        distance = jnp.minimum(distance, n - distance)\n",
-    "        covariance_matrix = sigma ** 2 * jnp.exp(- distance ** 2 / (2 * length_scale ** 2)) + eps * jnp.eye(n)\n",
+    "        covariance_matrix = sigma**2 * jnp.exp(\n",
+    "            -(distance**2) / (2 * length_scale**2)\n",
+    "        ) + eps * jnp.eye(n)\n",
     "        zdist = dist.MultivariateNormal(covariance_matrix=covariance_matrix)\n",
     "    z = numpyro.sample(\"z\", zdist)\n",
     "\n",
@@ -135,16 +137,18 @@
     "    model(x, method=\"circulant\")\n",
     "y = trace[\"y\"][\"value\"]\n",
     "\n",
+    "\n",
     "# Plot the synthetic data.\n",
     "def plot_data(x, trace, ax):\n",
     "    ax.plot(\n",
     "        x, expit(trace[\"z\"][\"value\"]), label=\"latent Gaussian process $z(x)$\", color=\"k\"\n",
     "    )\n",
     "    ax.scatter(\n",
-    "        x,  y,  label=\"binary observations $y$\", alpha=0.5, edgecolor=\"none\", color=\"k\"\n",
+    "        x, y, label=\"binary observations $y$\", alpha=0.5, edgecolor=\"none\", color=\"k\"\n",
     "    )\n",
     "    ax.set_xlabel(\"covariate $x$\")\n",
     "\n",
+    "\n",
     "fig, ax = plt.subplots()\n",
     "plot_data(x, trace, ax=ax)\n",
     "ax.legend()\n",
@@ -189,8 +193,9 @@
     "    samples_by_method[method] = mcmc.get_samples()\n",
     "    n_eff_per_second_by_method[method] = {\n",
     "        name: site[\"n_eff\"] / duration\n",
-    "        for name, site\n",
-    "        in numpyro.diagnostics.summary(mcmc.get_samples(group_by_chain=True)).items()\n",
+    "        for name, site in numpyro.diagnostics.summary(\n",
+    "            mcmc.get_samples(group_by_chain=True)\n",
+    "        ).items()\n",
     "    }"
    ]
   },
@@ -221,7 +226,9 @@
     "fig, ax = plt.subplots()\n",
     "plot_data(x, trace, ax=ax)\n",
     "for method, samples in samples_by_method.items():\n",
-    "    lower, median, upper = jnp.percentile(expit(samples[\"z\"]), jnp.array([5, 50.0, 95]), axis=0)\n",
+    "    lower, median, upper = jnp.percentile(\n",
+    "        expit(samples[\"z\"]), jnp.array([5, 50.0, 95]), axis=0\n",
+    "    )\n",
     "    (line,) = ax.plot(x, median, label=method)\n",
     "    ax.fill_between(x, lower, upper, color=line.get_color(), alpha=0.2)\n",
     "\n",

From 81c9beecc233e3da97b4cc6fa5501e8f5c3fcf5c Mon Sep 17 00:00:00 2001
From: Till Hoffmann <tillahoffmann@gmail.com>
Date: Wed, 26 Feb 2025 12:49:44 -0500
Subject: [PATCH 09/12] Fix keyword argument for
 `PackRealFastFourierCoefficientsTransform` test.

---
 test/test_transforms.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/test/test_transforms.py b/test/test_transforms.py
index 54c6e9449..4c4b39d9c 100644
--- a/test/test_transforms.py
+++ b/test/test_transforms.py
@@ -82,8 +82,12 @@ class T(namedtuple("TestCase", ["transform_cls", "params", "kwargs"])):
     "lower_cholesky_affine": T(
         LowerCholeskyAffine, (np.array([1.0, 2.0]), np.eye(2)), dict()
     ),
-    "pack_rfft_odd": T(PackRealFastFourierCoefficientsTransform, (), dict(shape=(7,))),
-    "pack_rfft_even": T(PackRealFastFourierCoefficientsTransform, (), dict(shape=(7,))),
+    "pack_rfft_odd": T(
+        PackRealFastFourierCoefficientsTransform, (), dict(transform_shape=(7,))
+    ),
+    "pack_rfft_even": T(
+        PackRealFastFourierCoefficientsTransform, (), dict(transform_shape=(7,))
+    ),
     "permute": T(PermuteTransform, (np.array([1, 0]),), dict()),
     "power": T(
         PowerTransform,

From 9f6dee2156c25980a61e76f2e710b186e52b50b7 Mon Sep 17 00:00:00 2001
From: Till Hoffmann <tillahoffmann@gmail.com>
Date: Thu, 27 Feb 2025 14:35:01 -0500
Subject: [PATCH 10/12] Fix batch shape for mean, covariance_row,
 covariance_matrix.

---
 numpyro/distributions/continuous.py | 16 +++++++++++-----
 test/test_distributions.py          | 21 +++++++++++++++++++--
 2 files changed, 30 insertions(+), 7 deletions(-)

diff --git a/numpyro/distributions/continuous.py b/numpyro/distributions/continuous.py
index 655da6a74..bf3292b65 100644
--- a/numpyro/distributions/continuous.py
+++ b/numpyro/distributions/continuous.py
@@ -3107,7 +3107,8 @@ def __init__(
         if covariance_rfft is None:
             assert covariance_row.shape[-1] == n
             covariance_rfft = jnp.fft.rfft(covariance_row).real
-            self.covariance_row = covariance_row
+            shape = jnp.broadcast_shapes(loc.shape, covariance_row.shape)
+            self.covariance_row = jnp.broadcast_to(covariance_row, shape)
         self.loc = loc
         self.covariance_rfft = covariance_rfft
 
@@ -3134,17 +3135,22 @@ def __init__(
 
     @property
     def mean(self) -> jnp.ndarray:
-        return self.loc
+        return jnp.broadcast_to(self.loc, self.shape())
 
     @lazy_property
     def covariance_row(self) -> jnp.ndarray:
-        return jnp.fft.irfft(self.covariance_rfft, n=self.event_shape[-1])
+        return jnp.broadcast_to(
+            jnp.fft.irfft(self.covariance_rfft, n=self.event_shape[-1]), self.shape()
+        )
 
     @lazy_property
     def covariance_matrix(self) -> jnp.ndarray:
         if self.batch_shape:
-            # toeplitz flattens the input, and we need to broadcast manually.
-            return vmap(toeplitz, range(len(self.batch_shape)))(self.covariance_row)
+            # `toeplitz` flattens the input, and we need to broadcast manually.
+            (n,) = self.event_shape
+            return vmap(toeplitz)(self.covariance_row.reshape((-1, n))).reshape(
+                self.batch_shape + (n, n)
+            )
         else:
             return toeplitz(self.covariance_row)
 
diff --git a/test/test_distributions.py b/test/test_distributions.py
index f1f78d11b..c08acaefb 100644
--- a/test/test_distributions.py
+++ b/test/test_distributions.py
@@ -493,8 +493,25 @@ def get_sp_dist(jax_dist):
     T(dist.Cauchy, 0.0, 1.0),
     T(dist.Cauchy, 0.0, np.array([1.0, 2.0])),
     T(dist.Cauchy, np.array([0.0, 1.0]), np.array([[1.0], [2.0]])),
-    T(dist.CirculantNormal, np.zeros(4), np.array([0.9, 0.2, 0.1, 0.2]), None),
-    T(dist.CirculantNormal, np.zeros(5), np.array([0.9, 0.2, 0.1, 0.1, 0.2]), None),
+    T(dist.CirculantNormal, np.zeros((3, 4)), np.array([0.9, 0.2, 0.1, 0.2]), None),
+    T(
+        dist.CirculantNormal,
+        np.zeros((7, 5)),
+        np.array([0.9, 0.2, 0.1, 0.1, 0.2]),
+        None,
+    ),
+    T(
+        dist.CirculantNormal,
+        np.zeros(4),
+        np.broadcast_to(np.array([0.9, 0.2, 0.1, 0.2]), (3, 4)),
+        None,
+    ),
+    T(
+        dist.CirculantNormal,
+        np.zeros(5),
+        np.broadcast_to(np.array([0.9, 0.2, 0.1, 0.1, 0.2]), (7, 5)),
+        None,
+    ),
     T(dist.Dirichlet, np.array([1.7])),
     T(dist.Dirichlet, np.array([0.2, 1.1])),
     T(dist.Dirichlet, np.array([[0.2, 1.1], [2.0, 2.0]])),

From c6e50924eabdbec066a6a71e28b1de5d2e2bd657 Mon Sep 17 00:00:00 2001
From: Till Hoffmann <tillahoffmann@gmail.com>
Date: Thu, 27 Feb 2025 14:41:30 -0500
Subject: [PATCH 11/12] Add analytic KL divergence of diagonal `Normal` from
 `CirculantNormal`.

---
 numpyro/distributions/kl.py | 22 ++++++++++++++++++++++
 test/test_distributions.py  | 19 +++++++++++++++++++
 2 files changed, 41 insertions(+)

diff --git a/numpyro/distributions/kl.py b/numpyro/distributions/kl.py
index 1f43ba5ae..07e3d64f6 100644
--- a/numpyro/distributions/kl.py
+++ b/numpyro/distributions/kl.py
@@ -33,6 +33,7 @@
 
 from numpyro.distributions.continuous import (
     Beta,
+    CirculantNormal,
     Dirichlet,
     Gamma,
     Kumaraswamy,
@@ -183,6 +184,27 @@ def _shapes_are_broadcastable(first_shape, second_shape):
     return 0.5 * (tr + t1 - D - log_det_ratio)
 
 
+@dispatch(Independent, CirculantNormal)
+def kl_divergence(p: Independent, q: CirculantNormal):
+    # We can only calculate the KL divergence if the base distribution is normal.
+    if not isinstance(p.base_dist, Normal) or p.reinterpreted_batch_ndims != 1:
+        raise NotImplementedError
+
+    residual = q.mean - p.mean
+    n = residual.shape[-1]
+    log_covariance_rfft = jnp.log(q.covariance_rfft)
+    return (
+        jnp.vecdot(
+            residual, jnp.fft.irfft(jnp.fft.rfft(residual) / q.covariance_rfft, n)
+        )
+        + jnp.fft.irfft(1 / q.covariance_rfft, n)[..., 0] * jnp.sum(p.variance, axis=-1)
+        + log_covariance_rfft.sum(axis=-1)
+        + log_covariance_rfft[..., 1 : (n + 1) // 2].sum(axis=-1)
+        - jnp.log(p.variance).sum(axis=-1)
+        - n
+    ) / 2
+
+
 @dispatch(Beta, Beta)
 def kl_divergence(p, q):
     # From https://en.wikipedia.org/wiki/Beta_distribution#Quantities_of_information_(entropy)
diff --git a/test/test_distributions.py b/test/test_distributions.py
index c08acaefb..3b0d008ad 100644
--- a/test/test_distributions.py
+++ b/test/test_distributions.py
@@ -3185,6 +3185,25 @@ def make_dist(dist_class):
     assert_allclose(actual, expected, rtol=0.05)
 
 
+@pytest.mark.parametrize("shape", [(3, 2, 10), (3, 2, 11), (10,), (11,)], ids=str)
+def test_kl_circulant_normal_consistency(shape: tuple) -> None:
+    key1, key2, key3, key4 = random.split(random.key(9), 4)
+    p = dist.Normal(random.normal(key1, shape), random.gamma(key2, 3, shape)).to_event(
+        1
+    )
+    # covariance_rfft = jnp.exp(-jnp.arange(shape[-1] // 2 + 1))
+    covariance_rfft = random.gamma(key4, 10, shape[:-1] + (shape[-1] // 2 + 1,)) / 10
+    q = dist.CirculantNormal(
+        random.normal(key3, shape), covariance_rfft=covariance_rfft
+    )
+    actual = kl_divergence(p, q)
+    expected = kl_divergence(
+        dist.MultivariateNormal(p.mean, jnp.eye(shape[-1]) * p.variance[..., None]),
+        dist.MultivariateNormal(q.mean, q.covariance_matrix),
+    )
+    assert_allclose(actual, expected, rtol=1e-6)
+
+
 @pytest.mark.parametrize("shape", [(4,), (2, 3)], ids=str)
 def test_kl_dirichlet_dirichlet(shape):
     p = dist.Dirichlet(np.exp(np.random.normal(size=shape)))

From 94c0409e31602e5bd0dce99401d618d29eec6b83 Mon Sep 17 00:00:00 2001
From: Till Hoffmann <tillahoffmann@gmail.com>
Date: Thu, 27 Feb 2025 14:46:52 -0500
Subject: [PATCH 12/12] Fix sign bug in `_PositiveDefiniteCirculantVector`
 validity check.

---
 numpyro/distributions/constraints.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/numpyro/distributions/constraints.py b/numpyro/distributions/constraints.py
index 37fc08333..f8a11e1bb 100644
--- a/numpyro/distributions/constraints.py
+++ b/numpyro/distributions/constraints.py
@@ -650,7 +650,7 @@ def __call__(self, x):
         jnp = np if isinstance(x, (np.ndarray, np.generic)) else jax.numpy
         tol = 10 * jnp.finfo(x.dtype).eps
         rfft = jnp.fft.rfft(x)
-        return (jnp.abs(rfft.imag) < tol) & (rfft.real > tol)
+        return (jnp.abs(rfft.imag) < tol) & (rfft.real > -tol)
 
     def feasible_like(self, prototype):
         return jnp.zeros_like(prototype).at[..., 0].set(1.0)