Skip to contents

Feature compatibility

Source: vignettes/compatibility.Rmd
compatibility.Rmd

This package accepts a large grammar: about thirty families, a dozen addition terms, twenty covariance structures, six predictor specials, eight estimation modes, and several model structures. Most of the combinations are meaningful. Some are refused. A few are accepted and give a wrong answer.

The worst defects in this package’s history were all of the third kind. rescor = TRUE once accepted cens() and then dropped the censoring from the likelihood. frmtmb_control(profile = TRUE) once accepted parameter bounds and applied them to the wrong parameters. Neither raised an error, so neither looked like a defect.

The lesson is that a guard which does not exist looks exactly like a guard that passed. The absence of an error is not evidence of support. This page therefore gives every pair of features one of five states, and it treats “nobody has checked” as a state of its own.

The five states

Symbol Status Meaning
+ works Supported and exercised by the test suite.
~ conditional Supported, but the combination must meet a stated condition.
x refused frm() or the post-fit method stops with an error. The refusal is deliberate.
! broken Accepted, but the result is wrong or the failure does not explain itself. Do not use the pair.
? untested Nothing checks this pair. It may work. Treat a silent success as unverified.

untested is the state that matters most. It does not mean the combination fails. It means that if it fails, it will fail quietly, because nothing in the test suite would notice.

Reading the registry from code

The tables on this page are generated from the registry, so you can ask it the same questions directly.

frm_compat("rescor", "cens()")
#>   feature_a    kind_a feature_b kind_b  status
#> 1    rescor structure    cens()  aterm refused
#>                                                                        note
#> 1 Refused. This pair was once accepted with the censoring silently dropped.

frm_compat("quadrature", "trunc()")$status
#> [1] "refused"

Give one feature to get every pair it takes part in, and status to filter:

head(frm_compat("se()", status = "works"), 3)
#>   feature_a kind_a   feature_b kind_b status
#> 1      se()  aterm    gaussian family  works
#> 2      se()  aterm     student family  works
#> 3      se()  aterm skew_normal family  works
#>                                                                                                                                                         note
#> 1                                                                    Supported. se(x, sigma = TRUE) keeps the estimated residual SD alongside the known one.
#> 2                                                                    Supported. se(x, sigma = TRUE) keeps the estimated residual SD alongside the known one.
#> 3 The known standard deviation is sigma, and se(x, sigma = TRUE) adds the two in quadrature, as brms 2.23.0 writes it. Equal to its log_prob at the optimum.

frm_compat_features() lists the vocabulary. frm_compat_rules() shows the underlying rules, which are written per kind or per feature group rather than per pair.

Combinations to avoid

These pairs are accepted and should not be. Each one is a defect, not a design decision.

Response distributions and addition terms

Addition terms are the most family-sensitive part of the grammar. cens() and trunc() need a family that supplies a cumulative distribution function, and that is all they need: a discrete family that has one is censored and truncated as brms censors and truncates it (see [frmtmb_family()]). mi() needs a family that DECLARES it, with accepts_aterms: the 14 continuous families brms takes it for. On frm(), a missing value no density reads leaves the objective, so the fit is the complete-case one; a value another density reads stays latent under a Laplace approximation, whose size ?bf states. se() needs a family that DECLARES it reads the term, with accepts_aterms; gaussian, student and skew_normal are the built-in ones that do.

weights() trials() cens() trunc() se() mi() vint() vreal() thres() rate() subset() index()
gaussian + x + + + + x x x x + +
student + x + + + + x x x x + +
lognormal + x + + x + x x x x + +
shifted_lognormal + x + ~ x x x x x x + +
skew_normal + x + ~ + + x x x x + +
exgaussian + x + ~ x + x x x x + +
asym_laplace + x + ~ x ~ x x x x + +
Gamma + x + + x + x x x x + +
weibull + x + + x + x x x x + +
exponential + x + + x + x x x x + +
inverse.gaussian + x + + x + x x x x + +
beta + x + ~ x + x x x x + +
tweedie + x x x x x x x x x + +
poisson + x + + x x x x x + + +
negbinomial + x + ~ x x x x x + + +
negbinomial2 + x + ~ x x x x x + + +
nbinom1 + x x x x x x x x x + +
geometric + x + ~ x x x x x + + +
compois + x + ~ x x x x x x + +
binomial + + + ~ x x x x x x + +
bernoulli + x x x x x x x x x + +
beta_binomial + + + ~ x x x x x x + +
zero_inflated_beta_binomial + + + ~ x x x x x x + +
multinomial + ~ x x x x x x x x + +
dirichlet_multinomial + ~ x x x x x x x x + +
zero_inflated_poisson + x + ~ x x x x x x + +
zero_inflated_negbinomial + x + ~ x x x x x x + +
zero_inflated_binomial + + + ~ x x x x x x + +
zero_inflated_beta + x + ~ x x x x x x + +
zero_one_inflated_beta + x x x x x x x x x + +
xbeta + x x x x x x x x x + +
hurdle_poisson + x + ~ x x x x x x + +
hurdle_negbinomial + x + ~ x x x x x x + +
hurdle_gamma + x + ~ x x x x x x + +
hurdle_lognormal + x + ~ x x x x x x + +
cumulative + x x x x x x x + x + +
hurdle_cumulative + x x x x x x x + x + +
sratio + x x x x x x x + x + +
cratio + x x x x x x x + x + +
acat + x x x x x x x + x + +
categorical + x x x x x x x x x + +
von_mises + x + ~ x + x x x x + +
dirichlet + x x x x x x x x x + +
dirichlet2 + x x x x x x x x x + +
logistic_normal + x x x x x x x x x + +
frechet + x + + x + x x x x + +
gen_extreme_value + x + + x + x x x x + +
discrete_weibull + x + + x x x x x x + +
Status Pairs Note
~ shifted_lognormal + trunc(); skew_normal + trunc(); exgaussian + trunc(); asym_laplace + trunc(); beta + trunc(); and 4 more The likelihood and simulate() work; fitted() and residuals(type = “response”) refuse a truncated response, as brms 2.23.0 does: it has no truncated mean for this family.
~ asym_laplace + mi() frm() fits the rows no density reads. A value another density reads is refused: its log density is piecewise linear, so there is no curvature at the mode for the Laplace approximation to read. brms 2.23.0 samples that model, and so does frmtmb.sample::frm_sample().
~ negbinomial + trunc(); negbinomial2 + trunc(); geometric + trunc() As for poisson: trunc(lb = k) is P(Y >= k), brms’s neg_binomial_2_lccdf(lb - 1), and lb <= 0 is no truncation. fitted() reports the truncated mean with the same inclusive lower bound; brms’s posterior_epred_trunc_*() sums from lb + 1, which disagrees with its own likelihood.
~ compois + trunc() As for poisson: trunc(lb = k) is P(Y >= k), brms’s com_poisson_lccdf(lb - 1), and lb <= 0 is no truncation. fitted() and residuals(type = “response”) refuse a truncated response, as brms 2.23.0 does: it has no truncated mean for this family. The likelihood and simulate() work.
~ binomial + trunc() As for poisson: trunc(lb = k) is P(Y >= k), brms’s binomial_lccdf(lb - 1), and lb <= 0 is no truncation. fitted() reports the truncated mean with the same inclusive lower bound; brms’s posterior_epred_trunc_*() sums from lb + 1, which disagrees with its own likelihood.
~ beta_binomial + trunc() As for poisson: trunc(lb = k) is P(Y >= k), brms’s beta_binomial_lccdf(lb - 1), and lb <= 0 is no truncation. fitted() and residuals(type = “response”) refuse a truncated response, as brms 2.23.0 does: it has no truncated mean for this family. The likelihood and simulate() work.
~ zero_inflated_beta_binomial + trunc() As for poisson: trunc(lb = k) is P(Y >= k), brms’s zero_inflated_beta_binomial_lccdf(lb - 1), and lb <= 0 is no truncation. fitted() and residuals(type = “response”) refuse a truncated response, as brms 2.23.0 does: it has no truncated mean for this family. The likelihood and simulate() work.
~ multinomial + trials() Required. The row sums of the response matrix must equal the trials.
~ dirichlet_multinomial + trials() Required, as for multinomial(). The row sums of the response matrix must equal the trials; the density reads the row sums, as brms’s does.
~ zero_inflated_poisson + trunc() As for poisson: trunc(lb = k) is P(Y >= k), brms’s zero_inflated_poisson_lccdf(lb - 1), and lb <= 0 is no truncation. fitted() and residuals(type = “response”) refuse a truncated response, as brms 2.23.0 does: it has no truncated mean for this family. The likelihood and simulate() work.
~ zero_inflated_negbinomial + trunc() As for poisson: trunc(lb = k) is P(Y >= k), brms’s zero_inflated_neg_binomial_lccdf(lb - 1), and lb <= 0 is no truncation. fitted() and residuals(type = “response”) refuse a truncated response, as brms 2.23.0 does: it has no truncated mean for this family. The likelihood and simulate() work.
~ zero_inflated_binomial + trunc() As for poisson: trunc(lb = k) is P(Y >= k), brms’s zero_inflated_binomial_lccdf(lb - 1), and lb <= 0 is no truncation. fitted() and residuals(type = “response”) refuse a truncated response, as brms 2.23.0 does: it has no truncated mean for this family. The likelihood and simulate() work.
~ hurdle_poisson + trunc() As for poisson: trunc(lb = k) is P(Y >= k), brms’s hurdle_poisson_lccdf(lb - 1), and lb <= 0 is no truncation. fitted() and residuals(type = “response”) refuse a truncated response, as brms 2.23.0 does: it has no truncated mean for this family. The likelihood and simulate() work.
~ hurdle_negbinomial + trunc() As for poisson: trunc(lb = k) is P(Y >= k), brms’s hurdle_neg_binomial_lccdf(lb - 1), and lb <= 0 is no truncation. fitted() and residuals(type = “response”) refuse a truncated response, as brms 2.23.0 does: it has no truncated mean for this family. The likelihood and simulate() work.
x gaussian + trials() Refused by declaration: gaussian names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x gaussian + vint() Refused by declaration: gaussian names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x gaussian + vreal() Refused by declaration: gaussian names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x gaussian + thres(); student + thres(); lognormal + thres(); shifted_lognormal + thres(); skew_normal + thres(); and 38 more Refused by name: thres() sets the number of thresholds of an ordinal family, and any other family has none.
x gaussian + rate(); student + rate(); lognormal + rate(); shifted_lognormal + rate(); skew_normal + rate(); and 39 more Refused by name: rate() is an exposure for a count, and brms 2.23.0 takes it for poisson, negbinomial, negbinomial2 and geometric only.
x student + trials() Refused by declaration: student names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x student + vint() Refused by declaration: student names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x student + vreal() Refused by declaration: student names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x lognormal + trials() Refused by declaration: lognormal names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x lognormal + se(); shifted_lognormal + se(); exgaussian + se(); asym_laplace + se(); Gamma + se(); and 40 more Refused unless the family DECLARES that it reads the term, with frmtmb_family(accepts_aterms = c(…, “se”)) or required_aterms = “se”. se() is the one core addition term whose whole effect is inside the density, so the core cannot act on it for a family that ignores it. gaussian and student are the built-in families that declare it. A declaring family is refused a SECOND way if it has no dpar named sigma and carries another free dpar: se() without sigma = TRUE replaces the residual scale, the core maps out only the dpar the convention names, and the other one would be left free and unread - a flat direction and a NaN standard error. A family whose whole scale IS the known one (no dpar beyond its primaries) is unaffected; the ways out are frmtmb_family(se_dpar =), which names the dpar the known standard error replaces or is NA where it replaces none, naming the scale sigma, pinning it in the formula, or se(x, sigma = TRUE). A FORMULA for the replaced dpar is refused too, on any family: it estimates a parameter the density never reads, so only a constant pins it.
x lognormal + vint() Refused by declaration: lognormal names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x lognormal + vreal() Refused by declaration: lognormal names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x shifted_lognormal + trials() Refused by declaration: shifted_lognormal names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x shifted_lognormal + mi(); tweedie + mi(); poisson + mi(); negbinomial + mi(); negbinomial2 + mi(); and 29 more Refused, as brms 2.23.0 refuses it: “Argument ‘mi’ is not supported for family”. A discrete or inflated family has no continuous density for a missing value.
x shifted_lognormal + vint() Refused by declaration: shifted_lognormal names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x shifted_lognormal + vreal() Refused by declaration: shifted_lognormal names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x skew_normal + trials() Refused by declaration: skew_normal names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x skew_normal + vint() Refused by declaration: skew_normal names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x skew_normal + vreal() Refused by declaration: skew_normal names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x exgaussian + trials() Refused by declaration: exgaussian names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x exgaussian + vint() Refused by declaration: exgaussian names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x exgaussian + vreal() Refused by declaration: exgaussian names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x asym_laplace + trials() Refused by declaration: asym_laplace names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x asym_laplace + vint() Refused by declaration: asym_laplace names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x asym_laplace + vreal() Refused by declaration: asym_laplace names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x Gamma + trials() Refused by declaration: Gamma names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x Gamma + vint() Refused by declaration: Gamma names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x Gamma + vreal() Refused by declaration: Gamma names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x weibull + trials() Refused by declaration: weibull names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x weibull + vint() Refused by declaration: weibull names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x weibull + vreal() Refused by declaration: weibull names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x exponential + trials() Refused by declaration: exponential names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x exponential + vint() Refused by declaration: exponential names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x exponential + vreal() Refused by declaration: exponential names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x inverse.gaussian + trials() Refused by declaration: inverse.gaussian names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x inverse.gaussian + vint() Refused by declaration: inverse.gaussian names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x inverse.gaussian + vreal() Refused by declaration: inverse.gaussian names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x beta + trials() Refused by declaration: beta names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x beta + vint() Refused by declaration: beta names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x beta + vreal() Refused by declaration: beta names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x tweedie + trials() Refused by declaration: tweedie names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x tweedie + cens(); multinomial + cens(); dirichlet_multinomial + cens() Refused: cens() needs a family with an AD log-CDF.
x tweedie + trunc(); multinomial + trunc(); dirichlet_multinomial + trunc() Refused: trunc() needs a family with an AD log-CDF.
x tweedie + vint() Refused by declaration: tweedie names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x tweedie + vreal() Refused by declaration: tweedie names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x poisson + trials() Refused by declaration: poisson names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x poisson + vint() Refused by declaration: poisson names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x poisson + vreal() Refused by declaration: poisson names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x negbinomial + trials() Refused by declaration: negbinomial names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x negbinomial + vint() Refused by declaration: negbinomial names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x negbinomial + vreal() Refused by declaration: negbinomial names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x negbinomial2 + trials() Refused by declaration: negbinomial2 names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x negbinomial2 + vint() Refused by declaration: negbinomial2 names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x negbinomial2 + vreal() Refused by declaration: negbinomial2 names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x nbinom1 + trials() Refused by declaration: nbinom1 names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x nbinom1 + cens(); nbinom1 + trunc() Refused by the family’s list of addition terms, which holds weights() alone. brms has no nbinom1 family. Its CDF is read by residuals(type = “osa”) alone.
x nbinom1 + vint() Refused by declaration: nbinom1 names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x nbinom1 + vreal() Refused by declaration: nbinom1 names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x geometric + trials() Refused by declaration: geometric names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x geometric + vint() Refused by declaration: geometric names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x geometric + vreal() Refused by declaration: geometric names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x compois + trials() Refused by declaration: compois names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x compois + vint() Refused by declaration: compois names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x compois + vreal() Refused by declaration: compois names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x binomial + vint() Refused by declaration: binomial names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x binomial + vreal() Refused by declaration: binomial names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x bernoulli + trials() Refused by declaration: bernoulli names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x bernoulli + cens() Refused, as brms 2.23.0 refuses it: “Argument ‘cens’ is not supported for family ‘bernoulli’”. Its CDF is read by residuals(type = “osa”) alone.
x bernoulli + trunc() Refused, as brms 2.23.0 refuses it: “Argument ‘trunc’ is not supported for family ‘bernoulli’”. Its CDF is read by residuals(type = “osa”) alone.
x bernoulli + vint() Refused by declaration: bernoulli names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x bernoulli + vreal() Refused by declaration: bernoulli names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x beta_binomial + vint() Refused by declaration: beta_binomial names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x beta_binomial + vreal() Refused by declaration: beta_binomial names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x zero_inflated_beta_binomial + vint() Refused by declaration: zero_inflated_beta_binomial names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x zero_inflated_beta_binomial + vreal() Refused by declaration: zero_inflated_beta_binomial names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x multinomial + vint() Refused by declaration: multinomial names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x multinomial + vreal() Refused by declaration: multinomial names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x dirichlet_multinomial + vint() Refused by declaration: dirichlet_multinomial names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x dirichlet_multinomial + vreal() Refused by declaration: dirichlet_multinomial names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x zero_inflated_poisson + trials() Refused by declaration: zero_inflated_poisson names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x zero_inflated_poisson + vint() Refused by declaration: zero_inflated_poisson names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x zero_inflated_poisson + vreal() Refused by declaration: zero_inflated_poisson names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x zero_inflated_negbinomial + trials() Refused by declaration: zero_inflated_negbinomial names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x zero_inflated_negbinomial + vint() Refused by declaration: zero_inflated_negbinomial names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x zero_inflated_negbinomial + vreal() Refused by declaration: zero_inflated_negbinomial names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x zero_inflated_binomial + vint() Refused by declaration: zero_inflated_binomial names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x zero_inflated_binomial + vreal() Refused by declaration: zero_inflated_binomial names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x zero_inflated_beta + trials() Refused by declaration: zero_inflated_beta names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x zero_inflated_beta + vint() Refused by declaration: zero_inflated_beta names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x zero_inflated_beta + vreal() Refused by declaration: zero_inflated_beta names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x zero_one_inflated_beta + trials() Refused by declaration: zero_one_inflated_beta names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x zero_one_inflated_beta + cens() Refused, as brms 2.23.0 refuses it: “Argument ‘cens’ is not supported for family ‘zero_one_inflated_beta’”. The family has no CDF.
x zero_one_inflated_beta + trunc() Refused, as brms 2.23.0 refuses it: “Argument ‘trunc’ is not supported for family ‘zero_one_inflated_beta’”. The family has no CDF.
x zero_one_inflated_beta + vint() Refused by declaration: zero_one_inflated_beta names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x zero_one_inflated_beta + vreal() Refused by declaration: zero_one_inflated_beta names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x xbeta + trials() Refused by declaration: xbeta names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x xbeta + cens() Refused, as brms 2.23.0 refuses it: “Argument ‘cens’ is not supported for family ‘xbeta’”. The family has no CDF.
x xbeta + trunc() Refused, as brms 2.23.0 refuses it: “Argument ‘trunc’ is not supported for family ‘xbeta’”. The family has no CDF.
x xbeta + vint() Refused by declaration: xbeta names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x xbeta + vreal() Refused by declaration: xbeta names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x hurdle_poisson + trials() Refused by declaration: hurdle_poisson names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x hurdle_poisson + vint() Refused by declaration: hurdle_poisson names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x hurdle_poisson + vreal() Refused by declaration: hurdle_poisson names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x hurdle_negbinomial + trials() Refused by declaration: hurdle_negbinomial names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x hurdle_negbinomial + vint() Refused by declaration: hurdle_negbinomial names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x hurdle_negbinomial + vreal() Refused by declaration: hurdle_negbinomial names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x hurdle_gamma + trials() Refused by declaration: hurdle_gamma names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x hurdle_gamma + vint() Refused by declaration: hurdle_gamma names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x hurdle_gamma + vreal() Refused by declaration: hurdle_gamma names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x hurdle_lognormal + trials() Refused by declaration: hurdle_lognormal names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x hurdle_lognormal + vint() Refused by declaration: hurdle_lognormal names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x hurdle_lognormal + vreal() Refused by declaration: hurdle_lognormal names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x cumulative + trials() Refused by declaration: cumulative names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x cumulative + cens(); cumulative + trunc(); hurdle_cumulative + cens(); hurdle_cumulative + trunc(); sratio + cens(); and 5 more Refused: ordinal families carry no AD log-CDF over the response scale.
x cumulative + vint() Refused by declaration: cumulative names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x cumulative + vreal() Refused by declaration: cumulative names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x hurdle_cumulative + trials() Refused by declaration: hurdle_cumulative names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x hurdle_cumulative + vint() Refused by declaration: hurdle_cumulative names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x hurdle_cumulative + vreal() Refused by declaration: hurdle_cumulative names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x sratio + trials() Refused by declaration: sratio names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x sratio + vint() Refused by declaration: sratio names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x sratio + vreal() Refused by declaration: sratio names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x cratio + trials() Refused by declaration: cratio names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x cratio + vint() Refused by declaration: cratio names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x cratio + vreal() Refused by declaration: cratio names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x acat + trials() Refused by declaration: acat names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x acat + vint() Refused by declaration: acat names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x acat + vreal() Refused by declaration: acat names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x categorical + trials() Refused by declaration: categorical names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x categorical + cens() Refused: a nominal response carries no order, so it has no CDF for a censored row to contribute.
x categorical + trunc() Refused for the same reason: no order, no CDF, no truncation window.
x categorical + vint() Refused by declaration: categorical names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x categorical + vreal() Refused by declaration: categorical names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x von_mises + trials() Refused by declaration: von_mises names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x von_mises + vint() Refused by declaration: von_mises names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x von_mises + vreal() Refused by declaration: von_mises names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x dirichlet + trials() Refused by declaration: dirichlet names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x dirichlet + cens(); dirichlet2 + cens(); logistic_normal + cens() Refused: a row of proportions has no scalar CDF, and brms takes only weights(), subset() and index() on these families.
x dirichlet + trunc(); dirichlet2 + trunc(); logistic_normal + trunc() Refused for the same reason: no scalar CDF, no truncation window.
x dirichlet + vint() Refused by declaration: dirichlet names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x dirichlet + vreal() Refused by declaration: dirichlet names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x dirichlet2 + trials() Refused by declaration: dirichlet2 names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x dirichlet2 + vint() Refused by declaration: dirichlet2 names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x dirichlet2 + vreal() Refused by declaration: dirichlet2 names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x logistic_normal + trials() Refused by declaration: logistic_normal names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x logistic_normal + vint() Refused by declaration: logistic_normal names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x logistic_normal + vreal() Refused by declaration: logistic_normal names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x frechet + trials() Refused by declaration: frechet names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x frechet + vint() Refused by declaration: frechet names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x frechet + vreal() Refused by declaration: frechet names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x gen_extreme_value + trials() Refused by declaration: gen_extreme_value names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x gen_extreme_value + vint() Refused by declaration: gen_extreme_value names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x gen_extreme_value + vreal() Refused by declaration: gen_extreme_value names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x discrete_weibull + trials() Refused by declaration: discrete_weibull names the addition terms it reads in frmtmb_family(accepts_aterms =), trials() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x discrete_weibull + vint() Refused by declaration: discrete_weibull names the addition terms it reads in frmtmb_family(accepts_aterms =), vint() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.
x discrete_weibull + vreal() Refused by declaration: discrete_weibull names the addition terms it reads in frmtmb_family(accepts_aterms =), vreal() is not among them, and frame assembly refuses it by name, listing the terms the family does take. This row is derived from that declaration rather than measured, so the table and the guard cannot drift apart.

Response distributions and post-fit methods

What you can do with a fit depends on what the family supplies. A family without a simulator cannot be simulated from. A family without a mean function has no fitted() value.

fitted predict simulate residuals residuals_osa emmeans confint_profile hypothesis_profile frm_lp_basis frm_curve frm_curve_contrast marginaleffects
gaussian ~ ~ + ~ ~ ~ ~ ~ ~ ~ ~ ~
student ~ ~ + ~ ~ ~ ~ ~ ~ ~ ~ ~
lognormal ~ ~ + ~ ~ ~ ~ ~ ~ ~ ~ ~
shifted_lognormal ~ ~ + ~ ~ ~ ~ ~ ~ ~ ~ ~
skew_normal ~ ~ + ~ ~ ~ ~ ~ ~ ~ ~ ~
exgaussian ~ ~ + ~ ~ ~ ~ ~ ~ ~ ~ ~
asym_laplace ~ ~ + ~ ~ ~ ~ ~ ~ ~ ~ ~
Gamma ~ ~ + ~ ~ ~ ~ ~ ~ ~ ~ ~
weibull ~ ~ + ~ ~ ~ ~ ~ ~ ~ ~ ~
exponential ~ ~ + ~ ~ ~ ~ ~ ~ ~ ~ ~
inverse.gaussian ~ ~ + ~ ~ ~ ~ ~ ~ ~ ~ ~
beta ~ ~ + ~ ~ ~ ~ ~ ~ ~ ~ ~
tweedie ~ ~ + ~ x ~ ~ ~ ~ ~ ~ ~
poisson ~ ~ + ~ ~ ~ ~ ~ ~ ~ ~ ~
negbinomial ~ ~ + ~ ~ ~ ~ ~ ~ ~ ~ ~
negbinomial2 ~ ~ + ~ ~ ~ ~ ~ ~ ~ ~ ~
nbinom1 ~ ~ + ~ ~ ~ ~ ~ ~ ~ ~ ~
geometric ~ ~ + ~ ~ ~ ~ ~ ~ ~ ~ ~
compois ~ ~ + ~ ~ ~ ~ ~ ~ ~ ~ ~
binomial ~ ~ + ~ ~ ~ ~ ~ ~ ~ ~ ~
bernoulli ~ ~ + ~ ~ ~ ~ ~ ~ ~ ~ ~
beta_binomial ~ ~ + ~ ~ ~ ~ ~ ~ ~ ~ ~
zero_inflated_beta_binomial ~ ~ + ~ + ~ ~ ~ ~ ~ ~ ~
multinomial + ~ + ~ ~ ~ ~ ~ ~ ~ ~ ~
dirichlet_multinomial + ~ + ~ ~ ~ ~ ~ ~ ~ ~ ~
zero_inflated_poisson ~ ~ + ~ + ~ ~ ~ ~ ~ ~ ~
zero_inflated_negbinomial ~ ~ + ~ + ~ ~ ~ ~ ~ ~ ~
zero_inflated_binomial ~ ~ + ~ + ~ ~ ~ ~ ~ ~ ~
zero_inflated_beta ~ ~ + ~ x ~ ~ ~ ~ ~ ~ ~
zero_one_inflated_beta ~ ~ + ~ x ~ ~ ~ ~ ~ ~ ~
xbeta ~ ~ + ~ x ~ ~ ~ ~ ~ ~ ~
hurdle_poisson ~ ~ + ~ + ~ ~ ~ ~ ~ ~ ~
hurdle_negbinomial ~ ~ + ~ + ~ ~ ~ ~ ~ ~ ~
hurdle_gamma ~ ~ + ~ x ~ ~ ~ ~ ~ ~ ~
hurdle_lognormal ~ ~ + ~ x ~ ~ ~ ~ ~ ~ ~
cumulative ~ ~ + ~ + ~ ~ ~ ~ ~ ~ ~
hurdle_cumulative ~ ~ + ~ x ~ ~ ~ ~ ~ ~ ~
sratio ~ ~ + ~ + ~ ~ ~ ~ ~ ~ ~
cratio ~ ~ + ~ + ~ ~ ~ ~ ~ ~ ~
acat ~ ~ + ~ + ~ ~ ~ ~ ~ ~ ~
categorical ~ ~ + x x ~ ~ ~ ~ ~ ~ ~
von_mises ~ ~ + ~ + ~ ~ ~ ~ ~ ~ ~
dirichlet ~ ~ + x x ~ ~ ~ ~ ~ ~ ~
dirichlet2 ~ ~ + x x ~ ~ ~ ~ ~ ~ ~
logistic_normal ~ ~ + x x ~ ~ ~ ~ ~ ~ ~
frechet ~ ~ + ~ ~ ~ ~ ~ ~ ~ ~ ~
gen_extreme_value ~ ~ + ~ ~ ~ ~ ~ ~ ~ ~ ~
discrete_weibull ~ ~ + ~ ~ ~ ~ ~ ~ ~ ~ ~
Status Pairs Note
~ gaussian + fitted; student + fitted; lognormal + fitted; shifted_lognormal + fitted; skew_normal + fitted; and 31 more Needs a family with a mean function.
~ gaussian + predict; student + predict; lognormal + predict; shifted_lognormal + predict; skew_normal + predict; and 34 more Rank-deficient designs drop aliased columns at fit time. New data that is not estimable from the retained columns predicts NA and warns.
~ gaussian + residuals; gaussian + confint_profile; gaussian + hypothesis_profile; gaussian + frm_lp_basis; gaussian + frm_curve; and 322 more Depends on which post-fit ingredients the family supplies (CDF, simulator, variance function).
~ gaussian + residuals_osa; student + residuals_osa; lognormal + residuals_osa; shifted_lognormal + residuals_osa; skew_normal + residuals_osa; and 21 more A core family with a CDF takes osa_method = “cdf”, except an untruncated, unweighted gaussian(), which takes fullGaussian: each row is read against its own fitted CDF, so with no group-level term the residual is the randomized quantile residual of the fit. With one, TMB integrates each row by the Laplace approximation, whose error is largest on the first row of each group: up to 0.15 under (1 | g) against the exact one-step predictive. A family without a CDF needs its observation registered through OBS() and a density that takes the osa object, and a discrete one without a CDF needs discreteSupport.
~ gaussian + emmeans; student + emmeans; lognormal + emmeans; shifted_lognormal + emmeans; skew_normal + emmeans; and 38 more Takes brms’s dpar =, nlpar =, resp =, epred = and re_formula = (see ?frmtmb-emmeans). A family with no mu needs dpar =. epred = TRUE needs one mean per row, so it is refused for the ordinal and categorical families.
~ cumulative + fitted; hurdle_cumulative + fitted; sratio + fitted; cratio + fitted; acat + fitted Returns the same n x K matrix of category probabilities frm_linpred(type = “response”) returns, not a vector: an ordinal response has no mean, so the modelled response is the category distribution. The frm_linpred(type = “response”) == fitted() identity holds. The latent linear predictor is frm_linpred(fit, type = “link”), which is also what emmeans and insight see.
~ cumulative + predict; hurdle_cumulative + predict; sratio + predict; cratio + predict; acat + predict type = “response” returns an n x K matrix of category probabilities (rows summing to 1, columns named by the response’s own levels), not a vector: an ordinal response has no mean. It equals fitted(). cs() terms are honored and re-evaluated on newdata. type = “link” gives the latent predictor, which is where se.fit is available; se.fit is refused on the response scale.
~ cumulative + residuals; hurdle_cumulative + residuals; sratio + residuals; cratio + residuals; acat + residuals “response” (“ordinary”) and “pearson” are refused, as brms refuses predictive errors for every ordinal family: a category has no scale for y - E[Y] to be read on. “osa” gives randomized quantile residuals that use only the order, and dharma_residuals() is the simulation-based check. “deviance” is refused, as for every family without a standard unit deviance.
~ cumulative + emmeans; hurdle_cumulative + emmeans; sratio + emmeans; cratio + emmeans; acat + emmeans Works on the LATENT linear predictor, emmeans’s mode = “latent” convention for clm-like models: the intercept is dropped there (the K-1 thresholds take its place), so contrasts are on the latent scale and absolute means carry no threshold offset. For category probabilities use frm_linpred(fit, type = “response”) or conditional_effects(), which are on a different scale from these means.
~ categorical + fitted Returns the n x K matrix of category probabilities, not a vector: a nominal response has no mean, so the modelled response is the category distribution. The frm_linpred(type = “response”) == fitted() identity holds.
~ categorical + predict type = “response” returns an n x K matrix of category probabilities, columns named by the response’s own levels and rows summing to 1, exactly as for the ordinal families; it equals fitted(). se.fit is refused there. Each category’s latent predictor is frm_linpred(type = “link”, dpar = “mu”), which is where se.fit works.
~ von_mises + fitted Returns the mean DIRECTION in radians on (-pi, pi], which is what brms’s posterior_epred() reports for this family; a circular response has no arithmetic mean.
~ dirichlet + fitted; dirichlet2 + fitted; logistic_normal + fitted dirichlet() and brmsfamily(“dirichlet2”) return brms’s n x 4 x K array of category means, layers named P(Y = k), with delta-method standard errors. logistic_normal() is refused in brms’s words: its mean has no closed form.
~ dirichlet + predict; dirichlet2 + predict; logistic_normal + predict Returns brms’s n x 4 x K summary of simulated compositions, layers named by category. type = “response” in frm_linpred() is the category means of fitted(), and refused for logistic_normal(); frm_linpred(dpar = “mu”) gives one category’s predictor.
x tweedie + residuals_osa Refused by name: the mass at zero is invisible to the one-step integral of a density, and through 0.79.1 the generic route read NaN on 71 of 150 rows with no warning. Use dharma_residuals().
x zero_inflated_beta + residuals_osa; zero_one_inflated_beta + residuals_osa; xbeta + residuals_osa; hurdle_gamma + residuals_osa; hurdle_lognormal + residuals_osa Refused by name: the density branches on y == 0 for its point mass, and oneStepPredict() hands it an observation object with no comparison operator. Through 0.63.0 each of these failed there with base R’s own message. Use residuals(type = “pearson”) or dharma_residuals().
x hurdle_cumulative + residuals_osa Refused by name, as for the other point-mass families: the density branches on y == 0 for the hurdle. Use dharma_residuals().
x categorical + residuals Refused: the categories carry no order, so no residual has a scale to live on. Compare fitted(fit), the n x K category probabilities, against the observed categories instead.
x categorical + residuals_osa Refused with residuals() as a whole: a one-step-ahead residual is a CDF value, and a nominal response has no CDF.
x dirichlet + residuals; dirichlet2 + residuals; logistic_normal + residuals Refused for every type, as brms refuses predictive errors for every polytomous family: a row of proportions has no scalar residual. Compare predict(fit) with the observed proportions.
x dirichlet + residuals_osa; dirichlet2 + residuals_osa; logistic_normal + residuals_osa Refused with residuals() as a whole: a one-step-ahead residual is a scalar CDF value, and a composition has none.

Estimation modes

The modes constrain each other more than they constrain anything else. REML, quadrature, and profile all move the fixed effects out of the outer optimization problem, and no two of them can do that at once. Bounds name outer parameters, so bounds on fixed effects are refused under REML and under profile.

autoscale, sparse_x, and verbose are different in kind. They change the arithmetic or the output, not the model.

REML quadrature importance profile autoscale sparse_x prior bounds verbose
REML x x x + + ~ x +
quadrature x x x + + + + +
importance x x x + + + + +
profile x x x + + ~ x +
autoscale + + + + + + + +
sparse_x + + + + + + + +
prior ~ + + ~ + + + +
bounds x + + x + + + +
verbose + + + + + + + +
Status Pairs Note
~ REML + prior Priors on fixed effects are accepted under REML while bounds on the same parameters are refused. The two surfaces are inconsistent. Such a prior is inside the integral REML computes over the fixed effects, so logLik() refuses it and logLik_penalized() gives the maximized value. Priors on variance parameters behave as expected, and logLik() subtracts them exactly.
~ profile + prior Priors on the profiled fixed effects are accepted, while bounds on the same parameters are refused. Treat priors under profile with care.
x REML + quadrature Refused: quadrature already marginalizes the random effects, so there is no inner problem left for REML to integrate.
x REML + importance Refused: the correction reweights the integral over the random effects, and REML puts the fixed effects into that same integral, where there is no per-group proposal for them.
x REML + profile Refused: profile = TRUE and REML both remove the fixed effects from the outer problem.
x REML + bounds Refused: under REML the fixed effects leave the outer parameter vector, so bounds naming them are rejected as unknown parameters.
x quadrature + importance Refused: two different corrections of the same approximation. Gauss-Kronrod marginalizes one scalar random intercept at a time; the importance correction reweights the Laplace Gaussian and takes any block dimension.
x quadrature + profile Refused: profile = TRUE cannot be combined with quadrature = TRUE.
x importance + profile Refused: profiling moves the fixed effects into the inner Laplace problem, and the corrected objective has no inner problem left to move them into.
x profile + bounds Refused: with the fixed effects profiled out they leave the outer parameter vector, so bounds naming them are rejected. This pair was once accepted and the bounds were then applied to the wrong parameters.

Modes and addition terms

REML quadrature importance profile autoscale sparse_x prior bounds verbose
weights() ? + + + + + ? ? +
trials() ? ? ? ? + + ? ? +
cens() + + + + + + ? ? +
trunc() + x + + + + ? ? +
se() + + ? + + + ? ? +
mi() + ~ ~ + + + ? ? +
vint() ? ? ? ? + + ? ? ?
vreal() ? ? ? ? + + ? ? ?
thres() + + + + + + + ? +
rate() ? ? ? ? + + ? ? +
subset() ? ? ? ? + + ? ? +
index() ? ? ? ? + + ? ? +
Status Pairs Note
~ mi() + quadrature A missing value no density reads has left the objective, so the rule reads the observed rows. A value another density reads is refused: it is itself a random effect that quadrature cannot marginalize.
~ mi() + importance A missing value no density reads has left the objective, so the correction reads the observed rows. A value another density reads is refused: it is a latent variable with no grouping factor, so it has no per-group proposal.
x trunc() + quadrature Refused: the truncation normalizer is log(F(ub) - F(lb)) over plain CDFs, and the Gauss-Kronrod nodes reach random-effect values where that difference underflows to exactly zero while the density is still representable. The integrand is then +Inf and the marginalized objective is -Inf, at the Laplace optimum as well as at the starting values, so the fit used to report logLik = +Inf as converged. Laplace stays near the mode and is unaffected: use quadrature = FALSE, REML, or profile for truncated responses.

Modes and covariance structures

Only quadrature reads the covariance structures. It marginalizes one scalar random intercept at a time, so every block in the model must be a one-dimensional us, diag, or homdiag term.

REML quadrature importance profile autoscale sparse_x prior bounds verbose
us + ~ ~ ? + + ? ? +
diag + ~ ~ ? + + ? ? +
homdiag + ~ ~ ? + + ? ? +
cs + x ~ ? + + ? ? +
ar1 + x ~ ? + + ~ ~ ~
hetar1 + x ~ ? + + ~ ~ ~
ou + x ~ ? + + ~ ~ ~
toep + x ~ ? + + ? ? +
homtoep + x ~ ? + + ? ? +
homcs + x ~ ? + + ? ? +
exp + x ~ ? + + ~ ~ ~
gau + x ~ ? + + ~ ~ ~
mat + x ~ ? + + ~ ~ ~
rr + x x ? + + ~ ~ ~
equalto + x x ? + + ~ ~ ~
gr_cov + x x ? + + ~ ~ ~
gr_prec + x x ? + + ~ ~ ~
smooth + x x ? + + ~ ~ ~
gp + x x ? + + ~ ~ ~
hsgp + x x ? + + ~ ~ ~
us_t + ~ x ? + + ? ? +
diag_t + ~ x ? + + ? ? +
Status Pairs Note
~ us + quadrature; diag + quadrature; homdiag + quadrature Allowed only when the block is one-dimensional, that is a scalar random intercept or slope. Correlated slopes are refused. A row may read two blocks when one is nested in the other, (1 | ga/gb), on the same predictors: the inner block is integrated inside each outer level by Gauss-Hermite rules (frmtmb_control(quad_nodes = ), default 11 outer and 15 inner nodes) centered and scaled by the Laplace fit, under a memory limit (frmtmb_control(quad_max_gb = )). Verified against an independent reference: 7e-6 in the log-likelihood on 72 weighted Bernoulli rows (Laplace 0.85), falling as the nodes rise. Crossed blocks are refused, because their integral does not factor; so are three or more blocks, and (1 | g) in both mu and sigma, where the rule converges slowly. A by-split gr(g, by = f), whose blocks read rows of their own, and mvbf() with one block per response are integrated by the one-block rule.
~ us + importance; diag + importance; homdiag + importance; cs + importance; ar1 + importance; and 8 more Allowed for any number of such blocks, of any dimension, provided they all sit over ONE grouping factor and carry the same levels. This is the correction for a correlated random slope, which quadrature cannot marginalize at all, and for the several blocks distributional regression writes: (1 | g) in mu together with (1 | g) in sigma is two blocks over g, and a level’s coefficients from both are drawn together from one joint proposal. Blocks over DIFFERENT grouping factors, crossed or nested, are refused by name: the marginal likelihood is then one integral over every factor at once and does not split into the per-group integrals the correction resamples. Measured on a correlated slope: 216 fits of six families settle at 64 to 2000 draws, and so does a Poisson slope whose correlation sits at its boundary (10 groups of 20).
~ ar1 + prior; ar1 + bounds; ar1 + verbose ar1() reads the level order. Over gapped integer levels it keeps positional semantics and warns. Use ou() over num_factor() for irregular spacing.
~ hetar1 + prior; hetar1 + bounds; hetar1 + verbose hetar1() reads the level order. Over gapped integer levels it keeps positional semantics and warns.
~ ou + prior; ou + bounds; ou + verbose ou() is the irregular-spacing structure. Build the levels with num_factor() so the metric distance is recoverable.
~ exp + prior; exp + bounds; exp + verbose; gau + prior; gau + bounds; and 4 more Spatial structures need coordinates built with num_factor(x, y).
~ rr + prior; rr + bounds; rr + verbose rr() gives a reduced-rank block; the rank d must not exceed the term dimension.
~ equalto + prior; equalto + bounds; equalto + verbose equalto(x + 0 | g, V) fixes the term covariance to V, which must be square and match the term dimension, and belongs in data2 = list(V = V).
~ gr_cov + prior; gr_cov + bounds; gr_cov + verbose gr(cov = A) accepts correlated slopes; the block covariance is the Kronecker product of A and the term covariance. A needs dimnames covering every grouping level, and belongs in data2 = list(A = A). Terms sharing an |ID| key over the same factor and the same A merge into one such block, which is the same model as writing the traits long with a single gr() term.
~ gr_prec + prior; gr_prec + bounds; gr_prec + verbose gr(prec = Q) takes correlated slopes; the block precision is the Kronecker product of Q and the inverse term covariance, so it stays as sparse as Q. Q needs dimnames covering every grouping level, and belongs in data2 = list(Q = Q). Terms sharing an |ID| key over the same factor and the same Q merge into one such block.
~ smooth + prior; smooth + bounds; smooth + verbose smooth is the internal structure behind s() and t2(); it is not written directly in a formula.
~ gp + prior; gp + bounds; gp + verbose; hsgp + prior; hsgp + bounds; hsgp + verbose gp() and hsgp() are predictor specials, not bar terms. Write gp(x), not (gp(x) | g).
~ us_t + quadrature; diag_t + quadrature Allowed for one-dimensional blocks, and RECOMMENDED there: the Gauss-Kronrod rule marginalizes a scalar t latent EXACTLY, where the Laplace default is approximate. Verified against adaptive Gauss-Hermite quadrature to 1e-6 in the log-likelihood and in every estimate. Correlated slopes are refused, as they are for a gaussian block, and so are two Student-t terms of one grouping factor, whose shared latent scale makes a level’s effects dependent while the rule integrates one at a time.
x cs + quadrature; ar1 + quadrature; hetar1 + quadrature; ou + quadrature; toep + quadrature; and 12 more Refused: quadrature marginalizes one scalar random intercept at a time. Every block must be a dimension-1 us, diag, or homdiag term.
x rr + importance; smooth + importance; gp + importance; hsgp + importance; us_t + importance; diag_t + importance Refused by name at the scope check. The Student-t latents (us_t, diag_t) factorize over grouping levels but are not gaussian in a level’s coefficients, and the correction recovers each level’s prior density from the block density by reading off a precision matrix, which would silently return a gaussian approximation to a t density; measured, that alone moves the corrected log-likelihood by 0.355. rr holds its parameters in a lower-dimensional factor space than its Z columns, so the positions the proposal draws into are not the positions the objective reads. smooth, gp and hsgp are one field over all observations with no grouping factor, so there are no independent groups to give separate proposals to.
x equalto + importance; gr_cov + importance; gr_prec + importance Refused: these structures correlate the grouping LEVELS with each other through a supplied relationship or neighbor matrix, so the marginal likelihood is one integral over every level at once and does not split into the per-group integrals the correction resamples.

Model structures

weights() trials() cens() trunc() se() mi() vint() vreal() thres() rate() subset() index()
mvbf + + + + + + ? ? + + + +
rescor x ? x x x x ? ? ? ? x ?
|ID| ? ? ? ? ? ? ? ? ? ? ~ ?
nl ? ? + ? ? ? ? ? + ? ? ?
mixture + ? + x x ~ ? ? + ? ? ?
disc ? ? x ? ? ? ? ? ? ? ? ?
equidistant ? ? x ? ? ? ? ? + ? ? ?
sum_to_zero ? ? ? ? ? ? x ? + ? ? ?
Status Pairs Note
~ mixture + mi() frm() fits the rows no density reads. A value another density reads is refused: it has one mode per component, so the Laplace approximation has no single mode to expand about, as under REML. brms 2.23.0 samples that model, and so does frmtmb.sample::frm_sample(), on the components’ chart when they share one.
~ |ID| + subset() A grouping level takes a parameter only in the responses whose rows carry it; brms keeps every level of the whole data. |ID|-linked terms therefore need the same levels on every linked response’s rows, and are refused by name otherwise. A level with no rows adds nothing to the marginal likelihood, so the fit is the same where both run.
x rescor + weights(); rescor + se() Refused.
x rescor + cens() Refused. This pair was once accepted with the censoring silently dropped.
x disc + cens() Refused, as brms 2.23.0 refuses it: disc belongs to the ordinal families, and they take no cens().
x equidistant + cens() Refused, as brms 2.23.0 refuses it: the structure belongs to the ordinal families, and they take no cens().
x rescor + trunc() Refused. This pair was once accepted with the truncation silently dropped.
x mixture + trunc() Refused: brms 2.23.0 truncates each component and then mixes them, and frmtmb’s density has no per-component window, so a CDF of the mixture would be another model.
x mixture + se() Refused: a mixture does not declare se() even when its components do. Reading the term is only half of what se() means; the other half is that the residual scale it replaces is mapped out, and that step names the dpar sigma, which sigma1 and sigma2 are not. Measured before the refusal was made explicit: mixture(gaussian, gaussian) with se() fitted with both component sigmas at their starting value and every standard error NaN.
x rescor + mi() Refused: mi() cannot be combined with rescor = TRUE.
x sum_to_zero + vint() Refused, as brms 2.23.0 refuses it: the structure belongs to the ordinal families, and they take no vint().
x rescor + subset() Refused: the residual correlation pairs the responses row by row.

Structures and post-fit methods

Several post-fit methods are univariate-only. A multivariate fit predicts one response at a time, through frm_linpred(fit, resp = ), and refuses fitted(), simulate() and residuals(). The inference surface is not univariate-only: confint(), hypothesis() and frmtmb.sample::frm_sample() read the outer parameter vector, which a multivariate fit has like any other.

fitted predict simulate residuals residuals_osa emmeans confint_profile hypothesis_profile frm_lp_basis frm_curve frm_curve_contrast marginaleffects
mvbf + + x + x + + + x ? ? x
rescor + + x + x + + + ? ? ? ?
|ID| ? ? ? ? ? ? ? ? ? ? ? ?
nl + + ? ? ? + ? ? + + + ?
mixture ? ? ~ ? ? ? ? ? ? ? ? ?
disc + + + ? + + + ? ? ? ? ?
equidistant + + + ? + + + ? ? ? ? ?
sum_to_zero + + + ? + + + ? ? ? ? ?
Status Pairs Note
~ mixture + simulate Works only when every component family has a simulator.
x mvbf + simulate; mvbf + frm_lp_basis; mvbf + marginaleffects Refused: the post-fit methods below are univariate-only for now.
x mvbf + residuals_osa; rescor + residuals_osa Refused: residuals(type = “osa”) is not supported for multivariate fits yet; the one-step tape steps through a single response’s observations.
x rescor + simulate Refused: simulate() is not supported for multivariate fits yet.

Within-group residual correlation

ar(), ma(), arma(), cosy(), unstr() and fcor() replace the response’s per-row density with one joint density per group (for fcor(), one group holding every row). That is what decides almost every pair below on gaussian() and student(): an addition term that reshapes a per-row contribution has nothing left to reshape. brms’s default cov = FALSE for ar(), ma() and arma() keeps the per-row density and shifts mu instead, so the rows naming those three terms say where its answer differs. On every other family that takes the terms, they are brms’s latent residual, a latent per row on the linear predictor of mu, and the density stays per row.

gaussian student lognormal shifted_lognormal skew_normal exgaussian asym_laplace Gamma weibull exponential inverse.gaussian beta tweedie poisson negbinomial negbinomial2 nbinom1 geometric compois binomial bernoulli beta_binomial zero_inflated_beta_binomial multinomial dirichlet_multinomial zero_inflated_poisson zero_inflated_negbinomial zero_inflated_binomial zero_inflated_beta zero_one_inflated_beta xbeta hurdle_poisson hurdle_negbinomial hurdle_gamma hurdle_lognormal cumulative hurdle_cumulative sratio cratio acat categorical von_mises dirichlet dirichlet2 logistic_normal frechet gen_extreme_value discrete_weibull
ar() + ~ ~ ~ ~ ~ x ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ x x ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ x ~ x x x ~ ~ ~
ma() + ~ ~ ~ ~ ~ x ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ x x ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ x ~ x x x ~ ~ ~
arma() + ~ ~ ~ ~ ~ x ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ x x ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ x ~ x x x ~ ~ ~
cosy() + ~ ~ ~ ~ ~ x ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ x x ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ x ~ x x x ~ ~ ~
unstr() + ~ ~ ~ ~ ~ x ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ x x ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ x ~ x x x ~ ~ ~
fcor() + ~ x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x
Status Pairs Note
~ ar() + student; ma() + student; arma() + student Under cov = TRUE the multivariate-t has one shape per group, so nu must be constant. Under cov = FALSE the density is brms’s rowwise student_t at the shifted mu, and a predicted nu ~ … works.
~ cosy() + student; unstr() + student The multivariate-t has one shape parameter per group, so nu must be constant; a predicted nu ~ … is refused. The density is brms’s multi_student_t with scale matrix D R D, verified against mvtnorm::dmvt exactly.
~ fcor() + student The multivariate t has one shape for the whole response, so nu must be constant; a predicted nu ~ … is refused. A predicted sigma ~ … works, as under gaussian().
~ ar() + lognormal; ma() + lognormal; arma() + lognormal; cosy() + lognormal; unstr() + lognormal; and 190 more brms’s latent residual: a family with no residual y - mu gets one latent per row added to mu’s linear predictor, with SD sderr. ar(), ma() and arma() are of order one under cov = TRUE, and cov = FALSE has the AR part of any order, as moving-average weights on independent latents; brms refuses the rest in the words frm() gives (‘Covariance formulation of ARMA structures is only possible for effects of maximal order one’, ‘Please set cov = TRUE when modeling MA structures for this family’). The joint at the conditional modes is an identity with brms’s log_prob on count, binary, binomial, positive continuous, bounded and ordinal families; the latents are integrated by Laplace, on a sparse chain. Lags count rows of a group, as in brms. The condition: frm() warns (class frmtmb_latres_laplace) on ordinal rows, and where a first-order Laplace correction moves log sderr or ar[1] by more than 0.15 or cannot be read. Above 3000 rows it reads the rows’ share of the latent. sderr reads 0.39 against an exact 1.10 on bernoulli and 0.26 against 0.65 on beta_binomial(); poisson is fine down to a mean of 1, and lognormal is exact. frm() refuses cov = FALSE after the inverse link before the fit, because 54 of 120 benign fits read true and no number from the fit says which. On a link that does not hold the mean, under cov = TRUE, frm() refuses after the fit at a margin below 2 marginal sds of the latent from the link’s edge, where 14 of 150 fits read true; above it, it fits. frm_sample() fits them all, and its draws agree with brms. ?frmtmb-autocor has the tables.
x fcor() + lognormal; fcor() + shifted_lognormal; fcor() + skew_normal; fcor() + exgaussian; fcor() + Gamma; and 34 more Refused as brms refuses it (‘FCOR terms are not implemented for this family’): the term is a residual covariance over all rows, which brms gives only the families with a residual y - mu.
x ar() + asym_laplace; ma() + asym_laplace; arma() + asym_laplace; cosy() + asym_laplace; unstr() + asym_laplace; fcor() + asym_laplace Refused, where brms builds it: the density has a kink in its mean, so the inner Hessian of a latent per row is zero or undefined and the Laplace approximation has no maximum. frm_sample() samples the model.
x ar() + multinomial; ma() + multinomial; arma() + multinomial; cosy() + multinomial; unstr() + multinomial; and 31 more Refused as brms refuses it (‘Explicit covariance terms can only be specified on ’mu’’): the term would sit on mu1, mu2, …
weights() trials() cens() trunc() se() mi() vint() vreal() thres() rate() subset() index()
ar() ~ ~ ~ ~ x ~ ~ ~ ~ ~ ~ ~
ma() ~ ~ ~ ~ x ~ ~ ~ ~ ~ ~ ~
arma() ~ ~ ~ ~ x ~ ~ ~ ~ ~ ~ ~
cosy() ~ ~ ~ ~ ~ ~ ? ? ~ ~ ~ ~
unstr() ~ ~ ~ ~ ~ ~ ? ? ~ ~ ~ ~
fcor() x x x x x x x x x x x x
Status Pairs Note
~ ar() + weights(); ma() + weights(); arma() + weights(); ar() + trials(); ma() + trials(); and 28 more On gaussian and student, under cov = FALSE, weights(), cens(), trunc() and mi() work: the term shifts mu and the density stays per row, so each addition term acts on its row as it does without the term, and under mi() the residual is taken against the observed-or-imputed response (brms’s Yl). brms 2.23.0 generates the same Stan code for each; verified against its model block to 1e-15 (dev/arcov-validate.R). Under cov = TRUE all of them are refused, because the group’s density is joint. On any other family, the term is a latent residual under both forms: weights(), trials(), rate(), thres(), subset(), cens() and trunc() act on their rows, with cens() and trunc() making cov = FALSE the post-link form that frm_sample() alone fits; se() is refused as brms refuses it; mi() on the response is refused where another density reads its missing values, since no measurement reads a latent response beside a latent residual; a missing value no density reads leaves the objective.
~ cosy() + weights(); unstr() + weights(); cosy() + trials(); unstr() + trials(); cosy() + cens(); and 15 more On a family with no residual y - mu (brms’s latent residual) the density stays per row and weights(), cens() and trunc() act on their rows, as in brms; se() is refused as brms refuses it, and mi() on the response is refused where another density reads its missing values, because no measurement reads a latent response beside a latent residual; a missing value no density reads leaves the objective, and the fit is then exact on lognormal. On gaussian and student they are refused: the group’s density is joint, so there is no per-row contribution for a frequency weight to repeat, a censoring indicator to replace with a tail probability, a truncation bound to renormalize, or a known standard error to add to. brms refuses weights(), cens() and trunc() here with ‘Invalid addition arguments for this model’.
x fcor() + weights(); fcor() + trials(); fcor() + cens(); fcor() + trunc(); fcor() + se(); and 7 more Refused: the density of the rows is joint, so there is no per-row contribution for a frequency weight to repeat, a censoring indicator to replace with a tail probability, or a truncation bound to renormalize. brms refuses weights(), cens() and trunc() here too.
x ar() + se(); ma() + se(); arma() + se() Refused under both forms. brms refuses se() with cov = FALSE (‘Please set cov = TRUE in ARMA structures when including known standard errors’). Under cov = TRUE brms 2.23.0 fits it, adding se^2 to the diagonal of each group’s covariance (normal_time_hom_se_lpdf() and its relatives); frmtmb refuses it there, a parity gap.
REML quadrature importance profile autoscale sparse_x prior bounds verbose
ar() + x x + + + + + +
ma() + x x + + + + + +
arma() + x x + + + + + +
cosy() + x x + + + + + +
unstr() + x x + + + + + +
fcor() + x x + + + + + +
Status Pairs Note
x ar() + quadrature; ma() + quadrature; arma() + quadrature; cosy() + quadrature; unstr() + quadrature; fcor() + quadrature Refused: the Gauss-Kronrod rule integrates one random effect per group against per-observation densities. On gaussian and student this residual is a joint density over each group. On any other family it is one latent per row, in a chain within the group, which no one-dimensional rule integrates.
x ar() + importance; ma() + importance; arma() + importance; cosy() + importance; unstr() + importance; fcor() + importance Refused: the correction resamples a random effect against a PRODUCT of per-row densities. On gaussian and student an R-side residual is one joint density over each group, so no per-row integrand exists; under brms’s cov = FALSE the rows are separate densities but each one’s mean reads the residuals of the rows before it, which the per-row integrand does not carry either. On any other family the term is a latent chain with no grouping factor to draw one proposal per level of.
mvbf rescor |ID| nl mixture disc equidistant sum_to_zero
ar() + ~ ? ~ x ? ? ?
ma() + ~ ? ~ x ? ? ?
arma() + ~ ? ~ x ? ? ?
cosy() + x ? ~ x ? ? ?
unstr() + x ? ~ x ? ? ?
fcor() + x ? ~ x ? ? ?
Status Pairs Note
~ ar() + rescor; ma() + rescor; arma() + rescor Works under cov = FALSE: each response’s mu is shifted by its own term and the rows keep their multivariate normal density across responses, which is brms’s Stan code; verified against it to 1e-15. Refused under cov = TRUE, where the joint structure would be a Kronecker product.
~ ar() + nl; ma() + nl; arma() + nl; cosy() + nl; unstr() + nl; fcor() + nl A nonlinear shape or zi beside a linear mu keeps its latent residual, as brms builds it. Written as brms writes it, bf(…, nl = TRUE, autocor = ~ term) or + acformula(~ term), since a body is evaluated rather than read as terms and a term in the body is refused. On gaussian and student: log density identical to brms 2.23.0’s Stan program at three points for ar, ma and arma with cov TRUE and FALSE, cosy, unstr and fcor (test-nl-brms.R); fitted() and simulate() read the term as they do for a linear mu, which under cov = FALSE is not brms’s posterior_epred() (see ?frmtmb-autocor). A family whose term would be a latent residual stays refused.
x ar() + mixture; ma() + mixture; arma() + mixture; cosy() + mixture; unstr() + mixture; fcor() + mixture Refused as brms refuses it (‘Explicit covariance terms can only be specified on ’mu’’): the term sits on mu1 rather than mu.
x cosy() + rescor; unstr() + rescor; fcor() + rescor Refused: both describe the residual covariance - one across time, one across responses - and the joint structure is their Kronecker product, which is not implemented. brms refuses the same pair.

Predictor specials

REML quadrature importance profile autoscale sparse_x prior bounds verbose
s() ? x x ? ? + + ? ?
t2() ? x x ? + + + ? +
mo() + ? + + ? ? ? ? ?
mi_pred() ? ? ? ? + + ? ? +
gp_pred() + x x ? ? ? ? ? ?
cs_pred() ? ? x ? + + ? ? +
ps() x x x x + + ? ? +
me() ~ x x + + + + ? ?
Status Pairs Note
~ me() + REML Runs (verified by a tiny fit), but REML integrates a mu me() coefficient together with the latent values it multiplies, so the integrand is not gaussian and even for a gaussian response the criterion is the Laplace-approximated integrated likelihood, not the exact restricted likelihood.
x s() + quadrature Refused in practice: a smooth is a wide random-effect block, so the scalar-intercept guard rejects it.
x s() + importance Refused: a smooth is one field over all observations, with no grouping factor, so there are no independent groups to give separate proposals to.
x t2() + quadrature Refused in practice: a smooth is a wide random-effect block.
x t2() + importance Refused: a smooth basis carries no grouping factor.
x gp_pred() + quadrature Refused in practice: gp() builds a wide block, so the scalar-intercept guard rejects it.
x gp_pred() + importance Refused: gp() builds a field over all observations, not a set of independent groups.
x cs_pred() + importance Refused: cs() contributes threshold-specific offsets as a matrix per observation, which the first version does not stack over draws.
x ps() + REML REML integrates the fixed coefficients out, and a ps() block puts its own null space among them inside a body that is nonlinear in it. Refused by name.
x ps() + quadrature Marginalizing the block by Gauss-Kronrod means integrating over a whole curve, and the rule takes one scalar random effect at a time. Refused by name.
x ps() + importance Inherited: the importance correction refuses EVERY nonlinear predictor, because a body mixes parameter values with raw data columns and the corrected objective evaluates it once per draw. Not a restriction of ps().
x ps() + profile Profiling assumes the objective is quadratic in the fixed coefficients, which a nonlinear body makes it not. Refused by name.
x me() + quadrature Refused: the latent values are one integral each, not the one scalar random effect the rule marginalizes.
x me() + importance Refused: the latent values have no grouping factor to give them a per-group proposal.

The specials mi(), gp(), and cs() share a name with a covariance structure. The registry writes the predictor forms as mi_pred(), gp_pred(), and cs_pred() to keep them apart. A row that marks the exact gp() as working means its model apart from the nugget, which ?"frmtmb-gp" states.

Formula grammar

Five spellings have restrictions of their own. mm() and mmc() are the multi-membership pair: (1 | mm(g1, g2)) averages the member levels’ effects into one design row, and mmc() gives that row a member-specific covariate. Their full rule set is longer than one table row; see ?frmtmb-multimembership.

Spelling Status Note
x * (1 | g) x Refused: a bar term crossed with * or : (as in x * (1 | g)) is not a random-effect specification (lme4#196). Write the crossing inside the bar: (x | g). This spelling was once accepted with the crossing silently dropped.
(1 | factor(x)) + Call-valued grouping factors are supported: (1 | factor(x)) and (1 | interaction(a, b)) both build the grouping factor from the model frame.
(x || g) + (x || g) is brms’s (x | gr(g, cor = FALSE)): one term coded with the formula’s own contrasts, a standard deviation per column and no correlation. (1 + f || g) has the columns Intercept, fb and fc of (1 + f | g), not lme4’s column per level of f. (x | gr(g, cor = FALSE)) is the same term, and (x | mm(g1, g2, cor = FALSE)) is the || term over the membership grouping.
(1 | mm(g1, g2)) + The membership design is built before the family sees it, exactly as an ordinary grouping factor’s is.
(mmc(x1, x2) | mm(g1, g2)) ~ mmc() only means something on the left of a multi-membership bar, where it supplies one covariate value per member. Anywhere else it is refused, including over a single-membership grouping factor. Inside an mm() term it composes like any other random-slope column.

Coverage

Status Pairs Share
works 2859 38%
conditional 2485 33%
refused 975 13%
broken 0 0%
untested 1199 16%

The untested share is the honest measure of what this registry does not yet know. It shrinks as pairs are tested, not as the code is trusted. To close one, add a test and change the rule in R/compat.R.

One class of cell closes without a test, and only that one: a family declares the addition terms it reads in frmtmb_family(accepts_aterms =), and frame assembly refuses any other term on that response BY NAME. Those cells are refusals with a reason rather than an absence of evidence, so they are derived from the declaration instead of being written out. Only the refusal is derived; a family that ACCEPTS a term has said nothing about whether the pair works, and that cell stays untested until somebody runs it.