Skip to content

Model syntax ​

Build a regression with several predictors, shared group effects and reusable components from one @brm declaration. The examples use named tuples; a data frame works too. Columns may have different lengths when they describe different observation or group axes.

This model predicts both the mean and the standard deviation. The subject's intercept and slope are correlated, and the scale stays positive through its explicit log link.

brm-comparison
Mean and scale regression
panes: brm|stanblocks|rkppl|stan|jax:3
julia
using BayesianRegressionModels

builder = @brm begin
    mu ~ 1 + x + (1 + x | person | subject)
    log(sigma) ~ 1 + x
    y ~ Normal(mu, sigma)

    effect(mu, :) ~ Normal(0, 1)
    effect(sigma, Intercept) ~ Normal(-1, 0.5)
    effect(sigma, x) ~ Normal(0, 0.2)
    sd(:, person) ~ Exponential(0.5)
    cor(:, person) ~ LKJCholesky(2, 2)
end
data = (; subject=["a", "a", "b", "b", "c", "c"],
          x=[-1., 1., -1., 1., -1., 1.],
          y=[-0.6, 0.9, -0.2, 1.4, -0.8, 0.5])
model = builder(data)
julia
SBBRMI with data keys = [:b_person_subject_lkj_eta, :col_idx_mu_person_subject, :n_subject, :n_terms_person_subject, :subject_idx, :x, :y]
configured submodels:
ranef_correlated_draws_generic_configured_1 = Base.merge(BayesianRegressionModels.ranef_correlated_draws_generic, quote
            tau ~ (StanBlocks.builtin.restricted)(exponential, 1.0 ./ 0.5; n = n_terms, lower = 0.0)
        end)
emitted @slic body:
begin
    b_person_subject ~ ranef_correlated_draws_generic_configured_1(; group_idx = subject_idx, n_groups = n_subject, n_terms = n_terms_person_subject, lkj_eta = b_person_subject_lkj_eta)
    X_mu = hcat(rep_vector(1.0, num_elements(x)), x)
    pop_mu ~ _popefs_normal(; X = X_mu, beta_loc = [0, 0], beta_scale = [1, 1])
    Z_mu_person_subject = hcat(rep_vector(1.0, num_elements(x)), x)
    r_mu_person_subject = rows_dot_product(Z_mu_person_subject, b_person_subject[subject_idx, col_idx_mu_person_subject])
    mu = pop_mu + r_mu_person_subject
    X_log_sigma = hcat(rep_vector(1.0, num_elements(x)), x)
    pop_log_sigma ~ _popefs_normal(; X = X_log_sigma, beta_loc = [-1, 0], beta_scale = [0.5, 0.2])
    log_sigma = pop_log_sigma
    sigma = exp(log_sigma)
    y ~ normal(mu, sigma)
end
julia
"""
Group-level (varying) effects of grouping `g`, `K` correlated margins per level.

Non-centered, from the scales `tau[1:K]` (drawn from their priors), the Cholesky factor of the margins' correlation `L ~ LKJCholesky(K, eta)` and standardized effects
`z[1:length(levels(g)), 1:K] ~ Normal(0, 1)`. Returns the
level-by-margin matrix `z * transpose(tau .* L)`, one row per level of `g` in order.
"""
brm_correlated_group_effects(g, K, eta) = begin
        tau[1:K] .~ Exponential.(0.5)
        L ~ LKJCholesky(K, eta)
        z[1:length(levels(g)), 1:K] .~ Normal.(0, 1)
        return z * transpose(tau .* L)
    end

"""
Population-level effects: one coefficient per column of the design matrix `X`.

Draws `beta_pop[1:ncoef] ~ Normal(loc, scale)` and returns the linear predictor
`X * beta_pop`. `ncoef` is the number of columns of `X`. Each prior argument (`loc`, `scale`) is one value for all coefficients or a vector with one per coefficient.
"""
brm_population_effects(X, ncoef, loc, scale) = begin
        beta_pop[1:ncoef] .~ Normal.(loc, scale)
        return X * beta_pop
    end

begin
    subject_fit_levels = brm_fit_levels(subject_fit)
    b_person_subject ~ brm_correlated_group_effects(subject_fit_levels, 2, bucket_person_subject_lkj_eta)
    subject_level = brm_level_indices(subject, subject_fit_levels)
    ranef_mu_person_subject = b_person_subject[subject_level, 1] .+ b_person_subject[subject_level, 2] .* x
    X_mu = hcat(ones(length(subject)), x)
    pop_mu ~ brm_population_effects(X_mu, 2, 0.0, 1.0)
    mu = pop_mu .+ ranef_mu_person_subject
    X_log_sigma = hcat(ones(length(x)), x)
    pop_log_sigma ~ brm_population_effects(X_log_sigma, 2, [-1.0, 0.0], [0.5, 0.2])
    log_sigma = pop_log_sigma
    sigma = exp.(log_sigma)
    y .~ Normal.(mu, exp.(log_sigma))
end
stan
functions {
matrix hcat(
    vector x,
    vector y
) {
    int n = dims(x)[1];
    if (dims(y)[1] != n) reject("hcat: dim mismatch — `y` dim 1 (= ", dims(y)[1], ") does not match `n` (= ", n, "), inferred from `x` dim 1. `n` sizes: `x` dim 1 (= ", dims(x)[1], "), `y` dim 1 (= ", dims(y)[1], ").");
    return append_col(x, y);
}
vector normal_lpdfs(
    vector obs,
    vector loc,
    vector scale
) {
    return jbroadcasted_normal_lpdfs(obs, loc, scale);
}
vector jbroadcasted_normal_lpdfs(
    vector x1,
    vector x2,
    vector x3
) {
    int n = dims(x1)[1];
    vector[n] rv;
    for(i in 1:n) {
        rv[i] = normal_lpdfs(broadcasted_getindex(x1, i), broadcasted_getindex(x2, i), broadcasted_getindex(x3, i));
    }
    return rv;
}
real normal_lpdfs(
    real args1,
    real args2,
    real args3
) {
    return normal_lpdf(args1 | args2, args3);
}
real broadcasted_getindex(vector x, int i) {
    return x[i];
}
vector normal_vector_rng(
    int anontok__1,
    vector a,
    vector b
) {
    int n = anontok__1;
    if((n == 0)) {
        vector[n] rv;
        return rv;
    } else {
        return to_vector(normal_rng(a, b));
    }
}
}
data {
    int n_terms_person_subject;
    real b_person_subject_lkj_eta;
    int n_subject;
    int x_n;
    vector[x_n] x;
    int subject_idx_n;
    int col_idx_mu_person_subject_n;
    array[subject_idx_n] int subject_idx;
    array[col_idx_mu_person_subject_n] int col_idx_mu_person_subject;
    int y_n;
    vector[y_n] y;
}
transformed data {
    matrix[x_n, 2] X_mu = hcat(rep_vector(1.0, num_elements(x)), x);
    int pop_mu_n_covariates = 2;
    matrix[x_n, 2] Z_mu_person_subject = hcat(rep_vector(1.0, num_elements(x)), x);
    matrix[x_n, 2] X_log_sigma = hcat(rep_vector(1.0, num_elements(x)), x);
    int pop_log_sigma_n_covariates = 2;
}
parameters {
    cholesky_factor_corr[n_terms_person_subject] b_person_subject_L;
    vector<lower=0.0>[n_terms_person_subject] b_person_subject_tau;
    vector[(n_terms_person_subject * n_subject)] b_person_subject_z_flat;
    vector[pop_mu_n_covariates] pop_mu_beta_pop;
    vector[pop_log_sigma_n_covariates] pop_log_sigma_beta_pop;
}
transformed parameters {
    matrix[n_terms_person_subject, n_subject] b_person_subject_z = to_matrix(b_person_subject_z_flat, n_terms_person_subject, n_subject);
    matrix[n_subject, n_terms_person_subject] b_person_subject = ((diag_pre_multiply(b_person_subject_tau, b_person_subject_L) * b_person_subject_z)');
    vector[x_n] pop_mu = (X_mu * pop_mu_beta_pop);
    vector[subject_idx_n] r_mu_person_subject = rows_dot_product(Z_mu_person_subject, b_person_subject[subject_idx, col_idx_mu_person_subject]);
    vector[x_n] mu = (pop_mu + r_mu_person_subject);
    vector[x_n] pop_log_sigma = (X_log_sigma * pop_log_sigma_beta_pop);
    vector[x_n] log_sigma = pop_log_sigma;
    vector[x_n] sigma = exp(log_sigma);
}
model {
    b_person_subject_L ~ lkj_corr_cholesky(b_person_subject_lkj_eta);
    b_person_subject_tau ~ exponential((1.0 ./ 0.5));
    b_person_subject_z_flat ~ std_normal();
    pop_mu_beta_pop ~ normal([0, 0]', [1, 1]');
    pop_log_sigma_beta_pop ~ normal([-1, 0]', [0.5, 0.2]');
    y ~ normal(mu, sigma);
}
generated quantities {
    vector[y_n] y_likelihood = normal_lpdfs(y, mu, sigma);
    vector[y_n] y_gen = normal_vector_rng(y_n, mu, sigma);
}
julia
using ReactiveKernels, ReactiveKernelsPPL
rk = RKBRMI(model)
source = jax_source(rk.model, rk_bound_plan(rk))
write("model.py", source)
inputs = rk_bound_data(rk, source)   # exactly the inputs prepare_data reads
python
import jax
import model as m

prepared = m.prepare_data(**inputs)
lp = m.log_density(u, **prepared)               # u: unconstrained, length m.dimension(prepared)
lp = jax.jit(m.log_density)(u, **prepared)      # one compiled function for every dataset of these shapes
python
"""Generated by ReactiveKernelsPPL.jax_source from a built @rkppl program; do not edit.

Data: X_log_sigma, bucket_person_subject_lkj_eta, subject, subject_fit, x, y.

Model documentation:

- `b_person_subject`: Group-level (varying) effects of grouping `g`, `K` correlated margins per level.

  Non-centered, from the scales `tau[1:K]` (drawn from their priors), the Cholesky factor of the margins' correlation `L ~ LKJCholesky(K, eta)` and standardized effects
  `z[1:length(levels(g)), 1:K] ~ Normal(0, 1)`. Returns the
  level-by-margin matrix `z * transpose(tau .* L)`, one row per level of `g` in order.
- `pop_mu`: Population-level effects: one coefficient per column of the design matrix `X`.

  Draws `beta_pop[1:ncoef] ~ Normal(loc, scale)` and returns the linear predictor
  `X * beta_pop`. `ncoef` is the number of columns of `X`. Each prior argument (`loc`, `scale`) is one value for all coefficients or a vector with one per coefficient.
- `pop_log_sigma`: Population-level effects: one coefficient per column of the design matrix `X`.

  Draws `beta_pop[1:ncoef] ~ Normal(loc, scale)` and returns the linear predictor
  `X * beta_pop`. `ncoef` is the number of columns of `X`. Each prior argument (`loc`, `scale`) is one value for all coefficients or a vector with one per coefficient.
"""
import numpy as np
import scipy.special as ssp
from typing import Any

import jax
import jax.numpy as jnp
import jax.scipy.linalg
import jax.scipy.special as jsp
from jax.typing import ArrayLike

jax.config.update("jax_enable_x64", True)

DATA = {"X_log_sigma": {"dtype": "float64", "ndim": 2, "ragged": False}, "bucket_person_subject_lkj_eta": {"dtype": "float64", "ndim": 0, "ragged": False}, "subject": {"dtype": "object", "ndim": 1, "ragged": False}, "subject_fit": {"dtype": "object", "ndim": 1, "ragged": False}, "x": {"dtype": "float64", "ndim": 1, "ragged": False}, "y": {"dtype": "float64", "ndim": 1, "ragged": False}}
INPUTS = ("unconstrained", "ppl_last_b_person_subject_z", "ppl_axis1_b_person_subject_z", "ppl_first_pop_mu_beta_pop", "ppl_last_pop_mu_beta_pop", "ppl_first_pop_log_sigma_beta_pop", "ppl_last_pop_log_sigma_beta_pop", "subject_level", "x", "X_mu", "X_log_sigma", "y", "bucket_person_subject_lkj_eta", "ppl_prior_b_person_subject_L_normalizer")
PREPARED = {"ppl_last_b_person_subject_z": {"dtype": "int64", "ndim": 0, "ragged": False}, "ppl_axis1_b_person_subject_z": {"dtype": "int64", "ndim": 0, "ragged": False}, "ppl_first_pop_mu_beta_pop": {"dtype": "int64", "ndim": 0, "ragged": False}, "ppl_last_pop_mu_beta_pop": {"dtype": "int64", "ndim": 0, "ragged": False}, "ppl_first_pop_log_sigma_beta_pop": {"dtype": "int64", "ndim": 0, "ragged": False}, "ppl_last_pop_log_sigma_beta_pop": {"dtype": "int64", "ndim": 0, "ragged": False}, "subject_level": {"dtype": "int64", "ndim": 1, "ragged": False}, "x": {"dtype": "float64", "ndim": 1, "ragged": False}, "X_mu": {"dtype": "float64", "ndim": 2, "ragged": False}, "X_log_sigma": {"dtype": "float64", "ndim": 2, "ragged": False}, "y": {"dtype": "float64", "ndim": 1, "ragged": False}, "bucket_person_subject_lkj_eta": {"dtype": "float64", "ndim": 0, "ragged": False}, "ppl_prior_b_person_subject_L_normalizer": {"dtype": "float64", "ndim": 0, "ragged": False}}
UNTRANSLATED = {}


def _rk_order_key_np(x):
    # Julia's isless order of an array as sortable keys: a float is an integer
    # key, -0.0 before 0.0 and every NaN last, equal for values isequal treats
    # as equal. Integer and string arrays are their own keys.
    x = np.asarray(x)
    if x.dtype.kind != "f":
        return x
    bits = np.where(np.isnan(x), np.nan, x).astype(np.float64).view(np.int64)
    return np.where(bits < 0, bits ^ np.int64(0x7FFFFFFFFFFFFFFF), bits)


def _rk_unique_np(x):
    # Julia's unique of a vector: the first value of each isequal class, in
    # order.
    x = np.asarray(x)
    _, first = np.unique(_rk_order_key_np(x), return_index=True)
    return x[np.sort(first)]


def _rk_sort_np(x):
    # Julia's sort of a vector: ascending in isless order, equal values in
    # their order.
    x = np.asarray(x)
    return x[np.argsort(_rk_order_key_np(x), kind="stable")]


def _brm_sorted_labels_np(source):
    labels = _rk_unique_np(source)
    sorted_ = _rk_sort_np(labels)
    return sorted_


def _brm_fit_levels_np(source):
    value = _brm_sorted_labels_np(source)
    levels = value
    return levels


def _rk_dict_key(x):
    if isinstance(x, tuple):
        return (1, tuple(map(_rk_dict_key, x)))
    if isinstance(x, np.ndarray):
        return (2, x.shape, tuple(map(_rk_dict_key, x.ravel(order="F"))))
    if isinstance(x, (complex, np.complexfloating)):
        if x.imag == 0 and not np.signbit(x.imag):
            return _rk_dict_key(x.real)
        return (3, _rk_dict_key(x.real), _rk_dict_key(x.imag))
    if isinstance(x, (float, np.floating)):
        if np.isnan(x):
            return (4,)
        if x == 0 and np.signbit(x):
            return (5,)
    return (0, x)

class _RKDict:
    def __init__(self, pairs=()):
        self.data = {}
        for key, value in pairs:
            self[key] = value

    def __len__(self):
        return len(self.data)

    def __contains__(self, key):
        return _rk_dict_key(key) in self.data

    def __getitem__(self, key):
        return self.data[_rk_dict_key(key)][1]

    def __setitem__(self, key, value):
        self.data[_rk_dict_key(key)] = (key, value)

    def get(self, key, default):
        item = self.data.get(_rk_dict_key(key))
        return default if item is None else item[1]

    def setdefault(self, key, default):
        return self.data.setdefault(_rk_dict_key(key), (key, default))[1]

    def pop(self, key, default):
        item = self.data.pop(_rk_dict_key(key), None)
        return default if item is None else item[1]

    def items(self):
        return self.data.values()

    def keys(self):
        return (item[0] for item in self.items())

    def values(self):
        return (item[1] for item in self.items())

    def copy(self):
        return _RKDict(self.items())


def _brm_level_indices_np(labels, source):
    value = _brm_fit_levels_np(source)
    levels = value
    lookup = _RKDict()
    for k in range(1, len(levels) + 1):
        lookup[levels[k - 1]] = k
    indices = np.zeros((len(labels),), dtype=np.int64)
    for r in range(1, len(labels) + 1):
        position = lookup.get(labels[r - 1], 0)
        if position == 0:
            raise ValueError("".join([str("RK backend: group label `"), str(labels[r - 1]), str("` is not one of the "), str(len(levels)), str(" fitted levels. A replay keeps the fitted levels of every grouping it does not resample; name the grouping in `resample_groups` to take the new data's own levels.")]))
        indices[r - 1] = position
    return indices


def _rk_levels_np(x):
    arr = np.asarray(x)
    values = sorted(set(v for v in arr.tolist() if v is not None))
    return np.array(values, dtype=object if arr.dtype == object else arr.dtype)


class StaticInt(int):
    """An integer of the prepared data that sets a shape.

    It is an `int` everywhere, and `jax.jit` treats it as static, so the
    functions jit with the prepared data as arguments; a new value traces
    them again.
    """

    def __repr__(self):
        return "StaticInt(%d)" % int(self)


jax.tree_util.register_pytree_node(StaticInt, lambda s: ((), int(s)), lambda v, _: StaticInt(v))


def brm_population_effects(X: ArrayLike, beta_pop: ArrayLike, *, outputs: tuple[str, ...]) -> dict:
    """Population-level effects: one coefficient per column of the design matrix `X`.

    Draws `beta_pop[1:ncoef] ~ Normal(loc, scale)` and returns the linear predictor
    `X * beta_pop`. `ncoef` is the number of columns of `X`. Each prior argument (`loc`, `scale`) is one value for all coefficients or a vector with one per coefficient.
    """
    results = {}
    if any(name in outputs for name in ("value",)):
        value = X @ beta_pop
    if any(name in outputs for name in ("ppl_prior_beta_pop", "ppl_pw_prior_beta_pop")):
        def ppl_pw_prior_beta_pop_cell(beta_pop_2):
            log_scale = np.log(1.0)
            standardized = (beta_pop_2 - 0.0) / jnp.where((beta_pop_2 == 0.0 if 1.0 == 0 else False), 1.0, 1.0)
            standard_logpdf = -0.5 * np.log(2 * np.pi) - 0.5 * standardized ** 2
            logpdf = standard_logpdf - jnp.where((beta_pop_2 != 0.0 if 1.0 == 0 else False), 0.0, log_scale)
            return logpdf
        ppl_pw_prior_beta_pop = (jnp.zeros(beta_pop.shape[:1], dtype=jnp.float64) if 0 in beta_pop.shape[:1] else jax.vmap(ppl_pw_prior_beta_pop_cell, in_axes=(0,))(beta_pop))
    if any(name in outputs for name in ("ppl_prior_beta_pop",)):
        ppl_prior_beta_pop = jnp.sum(ppl_pw_prior_beta_pop)
    if "ppl_prior_beta_pop" in outputs:
        results["ppl_prior_beta_pop"] = ppl_prior_beta_pop
    if "ppl_pw_prior_beta_pop" in outputs:
        results["ppl_pw_prior_beta_pop"] = ppl_pw_prior_beta_pop
    if "value" in outputs:
        results["value"] = value
    return results


def brm_population_effects_2(
    X: ArrayLike,
    beta_pop: ArrayLike,
    *,
    outputs: tuple[str, ...],
) -> dict:
    """Population-level effects: one coefficient per column of the design matrix `X`.

    Draws `beta_pop[1:ncoef] ~ Normal(loc, scale)` and returns the linear predictor
    `X * beta_pop`. `ncoef` is the number of columns of `X`. Each prior argument (`loc`, `scale`) is one value for all coefficients or a vector with one per coefficient.
    """
    results = {}
    if any(name in outputs for name in ("value",)):
        value = X @ beta_pop
    if any(name in outputs for name in ("ppl_prior_beta_pop", "ppl_pw_prior_beta_pop")):
        ppl_parg_beta_pop_1 = jnp.asarray([-1.0, 0.0], dtype=jnp.float64)
        ppl_parg_beta_pop_2 = jnp.asarray([0.5, 0.2], dtype=jnp.float64)
        def ppl_pw_prior_beta_pop_cell(beta_pop_2, location, scale):
            log_scale = jnp.log(scale)
            standardized = (beta_pop_2 - location) / jnp.where(jnp.logical_and(scale == 0, beta_pop_2 == location), 1.0, scale)
            standard_logpdf = -0.5 * np.log(2 * np.pi) - 0.5 * standardized ** 2
            logpdf = standard_logpdf - jnp.where(jnp.logical_and(scale == 0, beta_pop_2 != location), 0.0, log_scale)
            return logpdf
        ppl_pw_prior_beta_pop = (jnp.zeros(beta_pop.shape[:1], dtype=jnp.float64) if 0 in beta_pop.shape[:1] and ppl_parg_beta_pop_1.shape[:1] == beta_pop.shape[:1] and ppl_parg_beta_pop_2.shape[:1] == beta_pop.shape[:1] else jax.vmap(ppl_pw_prior_beta_pop_cell, in_axes=(0, 0, 0))(beta_pop, ppl_parg_beta_pop_1, ppl_parg_beta_pop_2))
    if any(name in outputs for name in ("ppl_prior_beta_pop",)):
        ppl_prior_beta_pop = jnp.sum(ppl_pw_prior_beta_pop)
    if "ppl_prior_beta_pop" in outputs:
        results["ppl_prior_beta_pop"] = ppl_prior_beta_pop
    if "ppl_pw_prior_beta_pop" in outputs:
        results["ppl_pw_prior_beta_pop"] = ppl_pw_prior_beta_pop
    if "value" in outputs:
        results["value"] = value
    return results


def brm_correlated_group_effects_density(
    ppl_last_z: ArrayLike,
    ppl_prior_L_normalizer: ArrayLike,
    eta: ArrayLike,
    tau: ArrayLike,
    unconstrained: ArrayLike,
    *,
    outputs: tuple[str, ...],
) -> dict:
    """Group-level (varying) effects of grouping `g`, `K` correlated margins per level.

    Non-centered, from the scales `tau[1:K]` (drawn from their priors), the Cholesky factor of the margins' correlation `L ~ LKJCholesky(K, eta)` and standardized effects
    `z[1:length(levels(g)), 1:K] ~ Normal(0, 1)`. Returns the
    level-by-margin matrix `z * transpose(tau .* L)`, one row per level of `g` in order.
    """
    results = {}
    if any(name in outputs for name in ("ppl_lkj_diagonal_L", "ppl_lkj_partials_L", "ppl_lkj_raw_L", "ppl_prior_L", "ppl_prior_L_diagonal")):
        ppl_lkj_raw_L = unconstrained[2:3]
    if any(name in outputs for name in ("ppl_lkj_diagonal_L", "ppl_lkj_partials_L", "ppl_prior_L", "ppl_prior_L_diagonal")):
        ppl_lkj_partials_L = jnp.tanh(ppl_lkj_raw_L)
    if any(name in outputs for name in ("ppl_lkj_diagonal_L", "ppl_prior_L", "ppl_prior_L_diagonal")):
        out = jnp.ones((2,), dtype=jnp.float64)
        tuple_ = (1, 2, 1.0)
        i = tuple_[0]
        j = tuple_[1]
        d = tuple_[2]
        def loop_body(p, carry):
            (d_2, i_2, j_2, out_2) = carry
            d_3 = d_2 * jnp.sqrt(1 - ppl_lkj_partials_L[p - 1] ** 2)
            def then_arm():
                i_3 = i_2 + 1
                return (None, jnp.asarray(d_3, dtype=jnp.float64), jnp.asarray(i_3, dtype=jnp.int64), jnp.asarray(j_2, dtype=jnp.int64), out_2)
            def else_arm():
                out_3 = out_2.at[j_2 - 1].set(d_3)
                tuple__2 = (1, j_2 + 1, 1.0)
                i_4 = tuple__2[0]
                j_3 = tuple__2[1]
                d_4 = tuple__2[2]
                return (None, jnp.asarray(d_4, dtype=jnp.float64), jnp.asarray(i_4, dtype=jnp.int64), jnp.asarray(j_3, dtype=jnp.int64), out_3)
            branch = jax.lax.cond(i_2 + 1 < j_2, then_arm, else_arm)
            return (branch[1], branch[2], branch[3], branch[4])
        loop_carry = jax.lax.fori_loop(1, 2, loop_body, (jnp.asarray(d, dtype=jnp.float64), jnp.asarray(i, dtype=jnp.int64), jnp.asarray(j, dtype=jnp.int64), out))
        ppl_lkj_diagonal_L = loop_carry[3]
    if any(name in outputs for name in ("ppl_arrflat_z", "ppl_prior_z", "ppl_pw_prior_z")):
        ppl_arrflat_z = unconstrained[3:ppl_last_z]
    if any(name in outputs for name in ("ppl_prior_tau", "ppl_pw_prior_tau")):
        def ppl_pw_prior_tau_cell(tau_2):
            log_scale = np.log(0.5)
            logpdf = jax.lax.cond(tau_2 < 0, lambda: -jnp.inf, lambda: -log_scale - tau_2 / 0.5)
            return logpdf
        ppl_pw_prior_tau = (jnp.zeros(tau.shape[:1], dtype=jnp.float64) if 0 in tau.shape[:1] else jax.vmap(ppl_pw_prior_tau_cell, in_axes=(0,))(tau))
    if any(name in outputs for name in ("ppl_prior_tau",)):
        ppl_prior_tau = jnp.sum(ppl_pw_prior_tau)
    if any(name in outputs for name in ("ppl_prior_L", "ppl_prior_L_diagonal")):
        ppl_prior_L_diagonal = jax.lax.cond(jnp.logical_and(jnp.isfinite(eta), eta > 0), lambda: (2 * eta - 2) * jnp.log(ppl_lkj_diagonal_L[1]), lambda: 0.0)
    if any(name in outputs for name in ("ppl_prior_L",)):
        ppl_prior_L = ppl_prior_L_normalizer + ppl_prior_L_diagonal
    if any(name in outputs for name in ("ppl_prior_z", "ppl_pw_prior_z")):
        def ppl_pw_prior_z_cell(z):
            log_scale = np.log(1.0)
            standardized = (z - 0.0) / jnp.where((z == 0.0 if 1.0 == 0 else False), 1.0, 1.0)
            standard_logpdf = -0.5 * np.log(2 * np.pi) - 0.5 * standardized ** 2
            logpdf = standard_logpdf - jnp.where((z != 0.0 if 1.0 == 0 else False), 0.0, log_scale)
            return logpdf
        ppl_pw_prior_z = (jnp.zeros(ppl_arrflat_z.shape[:1], dtype=jnp.float64) if 0 in ppl_arrflat_z.shape[:1] else jax.vmap(ppl_pw_prior_z_cell, in_axes=(0,))(ppl_arrflat_z))
    if any(name in outputs for name in ("ppl_prior_z",)):
        ppl_prior_z = jnp.sum(ppl_pw_prior_z)
    if "ppl_arrflat_z" in outputs:
        results["ppl_arrflat_z"] = ppl_arrflat_z
    if "ppl_lkj_diagonal_L" in outputs:
        results["ppl_lkj_diagonal_L"] = ppl_lkj_diagonal_L
    if "ppl_lkj_partials_L" in outputs:
        results["ppl_lkj_partials_L"] = ppl_lkj_partials_L
    if "ppl_lkj_raw_L" in outputs:
        results["ppl_lkj_raw_L"] = ppl_lkj_raw_L
    if "ppl_prior_L" in outputs:
        results["ppl_prior_L"] = ppl_prior_L
    if "ppl_prior_L_diagonal" in outputs:
        results["ppl_prior_L_diagonal"] = ppl_prior_L_diagonal
    if "ppl_prior_tau" in outputs:
        results["ppl_prior_tau"] = ppl_prior_tau
    if "ppl_prior_z" in outputs:
        results["ppl_prior_z"] = ppl_prior_z
    if "ppl_pw_prior_tau" in outputs:
        results["ppl_pw_prior_tau"] = ppl_pw_prior_tau
    if "ppl_pw_prior_z" in outputs:
        results["ppl_pw_prior_z"] = ppl_pw_prior_z
    return results


def _ppl_lkj_lower(z: ArrayLike, diagonal: ArrayLike, K: ArrayLike, P: ArrayLike) -> jax.Array:
    """Compute `_ppl_lkj_lower` from its authored source."""
    out = jnp.zeros((K, K), dtype=jnp.float64)
    out_2 = out.at[0, 0].set(1.0)
    tuple_ = (1, 2, 1.0)
    i = tuple_[0]
    j = tuple_[1]
    w = tuple_[2]
    def loop_body(p, carry):
        (i_2, j_2, out_3, w_2) = carry
        out_4 = out_3.at[j_2 - 1, i_2 - 1].set(z[p - 1] * w_2)
        w_3 = w_2 * jnp.sqrt(1 - z[p - 1] ** 2)
        def then_arm():
            i_3 = i_2 + 1
            return (None, jnp.asarray(i_3, dtype=jnp.int64), jnp.asarray(j_2, dtype=jnp.int64), out_4, jnp.asarray(w_3, dtype=jnp.float64))
        def else_arm():
            out_5 = out_4.at[j_2 - 1, j_2 - 1].set(diagonal[j_2 - 1])
            tuple__2 = (1, j_2 + 1, 1.0)
            i_4 = tuple__2[0]
            j_3 = tuple__2[1]
            w_4 = tuple__2[2]
            return (None, jnp.asarray(i_4, dtype=jnp.int64), jnp.asarray(j_3, dtype=jnp.int64), out_5, jnp.asarray(w_4, dtype=jnp.float64))
        branch = jax.lax.cond(i_2 + 1 < j_2, then_arm, else_arm)
        return (branch[1], branch[2], branch[3], branch[4])
    carry_init = (jnp.asarray(i, dtype=jnp.int64), jnp.asarray(j, dtype=jnp.int64), out_2, jnp.asarray(w, dtype=jnp.float64))
    loop_carry = jax.lax.fori_loop(1, P + 1, loop_body, carry_init) if 1 <= P else carry_init
    return loop_carry[2]


def brm_correlated_group_effects(
    L: ArrayLike,
    tau: ArrayLike,
    z: ArrayLike,
    *,
    outputs: tuple[str, ...],
) -> dict:
    """Group-level (varying) effects of grouping `g`, `K` correlated margins per level.

    Non-centered, from the scales `tau[1:K]` (drawn from their priors), the Cholesky factor of the margins' correlation `L ~ LKJCholesky(K, eta)` and standardized effects
    `z[1:length(levels(g)), 1:K] ~ Normal(0, 1)`. Returns the
    level-by-margin matrix `z * transpose(tau .* L)`, one row per level of `g` in order.
    """
    results = {}
    if any(name in outputs for name in ("value",)):
        value = z @ jnp.transpose(tau[..., None] * L)
    if "value" in outputs:
        results["value"] = value
    return results


def prepare_data(X_log_sigma: ArrayLike, bucket_person_subject_lkj_eta: ArrayLike, subject: Any, subject_fit: Any, x: ArrayLike, y: ArrayLike) -> dict:
    """The functions' data inputs, computed from the raw data once per dataset.

    Pass the data by the names the model reads them; a list of arrays is a ragged
    column. Call the other functions with the result: `f(u, **prepared)`.
    """
    X_log_sigma = np.asarray(X_log_sigma, dtype=np.float64)
    subject = np.asarray(subject, dtype=object)
    subject_fit = np.asarray(subject_fit, dtype=object)
    x = np.asarray(x, dtype=np.float64)
    y = np.asarray(y, dtype=np.float64)
    X_mu = np.asarray(np.concatenate([np.ones((len(subject),), dtype=np.float64)[:, None], x[:, None]], axis=1), dtype=np.float64)
    rkppl_value_bucket_person_subject_lkj_eta = bucket_person_subject_lkj_eta
    value = _brm_fit_levels_np(subject_fit)
    subject_fit_levels = value
    value_2 = _brm_level_indices_np(subject, subject_fit_levels)
    subject_level = np.asarray(value_2, dtype=np.int64)
    ppl_axis1_b_person_subject_z = len(_rk_levels_np(subject_fit_levels))
    ppl_last_b_person_subject_z = 3 + 2 * ppl_axis1_b_person_subject_z
    ppl_first_pop_mu_beta_pop = ppl_last_b_person_subject_z + 1
    ppl_last_pop_mu_beta_pop = ppl_first_pop_mu_beta_pop + 1
    ppl_first_pop_log_sigma_beta_pop = ppl_last_pop_mu_beta_pop + 1
    ppl_last_pop_log_sigma_beta_pop = ppl_first_pop_log_sigma_beta_pop + 1
    if np.isfinite(bucket_person_subject_lkj_eta) and bucket_person_subject_lkj_eta > 0:
        value_4 = ssp.gammaln(bucket_person_subject_lkj_eta + 0.5)
        total = 1 * value_4
        for k in range(1, 2):
            value_5 = ssp.gammaln(bucket_person_subject_lkj_eta + 0.5 * (1 - k))
            total = total - 0.5 * k * 1.1447298858494002 - value_5
        value_3 = total
    else:
        value_3 = -np.inf
    ppl_prior_b_person_subject_L_normalizer = value_3
    return {"ppl_last_b_person_subject_z": StaticInt(ppl_last_b_person_subject_z), "ppl_axis1_b_person_subject_z": StaticInt(ppl_axis1_b_person_subject_z), "ppl_first_pop_mu_beta_pop": StaticInt(ppl_first_pop_mu_beta_pop), "ppl_last_pop_mu_beta_pop": StaticInt(ppl_last_pop_mu_beta_pop), "ppl_first_pop_log_sigma_beta_pop": StaticInt(ppl_first_pop_log_sigma_beta_pop), "ppl_last_pop_log_sigma_beta_pop": StaticInt(ppl_last_pop_log_sigma_beta_pop), "subject_level": np.asarray(subject_level, dtype=np.int64), "x": np.asarray(x, dtype=np.float64), "X_mu": np.asarray(X_mu, dtype=np.float64), "X_log_sigma": np.asarray(X_log_sigma, dtype=np.float64), "y": np.asarray(y, dtype=np.float64), "bucket_person_subject_lkj_eta": bucket_person_subject_lkj_eta, "ppl_prior_b_person_subject_L_normalizer": ppl_prior_b_person_subject_L_normalizer}


def model(_entry: str, unconstrained: ArrayLike, **prepared: ArrayLike) -> Any:
    """Shared model computation. The generated entry wrappers select a static output."""
    ppl_last_b_person_subject_z = prepared["ppl_last_b_person_subject_z"]
    ppl_axis1_b_person_subject_z = prepared["ppl_axis1_b_person_subject_z"]
    ppl_first_pop_mu_beta_pop = prepared["ppl_first_pop_mu_beta_pop"]
    ppl_last_pop_mu_beta_pop = prepared["ppl_last_pop_mu_beta_pop"]
    ppl_first_pop_log_sigma_beta_pop = prepared["ppl_first_pop_log_sigma_beta_pop"]
    ppl_last_pop_log_sigma_beta_pop = prepared["ppl_last_pop_log_sigma_beta_pop"]
    subject_level = prepared["subject_level"]
    x = prepared["x"]
    X_mu = prepared["X_mu"]
    X_log_sigma = prepared["X_log_sigma"]
    y = prepared["y"]
    bucket_person_subject_lkj_eta = prepared["bucket_person_subject_lkj_eta"]
    ppl_prior_b_person_subject_L_normalizer = prepared["ppl_prior_b_person_subject_L_normalizer"]
    unconstrained = jnp.asarray(unconstrained)
    subject_level = jnp.asarray(subject_level)
    x = jnp.asarray(x)
    X_mu = jnp.asarray(X_mu)
    X_log_sigma = jnp.asarray(X_log_sigma)
    y = jnp.asarray(y)
    if _entry in ("log_density", "log_prior", "log_likelihood", "constrain"):
        prefix_stop = 2
        if not (prefix_stop <= unconstrained.size):
            raise ValueError("BoundsError: prefix exceeds array length")
        plate_argument = unconstrained[:max(prefix_stop, 0)]
        def b_person_subject_tau_cell(ppl_cell_b_person_subject_tau):
            constrain_2 = jnp.exp(ppl_cell_b_person_subject_tau)
            return constrain_2
        b_person_subject_tau = (jnp.zeros(plate_argument.shape[:1], dtype=jnp.float64) if 0 in plate_argument.shape[:1] else jax.vmap(b_person_subject_tau_cell, in_axes=(0,))(plate_argument))
    if _entry in ("log_density", "log_jacobian"):
        prefix_stop_2 = 2
        if not (prefix_stop_2 <= unconstrained.size):
            raise ValueError("BoundsError: prefix exceeds array length")
        plate_argument_2 = unconstrained[:max(prefix_stop_2, 0)]
        def ppl_ljcells_b_person_subject_tau_cell(ppl_cell_b_person_subject_tau):
            return ppl_cell_b_person_subject_tau
        ppl_ljcells_b_person_subject_tau = (jnp.zeros(plate_argument_2.shape[:1], dtype=jnp.float64) if 0 in plate_argument_2.shape[:1] else jax.vmap(ppl_ljcells_b_person_subject_tau_cell, in_axes=(0,))(plate_argument_2))
    if _entry in ("log_density", "log_prior", "log_likelihood", "constrain"):
        pop_mu_beta_pop = unconstrained[ppl_first_pop_mu_beta_pop - 1:ppl_last_pop_mu_beta_pop]
    if _entry in ("log_density", "log_prior", "log_likelihood"):
        pop_mu = brm_population_effects(
            X=(X_mu if _entry in ("log_density", "log_likelihood") else None),
            beta_pop=(pop_mu_beta_pop if _entry in ("log_density", "log_prior", "log_likelihood") else None),
            outputs=tuple(
                name for name, needed in (
                    ("ppl_prior_beta_pop", ("log_density", "log_prior")),
                    ("ppl_pw_prior_beta_pop", ("log_density", "log_prior")),
                    ("value", ("log_density", "log_likelihood")),
                )
                if _entry in needed
            ),
        )
    if _entry in ("log_density", "log_prior", "log_likelihood", "constrain"):
        pop_log_sigma_beta_pop = unconstrained[ppl_first_pop_log_sigma_beta_pop - 1:ppl_last_pop_log_sigma_beta_pop]
    if _entry in ("log_density", "log_prior", "log_likelihood"):
        pop_log_sigma = brm_population_effects_2(
            X=(X_log_sigma if _entry in ("log_density", "log_likelihood") else None),
            beta_pop=(pop_log_sigma_beta_pop if _entry in ("log_density", "log_prior", "log_likelihood") else None),
            outputs=tuple(
                name for name, needed in (
                    ("ppl_prior_beta_pop", ("log_density", "log_prior")),
                    ("ppl_pw_prior_beta_pop", ("log_density", "log_prior")),
                    ("value", ("log_density", "log_likelihood")),
                )
                if _entry in needed
            ),
        )
    if _entry in ("log_density", "log_likelihood"):
        rkppl_synth_1 = jnp.exp(pop_log_sigma["value"])
    if _entry in ("log_density", "log_jacobian"):
        plate_fold = jnp.sum(ppl_ljcells_b_person_subject_tau)
    b_person_subject = brm_correlated_group_effects_density(
        ppl_last_z=(ppl_last_b_person_subject_z if _entry in ("log_density", "log_prior", "log_likelihood", "constrain") else None),
        ppl_prior_L_normalizer=(ppl_prior_b_person_subject_L_normalizer if _entry in ("log_density", "log_prior") else None),
        eta=(bucket_person_subject_lkj_eta if _entry in ("log_density", "log_prior") else None),
        tau=(b_person_subject_tau if _entry in ("log_density", "log_prior") else None),
        unconstrained=unconstrained,
        outputs=tuple(
            name for name, needed in (
                ("ppl_arrflat_z", ("log_density", "log_prior", "log_likelihood", "constrain")),
                ("ppl_lkj_diagonal_L", ("log_density", "log_prior", "log_likelihood", "constrain")),
                ("ppl_lkj_partials_L", ("log_density", "log_prior", "log_likelihood", "log_jacobian", "constrain")),
                ("ppl_lkj_raw_L", ("log_density", "log_prior", "log_likelihood", "log_jacobian", "constrain")),
                ("ppl_prior_L", ("log_density", "log_prior")),
                ("ppl_prior_L_diagonal", ("log_density", "log_prior")),
                ("ppl_prior_tau", ("log_density", "log_prior")),
                ("ppl_prior_z", ("log_density", "log_prior")),
                ("ppl_pw_prior_tau", ("log_density", "log_prior")),
                ("ppl_pw_prior_z", ("log_density", "log_prior")),
            )
            if _entry in needed
        ),
    )
    if _entry in ("log_density", "log_likelihood", "constrain"):
        ppl_lkj_lower = _ppl_lkj_lower(b_person_subject["ppl_lkj_partials_L"], b_person_subject["ppl_lkj_diagonal_L"], 2, 1)
        b_person_subject_L = ppl_lkj_lower
    if _entry in ("log_density", "log_jacobian"):
        total = 0.0
        tuple_ = (1, 2)
        i = tuple_[0]
        j = tuple_[1]
        def loop_body(p, carry):
            (i_2, j_2, total_2) = carry
            total_3 = total_2 + (j_2 - i_2 + 1) / 2 * jnp.log(1 - b_person_subject["ppl_lkj_partials_L"][p - 1] ** 2)
            tuple__2 = jax.lax.cond(i_2 + 1 < j_2, lambda: (i_2 + 1, j_2), lambda: (1, j_2 + 1))
            i_3 = tuple__2[0]
            j_3 = tuple__2[1]
            return (i_3, j_3, total_3)
        loop_carry = jax.lax.fori_loop(1, 2, loop_body, (jnp.asarray(i, dtype=jnp.int64), jnp.asarray(j, dtype=jnp.int64), jnp.asarray(total, dtype=jnp.float64)))
        ppl_lkj_logjac_b_person_subject_L = loop_carry[2]
    if _entry in ("log_density", "log_likelihood", "constrain"):
        b_person_subject_z = jnp.reshape(b_person_subject["ppl_arrflat_z"], (ppl_axis1_b_person_subject_z, 2), order="F")
    if _entry in ("log_density", "log_prior"):
        prior = b_person_subject["ppl_prior_tau"] + b_person_subject["ppl_prior_L"] + b_person_subject["ppl_prior_z"] + pop_mu["ppl_prior_beta_pop"] + pop_log_sigma["ppl_prior_beta_pop"]
    if _entry in ("log_density", "log_jacobian"):
        log_jacobian_2 = plate_fold + ppl_lkj_logjac_b_person_subject_L
    if _entry in ("log_density", "log_likelihood"):
        b_person_subject_2 = brm_correlated_group_effects(
            L=(b_person_subject_L if _entry in ("log_density", "log_likelihood") else None),
            tau=(b_person_subject_tau if _entry in ("log_density", "log_likelihood") else None),
            z=(b_person_subject_z if _entry in ("log_density", "log_likelihood") else None),
            outputs=tuple(
                name for name, needed in (
                    ("value", ("log_density", "log_likelihood")),
                )
                if _entry in needed
            ),
        )
        ranef_mu_person_subject = b_person_subject_2["value"][subject_level - 1, 0] + b_person_subject_2["value"][subject_level - 1, 1] * x
        ppl_offset_mu = pop_mu["value"] + ranef_mu_person_subject
        def ppl_pw_y_resp_cell(y_2, mu, rkppl_synth_1_2):
            def then_arm():
                log_scale = jnp.log(rkppl_synth_1_2)
                standardized = (y_2 - mu) / jnp.where(jnp.logical_and(rkppl_synth_1_2 == 0, y_2 == mu), 1.0, rkppl_synth_1_2)
                standard_logpdf = -0.5 * np.log(2 * np.pi) - 0.5 * standardized ** 2
                return standard_logpdf - jnp.where(jnp.logical_and(rkppl_synth_1_2 == 0, y_2 != mu), 0.0, log_scale)
            ppl_density = jax.lax.cond(rkppl_synth_1_2 > 0, then_arm, lambda: -jnp.inf)
            return ppl_density
        ppl_pw_y_resp = (jnp.zeros(y.shape[:1], dtype=jnp.float64) if 0 in y.shape[:1] and ppl_offset_mu.shape[:1] == y.shape[:1] and rkppl_synth_1.shape[:1] == y.shape[:1] else jax.vmap(ppl_pw_y_resp_cell, in_axes=(0, 0, 0))(y, ppl_offset_mu, rkppl_synth_1))
        ppl_lik_y_resp = jnp.sum(ppl_pw_y_resp)
    if _entry in ("log_density",):
        posterior = prior + ppl_lik_y_resp + log_jacobian_2
    if not (unconstrained.size == ppl_last_pop_log_sigma_beta_pop):
        raise ValueError("[layout] packed length ≠ layout total: a packed point holds the coordinates of the binding whose layout packed it")
    if _entry == "log_density":
        return jnp.asarray(posterior, dtype=jnp.float64)
    if _entry == "log_prior":
        return jnp.asarray(prior, dtype=jnp.float64)
    if _entry == "log_likelihood":
        return jnp.asarray(ppl_lik_y_resp, dtype=jnp.float64)
    if _entry == "log_jacobian":
        return jnp.asarray(log_jacobian_2, dtype=jnp.float64)
    if _entry == "constrain":
        return {"b_person_subject": {"tau": jnp.asarray(b_person_subject_tau), "L": jnp.asarray(b_person_subject_L), "z": jnp.asarray(b_person_subject_z)}, "pop_mu": {"beta_pop": jnp.asarray(pop_mu_beta_pop)}, "pop_log_sigma": {"beta_pop": jnp.asarray(pop_log_sigma_beta_pop)}}


def log_density(unconstrained: ArrayLike, **prepared: ArrayLike) -> jax.Array:
    """The log density a sampler targets at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`.

    The sum of `log_prior`, `log_likelihood` and `log_jacobian`.
    """
    return model("log_density", unconstrained, **prepared)


def log_prior(unconstrained: ArrayLike, **prepared: ArrayLike) -> jax.Array:
    """The log prior density of the constrained parameters at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`."""
    return model("log_prior", unconstrained, **prepared)


def log_likelihood(unconstrained: ArrayLike, **prepared: ArrayLike) -> jax.Array:
    """The log likelihood of the observations at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`."""
    return model("log_likelihood", unconstrained, **prepared)


def log_jacobian(unconstrained: ArrayLike, **prepared: ArrayLike) -> jax.Array:
    """The log Jacobian of the constraining transforms at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`."""
    return model("log_jacobian", unconstrained, **prepared)


def constrain(unconstrained: ArrayLike, **prepared: ArrayLike) -> dict:
    """The constrained value of each parameter, and of each requested value, at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`. Returns a dict, a submodel's values nested under its name:

    - `b_person_subject.tau`
    - `b_person_subject.L`
    - `b_person_subject.z`
    - `pop_mu.beta_pop`
    - `pop_log_sigma.beta_pop`
    """
    return model("constrain", unconstrained, **prepared)


def dimension(prepared: dict) -> int:
    """The length of `unconstrained` for the data `prepared` (what `prepare_data` returned)."""
    return int(prepared["ppl_last_pop_log_sigma_beta_pop"])


def parameters(prepared: dict) -> dict:
    """Each parameter's 0-based `start`/`stop` in `unconstrained`, its transform and dimensions,
    for the data `prepared` (what `prepare_data` returned)."""
    return {"b_person_subject.tau": {"start": 0, "stop": 2, "transform": "exp", "dims": (2,)}, "b_person_subject.L": {"start": 2, "stop": 3, "transform": "lkj", "dims": (2, 2)}, "b_person_subject.z": {"start": 3, "stop": int(prepared["ppl_last_b_person_subject_z"]), "transform": "identity", "dims": (int(prepared["ppl_axis1_b_person_subject_z"]), 2)}, "pop_mu.beta_pop": {"start": int(prepared["ppl_first_pop_mu_beta_pop"]) - 1, "stop": int(prepared["ppl_last_pop_mu_beta_pop"]), "transform": "identity", "dims": (2,)}, "pop_log_sigma.beta_pop": {"start": int(prepared["ppl_first_pop_log_sigma_beta_pop"]) - 1, "stop": int(prepared["ppl_last_pop_log_sigma_beta_pop"]), "transform": "identity", "dims": (2,)}}

~ introduces a formula or a probability law; = computes a value. A formula allocates coefficients for its terms. Write 1 for an intercept: BRM does not insert one. The name sigma above holds the response-scale value exp(linear predictor). Its prior address is effect(sigma, ...); applying exp to sigma again would apply the link twice.

The BRM, intermediate-representation, StanBlocks and Stan panes all come from the same bound model. The following inspection checks the authored inputs and keeps the prior declarations visible.

julia
using BayesianRegressionModels
model = Main.BRMDocsComparisons.example_module(:SyntaxGuide).model
(inputs=data_columns(model), priors=string(priors_of(model)))

(inputs = [:x, :subject], priors = "effect(mu, 😃 ~ Normal(0, 1)\neffect(sigma, Intercept) ~ Normal(-1, 0.5)\neffect(sigma, x) ~ Normal(0, 0.2)\nsd(:, person) ~ Exponential(0.5)\ncor(:, person) ~ LKJCholesky(2, 2)")

Familiar formulaBRM meaning
1 + x + zAn intercept and two population effects
x * z / x & zMain effects plus interaction / interaction alone
(1 + x | subject)Correlated subject intercepts and slopes
(1 + x || subject)Independent subject intercepts and slopes
(1 | p | subject) in two predictorsOne correlation block spanning both predictors
(1 | gr(subject; by=arm))Separate group-effect distributions by stratum
Two response statementsA joint model; shared names share parameters
y ~ Normal(@brm(1 + x), exp(@brm(1)))Nested mean and log-scale formulas

Integer, string and categorical columns are factors; use floating-point values for a numeric trend. With an intercept, factors use treatment contrasts. Without one, the first eligible factor uses one coefficient per level. factor(g; cmc=false) keeps treatment coding; factor(g; ref=k) chooses a reference level. The reference gives the interaction and ordinal exceptions.

Nonlinear models and plates ​

Ordinary assignments combine sampled values without adding coefficients. This exponential-decay model has one rate per unit and several observations per unit. A groups binding connects the two axes.

brm-comparison
Two axes connected by a plate
panes: brm|stanblocks|rkppl|stan|jax:3
julia
decay = @brm begin
    log(rate) ~ 1 + (1 | unit)
    rows = groups(observation_unit => unit)
    @plate for i in eachindex(rate)
        mean_y = amplitude * exp.(-rate[i] .* time[rows[i]])
        y[rows[i]] ~ Normal(mean_y, noise)
    end

    amplitude ~ LogNormal(0, 0.5)
    noise ~ Exponential(0.2)
    effect(rate, Intercept) ~ Normal(-1, 0.5)
    sd(rate, unit) ~ Exponential(0.3)
end
model = decay((; unit=["a", "b"],
    observation_unit=["a", "b", "a", "b", "b"],
    time=[0., 0., 1., 1., 2.], y=[1.1, 0.9, 0.7, 0.6, 0.4]))
julia
SBBRMI with data keys = [:kernel_nsub_y_cell, :kernel_y_cell_time_ragged, :kernel_y_cell_y_ragged, :n_rows_time_observation_unit, :n_rows_y_observation_unit, :n_terms_rate__unit_unit, :n_unit, :time, :unit_idx, :y]
configured submodels:
ranef_correlated_draws_single_margin_1 = Base.merge(BayesianRegressionModels._sb_single_margin_ranef(BayesianRegressionModels.ranef_correlated_draws), quote
            tau ~ (StanBlocks.builtin.restricted)(exponential, 1.0 ./ 0.3; n = n_terms, lower = 0.0)
        end)
emitted @slic body:
begin
    b_rate__unit_unit ~ ranef_correlated_draws_single_margin_1(; group_idx = unit_idx, n_groups = n_unit, n_terms = n_terms_rate__unit_unit)
    X_log_rate = hcat(rep_vector(1.0, num_elements(unit_idx)))
    pop_log_rate ~ _popefs_normal(; X = X_log_rate, beta_loc = [-1], beta_scale = [0.5])
    r_log_rate_rate__unit_unit = b_rate__unit_unit[unit_idx, 1]
    log_rate = pop_log_rate + r_log_rate_rate__unit_unit
    rate = exp(log_rate)
    amplitude ~ lognormal(0, 0.5)
    noise ~ exponential(1.0 ./ 0.2)
    y_cell ~ plate(rate, kernel_y_cell_time_ragged, kernel_y_cell_y_ragged; outer = (kernel_nsub_y_cell,)) do rate, time, y
            #= brm-docs-example.jl:5 =#
            mean_y = amplitude * exp.(-rate .* time)
            #= brm-docs-example.jl:6 =#
            y ~ normal(mean_y, noise)
            #= brm-docs-example.jl:7 =#
            nothing
        end
end
julia
"""
Group-level (varying) effects of grouping `g`.

Non-centered, from the scale `tau[1]` (drawn from its prior) and standardized effects
`z[1:length(levels(g)), 1:1] ~ Normal(0, 1)`. Returns the
level-by-margin matrix `z .* tau[1]`, one row per level of `g` in order.
"""
brm_group_effects(g) = begin
        tau[1:1] .~ Exponential.(0.3)
        z[1:length(levels(g)), 1:1] .~ Normal.(0, 1)
        return z .* tau[1]
    end

begin
    unit_fit_levels = brm_fit_levels(unit_fit)
    b_rate__unit_unit ~ brm_group_effects(unit_fit_levels)
    unit_level = brm_level_indices(unit, unit_fit_levels)
    ranef_rate_rate__unit_unit = b_rate__unit_unit[unit_level, 1]
    rate_Intercept ~ Normal(-1.0, 0.5)
    log_rate = rate_Intercept .+ ranef_rate_rate__unit_unit
    rate = exp.(log_rate)
    amplitude ~ LogNormal(0.0, 0.5)
    noise ~ Exponential(0.2)
    y_cell_rows_2 = brm_ragged_rows([:time, :observation_unit, :unit, :time], observation_unit, unit, (time,))
    @plate for i = eachindex(unit)
            mean_y = amplitude * exp.(-(rate[i]) .* time[y_cell_rows_2[i]])
            y_cell_argument_y_1[i] = mean_y
        end
    @plate for i = eachindex(y)
            y[i] .~ Normal.(y_cell_argument_y_1[i], noise)
        end
end
stan
functions {
matrix hcat(vector x) {
    int n = dims(x)[1];
    return to_matrix(x, n, 1);
}
int ragged_end(array[] int ends, int i) {
    return ends[i];
}
int ragged_start(
    array[] int ends,
    int i
) {
    if((i == 1)) {
        return 1;
    } else {
        return (1 + ends[(i - 1)]);
    }
}
vector jbroadcasted_exp(
    vector x1
) {
    int n = dims(x1)[1];
    vector[n] rv;
    for(i in 1:n) {
        rv[i] = exp(broadcasted_getindex(x1, i));
    }
    return rv;
}
real broadcasted_getindex(vector x, int i) {
    return x[i];
}
vector normal_lpdfs(
    vector obs,
    vector loc,
    real scale
) {
    return jbroadcasted_normal_lpdfs(obs, loc, scale);
}
vector jbroadcasted_normal_lpdfs(
    vector x1,
    vector x2,
    real x3
) {
    int n = dims(x1)[1];
    vector[n] rv;
    for(i in 1:n) {
        rv[i] = normal_lpdfs(broadcasted_getindex(x1, i), broadcasted_getindex(x2, i), x3);
    }
    return rv;
}
real normal_lpdfs(
    real args1,
    real args2,
    real args3
) {
    return normal_lpdf(args1 | args2, args3);
}
vector normal_vector_rng(
    int anontok__1,
    vector a,
    real b
) {
    int n = anontok__1;
    if((n == 0)) {
        vector[n] rv;
        return rv;
    } else {
        return to_vector(normal_rng(a, b));
    }
}
}
data {
    int n_terms_rate__unit_unit;
    int n_unit;
    int unit_idx_n;
    array[unit_idx_n] int unit_idx;
    int kernel_nsub_y_cell;
    int kernel_y_cell_time_ragged_ends_n;
    int kernel_y_cell_time_ragged_mem_n;
    tuple(vector[kernel_y_cell_time_ragged_mem_n], array[kernel_y_cell_time_ragged_ends_n] int) kernel_y_cell_time_ragged;
    int kernel_y_cell_y_ragged_mem_n;
    int kernel_y_cell_y_ragged_ends_n;
    tuple(vector[kernel_y_cell_y_ragged_mem_n], array[kernel_y_cell_y_ragged_ends_n] int) kernel_y_cell_y_ragged;
}
transformed data {
    matrix[num_elements(unit_idx), 1] X_log_rate = hcat(rep_vector(1.0, num_elements(unit_idx)));
    int pop_log_rate_n_covariates = 1;
    array[kernel_nsub_y_cell] int y_cell_mean_y__pl_len;
    for(plate_i__pl_1 in 1:kernel_nsub_y_cell) {
        y_cell_mean_y__pl_len[plate_i__pl_1] = (
            1 +
            (
                ragged_end(kernel_y_cell_time_ragged.2, plate_i__pl_1) -
                ragged_start(kernel_y_cell_time_ragged.2, plate_i__pl_1)
            )
        );
    }
    array[kernel_nsub_y_cell] int y_cell_mean_y__pl_end = cumulative_sum(y_cell_mean_y__pl_len);
}
parameters {
    vector<lower=0.0>[n_terms_rate__unit_unit] b_rate__unit_unit_tau;
    vector[(n_terms_rate__unit_unit * n_unit)] b_rate__unit_unit_z_flat;
    vector[pop_log_rate_n_covariates] pop_log_rate_beta_pop;
    real<lower=0.0> amplitude;
    real<lower=0.0> noise;
}
transformed parameters {
    matrix[n_terms_rate__unit_unit, n_unit] b_rate__unit_unit_z = to_matrix(b_rate__unit_unit_z_flat, n_terms_rate__unit_unit, n_unit);
    matrix[n_unit, n_terms_rate__unit_unit] b_rate__unit_unit = ((diag_matrix(b_rate__unit_unit_tau) * b_rate__unit_unit_z)');
    vector[num_elements(unit_idx)] pop_log_rate = (X_log_rate * pop_log_rate_beta_pop);
    vector[unit_idx_n] r_log_rate_rate__unit_unit = b_rate__unit_unit[unit_idx, 1];
    vector[num_elements(unit_idx)] log_rate = (pop_log_rate + r_log_rate_rate__unit_unit);
    vector[num_elements(unit_idx)] rate = exp(log_rate);
    vector[sum(y_cell_mean_y__pl_len)] y_cell_mean_y;
    for(plate_i__pl_1 in 1:kernel_nsub_y_cell) {
        y_cell_mean_y[
            ragged_start(y_cell_mean_y__pl_end, plate_i__pl_1):ragged_end(y_cell_mean_y__pl_end, plate_i__pl_1)
        ] = (
            amplitude *
            jbroadcasted_exp(
                (
                    (-rate[plate_i__pl_1]) .*
                    kernel_y_cell_time_ragged.1[
                        ragged_start(kernel_y_cell_time_ragged.2, plate_i__pl_1):ragged_end(kernel_y_cell_time_ragged.2, plate_i__pl_1)
                    ]
                )
            )
        );
    }
}
model {
    b_rate__unit_unit_tau ~ exponential((1.0 ./ 0.3));
    b_rate__unit_unit_z_flat ~ std_normal();
    pop_log_rate_beta_pop ~ normal([-1]', [0.5]');
    amplitude ~ lognormal(0, 0.5);
    noise ~ exponential((1.0 ./ 0.2));
    for(plate_i__pl_1 in 1:kernel_nsub_y_cell) {
        kernel_y_cell_y_ragged.1[
            ragged_start(kernel_y_cell_y_ragged.2, plate_i__pl_1):ragged_end(kernel_y_cell_y_ragged.2, plate_i__pl_1)
        ] ~ normal(
            y_cell_mean_y[
                ragged_start(y_cell_mean_y__pl_end, plate_i__pl_1):ragged_end(y_cell_mean_y__pl_end, plate_i__pl_1)
            ],
            noise
        );
    }
}
generated quantities {
    vector[num_elements(kernel_y_cell_y_ragged.1)] kernel_y_cell_y_ragged_gen;
    vector[num_elements(kernel_y_cell_y_ragged.2)] kernel_y_cell_y_ragged_likelihood;
    for(plate_i__pl_1 in 1:kernel_nsub_y_cell) {
        kernel_y_cell_y_ragged_gen[
            ragged_start(kernel_y_cell_y_ragged.2, plate_i__pl_1):ragged_end(kernel_y_cell_y_ragged.2, plate_i__pl_1)
        ] = normal_vector_rng(
            (1 + (ragged_end(kernel_y_cell_y_ragged.2, plate_i__pl_1) - ragged_start(kernel_y_cell_y_ragged.2, plate_i__pl_1))),
            y_cell_mean_y[
                ragged_start(y_cell_mean_y__pl_end, plate_i__pl_1):ragged_end(y_cell_mean_y__pl_end, plate_i__pl_1)
            ],
            noise
        );
        kernel_y_cell_y_ragged_likelihood[plate_i__pl_1] = normal_lpdf(kernel_y_cell_y_ragged.1[
            ragged_start(kernel_y_cell_y_ragged.2, plate_i__pl_1):ragged_end(kernel_y_cell_y_ragged.2, plate_i__pl_1)
        ] | 
            y_cell_mean_y[
                ragged_start(y_cell_mean_y__pl_end, plate_i__pl_1):ragged_end(y_cell_mean_y__pl_end, plate_i__pl_1)
            ],
            noise
        );
    }
}
julia
using ReactiveKernels, ReactiveKernelsPPL
rk = RKBRMI(model)
source = jax_source(rk.model, rk_bound_plan(rk))
write("model.py", source)
inputs = rk_bound_data(rk, source)   # exactly the inputs prepare_data reads
python
import jax
import model as m

prepared = m.prepare_data(**inputs)
lp = m.log_density(u, **prepared)               # u: unconstrained, length m.dimension(prepared)
lp = jax.jit(m.log_density)(u, **prepared)      # one compiled function for every dataset of these shapes
python
"""Generated by ReactiveKernelsPPL.jax_source from a built @rkppl program; do not edit.

Data: observation_unit, time, unit, unit_fit, y.

Model documentation:

- `b_rate__unit_unit`: Group-level (varying) effects of grouping `g`.

  Non-centered, from the scale `tau[1]` (drawn from its prior) and standardized effects
  `z[1:length(levels(g)), 1:1] ~ Normal(0, 1)`. Returns the
  level-by-margin matrix `z .* tau[1]`, one row per level of `g` in order.
"""
import numpy as np
import scipy.special as ssp
from typing import Any

import jax
import jax.numpy as jnp
import jax.scipy.linalg
import jax.scipy.special as jsp
from jax.typing import ArrayLike

jax.config.update("jax_enable_x64", True)

DATA = {"observation_unit": {"dtype": "object", "ndim": 1, "ragged": False}, "time": {"dtype": "float64", "ndim": 1, "ragged": False}, "unit": {"dtype": "object", "ndim": 1, "ragged": False}, "unit_fit": {"dtype": "object", "ndim": 1, "ragged": False}, "y": {"dtype": "float64", "ndim": 1, "ragged": True}}
INPUTS = ("unconstrained", "ppl_last_b_rate_unit_unit_z", "ppl_axis1_b_rate_unit_unit_z", "unit_level", "plate_argument", "time", "y_cell_rows_2", "y_cell_rows_2_lengths", "y_cell_rows_2_flat", "y", "y_lengths", "y_flat")
PREPARED = {"ppl_last_b_rate_unit_unit_z": {"dtype": "int64", "ndim": 0, "ragged": False}, "ppl_axis1_b_rate_unit_unit_z": {"dtype": "int64", "ndim": 0, "ragged": False}, "unit_level": {"dtype": "int64", "ndim": 1, "ragged": False}, "plate_argument": {"dtype": "int64", "ndim": 1, "ragged": False}, "time": {"dtype": "float64", "ndim": 1, "ragged": False}, "y_cell_rows_2": {"dtype": "int64", "ndim": 1, "ragged": True}, "y": {"dtype": "float64", "ndim": 1, "ragged": True}}
UNTRANSLATED = {}


def _rk_order_key_np(x):
    # Julia's isless order of an array as sortable keys: a float is an integer
    # key, -0.0 before 0.0 and every NaN last, equal for values isequal treats
    # as equal. Integer and string arrays are their own keys.
    x = np.asarray(x)
    if x.dtype.kind != "f":
        return x
    bits = np.where(np.isnan(x), np.nan, x).astype(np.float64).view(np.int64)
    return np.where(bits < 0, bits ^ np.int64(0x7FFFFFFFFFFFFFFF), bits)


def _rk_unique_np(x):
    # Julia's unique of a vector: the first value of each isequal class, in
    # order.
    x = np.asarray(x)
    _, first = np.unique(_rk_order_key_np(x), return_index=True)
    return x[np.sort(first)]


def _rk_sort_np(x):
    # Julia's sort of a vector: ascending in isless order, equal values in
    # their order.
    x = np.asarray(x)
    return x[np.argsort(_rk_order_key_np(x), kind="stable")]


def _brm_sorted_labels_np(source):
    labels = _rk_unique_np(source)
    sorted_ = _rk_sort_np(labels)
    return sorted_


def _brm_fit_levels_np(source):
    value = _brm_sorted_labels_np(source)
    levels = value
    return levels


def _rk_dict_key(x):
    if isinstance(x, tuple):
        return (1, tuple(map(_rk_dict_key, x)))
    if isinstance(x, np.ndarray):
        return (2, x.shape, tuple(map(_rk_dict_key, x.ravel(order="F"))))
    if isinstance(x, (complex, np.complexfloating)):
        if x.imag == 0 and not np.signbit(x.imag):
            return _rk_dict_key(x.real)
        return (3, _rk_dict_key(x.real), _rk_dict_key(x.imag))
    if isinstance(x, (float, np.floating)):
        if np.isnan(x):
            return (4,)
        if x == 0 and np.signbit(x):
            return (5,)
    return (0, x)

class _RKDict:
    def __init__(self, pairs=()):
        self.data = {}
        for key, value in pairs:
            self[key] = value

    def __len__(self):
        return len(self.data)

    def __contains__(self, key):
        return _rk_dict_key(key) in self.data

    def __getitem__(self, key):
        return self.data[_rk_dict_key(key)][1]

    def __setitem__(self, key, value):
        self.data[_rk_dict_key(key)] = (key, value)

    def get(self, key, default):
        item = self.data.get(_rk_dict_key(key))
        return default if item is None else item[1]

    def setdefault(self, key, default):
        return self.data.setdefault(_rk_dict_key(key), (key, default))[1]

    def pop(self, key, default):
        item = self.data.pop(_rk_dict_key(key), None)
        return default if item is None else item[1]

    def items(self):
        return self.data.values()

    def keys(self):
        return (item[0] for item in self.items())

    def values(self):
        return (item[1] for item in self.items())

    def copy(self):
        return _RKDict(self.items())


def _brm_level_indices_np(labels, source):
    value = _brm_fit_levels_np(source)
    levels = value
    lookup = _RKDict()
    for k in range(1, len(levels) + 1):
        lookup[levels[k - 1]] = k
    indices = np.zeros((len(labels),), dtype=np.int64)
    for r in range(1, len(labels) + 1):
        position = lookup.get(labels[r - 1], 0)
        if position == 0:
            raise ValueError("".join([str("RK backend: group label `"), str(labels[r - 1]), str("` is not one of the "), str(len(levels)), str(" fitted levels. A replay keeps the fitted levels of every grouping it does not resample; name the grouping in `resample_groups` to take the new data's own levels.")]))
        indices[r - 1] = position
    return indices


def _rk_levels_np(x):
    arr = np.asarray(x)
    values = sorted(set(v for v in arr.tolist() if v is not None))
    return np.array(values, dtype=object if arr.dtype == object else arr.dtype)


def _brm_group_values_np(raw):
    return raw


def _brm_cell_labels_np(raw, group, prefix):
    if np.logical_not(True):
        raise ValueError("_brm_not_a_label_vector threw")
    value = _brm_group_values_np(raw)
    values = value
    unique_labels = True
    seen = _RKDict()
    for k in range(1, len(values) + 1):
        if (values[k - 1] is None) or (values[k - 1] in seen):
            unique_labels = False
        seen[values[k - 1]] = k
    if np.logical_not(unique_labels):
        raise ValueError("".join([str(prefix), str(": kernel(...) needs pre-grouped per-subject data — `"), str(group), str("` must list one non-missing unique subject per row. Repeated levels indicate long-format data. Got "), str(values), str(".")]))
    return values


def _brm_check_ragged_axis_np(x, group, column, len_, n, prefix):
    if len_ != n:
        raise ValueError("".join([str(prefix), str(": `"), str(x), str("` read through `"), str(group), str("`: `"), str(x), str("` has "), str(len_), str(" entries (data vector `"), str(column), str("`) but `"), str(group), str("` has "), str(n), str(". The grouping column must label EVERY entry of `"), str(x), str("`; an entry whose label names no cell is read by no cell.")]))
    return None


def _brm_check_ragged_axes_np(names, offset, axes, n, prefix):
    k = offset
    for axis in axes:
        k = k + 1
        value = _brm_check_ragged_axis_np(names[0], names[1], names[k - 1], len(axis), n, prefix)
    return None


def _brm_check_missing_labels_np(x, group, values, prefix):
    return None


def _brm_hashed_label_table_np(labels):
    table = _RKDict()
    for k in range(1, len(labels) + 1):
        table[labels[k - 1]] = k
    return table


def _brm_label_position_np(table, lo, hi, v):
    return table.get(v, 0)


def _rk_isequal_np(a, b):
    # Julia's isequal on scalars: NaN equals NaN, -0.0 differs from 0.0, and
    # missing (None) equals only missing.
    if a is None or b is None:
        return a is b
    if a != a and b != b:
        return True
    if not bool(a == b):
        return False
    if isinstance(a, (int, float, np.number)) and isinstance(b, (int, float, np.number)) and a == 0:
        return bool(np.signbit(a) == np.signbit(b))
    return True


def _brm_partition_rows_np(values, ncells, table, lo, hi):
    counts = np.zeros((ncells,), dtype=np.int64)
    if np.logical_not((len(values) == 0)):
        previous = values[0]
        value = _brm_label_position_np(table, lo, hi, previous)
        at = value
        for r_2 in range(1, len(values) + 1):
            if np.logical_not(_rk_isequal_np(values[r_2 - 1], previous)):
                previous = values[r_2 - 1]
                value_2 = _brm_label_position_np(table, lo, hi, previous)
                at = value_2
            if at != 0:
                counts[at - 1] = counts[at - 1] + 1
    rows = [np.zeros((counts[k - 1],), dtype=np.int64) for k in range(1, ncells + 1)]
    for k_2 in range(1, ncells + 1):
        counts[k_2 - 1] = 0
    if np.logical_not((len(values) == 0)):
        previous = values[0]
        value_3 = _brm_label_position_np(table, lo, hi, previous)
        at = value_3
        for r_3 in range(1, len(values) + 1):
            if np.logical_not(_rk_isequal_np(values[r_3 - 1], previous)):
                previous = values[r_3 - 1]
                value_4 = _brm_label_position_np(table, lo, hi, previous)
                at = value_4
            if at != 0:
                counts[at - 1] = counts[at - 1] + 1
                rows[at - 1][counts[at - 1] - 1] = r_3
    return rows


def _brm_ragged_partition_np(x, group, values, labels, prefix):
    value = _brm_check_missing_labels_np(x, group, values, prefix)
    value_2 = _brm_hashed_label_table_np(labels)
    value_3 = _brm_partition_rows_np(values, len(labels), value_2, None, None)
    rows = value_3
    return rows


def _brm_ragged_rows_np(names, groups, cells, axes):
    value = _brm_cell_labels_np(cells, names[2], "RK backend")
    labels = value
    value_2 = _brm_group_values_np(groups)
    values = value_2
    value_3 = _brm_check_ragged_axes_np(names, 3, axes, len(values), "RK backend")
    value_4 = _brm_ragged_partition_np(names[0], names[1], values, labels, "RK backend")
    return value_4


class StaticInt(int):
    """An integer of the prepared data that sets a shape.

    It is an `int` everywhere, and `jax.jit` treats it as static, so the
    functions jit with the prepared data as arguments; a new value traces
    them again.
    """

    def __repr__(self):
        return "StaticInt(%d)" % int(self)


jax.tree_util.register_pytree_node(StaticInt, lambda s: ((), int(s)), lambda v, _: StaticInt(v))


def _rk_pad_rows(rows, dtype, rank=1):
    # A ragged value as the functions take it: the padded array (each row
    # repeats its last entry; an empty row is zeros), the lengths, and the
    # positions of the valid entries in the flattened padded array, whose
    # length is the total. `dtype` is the element type the program declares,
    # so an empty row (`[]`) keeps an integer column integer.
    rows = [np.asarray(r, dtype=dtype) for r in rows]
    # One length per cell describes its first axis. Other axes retain a
    # common shape; independently ragged axes need separate extents.
    tail = rows[0].shape[1:] if rows else (1,) * (rank - 1)
    if any(r.ndim != rank or r.shape[1:] != tail for r in rows):
        raise ValueError("ragged cells need their declared rank and common trailing dimensions")
    lengths = np.asarray([r.shape[0] for r in rows], dtype=np.int64)
    width = max([1 if rank > 1 and not rows else 0] + [int(n) for n in lengths])
    padded = np.stack([np.pad(r, ((0, width - r.shape[0]),) + ((0, 0),) * (rank - 1),
                             mode="edge") if r.shape[0] > 0
                       else np.zeros((width,) + tail, dtype=dtype) for r in rows]) if rows else np.zeros((0, width) + tail, dtype=dtype)
    flat = np.flatnonzero(np.arange(width)[None, :] < lengths[:, None])
    return padded, lengths, flat


def _log_of(x: ArrayLike, active: ArrayLike) -> jax.Array:
    """Compute `_rk_log_of` from its authored source."""
    return jnp.asarray(x, dtype=jnp.float64)


def brm_group_effects_density(
    ppl_last_z: ArrayLike,
    tau: ArrayLike,
    unconstrained: ArrayLike,
    *,
    outputs: tuple[str, ...],
) -> dict:
    """Group-level (varying) effects of grouping `g`.

    Non-centered, from the scale `tau[1]` (drawn from its prior) and standardized effects
    `z[1:length(levels(g)), 1:1] ~ Normal(0, 1)`. Returns the
    level-by-margin matrix `z .* tau[1]`, one row per level of `g` in order.
    """
    results = {}
    if any(name in outputs for name in ("ppl_arrflat_z", "ppl_prior_z", "ppl_pw_prior_z")):
        ppl_arrflat_z = unconstrained[4:ppl_last_z]
    if any(name in outputs for name in ("ppl_prior_tau", "ppl_pw_prior_tau")):
        def ppl_pw_prior_tau_cell(tau_2):
            log_scale = np.log(0.3)
            logpdf = jax.lax.cond(tau_2 < 0, lambda: -jnp.inf, lambda: -log_scale - tau_2 / 0.3)
            return logpdf
        ppl_pw_prior_tau = (jnp.zeros(tau.shape[:1], dtype=jnp.float64) if 0 in tau.shape[:1] else jax.vmap(ppl_pw_prior_tau_cell, in_axes=(0,))(tau))
    if any(name in outputs for name in ("ppl_prior_tau",)):
        ppl_prior_tau = jnp.sum(ppl_pw_prior_tau)
    if any(name in outputs for name in ("ppl_prior_z", "ppl_pw_prior_z")):
        def ppl_pw_prior_z_cell(z):
            log_scale = np.log(1.0)
            standardized = (z - 0.0) / jnp.where((z == 0.0 if 1.0 == 0 else False), 1.0, 1.0)
            standard_logpdf = -0.5 * np.log(2 * np.pi) - 0.5 * standardized ** 2
            logpdf = standard_logpdf - jnp.where((z != 0.0 if 1.0 == 0 else False), 0.0, log_scale)
            return logpdf
        ppl_pw_prior_z = (jnp.zeros(ppl_arrflat_z.shape[:1], dtype=jnp.float64) if 0 in ppl_arrflat_z.shape[:1] else jax.vmap(ppl_pw_prior_z_cell, in_axes=(0,))(ppl_arrflat_z))
    if any(name in outputs for name in ("ppl_prior_z",)):
        ppl_prior_z = jnp.sum(ppl_pw_prior_z)
    if "ppl_arrflat_z" in outputs:
        results["ppl_arrflat_z"] = ppl_arrflat_z
    if "ppl_prior_tau" in outputs:
        results["ppl_prior_tau"] = ppl_prior_tau
    if "ppl_prior_z" in outputs:
        results["ppl_prior_z"] = ppl_prior_z
    if "ppl_pw_prior_tau" in outputs:
        results["ppl_pw_prior_tau"] = ppl_pw_prior_tau
    if "ppl_pw_prior_z" in outputs:
        results["ppl_pw_prior_z"] = ppl_pw_prior_z
    return results


def brm_group_effects(tau: ArrayLike, z: ArrayLike, *, outputs: tuple[str, ...]) -> dict:
    """Group-level (varying) effects of grouping `g`.

    Non-centered, from the scale `tau[1]` (drawn from its prior) and standardized effects
    `z[1:length(levels(g)), 1:1] ~ Normal(0, 1)`. Returns the
    level-by-margin matrix `z .* tau[1]`, one row per level of `g` in order.
    """
    results = {}
    if any(name in outputs for name in ("value",)):
        value = z * tau[0]
    if "value" in outputs:
        results["value"] = value
    return results


def prepare_data(observation_unit: Any, time: ArrayLike, unit: Any, unit_fit: Any, y: list) -> dict:
    """The functions' data inputs, computed from the raw data once per dataset.

    Pass the data by the names the model reads them; a list of arrays is a ragged
    column. Call the other functions with the result: `f(u, **prepared)`.
    """
    observation_unit = np.asarray(observation_unit, dtype=object)
    time = np.asarray(time, dtype=np.float64)
    unit = np.asarray(unit, dtype=object)
    unit_fit = np.asarray(unit_fit, dtype=object)
    y = [np.asarray(a, dtype=np.float64) for a in y]
    value = _brm_fit_levels_np(unit_fit)
    unit_fit_levels = value
    value_2 = _brm_level_indices_np(unit, unit_fit_levels)
    unit_level = np.asarray(value_2, dtype=np.int64)
    ppl_axis1_b_rate_unit_unit_z = len(_rk_levels_np(unit_fit_levels))
    ppl_last_b_rate_unit_unit_z = 4 + ppl_axis1_b_rate_unit_unit_z
    value_3 = _brm_ragged_rows_np(np.stack(["time", "observation_unit", "unit", "time"]), observation_unit, unit, (time,))
    y_cell_rows_2 = value_3
    plate_argument = np.arange(1, len(unit) + 1)
    y_cell_rows_2_padded, y_cell_rows_2_lengths, y_cell_rows_2_flat = _rk_pad_rows(y_cell_rows_2, np.int64, 1)
    y_padded, y_lengths, y_flat = _rk_pad_rows(y, np.float64, 1)
    return {"ppl_last_b_rate_unit_unit_z": StaticInt(ppl_last_b_rate_unit_unit_z), "ppl_axis1_b_rate_unit_unit_z": StaticInt(ppl_axis1_b_rate_unit_unit_z), "unit_level": np.asarray(unit_level, dtype=np.int64), "plate_argument": np.asarray(plate_argument, dtype=np.int64), "time": np.asarray(time, dtype=np.float64), "y_cell_rows_2": y_cell_rows_2_padded, "y_cell_rows_2_lengths": y_cell_rows_2_lengths, "y_cell_rows_2_flat": y_cell_rows_2_flat, "y": y_padded, "y_lengths": y_lengths, "y_flat": y_flat}


def model(_entry: str, unconstrained: ArrayLike, **prepared: ArrayLike) -> Any:
    """Shared model computation. The generated entry wrappers select a static output."""
    ppl_last_b_rate_unit_unit_z = prepared["ppl_last_b_rate_unit_unit_z"]
    ppl_axis1_b_rate_unit_unit_z = prepared["ppl_axis1_b_rate_unit_unit_z"]
    unit_level = prepared["unit_level"]
    plate_argument = prepared["plate_argument"]
    time = prepared["time"]
    y_cell_rows_2 = prepared["y_cell_rows_2"]
    y_cell_rows_2_lengths = prepared["y_cell_rows_2_lengths"]
    y_cell_rows_2_flat = prepared["y_cell_rows_2_flat"]
    y = prepared["y"]
    y_lengths = prepared["y_lengths"]
    y_flat = prepared["y_flat"]
    unconstrained = jnp.asarray(unconstrained)
    unit_level = jnp.asarray(unit_level)
    plate_argument = jnp.asarray(plate_argument)
    time = jnp.asarray(time)
    y_cell_rows_2 = jnp.asarray(y_cell_rows_2)
    y_cell_rows_2_lengths = jnp.asarray(y_cell_rows_2_lengths)
    y_cell_rows_2_flat = jnp.asarray(y_cell_rows_2_flat)
    y = jnp.asarray(y)
    y_lengths = jnp.asarray(y_lengths)
    y_flat = jnp.asarray(y_flat)
    if _entry in ("log_density", "log_prior", "log_likelihood", "constrain"):
        rate_Intercept = unconstrained[0]
        u_argument = unconstrained[1]
        constrain_2 = jnp.exp(u_argument)
        u_argument_2 = unconstrained[2]
        constrain_3 = jnp.exp(u_argument_2)
        plate_argument_2 = unconstrained[3:4]
        def b_rate_unit_unit_tau_cell(ppl_cell_b_rate_unit_unit_tau):
            constrain_4 = jnp.exp(ppl_cell_b_rate_unit_unit_tau)
            return constrain_4
        b_rate_unit_unit_tau = (jnp.zeros(plate_argument_2.shape[:1], dtype=jnp.float64) if 0 in plate_argument_2.shape[:1] else jax.vmap(b_rate_unit_unit_tau_cell, in_axes=(0,))(plate_argument_2))
    if _entry in ("log_density", "log_jacobian"):
        plate_argument_3 = unconstrained[3:4]
        def ppl_ljcells_b_rate_unit_unit_tau_cell(ppl_cell_b_rate_unit_unit_tau):
            return ppl_cell_b_rate_unit_unit_tau
        ppl_ljcells_b_rate_unit_unit_tau = (jnp.zeros(plate_argument_3.shape[:1], dtype=jnp.float64) if 0 in plate_argument_3.shape[:1] else jax.vmap(ppl_ljcells_b_rate_unit_unit_tau_cell, in_axes=(0,))(plate_argument_3))
    if _entry in ("log_density", "log_prior"):
        ppl_prior_rate_Intercept_log_scale = np.log(0.5)
        ppl_prior_rate_Intercept_standardized = (rate_Intercept - -1.0) / jnp.where((rate_Intercept == -1.0 if 0.5 == 0 else False), 1.0, 0.5)
        ppl_prior_rate_Intercept_standard_logpdf = -0.5 * np.log(2 * np.pi) - 0.5 * ppl_prior_rate_Intercept_standardized ** 2
        logpdf = ppl_prior_rate_Intercept_standard_logpdf - jnp.where((rate_Intercept != -1.0 if 0.5 == 0 else False), 0.0, ppl_prior_rate_Intercept_log_scale)
        ppl_prior_amplitude_log_scale = np.log(0.5)
        def else_arm():
            log_of = _log_of(u_argument, jnp.logical_not(constrain_2 <= 0))
            return log_of
        ppl_prior_amplitude_logpdf_log_x = jax.lax.cond(constrain_2 <= 0, lambda: -jnp.inf, else_arm)
        ppl_prior_amplitude_logpdf_jacobian = jnp.where(constrain_2 <= 0, 0.0, ppl_prior_amplitude_logpdf_log_x)
        ppl_prior_amplitude_logpdf_logpdf_standardized = (ppl_prior_amplitude_logpdf_log_x - 0.0) / jnp.where((ppl_prior_amplitude_logpdf_log_x == 0.0 if 0.5 == 0 else False), 1.0, 0.5)
        ppl_prior_amplitude_logpdf_logpdf_standard_logpdf = -0.5 * np.log(2 * np.pi) - 0.5 * ppl_prior_amplitude_logpdf_logpdf_standardized ** 2
        ppl_prior_amplitude_logpdf = ppl_prior_amplitude_logpdf_logpdf_standard_logpdf - jnp.where((ppl_prior_amplitude_logpdf_log_x != 0.0 if 0.5 == 0 else False), 0.0, ppl_prior_amplitude_log_scale)
        logpdf_2 = ppl_prior_amplitude_logpdf - ppl_prior_amplitude_logpdf_jacobian
        ppl_prior_noise_log_scale = np.log(0.2)
        logpdf_3 = jax.lax.cond(constrain_3 < 0, lambda: -jnp.inf, lambda: -ppl_prior_noise_log_scale - constrain_3 / 0.2)
    if _entry in ("log_density", "log_jacobian"):
        u_argument_3 = unconstrained[1]
        u_argument_4 = unconstrained[2]
        plate_fold = jnp.sum(ppl_ljcells_b_rate_unit_unit_tau)
        log_jacobian_2 = u_argument_3 + u_argument_4 + plate_fold
    if _entry in ("log_density", "log_prior", "log_likelihood", "constrain"):
        b_rate_unit_unit = brm_group_effects_density(
            ppl_last_z=(ppl_last_b_rate_unit_unit_z if _entry in ("log_density", "log_prior", "log_likelihood", "constrain") else None),
            tau=(b_rate_unit_unit_tau if _entry in ("log_density", "log_prior") else None),
            unconstrained=(unconstrained if _entry in ("log_density", "log_prior", "log_likelihood", "constrain") else None),
            outputs=tuple(
                name for name, needed in (
                    ("ppl_arrflat_z", ("log_density", "log_prior", "log_likelihood", "constrain")),
                    ("ppl_prior_tau", ("log_density", "log_prior")),
                    ("ppl_prior_z", ("log_density", "log_prior")),
                    ("ppl_pw_prior_tau", ("log_density", "log_prior")),
                    ("ppl_pw_prior_z", ("log_density", "log_prior")),
                )
                if _entry in needed
            ),
        )
    if _entry in ("log_density", "log_likelihood", "constrain"):
        b_rate_unit_unit_z = jnp.reshape(b_rate_unit_unit["ppl_arrflat_z"], (ppl_axis1_b_rate_unit_unit_z, 1), order="F")
    if _entry in ("log_density", "log_prior"):
        prior = logpdf + logpdf_2 + logpdf_3 + b_rate_unit_unit["ppl_prior_tau"] + b_rate_unit_unit["ppl_prior_z"]
    if _entry in ("log_density", "log_likelihood"):
        b_rate_unit_unit_2 = brm_group_effects(
            tau=(b_rate_unit_unit_tau if _entry in ("log_density", "log_likelihood") else None),
            z=(b_rate_unit_unit_z if _entry in ("log_density", "log_likelihood") else None),
            outputs=tuple(
                name for name, needed in (
                    ("value", ("log_density", "log_likelihood")),
                )
                if _entry in needed
            ),
        )
        ppl_column_b_rate_unit_unit_1 = b_rate_unit_unit_2["value"][:, 0]
        plate_argument_4 = ppl_column_b_rate_unit_unit_1[unit_level - 1]
        def log_rate_cell(rate_Intercept_2, value):
            plate_value = rate_Intercept_2 + value
            return plate_value
        log_rate = (jnp.zeros(plate_argument_4.shape[:1], dtype=jnp.float64) if 0 in plate_argument_4.shape[:1] else jax.vmap(log_rate_cell, in_axes=(None, 0))(rate_Intercept, plate_argument_4))
        rate = jnp.exp(log_rate)
        def y_cell_argument_y_1_cell(ppl_pi_y_cell_argument_y_1, time_2, amplitude, rate_2, y_cell_rows_2_2, y_cell_rows_2_n):
            ppl_linear_time = time_2
            mean_y = amplitude * jnp.exp(-rate_2[ppl_pi_y_cell_argument_y_1 - 1] * ppl_linear_time[y_cell_rows_2_2[ppl_pi_y_cell_argument_y_1 - 1] - 1])
            return (mean_y, y_cell_rows_2_n[ppl_pi_y_cell_argument_y_1 - 1])
        plate_value, plate_lengths = ((jnp.zeros((0, 0), dtype=jnp.float64), jnp.zeros((0,), dtype=jnp.int64)) if 0 in plate_argument.shape[:1] else jax.vmap(y_cell_argument_y_1_cell, in_axes=(0, None, None, None, None, None))(plate_argument, time, constrain_2, rate, y_cell_rows_2, y_cell_rows_2_lengths))
        y_cell_argument_y_1 = plate_value
        def ppl_pw_y_resp_totals_cell(ppl_group_y, ppl_group_y_n, ppl_group_y_cell_argument_y_1, ppl_group_y_cell_argument_y_1_n, noise):
            def ppl_pw_y_resp_group_cell(ppl_group_y_2, ppl_group_y_cell_argument_y_1_2, noise_2, active_cell):
                def then_arm():
                    log_scale = jnp.log(noise_2)
                    standardized = (ppl_group_y_2 - ppl_group_y_cell_argument_y_1_2) / jnp.where(jnp.logical_and(noise_2 == 0, ppl_group_y_2 == ppl_group_y_cell_argument_y_1_2), 1.0, noise_2)
                    standard_logpdf = -0.5 * np.log(2 * np.pi) - 0.5 * standardized ** 2
                    return standard_logpdf - jnp.where(jnp.logical_and(noise_2 == 0, ppl_group_y_2 != ppl_group_y_cell_argument_y_1_2), 0.0, log_scale)
                ppl_density = jax.lax.cond(noise_2 > 0, then_arm, lambda: -jnp.inf)
                return ppl_density
            ppl_pw_y_resp_group = (jnp.zeros(ppl_group_y.shape[:1], dtype=jnp.float64) if 0 in ppl_group_y.shape[:1] and ppl_group_y_cell_argument_y_1.shape[:1] == ppl_group_y.shape[:1] else jax.vmap(ppl_pw_y_resp_group_cell, in_axes=(0, 0, None, 0))(ppl_group_y, ppl_group_y_cell_argument_y_1, noise, jnp.logical_and(jnp.broadcast_to((jnp.arange(ppl_group_y.shape[0]) < ppl_group_y_n), ppl_group_y.shape[:1]), jnp.broadcast_to((jnp.arange(ppl_group_y_cell_argument_y_1.shape[0]) < ppl_group_y_cell_argument_y_1_n), ppl_group_y_cell_argument_y_1.shape[:1]))))
            ppl_group_total = jnp.sum(jnp.where((jnp.arange(ppl_pw_y_resp_group.shape[0]) < ppl_group_y_n), ppl_pw_y_resp_group, 0.0))
            return ppl_group_total
        ppl_pw_y_resp_totals = (jnp.zeros(y.shape[:1], dtype=jnp.float64) if 0 in y.shape[:1] and y_cell_argument_y_1.shape[:1] == y.shape[:1] else jax.vmap(ppl_pw_y_resp_totals_cell, in_axes=(0, 0, 0, 0, None))(y, y_lengths, y_cell_argument_y_1, y_cell_rows_2_lengths[plate_argument - 1], constrain_3))
        ppl_lik_y_resp = jnp.sum(ppl_pw_y_resp_totals)
    if _entry in ("log_density",):
        posterior = prior + ppl_lik_y_resp + log_jacobian_2
    if not (unconstrained.size == ppl_last_b_rate_unit_unit_z):
        raise ValueError("[layout] packed length ≠ layout total: a packed point holds the coordinates of the binding whose layout packed it")
    if _entry == "log_density":
        return jnp.asarray(posterior, dtype=jnp.float64)
    if _entry == "log_prior":
        return jnp.asarray(prior, dtype=jnp.float64)
    if _entry == "log_likelihood":
        return jnp.asarray(ppl_lik_y_resp, dtype=jnp.float64)
    if _entry == "log_jacobian":
        return jnp.asarray(log_jacobian_2, dtype=jnp.float64)
    if _entry == "constrain":
        return {"rate_Intercept": jnp.asarray(rate_Intercept, dtype=jnp.float64), "amplitude": jnp.asarray(constrain_2, dtype=jnp.float64), "noise": jnp.asarray(constrain_3, dtype=jnp.float64), "b_rate__unit_unit": {"tau": jnp.asarray(b_rate_unit_unit_tau), "z": jnp.asarray(b_rate_unit_unit_z)}}


def log_density(unconstrained: ArrayLike, **prepared: ArrayLike) -> jax.Array:
    """The log density a sampler targets at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`.

    The sum of `log_prior`, `log_likelihood` and `log_jacobian`.
    """
    return model("log_density", unconstrained, **prepared)


def log_prior(unconstrained: ArrayLike, **prepared: ArrayLike) -> jax.Array:
    """The log prior density of the constrained parameters at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`."""
    return model("log_prior", unconstrained, **prepared)


def log_likelihood(unconstrained: ArrayLike, **prepared: ArrayLike) -> jax.Array:
    """The log likelihood of the observations at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`."""
    return model("log_likelihood", unconstrained, **prepared)


def log_jacobian(unconstrained: ArrayLike, **prepared: ArrayLike) -> jax.Array:
    """The log Jacobian of the constraining transforms at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`."""
    return model("log_jacobian", unconstrained, **prepared)


def constrain(unconstrained: ArrayLike, **prepared: ArrayLike) -> dict:
    """The constrained value of each parameter, and of each requested value, at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`. Returns a dict, a submodel's values nested under its name:

    - `rate_Intercept`
    - `amplitude`
    - `noise`
    - `b_rate__unit_unit.tau`
    - `b_rate__unit_unit.z`
    """
    return model("constrain", unconstrained, **prepared)


def dimension(prepared: dict) -> int:
    """The length of `unconstrained` for the data `prepared` (what `prepare_data` returned)."""
    return int(prepared["ppl_last_b_rate_unit_unit_z"])


def parameters(prepared: dict) -> dict:
    """Each parameter's 0-based `start`/`stop` in `unconstrained`, its transform and dimensions,
    for the data `prepared` (what `prepare_data` returned)."""
    return {"rate_Intercept": {"start": 0, "stop": 1, "transform": "identity", "dims": ()}, "amplitude": {"start": 1, "stop": 2, "transform": "exp", "dims": ()}, "noise": {"start": 2, "stop": 3, "transform": "exp", "dims": ()}, "b_rate__unit_unit.tau": {"start": 3, "stop": 4, "transform": "exp", "dims": (1,)}, "b_rate__unit_unit.z": {"start": 4, "stop": int(prepared["ppl_last_b_rate_unit_unit_z"]), "transform": "identity", "dims": (int(prepared["ppl_axis1_b_rate_unit_unit_z"]), 1)}}

The loop follows the unit-level rate vector. Inside the cell, rate[i] is a unit's value, time[rows[i]] its observations, and bare amplitude is shared. Cell code uses Julia broadcasting explicitly. A bare left-hand name is local; an indexed left-hand name exposes a model output. Observe the response slice directly: an assignment that aliases it does not become a new observation.

For long-format series, @plate for p in groups(unit; order=time) iterates each unit's ordered row indices. An @scan within the cell states a recurrence; AR1Normal(mu[p], sigma, phi; time=time[p]) supplies an AR(1) residual law that accounts for gaps. Response families distinguishes residual dependence from a latent rw, dar or cdar term.

Reusable components ​

A function-style component gives each call its own parameters. Shared values are explicit arguments. This calibration is used twice with separate local intercepts and slopes.

brm-comparison
Independent calls with a shared prior scale
panes: brm|stanblocks|rkppl|stan|jax:3
julia
"A calibration curve; every call owns its intercept and slope."
@brm function calibration(x, shared_scale)
    value = a + b * x
    a ~ Normal(0, shared_scale)
    b ~ Normal(1, 0.2)
    return value
end

joint = @brm begin
    left ~ calibration(x_left, shared_scale)
    right ~ calibration(x_right, shared_scale)
    y_left ~ Normal(left, noise)
    y_right ~ Normal(right, noise)
    shared_scale ~ Exponential(1)
    noise ~ Exponential(0.5)
end
model = joint((; x_left=[-0.4, 0.2, 0.7], x_right=[0.3, -0.2],
    y_left=[0.1, 0.4, 0.8], y_right=[0.3, -0.1]))
julia
SBBRMI with data keys = [:x_left, :x_right, :y_left, :y_right]
emitted @slic body:
begin
    shared_scale ~ exponential(1.0 ./ 1)
    left ~ (SlicModel(untraced; inputs=0, statements=5))(; x = x_left, shared_scale = shared_scale)
    right ~ (SlicModel(untraced; inputs=0, statements=5))(; x = x_right, shared_scale = shared_scale)
    noise ~ exponential(1.0 ./ 0.5)
    y_left ~ normal(left, noise)
    y_right ~ normal(right, noise)
end
julia
"""
A calibration curve; every call owns its intercept and slope.
"""
left_component(x, shared_scale) = begin
        b ~ Normal(1.0, 0.2)
        a ~ Normal(0.0, shared_scale)
        value = a .+ b .* x
        component_result = value
        return component_result
    end

"""
A calibration curve; every call owns its intercept and slope.
"""
right_component(x, shared_scale) = begin
        b ~ Normal(1.0, 0.2)
        a ~ Normal(0.0, shared_scale)
        value = a .+ b .* x
        component_result = value
        return component_result
    end

begin
    shared_scale ~ Exponential(1.0)
    noise ~ Exponential(0.5)
    Core.@doc "A calibration curve; every call owns its intercept and slope." left ~ left_component(x_left, shared_scale)
    Core.@doc "A calibration curve; every call owns its intercept and slope." right ~ right_component(x_right, shared_scale)
    y_left .~ Normal.(left, noise)
    y_right .~ Normal.(right, noise)
end
stan
functions {
vector normal_lpdfs(
    vector obs,
    vector loc,
    real scale
) {
    return jbroadcasted_normal_lpdfs(obs, loc, scale);
}
vector jbroadcasted_normal_lpdfs(
    vector x1,
    vector x2,
    real x3
) {
    int n = dims(x1)[1];
    vector[n] rv;
    for(i in 1:n) {
        rv[i] = normal_lpdfs(broadcasted_getindex(x1, i), broadcasted_getindex(x2, i), x3);
    }
    return rv;
}
real normal_lpdfs(
    real args1,
    real args2,
    real args3
) {
    return normal_lpdf(args1 | args2, args3);
}
real broadcasted_getindex(vector x, int i) {
    return x[i];
}
vector normal_vector_rng(
    int anontok__1,
    vector a,
    real b
) {
    int n = anontok__1;
    if((n == 0)) {
        vector[n] rv;
        return rv;
    } else {
        return to_vector(normal_rng(a, b));
    }
}
}
data {
    int x_left_n;
    vector[x_left_n] x_left;
    int x_right_n;
    vector[x_right_n] x_right;
    int y_left_n;
    vector[y_left_n] y_left;
    int y_right_n;
    vector[y_right_n] y_right;
}
transformed data {
}
parameters {
    real<lower=0.0> shared_scale;
    real left_b;
    real left_a;
    real right_b;
    real right_a;
    real<lower=0.0> noise;
}
transformed parameters {
    vector[x_left_n] left_value = (left_a + (left_b .* x_left));
    vector[x_left_n] left_component_result = left_value;
    vector[x_left_n] left = left_component_result;
    vector[x_right_n] right_value = (right_a + (right_b .* x_right));
    vector[x_right_n] right_component_result = right_value;
    vector[x_right_n] right = right_component_result;
}
model {
    shared_scale ~ exponential((1.0 ./ 1));
    left_b ~ normal(1, 0.2);
    left_a ~ normal(0, shared_scale);
    right_b ~ normal(1, 0.2);
    right_a ~ normal(0, shared_scale);
    noise ~ exponential((1.0 ./ 0.5));
    y_left ~ normal(left, noise);
    y_right ~ normal(right, noise);
}
generated quantities {
    vector[y_left_n] y_left_likelihood = normal_lpdfs(y_left, left, noise);
    vector[y_left_n] y_left_gen = normal_vector_rng(y_left_n, left, noise);
    vector[y_right_n] y_right_likelihood = normal_lpdfs(y_right, right, noise);
    vector[y_right_n] y_right_gen = normal_vector_rng(y_right_n, right, noise);
}
julia
using ReactiveKernels, ReactiveKernelsPPL
rk = RKBRMI(model)
source = jax_source(rk.model, rk_bound_plan(rk))
write("model.py", source)
inputs = rk_bound_data(rk, source)   # exactly the inputs prepare_data reads
python
import jax
import model as m

prepared = m.prepare_data(**inputs)
lp = m.log_density(u, **prepared)               # u: unconstrained, length m.dimension(prepared)
lp = jax.jit(m.log_density)(u, **prepared)      # one compiled function for every dataset of these shapes
python
"""Generated by ReactiveKernelsPPL.jax_source from a built @rkppl program; do not edit.

Data: x_left, x_right, y_left, y_right.

Model documentation:

- `left`: A calibration curve; every call owns its intercept and slope.
- `right`: A calibration curve; every call owns its intercept and slope.
- `left`: A calibration curve; every call owns its intercept and slope.
- `right`: A calibration curve; every call owns its intercept and slope.
"""
import numpy as np
import scipy.special as ssp
from typing import Any

import jax
import jax.numpy as jnp
import jax.scipy.linalg
import jax.scipy.special as jsp
from jax.typing import ArrayLike

jax.config.update("jax_enable_x64", True)

DIMENSION = 6
PARAMETERS = {"shared_scale": {"start": 0, "stop": 1, "transform": "exp", "dims": ()}, "noise": {"start": 1, "stop": 2, "transform": "exp", "dims": ()}, "left.b": {"start": 2, "stop": 3, "transform": "identity", "dims": ()}, "left.a": {"start": 3, "stop": 4, "transform": "identity", "dims": ()}, "right.b": {"start": 4, "stop": 5, "transform": "identity", "dims": ()}, "right.a": {"start": 5, "stop": 6, "transform": "identity", "dims": ()}}
DATA = {"x_left": {"dtype": "float64", "ndim": 1, "ragged": False}, "x_right": {"dtype": "float64", "ndim": 1, "ragged": False}, "y_left": {"dtype": "float64", "ndim": 1, "ragged": False}, "y_right": {"dtype": "float64", "ndim": 1, "ragged": False}}
INPUTS = ("unconstrained", "x_left", "x_right", "y_left", "y_right")
PREPARED = {"x_left": {"dtype": "float64", "ndim": 1, "ragged": False}, "x_right": {"dtype": "float64", "ndim": 1, "ragged": False}, "y_left": {"dtype": "float64", "ndim": 1, "ragged": False}, "y_right": {"dtype": "float64", "ndim": 1, "ragged": False}}
UNTRANSLATED = {}


def _log_of(x: ArrayLike) -> jax.Array:
    """Compute `_rk_log_of` from its authored source."""
    return jnp.asarray(x, dtype=jnp.float64)


def left_component(
    a: ArrayLike,
    b: ArrayLike,
    shared_scale: ArrayLike,
    u_argument: ArrayLike,
    x: ArrayLike,
    *,
    outputs: tuple[str, ...],
) -> dict:
    """A calibration curve; every call owns its intercept and slope."""
    results = {}
    if any(name in outputs for name in ("value",)):
        def value_cell(a_2, b_2, x_2):
            plate_value = a_2 + b_2 * x_2
            return plate_value
        value = (jnp.zeros(x.shape[:1], dtype=jnp.float64) if 0 in x.shape[:1] else jax.vmap(value_cell, in_axes=(None, None, 0))(a, b, x))
    if any(name in outputs for name in ("ppl_prior_a", "ppl_prior_a_location", "ppl_prior_a_standard_logpdf")):
        ppl_prior_a_location = 0.0
    if any(name in outputs for name in ("ppl_prior_a", "ppl_prior_a_log_scale")):
        log_of = _log_of(u_argument)
        ppl_prior_a_log_scale = log_of
    if any(name in outputs for name in ("ppl_prior_a", "ppl_prior_a_standard_logpdf")):
        ppl_prior_a_logpdf_z = (a - ppl_prior_a_location) / jnp.where(jnp.logical_and(shared_scale == 0, a == ppl_prior_a_location), 1.0, shared_scale)
        ppl_prior_a_standard_logpdf = -0.5 * np.log(2 * np.pi) - 0.5 * ppl_prior_a_logpdf_z ** 2
    if any(name in outputs for name in ("ppl_prior_a",)):
        ppl_prior_a = ppl_prior_a_standard_logpdf - jnp.where(jnp.logical_and(shared_scale == 0, a != ppl_prior_a_location), 0.0, ppl_prior_a_log_scale)
    if "ppl_prior_a" in outputs:
        results["ppl_prior_a"] = ppl_prior_a
    if "ppl_prior_a_location" in outputs:
        results["ppl_prior_a_location"] = ppl_prior_a_location
    if "ppl_prior_a_log_scale" in outputs:
        results["ppl_prior_a_log_scale"] = ppl_prior_a_log_scale
    if "ppl_prior_a_standard_logpdf" in outputs:
        results["ppl_prior_a_standard_logpdf"] = ppl_prior_a_standard_logpdf
    if "value" in outputs:
        results["value"] = value
    return results


def prepare_data(x_left: ArrayLike, x_right: ArrayLike, y_left: ArrayLike, y_right: ArrayLike) -> dict:
    """The functions' data inputs, computed from the raw data once per dataset.

    Pass the data by the names the model reads them; a list of arrays is a ragged
    column. Call the other functions with the result: `f(u, **prepared)`.
    """
    x_left = np.asarray(x_left, dtype=np.float64)
    x_right = np.asarray(x_right, dtype=np.float64)
    y_left = np.asarray(y_left, dtype=np.float64)
    y_right = np.asarray(y_right, dtype=np.float64)
    return {"x_left": np.asarray(x_left, dtype=np.float64), "x_right": np.asarray(x_right, dtype=np.float64), "y_left": np.asarray(y_left, dtype=np.float64), "y_right": np.asarray(y_right, dtype=np.float64)}


def model(_entry: str, unconstrained: ArrayLike, **prepared: ArrayLike) -> Any:
    """Shared model computation. The generated entry wrappers select a static output."""
    x_left = prepared["x_left"]
    x_right = prepared["x_right"]
    y_left = prepared["y_left"]
    y_right = prepared["y_right"]
    unconstrained = jnp.asarray(unconstrained)
    x_left = jnp.asarray(x_left)
    x_right = jnp.asarray(x_right)
    y_left = jnp.asarray(y_left)
    y_right = jnp.asarray(y_right)
    if _entry in ("log_density", "log_prior", "constrain"):
        u_argument = unconstrained[0]
        constrain_2 = jnp.exp(u_argument)
    if _entry in ("log_density", "log_prior", "log_likelihood", "constrain"):
        u_argument_2 = unconstrained[1]
        constrain_3 = jnp.exp(u_argument_2)
        left_b = unconstrained[2]
        left_a = unconstrained[3]
    if _entry in ("log_density", "log_prior", "log_likelihood"):
        left = left_component(
            a=(left_a if _entry in ("log_density", "log_prior", "log_likelihood") else None),
            b=(left_b if _entry in ("log_density", "log_likelihood") else None),
            shared_scale=(constrain_2 if _entry in ("log_density", "log_prior") else None),
            u_argument=(u_argument if _entry in ("log_density", "log_prior") else None),
            x=(x_left if _entry in ("log_density", "log_likelihood") else None),
            outputs=tuple(
                name for name, needed in (
                    ("ppl_prior_a", ("log_density", "log_prior")),
                    ("ppl_prior_a_location", ("log_density", "log_prior")),
                    ("ppl_prior_a_log_scale", ("log_density", "log_prior")),
                    ("ppl_prior_a_standard_logpdf", ("log_density", "log_prior")),
                    ("value", ("log_density", "log_likelihood")),
                )
                if _entry in needed
            ),
        )
    if _entry in ("log_density", "log_prior", "log_likelihood", "constrain"):
        right_b = unconstrained[4]
        right_a = unconstrained[5]
    if _entry in ("log_density", "log_likelihood"):
        def right_value_cell(right_a_2, right_b_2, x_right_2):
            plate_value = right_a_2 + right_b_2 * x_right_2
            return plate_value
        right_value = (jnp.zeros(x_right.shape[:1], dtype=jnp.float64) if 0 in x_right.shape[:1] else jax.vmap(right_value_cell, in_axes=(None, None, 0))(right_a, right_b, x_right))
        def ppl_pw_y_left_resp_cell(y_left_2, left_2, noise):
            def then_arm():
                log_scale = jnp.log(noise)
                standardized = (y_left_2 - left_2) / jnp.where(jnp.logical_and(noise == 0, y_left_2 == left_2), 1.0, noise)
                standard_logpdf = -0.5 * np.log(2 * np.pi) - 0.5 * standardized ** 2
                return standard_logpdf - jnp.where(jnp.logical_and(noise == 0, y_left_2 != left_2), 0.0, log_scale)
            ppl_density = jax.lax.cond(noise > 0, then_arm, lambda: -jnp.inf)
            return ppl_density
        ppl_pw_y_left_resp = (jnp.zeros(y_left.shape[:1], dtype=jnp.float64) if 0 in y_left.shape[:1] and left["value"].shape[:1] == y_left.shape[:1] else jax.vmap(ppl_pw_y_left_resp_cell, in_axes=(0, 0, None))(y_left, left["value"], constrain_3))
        ppl_lik_y_left_resp = jnp.sum(ppl_pw_y_left_resp)
        def ppl_pw_y_right_resp_cell(y_right_2, right, noise):
            def then_arm():
                log_scale = jnp.log(noise)
                standardized = (y_right_2 - right) / jnp.where(jnp.logical_and(noise == 0, y_right_2 == right), 1.0, noise)
                standard_logpdf = -0.5 * np.log(2 * np.pi) - 0.5 * standardized ** 2
                return standard_logpdf - jnp.where(jnp.logical_and(noise == 0, y_right_2 != right), 0.0, log_scale)
            ppl_density = jax.lax.cond(noise > 0, then_arm, lambda: -jnp.inf)
            return ppl_density
        ppl_pw_y_right_resp = (jnp.zeros(y_right.shape[:1], dtype=jnp.float64) if 0 in y_right.shape[:1] and right_value.shape[:1] == y_right.shape[:1] else jax.vmap(ppl_pw_y_right_resp_cell, in_axes=(0, 0, None))(y_right, right_value, constrain_3))
        ppl_lik_y_right_resp = jnp.sum(ppl_pw_y_right_resp)
        likelihood = ppl_lik_y_left_resp + ppl_lik_y_right_resp
    if _entry in ("log_density", "log_prior"):
        ppl_prior_parameters_normal_mu = jnp.asarray([1.0, 1.0], dtype=jnp.float64)
        ppl_prior_parameters_normal_sd = jnp.asarray([0.2, 0.2], dtype=jnp.float64)
        plate_argument = (left_b, right_b)
        def ppl_prior_parameters_normal_pw_cell(value, location, scale):
            log_scale = jnp.log(scale)
            standardized = (value - location) / jnp.where(jnp.logical_and(scale == 0, value == location), 1.0, scale)
            standard_logpdf = -0.5 * np.log(2 * np.pi) - 0.5 * standardized ** 2
            logpdf = standard_logpdf - jnp.where(jnp.logical_and(scale == 0, value != location), 0.0, log_scale)
            return logpdf
        ppl_prior_parameters_normal_pw = (jnp.zeros(jnp.stack(plate_argument).shape[:1], dtype=jnp.float64) if 0 in jnp.stack(plate_argument).shape[:1] and ppl_prior_parameters_normal_mu.shape[:1] == jnp.stack(plate_argument).shape[:1] and ppl_prior_parameters_normal_sd.shape[:1] == jnp.stack(plate_argument).shape[:1] else jax.vmap(ppl_prior_parameters_normal_pw_cell, in_axes=(0, 0, 0))(jnp.stack(plate_argument), ppl_prior_parameters_normal_mu, ppl_prior_parameters_normal_sd))
        ppl_prior_parameters_normal = jnp.sum(ppl_prior_parameters_normal_pw)
        ppl_prior_shared_scale_log_scale = np.log(1.0)
        logpdf = jax.lax.cond(constrain_2 < 0, lambda: -jnp.inf, lambda: -ppl_prior_shared_scale_log_scale - constrain_2 / 1.0)
        ppl_prior_noise_log_scale = np.log(0.5)
        logpdf_2 = jax.lax.cond(constrain_3 < 0, lambda: -jnp.inf, lambda: -ppl_prior_noise_log_scale - constrain_3 / 0.5)
        ppl_prior_right_a_standardized = (right_a - 0.0) / jnp.where(jnp.logical_and(constrain_2 == 0, right_a == 0.0), 1.0, constrain_2)
        ppl_prior_right_a_standard_logpdf = -0.5 * np.log(2 * np.pi) - 0.5 * ppl_prior_right_a_standardized ** 2
        logpdf_3 = ppl_prior_right_a_standard_logpdf - jax.lax.cond(jnp.logical_and(constrain_2 == 0, right_a != 0.0), lambda: 0.0, lambda: left["ppl_prior_a_log_scale"])
        prior = ppl_prior_parameters_normal + logpdf + logpdf_2 + left["ppl_prior_a"] + logpdf_3
    if _entry in ("log_density", "log_jacobian"):
        u_argument_3 = unconstrained[0]
        u_argument_4 = unconstrained[1]
        log_jacobian_2 = u_argument_3 + u_argument_4
    if _entry in ("log_density",):
        posterior = prior + likelihood + log_jacobian_2
    if not (unconstrained.size == 6):
        raise ValueError("[layout] packed length ≠ layout total: a packed point holds the coordinates of the binding whose layout packed it")
    if _entry == "log_density":
        return jnp.asarray(posterior, dtype=jnp.float64)
    if _entry == "log_prior":
        return jnp.asarray(prior, dtype=jnp.float64)
    if _entry == "log_likelihood":
        return jnp.asarray(likelihood, dtype=jnp.float64)
    if _entry == "log_jacobian":
        return jnp.asarray(log_jacobian_2, dtype=jnp.float64)
    if _entry == "constrain":
        return {"shared_scale": jnp.asarray(constrain_2, dtype=jnp.float64), "noise": jnp.asarray(constrain_3, dtype=jnp.float64), "left": {"b": jnp.asarray(left_b, dtype=jnp.float64), "a": jnp.asarray(left_a, dtype=jnp.float64)}, "right": {"b": jnp.asarray(right_b, dtype=jnp.float64), "a": jnp.asarray(right_a, dtype=jnp.float64)}}


def log_density(unconstrained: ArrayLike, **prepared: ArrayLike) -> jax.Array:
    """The log density a sampler targets at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`.

    The sum of `log_prior`, `log_likelihood` and `log_jacobian`.
    """
    return model("log_density", unconstrained, **prepared)


def log_prior(unconstrained: ArrayLike, **prepared: ArrayLike) -> jax.Array:
    """The log prior density of the constrained parameters at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`."""
    return model("log_prior", unconstrained, **prepared)


def log_likelihood(unconstrained: ArrayLike, **prepared: ArrayLike) -> jax.Array:
    """The log likelihood of the observations at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`."""
    return model("log_likelihood", unconstrained, **prepared)


def log_jacobian(unconstrained: ArrayLike, **prepared: ArrayLike) -> jax.Array:
    """The log Jacobian of the constraining transforms at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`."""
    return model("log_jacobian", unconstrained, **prepared)


def constrain(unconstrained: ArrayLike, **prepared: ArrayLike) -> dict:
    """The constrained value of each parameter, and of each requested value, at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`. Returns a dict, a submodel's values nested under its name:

    - `shared_scale`
    - `noise`
    - `left.b`
    - `left.a`
    - `right.b`
    - `right.a`
    """
    return model("constrain", unconstrained, **prepared)


def dimension(prepared: dict) -> int:
    """The length of `unconstrained` for the data `prepared` (what `prepare_data` returned)."""
    return 6


def parameters(prepared: dict) -> dict:
    """Each parameter's 0-based `start`/`stop` in `unconstrained`, its transform and dimensions,
    for the data `prepared` (what `prepare_data` returned)."""
    return {"shared_scale": {"start": 0, "stop": 1, "transform": "exp", "dims": ()}, "noise": {"start": 1, "stop": 2, "transform": "exp", "dims": ()}, "left.b": {"start": 2, "stop": 3, "transform": "identity", "dims": ()}, "left.a": {"start": 3, "stop": 4, "transform": "identity", "dims": ()}, "right.b": {"start": 4, "stop": 5, "transform": "identity", "dims": ()}, "right.a": {"start": 5, "stop": 6, "transform": "identity", "dims": ()}}
julia
using BayesianRegressionModels
model = Main.BRMDocsComparisons.example_module(:ComponentGuide).model
calls = brm_components(model)
@assert length(calls) == 2
[call.path for call in calls]

(:left,)(:right,)

Components accept positional and keyword inputs, including defaults, and resolve functions in their defining module. A named return such as return (; recovery, decay) exposes kin.recovery and kin.decay after kin ~ kinetics(...). Before indexing a returned field in a plate, bind it at model scope, recovery = kin.recovery, then read recovery[i]. brm_components discovers the definitions and call paths; descriptor queries use submodel=:left rather than generated names.

Use merge(structure_a, structure_b, priors_a, priors_b) for fragments that share one namespace. Put structure first and priors last within each scope; moving a cell-local prior outside the plate changes the model. A retained builder can bind new data; reprocess(backend, new_data) instead preserves the fit's preprocessing. These are different operations.

The Warfarin example combines group predictors, nonlinear time courses and observations on several axes.