How the numbers are computed

November 2026: witnessed partner violence as its own category

Until November 2026 the score grouped the 11 items into 7 categories, not the 8 CDC scores. It counted ACEPUNCH, which asks how often the adults in the respondent’s home slapped, hit, kicked, punched or beat each other up, as physical abuse alongside ACEHURT, which asks whether a parent or adult in the home hit, beat, kicked or physically hurt the respondent. CDC’s published BRFSS analyses, including both sources in the cross-checks section, score ACEPUNCH as a household-dysfunction category of its own, witnessed intimate partner violence. The grouping appears to trace to the prototype’s data dictionary, which gave ACEPUNCH the wording of the physical-abuse question.

An outside review of the dashboard’s maps in November 2026 recommended scoring the two separately, for two reasons. First, they are different experiences: physical abuse is violence aimed at the child, while witnessed partner violence is violence between the adults the child lived with. Counting them as one category treated a direct exposure and a vicarious one as the same thing. Second, merging them squeezed the top of the score. A respondent who reported both counted once, so the score stopped at 7 and every such adult scored a point lower than CDC’s method scores them, which put fewer people in the four-or-more band than belong there.

The score now runs 0-8, and the expanded score with the two neglect items 0-10. On the same respondents, physical abuse went from 31.08% to 24.65% (CDC: 23.3%), and witnessed intimate partner violence reads 17.58% (CDC: 17.2%). Respondents with both experiences now score one point higher, so the mean ACE score rose from 1.600 to 1.704, and four or more ACEs from 15.67% to 17.62% (CDC: 17.3%). The share with at least one ACE did not change, since anyone who reported either item already counted once, and neither did who is scored. The figures earlier in this section are on the old 7-category score; the new ones here are live.

Survey weight: each row’s own file’s final weight, in the Weight column below. _LLCPWT (2011 onward) or _FINALWT (2009-2010) for a main file; _FINALQn (2009-2010), _LNDWTVn (2011) or _LCPWTVn (2012 onward) for questionnaire version n; _LANDWT for the landline file. CDC weights each of them to the whole state’s adult population, cell-only adults included even for the landline-only 2011 files, so a state-year read from a version or landline file is on the same scale as one read from a main file. The rows we keep, the respondents who reached the ACE module, carry most of that total but not all of it: interviews that ended before the module are not in the data, so a state-year’s weights sum to somewhat less than its adult population, by more where more interviews broke off. Weights are stored raw apart from the two-version rescale. Years are pooled with no renormalization, no year filter exists anywhere in the query layer, and no design variables (_STSTR, _PSU) are extracted.

The one state-year CDC did not blank in the main file is Oklahoma 2012: LLCP2012 carries its version-2 answers under _LLCPWT, which projects those respondents onto only about half the state’s adults. The same respondents are taken from LLCP12V2 with _LCPWTV2 instead, as CDC’s 2012 guidance directs.

Source files

41 state-years come from a version or landline file; the last column names them.

Effective coverage by year

Percent of that year’s respondents with a non-null recoded value, computed live from the database (for ace_module_asked, percent with the flag true). A 0.0 cell means the column is entirely absent for that year; every such cell carries a footnote. The practical consequence: each statistic has its own implicit year window, and therefore its own state mix.

Why the zero cells are zero

ace_score_10 (2009, 2010, 2011, 2012, 2019, 2020)

The two neglect items (ACEADSAF, ACEADNED) were added to the module in 2021, so nothing derived from them exists for earlier ACE years (documented in variable-mappings.ts absentYears).

ace_emotional_neglect (2009, 2010, 2011, 2012, 2019, 2020)

The two neglect items (ACEADSAF, ACEADNED) were added to the module in 2021, so nothing derived from them exists for earlier ACE years (documented in variable-mappings.ts absentYears).

ace_physical_neglect (2009, 2010, 2011, 2012, 2019, 2020)

The two neglect items (ACEADSAF, ACEADNED) were added to the module in 2021, so nothing derived from them exists for earlier ACE years (documented in variable-mappings.ts absentYears).

depression (2009)

BRFSS carried no depression-diagnosis question in 2009; ADDEPEV first appears in 2010 (as an optional module; see the limitations register).

copd (2009, 2010)

BRFSS did not ask this before 2011 (documented in variable-mappings.ts absentYears).

kidney_disease (2009, 2010)

BRFSS did not ask this before 2011 (documented in variable-mappings.ts absentYears).

skin_cancer (2009, 2010)

BRFSS did not ask this before 2011 (documented in variable-mappings.ts absentYears).

other_cancer (2009, 2010)

BRFSS did not ask this before 2011 (documented in variable-mappings.ts absentYears).

Demographic recodes

Race is era-switched on the row’s own year, and the tables above show the 2013+ codes. RACE2 (2009-2012) and _RACE (2013+) both carry eight categories, but three of them sit at different raw codes, so for a 2009-2012 row the extractor remaps before recoding. Every other code, and every other dimension, is era-free.

A replication that reads RACE2 straight onto the _RACE scale relabels Asian, Native Hawaiian/Pacific Islander and American Indian/Alaska Native respondents as each other for every 2009-2012 row.

Codes not listed above become null (the row is kept; the respondent drops out of that dimension’s breakdowns): race 9, education 9, income 77/99, and any other out-of-range code. Income is era-switched on the row’s own year: through 2020 the question is INCOME2 and code 8 means 75k_plus; from 2021 it is INCOME3 and code 8 means 75k_100k, with codes 9-11 covering the finer top buckets. The two code-8 meanings are stored as distinct labels and never unioned, so filtering on 75k_plus implicitly selects only 2009-2020 respondents and the fine buckets select only 2021+ respondents.

ACE items

• ACEDIVRC code 8 (“parents were never married”) is treated as invalid, not as “no separation or divorce”: it nulls the divorce category and, because scoring is complete-case, the whole ACE-8 score for that respondent. This matches the handling in Swedo et al. (MMWR 2023) but is a choice a replication must copy exactly.
• Frequency items are endorsed at code 2 (“Once”): a single occurrence counts.
• The 2021+ neglect items are reverse-coded protective questions (an adult “made you feel safe and protected” / “tried hard to make sure your basic needs were met”), so neglect present is the LOW end of the scale: codes 1 (Never) or 2 (A little of the time), per CDC’s published cut. Code 3 (“Some of the time”) is deliberately neither pole. They feed the two neglect indicators and the expanded 10-item score only; the ACE-8 score never touches them. They also count toward the asked-population test.
• ACEPUNCH (adults in the home hitting each other) is its own category, witnessed intimate partner violence, as in CDC’s published 8-category scoring. It is not part of physical abuse, which is ACEHURT/ACEHURT1 alone. Versions of this dashboard before November 2026 folded the two together (see the audit section). The expanded 10-item score adds the two neglect categories on their restricted 2021+ basis; see the scoring section and the limitations register.

Health-outcome recodes

Every outcome is recoded to case / non-case / excluded (null). Excluded respondents leave both the numerator and the denominator of that outcome’s statistic; they are never counted as “no”. Each rule below is machine-checked against the recode functions in CI.

The 10 ACE indicator columns referenced throughout are ace_emotional_abuse, ace_physical_abuse, ace_sexual_abuse, ace_emotional_neglect, ace_physical_neglect, ace_witnessed_violence, ace_household_depression, ace_incarceration, ace_substance_abuse, ace_divorce.

• All items answered No/Never: All 11 items valid, nothing endorsed: score 0 (a real zero, not missing).
• Household depression, substance use, sworn at more than once: Three categories endorsed: score 3.
• Touched once (code 2): Frequency items are endorsed at 2 (Once), so sexual abuse counts: score 1.
• Hit by an adult once, saw adults hit each other more than once: Two separate categories, physical abuse (ACEHURT) and witnessed intimate partner violence (ACEPUNCH), as CDC scores them: score 2. Until November 2026 this dashboard counted both as physical abuse and scored this respondent 1.
• Parents never married (ACEDIVRC code 8): Code 8 is invalid, not No: the divorce flag is null and the complete-case score is null even though the other 10 items are valid.
• Refused the incarceration item (code 7): Refusal nulls that category and the score; the other seven categories keep their flags.
• Physical-abuse item never asked (blank): One blank item nulls its category and the score. An extraction gap once made this true for every 2009-2012 respondent; the audit behind this page caught and fixed it.

Aggregate glossary (aliases as they appear in the SQL):

score_n, score_w, score_ws

Unweighted count, Σw, and Σ(w x score) over respondents with a complete ACE-8 score (the “scored base”). The average score is score_ws / score_w.

w_eq0, w_ge1 ... w_ge4

Σw over scored respondents with score = 0 and score >= 1..4. The score bands are cumulative and share the scored-base denominator: “score 0” and “1 or more” sum to 1, but the 1+/2+/3+/4+ bands are nested, not a partition.

<indicator>_n, _w, _s

Per ACE indicator: unweighted count and Σw over respondents whose category flag is non-null (that indicator’s own valid-response base), and Σw over flag-true. Each indicator has its own denominator; the 10 prevalences are not on a common base and do not sum to anything meaningful.

score10_n, score10_w, score10_ws

The same three quantities over respondents with a complete expanded 10-item score (all 13 items valid, neglect included). Always a subset of the 8-item scored base: the neglect items exist only for 2021+ in the states that fielded them, so this mean has its own, smaller denominator and can read no data where the 8-item score publishes. Mean only; the expanded score has no cumulative bands.

asked_n, asked_w

Unweighted count and Σw over respondents asked all 11 scored items (refusers included). Module completion is score_w / asked_w: the share of the asked population that produced a complete score.

Population semantics

An ACE-indicator population narrows the scan itself, adding WHERE <flag> IS TRUE. “Any ACE score” adds no WHERE clause at all.

A score-group population is the one case that is neither, because the same band is doing two jobs. Its own map metric is the share of the scored base in that band, so WHERE ace_score >= 4 would pin it at a trivial 100% in every state. Everything else on screen is a rate within the band. So the band is applied as a FILTER conjunct rather than a WHERE: the score family (the mean and the cumulative bands) keeps scanning the unnarrowed scored base, while every indicator prevalence, Compare y variable and co-occurrence arm carries AND ace_score >= 4 on both its numerator and its denominator. A replication that row-filters to score >= 4 before computing indicator prevalence will match this view; one that also recomputes the “percent with 4 or more” off that filtered set will not, and should read it off the full scored base instead. The exact statement for the current scope, bands included, is in the worked example below.

Compare-view y variables

• A health outcome: Σw(outcome true) / Σw(outcome non-null), each outcome on its own valid-response base.
• Any outcome: numerator is “at least one of the 19 flags true”; denominator is “at least one of the 19 flags non-null”.
• No outcome: numerator is “at least one flag non-null AND none true” over the same denominator. Note the asymmetry: a respondent with one valid “no” and 18 nulls counts as having no outcome.
• The era-safe buckets: less than high school (education in never_attended, elementary, some_high_school over education non-null) and household income under $35K (the five sub-35k labels over income non-null). There is deliberately no $100K+ bucket: pre-2021 income is topcoded at $75K+.
• Module completion: score non-null over ace_module_asked, only offered for the unnarrowed “Any ACE score” population (an ACE population would condition on having answered the category whose nonresponse is being measured).

Age adjustment (Compare view only)

Explore publishes crude estimates. Compare publishes age-adjusted estimates by default, with crude one switch away (adj=crude), because age moves both of the things Compare sets side by side: older adults report fewer ACEs and have more long-term conditions, and jurisdictions differ in how old their adults are (limitation 5 below). The method is direct standardisation:

1. Split the scope into the six age groups the data carries (_AGE_G).
2. Compute each ratio within each age group, on that ratio’s own valid-response denominator, with the survey weights: Σw(numerator) / Σw(denominator), exactly as the crude statistic does.
3. Average the six ratios with one fixed set of weights, the standard population, the same for every jurisdiction and for both co-occurrence arms: adjusted = Σ_a pop_a · ratio_a / Σ_a pop_a.

The standard is the 2000 U.S. projected population (Klein and Schoenborn, Healthy People Statistical Notes no. 20, NCHS 2001, Table 2), the standard CDC uses for age-adjusted BRFSS prevalence. Its published Distribution #9 merges ages 45-64; the two ten-year counts below are the same table’s rows and sum to that group.

What a replication must copy:

• Every Compare ratio is adjusted separately: x, y, and each co-occurrence arm, each on its own denominator. Do not rescale the survey weight once and reuse it: that is only exact when item nonresponse is the same at every age.
• Filters apply first. The filtered group is what gets standardised. Under an age filter the standard is applied within the selected age groups only, and with a single age group selected the adjusted value equals the crude one.
• Counts are not adjusted. The published n is the plain respondent count behind the cell, the same under either kind of estimate.
• Module completion is never adjusted. As a y variable it is returned crude even when x is adjusted: it measures how the interviews went, not a rate to compare on an equal age footing.
• An extra suppression gate applies to adjusted values (see the suppression section): every age group in scope must have respondents, and the estimate’s effective sample size, (Σ pop_a)² / Σ(pop_a² / n_a), must reach 30.
• An adjusted value is a comparison, not a head count. It answers what a group would read with the standard age mix. Because that standard is younger than today’s adults, adjusted figures for conditions of older age read lower than crude ones, and ACE measures read higher.

Co-occurrence

ACE accumulation split by y. For each cumulative band, 1+ through 4+, the card publishes Σw(score at or above the band) / Σw(score non-null) twice: once among respondents with the y variable, once among those without it. “Without” is a valid y response that is not positive (depression IS FALSE; for Any outcome it is the No outcome definition, and the reverse). Respondents with no complete score or no valid y are on neither side, and each side’s four bands share one denominator and one n, so a side suppresses all four rows together.

Two adjustments keep the rows from being true by definition. When y is itself an ACE the score counts (every indicator but the two neglect items), the bands threshold ace_score - <y flag>::int, the count of the other ACEs, on both sides: otherwise everyone with y would read 100% at 1+. And a band the population already decides is not shown, because it is the same on both sides by construction: 1+ under an ACE population the score counts, every band up to k under “an ACE score of k or more”, and every band under “an ACE score of 0”. When y is module completion the whole card is skipped: completing the module is what produces a score, so the side without completion is always empty.

The number the card displays is neither side. Its value column is headed “Prevalence gap (%)” and holds with − without in percentage points: a difference of two proportions, so it carries no denominator of its own. Three properties a replication must copy exactly:

• It differences the two published values, i.e. the already-rounded 4-decimal proportions, not the unrounded quotients. Differencing your own unrounded ratios can move the last displayed digit; the on-screen gap is always exactly the difference of the two bars beside it.
• It is null unless both sides publish, under the same pair rule as the bivariate map tile (see the suppression section). A row with one publishable side shows no gap.
• It is rendered to one decimal, as points: a gap of 0.1763 displays as 17.6, meaning 17.6 percentage points, not 17.6%.

With no demographic filter every jurisdiction passes. The gate bites on narrow filters, where a state’s age groups thin out. Computed by calling the production suppressedValue() as this page renders, for a cell of 400 respondents:

Explore, number of respondents: a log scale with a gray floor

The respondents display maps score_n itself: the unweighted count of respondents with a complete ACE score in the scope. No weight touches it, and it is never suppressed, because a count is exact at any size. Counts are skewed, so it is not classed like the statistics above (in this scope the largest classable count is 47.0 times the smallest): equal-width classes would spend most of the ramp on a few big states. Instead it cuts log10 of the count into equal intervals with the same three stops, so each step up is the same multiple. Each cut is rounded to two significant figures and the rounded value is the threshold drawn (if rounding would collapse a class, the cut falls back to the next whole respondent, which classes every count exactly as the unrounded cut would). The legend note under that map prints these cuts.

States under n = 30 stay out of the domain and take the no-data gray, and their tile reads < 30 rather than the exact count, because it is too small for any of the estimates above. In this scope that is 0 of 49 jurisdictions. Live:

Compare: a 2×2 split at the national value

The bivariate map does not class against the data range. It classes each state against the national value of each axis: the same two numbers the scatterplot draws as its crosshair, so a tile’s color and its dot’s quadrant can never disagree. A state is “high” on an axis when its value is greater than or equal to the national value: a state exactly on the line counts as high.

Live thresholds for the current pair. x = Average ACE score 1.79, y = Depression 19.69%:

Tiles with nothing to say

A tile with no class is filled with the no-data gray on both maps, and keeps a text marker so suppression is never encoded in color alone. The two maps reach that state by different rules:

• Explore classes one cell, so it follows the single-cell rule in the suppression section: -- below n = 30, N/A at n = 0. A jurisdiction with no ACE module data returns no row at all and so reads N/A. The respondents display is the exception: its value is the count, so a tile under the threshold is gray and reads < 30, and only n = 0 reads N/A.
• Compare classes a pair, and needs both sides. A pair reads -- only when both x and y were measured (n > 0 on each) but at least one is below the threshold; if either side measured nothing at all, the pair reads N/A, because “low sample size” would be the wrong caution there. So a Compare tile can read N/A for a state whose x value publishes perfectly well on the Explore map. The same pair rule governs each co-occurrence row.

The scatterplot

The Compare scatterplot plots one dot per jurisdiction at (x, y), with the national values drawn as a crosshair: the same two thresholds the bivariate map splits on. Its axes are scaled to round ticks (the smallest 1 / 2.5 / 5 × 10ⁿ step covering the data in about four intervals, with the domain floored and ceiled to that step and the national values forced inside it), so the axis bounds are display choices and not data limits.

It also draws a line of best fit: ordinary least squares over the plotted dots. Two properties to be explicit about, since the page publishes no other fitted quantity:

• It is unweighted across states. Every jurisdiction contributes one point regardless of its sample size or population, which is what makes the line match what the eye fits to the chart, but it is not a population-weighted relationship, and it is not the within-person association the co-occurrence card measures.
• No slope, intercept, R², standard error, or p-value is computed for display or published anywhere. The line is a visual summary only; see the limitations register on variance estimation.

A metric or Compare x that is invalid for the chosen population coerces to that population’s default, exactly as the dashboard’s URLs do. Demographic filters have no form controls here; paste any /explore or /compare query string onto /methods instead (for example /methods?state=GA&sex=female&age=25_34 or /methods?pop=4plus).

Current scope: adults with any ACE score, metric Average ACE score. Open it on the dashboard: Explore / Compare.

Explore: the statement

One scan computes every aggregate for the scope (national total, every state, and the national demographic rows; gset is the GROUPING bitmask that routes them). This is the exact statement and bindings the dashboard executes:

SELECT state_fips,
    sex::text AS sex,
    age_group::text AS age_group,
    race::text AS race,
    education::text AS education,
    income::text AS income,
    GROUPING(state_fips, sex, age_group, race, education, income)::int AS gset,
    COUNT(*) FILTER (WHERE ace_module_asked)::int AS asked_n,
    SUM(weight) FILTER (WHERE ace_module_asked)::float8 AS asked_w,
    COUNT(*) FILTER (WHERE ace_score IS NOT NULL)::int AS score_n,
    SUM(weight) FILTER (WHERE ace_score IS NOT NULL)::float8 AS score_w,
    SUM(weight * ace_score) FILTER (WHERE ace_score IS NOT NULL)::float8 AS score_ws,
    SUM(weight) FILTER (WHERE ace_score = 0)::float8 AS w_eq0,
    SUM(weight) FILTER (WHERE ace_score >= 1)::float8 AS w_ge1,
    SUM(weight) FILTER (WHERE ace_score >= 2)::float8 AS w_ge2,
    SUM(weight) FILTER (WHERE ace_score >= 3)::float8 AS w_ge3,
    SUM(weight) FILTER (WHERE ace_score >= 4)::float8 AS w_ge4,
    COUNT(*) FILTER (WHERE ace_score_10 IS NOT NULL)::int AS score10_n,
    SUM(weight) FILTER (WHERE ace_score_10 IS NOT NULL)::float8 AS score10_w,
    SUM(weight * ace_score_10) FILTER (WHERE ace_score_10 IS NOT NULL)::float8 AS score10_ws,
    COUNT(*) FILTER (WHERE ace_emotional_abuse IS NOT NULL)::int AS ace_emotional_abuse_n,
    SUM(weight) FILTER (WHERE ace_emotional_abuse IS NOT NULL)::float8 AS ace_emotional_abuse_w,
    SUM(weight) FILTER (WHERE ace_emotional_abuse)::float8 AS ace_emotional_abuse_s,
    COUNT(*) FILTER (WHERE ace_physical_abuse IS NOT NULL)::int AS ace_physical_abuse_n,
    SUM(weight) FILTER (WHERE ace_physical_abuse IS NOT NULL)::float8 AS ace_physical_abuse_w,
    SUM(weight) FILTER (WHERE ace_physical_abuse)::float8 AS ace_physical_abuse_s,
    COUNT(*) FILTER (WHERE ace_sexual_abuse IS NOT NULL)::int AS ace_sexual_abuse_n,
    SUM(weight) FILTER (WHERE ace_sexual_abuse IS NOT NULL)::float8 AS ace_sexual_abuse_w,
    SUM(weight) FILTER (WHERE ace_sexual_abuse)::float8 AS ace_sexual_abuse_s,
    COUNT(*) FILTER (WHERE ace_emotional_neglect IS NOT NULL)::int AS ace_emotional_neglect_n,
    SUM(weight) FILTER (WHERE ace_emotional_neglect IS NOT NULL)::float8 AS ace_emotional_neglect_w,
    SUM(weight) FILTER (WHERE ace_emotional_neglect)::float8 AS ace_emotional_neglect_s,
    COUNT(*) FILTER (WHERE ace_physical_neglect IS NOT NULL)::int AS ace_physical_neglect_n,
    SUM(weight) FILTER (WHERE ace_physical_neglect IS NOT NULL)::float8 AS ace_physical_neglect_w,
    SUM(weight) FILTER (WHERE ace_physical_neglect)::float8 AS ace_physical_neglect_s,
    COUNT(*) FILTER (WHERE ace_witnessed_violence IS NOT NULL)::int AS ace_witnessed_violence_n,
    SUM(weight) FILTER (WHERE ace_witnessed_violence IS NOT NULL)::float8 AS ace_witnessed_violence_w,
    SUM(weight) FILTER (WHERE ace_witnessed_violence)::float8 AS ace_witnessed_violence_s,
    COUNT(*) FILTER (WHERE ace_household_depression IS NOT NULL)::int AS ace_household_depression_n,
    SUM(weight) FILTER (WHERE ace_household_depression IS NOT NULL)::float8 AS ace_household_depression_w,
    SUM(weight) FILTER (WHERE ace_household_depression)::float8 AS ace_household_depression_s,
    COUNT(*) FILTER (WHERE ace_incarceration IS NOT NULL)::int AS ace_incarceration_n,
    SUM(weight) FILTER (WHERE ace_incarceration IS NOT NULL)::float8 AS ace_incarceration_w,
    SUM(weight) FILTER (WHERE ace_incarceration)::float8 AS ace_incarceration_s,
    COUNT(*) FILTER (WHERE ace_substance_abuse IS NOT NULL)::int AS ace_substance_abuse_n,
    SUM(weight) FILTER (WHERE ace_substance_abuse IS NOT NULL)::float8 AS ace_substance_abuse_w,
    SUM(weight) FILTER (WHERE ace_substance_abuse)::float8 AS ace_substance_abuse_s,
    COUNT(*) FILTER (WHERE ace_divorce IS NOT NULL)::int AS ace_divorce_n,
    SUM(weight) FILTER (WHERE ace_divorce IS NOT NULL)::float8 AS ace_divorce_w,
    SUM(weight) FILTER (WHERE ace_divorce)::float8 AS ace_divorce_s
  FROM respondents
  
  GROUP BY GROUPING SETS ((state_fips), (sex), (age_group), (race), (education), (income), ())

No bound parameters; this scan is unfiltered.

National: Average ACE score

Self-check: this ledger’s result equals the production API value for the same scope. Recomputed and compared as the page rendered.

A deliberately suppressed cell

Suppression fires on the unweighted count, so small cells exist in every seed. This one is live from Puerto Rico’s default-scope scan: Income = $150-200K, average ACE score. Your own run WILL produce a value here; we deliberately publish neither the value nor its weighted sums, since at small n those sums approach an individual respondent’s own survey weight. The ledger shows the n and the decision, which is everything a replication needs to confirm the rule fired.

Puerto Rico, Income = $150-200K: Average ACE score

Self-check: this ledger’s result equals the production API value for the same scope. Recomputed and compared as the page rendered.

Compare: x and y on one scan

The Compare view computes both axes in one per-state statement; x and y have independent denominators and suppression counts. National ledgers for Average ACE score (x) versus Depression (y):

These are age-adjusted estimates, Compare’s default. The statement’s inner query (strata) is the crude scan with the age group added to every grouping set; the outer query averages each ratio over the age groups on the standard population listed in its VALUES clause. Counts and denominators come back as plain sums, so they are the crude ones; each numerator comes back as the adjusted rate times that denominator, so the same quotient applies. Add adj=crude to this page’s address to see the crude statement instead.

WITH strata AS (
  SELECT state_fips,
    GROUPING(state_fips)::int AS gset,
    std_age,
    SUM(weight * ace_score) FILTER (WHERE ace_score IS NOT NULL)::float8 AS x_num,
    SUM(weight) FILTER (WHERE ace_score IS NOT NULL)::float8 AS x_den,
    COUNT(*) FILTER (WHERE ace_score IS NOT NULL)::int AS x_n,
    SUM(weight) FILTER (WHERE depression IS TRUE)::float8 AS y_num,
    SUM(weight) FILTER (WHERE depression IS NOT NULL)::float8 AS y_den,
    COUNT(*) FILTER (WHERE depression IS NOT NULL)::int AS y_n
  FROM (SELECT *, age_group::text AS std_age FROM respondents) AS respondents
  
  GROUP BY GROUPING SETS ((state_fips, std_age), (std_age))
)
SELECT state_fips, gset,
    SUM(x_n)::int AS x_n,
    SUM(x_den)::float8 AS x_den,
    (CASE WHEN COUNT(*) FILTER (WHERE x_den > 0) = 6
      THEN POWER(SUM(std.pop) FILTER (WHERE x_den > 0), 2) / SUM(POWER(std.pop, 2) / NULLIF(x_n, 0))
      ELSE 0 END)::float8 AS x_n_eff,
    (SUM(x_den) * SUM(std.pop * COALESCE(x_num, 0) / NULLIF(x_den, 0))
      / NULLIF(SUM(std.pop) FILTER (WHERE x_den > 0), 0))::float8 AS x_num,
    SUM(y_n)::int AS y_n,
    SUM(y_den)::float8 AS y_den,
    (CASE WHEN COUNT(*) FILTER (WHERE y_den > 0) = 6
      THEN POWER(SUM(std.pop) FILTER (WHERE y_den > 0), 2) / SUM(POWER(std.pop, 2) / NULLIF(y_n, 0))
      ELSE 0 END)::float8 AS y_n_eff,
    (SUM(y_den) * SUM(std.pop * COALESCE(y_num, 0) / NULLIF(y_den, 0))
      / NULLIF(SUM(std.pop) FILTER (WHERE y_den > 0), 0))::float8 AS y_num
FROM strata
JOIN (VALUES ('18_24', 26258), ('25_34', 37233), ('35_44', 44659), ('45_54', 37030), ('55_64', 23961), ('65_plus', 34710)) AS std(age, pop) ON std.age = strata.std_age
GROUP BY state_fips, gset

No bound parameters; this scan is unfiltered.

National x: Average ACE score

Self-check: this ledger’s result equals the production API value for the same scope. Recomputed and compared as the page rendered.

National y: Depression

Self-check: this ledger’s result equals the production API value for the same scope. Recomputed and compared as the page rendered.

Co-occurrence: ACE accumulation with versus without y

The card’s 4+ ACEs row: the share of scored adults with ace_score >= 4, among adults with Depression versus adults without it. Respondents with no complete score or no valid y are on neither side, and both sides divide every band by the same scored base.

With Depression: 4+ ACEs

Self-check: this ledger’s result equals the production API value for the same scope. Recomputed and compared as the page rendered.

Without Depression: 4+ ACEs

Self-check: this ledger’s result equals the production API value for the same scope. Recomputed and compared as the page rendered.

The number the card actually prints: the gap

The card’s value column is headed “Prevalence gap (%)” and holds the difference of the two published values above, in percentage points. It is computed by the same coOccurrenceGap() the card calls, from the same rounded proportions, so this row is the card’s number by construction and not a re-derivation.

WITH strata AS (
  SELECT std_age,
    SUM(weight) FILTER (WHERE ace_score IS NOT NULL AND depression IS TRUE)::float8 AS with_score_w,
    COUNT(*) FILTER (WHERE ace_score IS NOT NULL AND depression IS TRUE)::int AS with_score_n,
    SUM(weight) FILTER (WHERE ace_score >= 1 AND depression IS TRUE)::float8 AS with_w_ge1,
    SUM(weight) FILTER (WHERE ace_score >= 2 AND depression IS TRUE)::float8 AS with_w_ge2,
    SUM(weight) FILTER (WHERE ace_score >= 3 AND depression IS TRUE)::float8 AS with_w_ge3,
    SUM(weight) FILTER (WHERE ace_score >= 4 AND depression IS TRUE)::float8 AS with_w_ge4,
    SUM(weight) FILTER (WHERE ace_score IS NOT NULL AND depression IS FALSE)::float8 AS without_score_w,
    COUNT(*) FILTER (WHERE ace_score IS NOT NULL AND depression IS FALSE)::int AS without_score_n,
    SUM(weight) FILTER (WHERE ace_score >= 1 AND depression IS FALSE)::float8 AS without_w_ge1,
    SUM(weight) FILTER (WHERE ace_score >= 2 AND depression IS FALSE)::float8 AS without_w_ge2,
    SUM(weight) FILTER (WHERE ace_score >= 3 AND depression IS FALSE)::float8 AS without_w_ge3,
    SUM(weight) FILTER (WHERE ace_score >= 4 AND depression IS FALSE)::float8 AS without_w_ge4
  FROM (SELECT *, age_group::text AS std_age FROM respondents) AS respondents
  
  GROUP BY std_age
)
SELECT SUM(with_score_n)::int AS with_score_n,
    SUM(with_score_w)::float8 AS with_score_w,
    (CASE WHEN COUNT(*) FILTER (WHERE with_score_w > 0) = 6
      THEN POWER(SUM(std.pop) FILTER (WHERE with_score_w > 0), 2) / SUM(POWER(std.pop, 2) / NULLIF(with_score_n, 0))
      ELSE 0 END)::float8 AS with_score_n_eff,
    (SUM(with_score_w) * SUM(std.pop * COALESCE(with_w_ge1, 0) / NULLIF(with_score_w, 0))
      / NULLIF(SUM(std.pop) FILTER (WHERE with_score_w > 0), 0))::float8 AS with_w_ge1,
    (SUM(with_score_w) * SUM(std.pop * COALESCE(with_w_ge2, 0) / NULLIF(with_score_w, 0))
      / NULLIF(SUM(std.pop) FILTER (WHERE with_score_w > 0), 0))::float8 AS with_w_ge2,
    (SUM(with_score_w) * SUM(std.pop * COALESCE(with_w_ge3, 0) / NULLIF(with_score_w, 0))
      / NULLIF(SUM(std.pop) FILTER (WHERE with_score_w > 0), 0))::float8 AS with_w_ge3,
    (SUM(with_score_w) * SUM(std.pop * COALESCE(with_w_ge4, 0) / NULLIF(with_score_w, 0))
      / NULLIF(SUM(std.pop) FILTER (WHERE with_score_w > 0), 0))::float8 AS with_w_ge4,
    SUM(without_score_n)::int AS without_score_n,
    SUM(without_score_w)::float8 AS without_score_w,
    (CASE WHEN COUNT(*) FILTER (WHERE without_score_w > 0) = 6
      THEN POWER(SUM(std.pop) FILTER (WHERE without_score_w > 0), 2) / SUM(POWER(std.pop, 2) / NULLIF(without_score_n, 0))
      ELSE 0 END)::float8 AS without_score_n_eff,
    (SUM(without_score_w) * SUM(std.pop * COALESCE(without_w_ge1, 0) / NULLIF(without_score_w, 0))
      / NULLIF(SUM(std.pop) FILTER (WHERE without_score_w > 0), 0))::float8 AS without_w_ge1,
    (SUM(without_score_w) * SUM(std.pop * COALESCE(without_w_ge2, 0) / NULLIF(without_score_w, 0))
      / NULLIF(SUM(std.pop) FILTER (WHERE without_score_w > 0), 0))::float8 AS without_w_ge2,
    (SUM(without_score_w) * SUM(std.pop * COALESCE(without_w_ge3, 0) / NULLIF(without_score_w, 0))
      / NULLIF(SUM(std.pop) FILTER (WHERE without_score_w > 0), 0))::float8 AS without_w_ge3,
    (SUM(without_score_w) * SUM(std.pop * COALESCE(without_w_ge4, 0) / NULLIF(without_score_w, 0))
      / NULLIF(SUM(std.pop) FILTER (WHERE without_score_w > 0), 0))::float8 AS without_w_ge4
FROM strata
JOIN (VALUES ('18_24', 26258), ('25_34', 37233), ('35_44', 44659), ('45_54', 37030), ('55_64', 23961), ('65_plus', 34710)) AS std(age, pop) ON std.age = strata.std_age

year,state,sex,age_group,race,education,income,ace_depressed,ace_alcoholic,ace_drugs,ace_prison,ace_divorce,ace_punch,ace_hurt,ace_swear,ace_touch,ace_touched,ace_sex,ace_safe,ace_needs,general_health,mental_health_days,physical_health_days,depression,smoking_status,smoking_current,bmi_category,heavy_drinker,binge_drinker,physical_activity,health_insurance,cost_barrier,diabetes,heart_disease,heart_attack,angina_chd,stroke,asthma,copd,kidney_disease,arthritis,skin_cancer,other_cancer,weight

Cells are raw BRFSS codes as extracted (blank = never asked), each state-year already taken from its one source file (steps 2-4). The weight cell is that file’s own weight, already multiplied by the version share for the two-version state-years; the file has no source column, so use coverage.csv’s to see which file and weight a state-year carries. Steps 5-7 still apply.

Downloads: the intermediates behind one scan

• aggregates.csv: one row per scope and metric with unweighted n, weighted numerator and denominator (full precision), unrounded quotient, published value, and the suppression flag. Diff your whole run against ours in one join. Suppressed and empty cells carry only their n and the flag; their weighted sums are withheld under the same rule as the value, since at small n those sums approach an individual respondent’s weight.
  What is in it: every cell the current scope’s single Explore scan publishes: the national total, every participating jurisdiction, and every demographic member row (written age=25_34 and so on), for every Explore metric. The link above carries this page’s current scope, so re-scope the page and download again to get a different population or filter set.
  What is not: Compare cells. The per-state x/y pairs and the co-occurrence sides come from two different statements, so they are not in this file; use the worked examples above, which print those statements and their raw rows in full.
• coverage.csv: one row per state and survey year with the file(s) and weight variable it was read from, row counts, asked and scored bases, and pooled weight. Reconcile your extraction row counts here before any statistic. The pooled weight obeys the same publication gate as every other weighted sum on this page: a state-year cell under the threshold carries its counts and a weight_withheld flag but no weight, since at that size the pooled weight approaches a single respondent’s own. The counts are never withheld.

Minimal snippets

R (one year, 2023, one indicator; pool years by concatenating before the ratio). The file names, state codes and weights are generated from the same registries the extractor runs on, so they are that year’s actual sources:

library(haven)
library(dplyr)

ace_vars <- c("ACEDEPRS","ACEDRINK","ACEDRUGS","ACEPRISN","ACEDIVRC",
              "ACEPUNCH","ACEHURT1","ACESWEAR","ACETOUCH","ACETTHEM",
              "ACEHVSEX","ACEADSAF","ACEADNED")

# One year (2023). Each state-year comes from ONE file, weighted by that
# file's own final weight: the main file, except for the split-sample states,
# whose answers are in a questionnaire-version file. Repeat per year with that
# year's files (the source table) and pool (no weight renormalization).
part <- function(file, weight, keep) {
  read_xpt(file) %>%
    filter(keep(`_STATE`)) %>%
    select(`_STATE`, any_of(ace_vars), w = all_of(weight))
}
d <- bind_rows(
  part("LLCP2023.XPT", "_LLCPWT", function(s) !(s %in% c(24, 39))),
  part("LLCP23V1.XPT", "_LCPWTV1", function(s) s %in% c(39)),  # OH
  part("LLCP23V3.XPT", "_LCPWTV3", function(s) s %in% c(24))  # MD
)

# Asked population: any ACE item non-missing (7/9 refusals are NOT missing).
asked <- d %>% filter(if_any(any_of(ace_vars), ~ !is.na(.x)))

# One indicator, e.g. emotional abuse (ACESWEAR, frequency item):
emo <- asked %>%
  mutate(flag = case_when(ACESWEAR %in% c(2, 3) ~ TRUE,
                          ACESWEAR == 1        ~ FALSE,
                          TRUE                 ~ NA)) %>%
  filter(!is.na(flag))
emo %>% summarise(prevalence = sum(w[flag]) / sum(w))

SAS skeleton:

/* Same shape in SAS: one year, each state-year from ONE file with that file's
   own weight, then a weighted ratio. No PROC SURVEYFREQ variance will match
   ours, because we publish none. */
data emo;
  set llcp2023 (in=f0) llcp23v1 (in=f1) llcp23v3 (in=f2);
  if f0 then do; if _STATE in (24, 39) then delete; w = _LLCPWT; end;
  if f1 then do; if _STATE not in (39) then delete; w = _LCPWTV1; end;  /* OH */
  if f2 then do; if _STATE not in (24) then delete; w = _LCPWTV3; end;  /* MD */
  if n(of ACEDEPRS ACEDRINK ACEDRUGS ACEPRISN ACEDIVRC ACEPUNCH ACEHURT1
       ACESWEAR ACETOUCH ACETTHEM ACEHVSEX ACEADSAF ACEADNED) = 0 then delete;
  if ACESWEAR in (2, 3) then flag = 1;
  else if ACESWEAR = 1 then flag = 0;
  else delete;
run;
proc means data=emo mean;
  var flag;
  weight w;  /* weighted mean of flag = the prevalence */
run;

Full citations: Swedo EA, Aslam MV, Dahlberg LL, Holditch Niolon P, Guinn AS, Simon TR, Mercy JA. Prevalence of Adverse Childhood Experiences Among U.S. Adults, Behavioral Risk Factor Surveillance System, 2011-2020. MMWR Morb Mortal Wkly Rep 2023;72(26):707-715. Merrick MT, Ford DC, Ports KA, Guinn AS. Prevalence of Adverse Childhood Experiences From the 2011-2014 Behavioral Risk Factor Surveillance System in 23 States. JAMA Pediatr 2018;172(11):1038-1044.

3. Complete-case scoring narrows the scored population

The score is null unless all 11 items are valid, so score-based metrics (average, the bands) cover a narrower and potentially non-random subset than the indicator metrics, each of which uses its own valid-response base. Module completion quantifies exactly this gap, per state, on the dashboard.

4. A break in series in the physical-abuse item (confirmed rewording)

The CDC renamed the physical-abuse item between eras (ACEHURT in 2009-2012, ACEHURT1 from 2019), and the two eras do not read alike: endorsement is about 9 percentage points lower pre-2013 even within the 16 jurisdictions present in both eras (16.1% vs 25.3% unweighted, 2009-2012 vs 2019-2024; every one of the 16 jumps 7-13 points). ACEPUNCH (witnessed intimate partner violence), the adjacent question on the same scale, barely moves (+0.8 points), and no other ACE item rises more than 4.6 (parental divorce, about half the jump), so this is specific to the one renamed item, not a cohort or mode story. Nor is it the 2011 landline-only rows: without them the gap is 9.5 points. Physical abuse is scored from this item alone, so the indicator carries the full jump. These figures were measured on 2026-09-22, after the split-sample state-years were added, and re-derived unchanged on 2026-11-09; the 2026-07-30 audit, with eight states then in both eras, found 15.2% vs 23.9% on a sample of the raw files with 2019-2021 as the later era. CDC’s national codebook margins show the same pattern (17.9% endorsed in 2011 vs 24.5% in 2019, while ACEPUNCH sits at 17.0% in both).

The cause is a confirmed rewording, verified against the archived CDC questionnaires for 2009-2012 and 2019-2021. The early item reads: “Before age 18, how often did a parent or adult in your home ever hit, beat, kick, or physically hurt you in any way? Do not include spanking. Would you say--”. The 2019+ item reads: “Not including spanking, (before age 18), how often did a parent or adult in your home ever hit, beat, kick, or physically hurt you in any way? Was it--”. The spanking exclusion moved from a standalone sentence heard immediately before answering to a clause at the front of a long sentence, and the age frame became a parenthetical (optional for the interviewer to read). The direction of the jump is consistent with the exclusion losing salience, though no published split-ballot experiment quantifies this change; the module preamble, item order, response scale, and surrounding items are verbatim identical across eras, ruling the alternatives out. CDC’s own pooled publications (including Swedo et al. 2023) mix the two versions without a comparability note.

Weighted effect of pooling the eras here: mean ACE score 1.746 for 2019-2024 alone against 1.704 pooled, physical-abuse prevalence 26.6% against 24.6%. (The audit of 2026-07-30, before the split-sample state-years were added and on the old 7-category score, measured 1.634 to 1.605 and 32.0% to 30.8%.) Score-based and physical-abuse estimates blend two versions of this item; era-restricted replications will not match pooled values exactly.

5. Explore is crude; Compare is age-adjusted by default

Age sits on both sides of this dashboard. Reported ACEs fall with age (the mean ACE score is 2.12 among adults 18-24 and 1.06 among adults 65 and over), while most long-term conditions rise with it. Jurisdictions differ in age mix, and so do the survey years, so a crude gap between two states or two periods is partly a gap in who was young and who was old. Of two states with identical rates at every age, the older one reads lower on ACE measures and higher on long-term conditions.

Every number on Explore is crude: a weighted proportion or mean, not standardised to a common age distribution. That is the right figure for how common something is in a state, and the wrong one for ranking states. To compare states on Explore, filter to one age group or read the age breakdown; each holds age roughly constant.

Compare is age-adjusted by default (direct standardisation to the 2000 U.S. standard population; see the formulas), because there age moves both axes at once and both sides of the co-occurrence card: adults with a condition of older age are older on average than adults without it, and older adults report fewer ACEs, which narrows a crude gap for those conditions and widens it for behaviours of younger age. Its switch to crude shows the figures as surveyed. Three consequences to keep in mind:

• The same state reads differently in the two views. Compare’s x axis and Explore’s map can show different values for one measure and one state, because one is adjusted and the other is not. Set Compare to crude to reproduce Explore’s figure.
• Adjusted values depend on the standard. They are for comparing groups, not for counting people, and they are comparable only with other figures standardised the same way (same standard, same six age groups).
• Adjustment removes the effect of a group’s age mix. It does not correct the age-specific rates themselves: the lower ACE reporting of older adults is partly a real difference between generations and partly recall and survival, and all of it remains.

The two published sources in the cross-checks above report crude estimates, and those rows read Explore’s crude scan, so they are like for like.

The register

No bound parameters; this scan is unfiltered.