How the numbers are computed

Every statistic on the dashboard is computed from one fact table seeded from one committed file. The fingerprint below identifies exactly which data this page (and the dashboard) is describing right now; all numbers on this page are computed live from that table or imported from the code that computes them.

Source file

prisma/data/brfss-ace.csv.gz (committed via Git LFS), extracted from 32 CDC files: the main file of each of the 10 ACE module years, plus 22 questionnaire-version and landline files for the 41 split-sample state-years (see the pipeline)

SHA-256 of the seeded file

7b29cdedbc41f0affefd10d78fd6fc161aad8581954164cf253407272c0e687d
After git lfs pull, shasum -a 256 prisma/data/brfss-ace.csv.gz must print this value; it is also the file’s Git LFS object id, so the file you pull is verifiably the file we seeded.

Rows loaded / skipped at seed

758,236 loaded, 0 skipped (skip rule: unknown state FIPS, or missing/non-positive survey weight; nothing else drops a row)

Transform version

5 in the database, 5 in the code (in sync)

Seeded at

2026-11-09T11:33:41.522Z

Participating states/territories

49 of 54 seeded jurisdictions have respondents

Suppression threshold

unweighted n < 30 suppresses a value (see the suppression section)

Income question eras

INCOME2 through 2020, INCOME3 from 2021 (see recodes)

Survey years in the table

Rows per year, the states and territories they come from, and the pooled survey weight each year contributes. How many jurisdictions fielded the ACE module changes from year to year, from 5 to 28, and that is most of why the respondent counts swing so widely: each year averages between 4,653 and 8,133 respondents per jurisdiction.

Every file’s weight is calibrated to its state’s whole adult population, whichever file a state-year was read from; the respondents who reached the ACE module carry most of that total, so each year’s weights sum to somewhat less than that year’s covered adult population. We pool them without renormalization, so the total weight is a person-years-style quantity of about 529,007,713 across 758,236 respondents, which should never be read as a population count.

The arbitrary scale cancels in every ratio we publish. What the pooling does decide is what each ratio averages over: a year enters in proportion to its own total weight, which is not its share of the respondents. In this seed the widest gap is 2020, which carries 21.8% of the pooled weight but 19.5% of the respondents. A state that fielded the module in 7 years therefore contributes far more weight than one that fielded it once, and the pooled figure is neither a single-year estimate nor an equal-weight average of the years. See the limitations register for what that means when comparing states.

Assembling this page in July 2026 surfaced a real extraction defect: the pipeline matched each CDC variable by a single name, but the CDC renames variables across years, so 14 columns were silently blank for whole year blocks. The worst case was the physical-abuse item, blank for all of 2009-2012, which made a complete ACE score impossible for 21% of the table and made six states (Louisiana, Minnesota, North Carolina, Oklahoma, Vermont, and Washington) appear to have no score data at all.

The fix (2026-07-30) repaired the alias lists, added era-aware recodes where a rename also changed response coding, and made the extractor refuse to write a CSV when a column resolves to nothing without a documented reason, so this class of defect now fails loudly instead of shipping silently. The scored population grew from 393,535 respondents (effectively 2019-2024) to 501,877 spanning 2009-2024, and the six states above went from N/A to real values.

What the recovered data changed, and the era-comparability questions it raised (a break in series in the physical-abuse item, a melanoma reclassification, definition drift in the drinking flags), are documented in the limitations register below; headline effects were modest (mean ACE score 1.634 to 1.605).

September 2026: the split-sample state-years

A second audit (2026-09-22) found that the dashboard had been missing ACE data CDC publishes outside its main annual files. When a state asks a module on only some versions of its questionnaire, CDC blanks those answers in the main file and publishes them in per-version files with their own weights, and in 2011 it did the same for modules asked on the landline survey only. The extractor read the main files alone, so 40 state-years never reached the dashboard, including every year of eight states (California, Kansas, Maine, Maryland, Massachusetts, Nebraska, New York, and Ohio). Oklahoma 2012 was loaded, but from the main file, where CDC had left its version-2 answers under the main-file weight: that weight summed to 1.34 million over those respondents, about half the state’s adults, where the version weight sums to 2.74 million.

The fix (2026-09-22) added a registry of which file each such state-year comes from (the last column of the pipeline’s source table), reads each from its version or landline file with that file’s own weight, rescales the two state-years asked on two versions, and makes the extractor stop with an error if any file it reads carries ACE answers the registry does not account for. Rows went from 557,014 to 758,236, jurisdictions with ACE data from 41 to 49, and state-years from 93 to 133; the scored population, 501,877 before, is 673,232 now (live). Every other state-year is unchanged row for row. Headline effects were again small (mean ACE score 1.605 to 1.600; one or more ACEs 64.45% to 64.40%), and the new state-years’ own caveats (subsample size, landline-only 2011 rows, California 2011’s missing incarceration item) are in the limitations register.

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.

1. CDC download. The BRFSS public-use files (XPT inside ZIP) listed below. Each ACE module year has a main annual file, three questionnaire-version files and, in 2011-2012, a landline-only file. CDC also publishes three landline-only version files for 2012 (LAND12V1-V3), which the extractor does not read: CDC’s 2012 module tables put the ACE module on none of them, only on Iowa (every version) and Oklahoma (version 2), and both come from the files above. A state that asked the ACE module on only some versions of its questionnaire (a split sample) has its answers in those version files alone, blanked in the main file, and in 2011 the versions, like the landline file, cover the landline survey only. The main files for 2013-2018 are probed too but contain no ACE module variables, so they contribute zero rows.
2. Extraction (scripts/process-brfss.ts). Every state-year is read from exactly one source: its year’s main file, unless the split-sample registry (src/lib/brfss/split-sample.ts, the last column below) lists it, in which case its rows come from the listed version or landline file(s) only and its copies in every other file are ignored. That is what keeps a respondent from being counted twice: version files repeat the states that asked the module on every version, and the 2012 main file repeats Oklahoma’s version-2 answers under the main-file weight. Each row keeps its own file’s final weight. For the state-years asked on two versions (CA 2011 and NE 2011), each version’s weight is multiplied by that version’s share of the state-year’s ACE respondents, P_k = n_k / (n_1 + n_2) (CDC’s rule for combining versions), so the two together sum to one state population rather than two. The run stops with an error if any file it reads carries ACE answers the registry does not account for, or a listed state-year yields no rows; that is the only reason the files that supply nothing are read. Within a file, each standardized column takes the first alias present (see the variable mapping table). A respondent’s row is kept if any ACE item cell is non-blank: BRFSS codes a refusal or “don’t know” as 7 or 9 and leaves a never-asked item blank, so non-blank-anywhere is exactly the asked population, refusers included. The two 2021+ neglect items count for this test even though they are not scored.
3. Transform and seed (src/lib/brfss/transform.ts, prisma/seed.ts). Recodes every demographic and outcome, derives the ACE-8 score and category flags (see scoring), derives ace_module_asked by testing that all 11 scored item cells are non-blank on the raw strings (a replication must test missingness on the raw variable, not the recode, to keep refusers in the asked base), then bulk-COPYs into the respondents table. Only two rules drop a row entirely: unknown state FIPS, or a missing/non-positive weight.
4. Query (src/lib/queries/sql.ts). One GROUPING SETS scan computes every weighted numerator, weighted denominator, and unweighted count the dashboard needs; there are no precomputed rollup tables. The worked examples below show the exact statements.
5. Shaping, suppression, rounding (src/lib/queries/shape.ts, suppress.ts). Numerator over denominator, suppression when the unweighted count is under the threshold, deterministic half-up rounding. Suppression happens only here, after aggregation; the database never stores a suppressed value.

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.

Extraction aliases

The CDC renames a variable whenever a question changes, so one concept can carry several names across 2009-2024. Each standardized column lists its CDC names newest first, and in each file it reads the extractor takes the first name present. A year’s version and landline files use that year’s names too, apart from the weight: the weight row lists the main files’ weights, and every other file is weighted by its own final weight instead (the Weight column of the pipeline’s source table). Where a rename also changed the response coding, the recode branches on year (see the outcome rules below) rather than pretending the codes are compatible. Years listed as “not asked” are documented absences; the extractor refuses to write a CSV if a column fails to resolve in any file of any other year, so a future CDC rename breaks the pipeline loudly instead of leaving a silently hollow column.

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.

The 11 scored items collapse into the 8 categories CDC scores in its published BRFSS analyses (Merrick et al., JAMA Pediatrics 2018; Swedo et al., MMWR 2023), under three rules:

1. Item validity. A binary item is valid iff its code is 1 or 2, and endorsed iff 1. A frequency item is valid iff 1-3, and endorsed iff 2 or more (“Once” counts). A reverse protective item (the two 2021+ neglect items) is valid iff 1-5 and endorsed, meaning neglect present, iff 1 or 2 (Never or A little of the time), per CDC’s published cut.
2. Category flag. Null unless every item in the category is valid; true iff any item is endorsed. So one refused item nulls its whole category even when another item in it is a clear yes.
3. Score. Strict complete case: null unless all 11 items are valid; otherwise the count of endorsed categories, 0-8. No imputation, no partial scores.

Category composition: Sexual Abuse = ace_touch + ace_touched + ace_sex; Physical Abuse = ace_hurt; Witnessed Intimate Partner Violence = ace_punch; Household Substance Abuse = ace_alcoholic + ace_drugs; Emotional/Verbal Abuse = ace_swear; Household Mental Illness = ace_depressed; Household Member Incarcerated = ace_prison; Parental Separation/Divorce = ace_divorce.

The expanded 10-item score

The two 2021+ neglect items add two categories on top of the eight: Emotional Neglect = ace_safe; Physical Neglect = ace_needs. The expanded score is complete-case over all 13 items (0-10, mean only, no bands) and is scored separately, so the ACE-8 score never moves. Its basis is strictly smaller: the neglect items were fielded 2021-2024 by 29 of the 49 ACE jurisdictions, so expanded-score and neglect-indicator numbers are not comparable to the pooled metrics (see the limitations register). One computed contrast, live from the production scorers: a respondent answering No to all 11 pooled items who was never made to feel safe scores ACE-8 = 0 but ACE-10 = 1.

Worked scoring examples

Only the input vectors are authored; every flag and score below is computed by the production scoring functions as this page renders.

• 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.

Let w be the survey weight: each respondent’s final weight from the file their state-year was read from (see the pipeline), unmodified except that a state-year read from two questionnaire-version files has each version’s weight multiplied by that version’s share of the state-year’s respondents (P_k = n_k / Σn), pooled over every year and state in scope with no renormalization. Every statistic is a ratio of two weighted sums from one scan, published as round(numerator / denominator, digits) unless suppressed. The table names the exact SQL aggregate aliases; the worked examples below show the statement that computes them and the live values.

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%.

The full chain for one value, in order:

1. The scan returns a float8 numerator, float8 denominator, and unweighted count n.
2. If n < 30 or the weighted denominator is not positive, the value is nulled. The count n is kept, so the UI can distinguish suppressed (n > 0, rendered “--”, interpret with caution) from no data (n = 0, rendered “N/A”). The gate reads the unweighted count; there is no relative-standard-error rule.
3. Otherwise deterministic half-up rounding: proportions to 4 decimals, the average score to 3 (a scaled Math.round, avoiding toFixed float drift).
4. Display: proportions x 100 to one decimal (“63.4%” from 0.63385 via 0.6339), the average to one decimal.

For replication: match the rounded API value, not the display string; your unrounded estimate should agree with our unrounded quotient to well under 5e-5 before rounding. The boundary behavior below is computed by calling the production makeCell() as this page renders:

Age-adjusted values (Compare view)

An age-adjusted value passes the same gate and one more. It is an average of six age-group ratios on fixed weights, so a cell with plenty of respondents overall can still rest on a handful in one age group that the standard counts heavily. Two extra conditions apply, and failing either renders “--” with the cell’s real n:

• every age group in scope has at least one respondent with a valid answer, and
• the estimate’s effective sample size (the size of a simple sample that would be as precise, defined in the age-adjustment formulas) is at least 30.

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:

Both maps are cartograms: one equal-size tile per jurisdiction, laid out in an approximate geography, so tile area carries no meaning and no state is visually larger than another. The color is the encoding. This section states the rule for each map, because a color is a published statistic like any other, and on the Compare map it is the only thing a classed tile shows.

Explore: a 3-class ramp in this scope, recomputed per view

Every state’s value for the selected metric is classed together. The domain is the observed [minimum, maximum] across the states currently on the map, cut by scaleQuantize into as many equal-width classes as the ramp has stops (3). Each cut is then snapped to what the tiles print: it moves to the half-step just above the last value a tile can print at or below it, and every state is classed by its printed value, so two tiles that read the same always share a color. If every state prints the same value there is nothing to cut, and a single stop carries the whole map, which is why the count above is 3 for the scope you are looking at. The table below is not a description of that arithmetic; it is the scale’s own cut points, read back out of the object the tiles are filled from. Three consequences a reader must not miss:

• The breaks are relative, not absolute. They are recomputed whenever the metric, population, or demographic filter changes, so the same fill means different values in two different views, and colors are never comparable across screenshots.
• The cut is by value, not by rank: classes hold equal value ranges rather than equal numbers of states, so a skewed distribution can leave a class nearly empty. Compare the widths in the table to see it.
• The legend ticks the lowest and highest values the tiles print and, at each color change, the first value of the class above; the “Tiles reading” column below spells out each class’s range. Read the tile values, not the fills, to compare states. The respondents display, below, labels its cuts in a note instead. A tile rounds to one decimal; its hover probe and the selected-state card give one more (the national value reads 17.6 on a tile and 17.62% in a probe). Snapping keeps equal tiles together, but two states a hair apart still fall on either side of a boundary when their tiles print different values.

Live for the current scope (metric Percent of adults with 4+ ACEs), classed over 49 jurisdictions:

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 = Percent of adults with 4+ ACEs 18.97%, y = Depression 38.87%:

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.

Everything below runs the production statements against the live database as this page renders, shows the raw intermediate aggregates, and re-derives the published value step by step. The intermediates obey the same publication rule as the values: weighted sums appear only for cells of at least 30 respondents, and a suppressed or empty cell shows its unweighted n and the decision but withholds the sums, because for a tiny cell the weighted numerator and denominator would be a single respondent’s own survey weight. Per-respondent weights never appear (this page’s one deliberate extension of the API’s “ratios and counts only” rule stops exactly there).

Current scope: adults with an ACE score of 4 or more, metric Percent of adults with 4+ ACEs. 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 AND ace_score >= 4)::int AS ace_emotional_abuse_n,
    SUM(weight) FILTER (WHERE ace_emotional_abuse IS NOT NULL AND ace_score >= 4)::float8 AS ace_emotional_abuse_w,
    SUM(weight) FILTER (WHERE ace_emotional_abuse AND ace_score >= 4)::float8 AS ace_emotional_abuse_s,
    COUNT(*) FILTER (WHERE ace_physical_abuse IS NOT NULL AND ace_score >= 4)::int AS ace_physical_abuse_n,
    SUM(weight) FILTER (WHERE ace_physical_abuse IS NOT NULL AND ace_score >= 4)::float8 AS ace_physical_abuse_w,
    SUM(weight) FILTER (WHERE ace_physical_abuse AND ace_score >= 4)::float8 AS ace_physical_abuse_s,
    COUNT(*) FILTER (WHERE ace_sexual_abuse IS NOT NULL AND ace_score >= 4)::int AS ace_sexual_abuse_n,
    SUM(weight) FILTER (WHERE ace_sexual_abuse IS NOT NULL AND ace_score >= 4)::float8 AS ace_sexual_abuse_w,
    SUM(weight) FILTER (WHERE ace_sexual_abuse AND ace_score >= 4)::float8 AS ace_sexual_abuse_s,
    COUNT(*) FILTER (WHERE ace_emotional_neglect IS NOT NULL AND ace_score >= 4)::int AS ace_emotional_neglect_n,
    SUM(weight) FILTER (WHERE ace_emotional_neglect IS NOT NULL AND ace_score >= 4)::float8 AS ace_emotional_neglect_w,
    SUM(weight) FILTER (WHERE ace_emotional_neglect AND ace_score >= 4)::float8 AS ace_emotional_neglect_s,
    COUNT(*) FILTER (WHERE ace_physical_neglect IS NOT NULL AND ace_score >= 4)::int AS ace_physical_neglect_n,
    SUM(weight) FILTER (WHERE ace_physical_neglect IS NOT NULL AND ace_score >= 4)::float8 AS ace_physical_neglect_w,
    SUM(weight) FILTER (WHERE ace_physical_neglect AND ace_score >= 4)::float8 AS ace_physical_neglect_s,
    COUNT(*) FILTER (WHERE ace_witnessed_violence IS NOT NULL AND ace_score >= 4)::int AS ace_witnessed_violence_n,
    SUM(weight) FILTER (WHERE ace_witnessed_violence IS NOT NULL AND ace_score >= 4)::float8 AS ace_witnessed_violence_w,
    SUM(weight) FILTER (WHERE ace_witnessed_violence AND ace_score >= 4)::float8 AS ace_witnessed_violence_s,
    COUNT(*) FILTER (WHERE ace_household_depression IS NOT NULL AND ace_score >= 4)::int AS ace_household_depression_n,
    SUM(weight) FILTER (WHERE ace_household_depression IS NOT NULL AND ace_score >= 4)::float8 AS ace_household_depression_w,
    SUM(weight) FILTER (WHERE ace_household_depression AND ace_score >= 4)::float8 AS ace_household_depression_s,
    COUNT(*) FILTER (WHERE ace_incarceration IS NOT NULL AND ace_score >= 4)::int AS ace_incarceration_n,
    SUM(weight) FILTER (WHERE ace_incarceration IS NOT NULL AND ace_score >= 4)::float8 AS ace_incarceration_w,
    SUM(weight) FILTER (WHERE ace_incarceration AND ace_score >= 4)::float8 AS ace_incarceration_s,
    COUNT(*) FILTER (WHERE ace_substance_abuse IS NOT NULL AND ace_score >= 4)::int AS ace_substance_abuse_n,
    SUM(weight) FILTER (WHERE ace_substance_abuse IS NOT NULL AND ace_score >= 4)::float8 AS ace_substance_abuse_w,
    SUM(weight) FILTER (WHERE ace_substance_abuse AND ace_score >= 4)::float8 AS ace_substance_abuse_s,
    COUNT(*) FILTER (WHERE ace_divorce IS NOT NULL AND ace_score >= 4)::int AS ace_divorce_n,
    SUM(weight) FILTER (WHERE ace_divorce IS NOT NULL AND ace_score >= 4)::float8 AS ace_divorce_w,
    SUM(weight) FILTER (WHERE ace_divorce AND ace_score >= 4)::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: Percent of adults with 4+ ACEs

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 Percent of adults with 4+ ACEs (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) FILTER (WHERE ace_score >= 4)::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 AND ace_score >= 4)::float8 AS y_num,
    SUM(weight) FILTER (WHERE depression IS NOT NULL AND ace_score >= 4)::float8 AS y_den,
    COUNT(*) FILTER (WHERE depression IS NOT NULL AND ace_score >= 4)::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: Percent of adults with 4+ ACEs

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 population decides every band in this scope (adults with an ACE score of 4 or more), so the card blanks all four rows and there is no ledger to show. See the co-occurrence formulas above.

1. Get the files from the source table above: the main file of every ACE module year (2009-2012 and 2019-2024; 2010 and earlier use the CDBRFS naming), plus each questionnaire-version or landline file the table lists as supplying a state, 32 files in all.
2. Take each state-year from one file. A state-year comes from its year’s main file unless the source table lists it under a version or landline file; then take that state’s rows from those files only, and none from any other. Version files repeat the states that asked the module on every version, and the 2012 main file repeats Oklahoma’s version-2 answers under the main weight, so reading every file would count respondents twice. For the state-years asked on two versions (CA 2011 and NE 2011), multiply each version’s weight by that version’s share of the state-year’s respondents with any ACE answer, P_k = n_k / (n_1 + n_2), CDC’s rule for combining versions.
3. Read the variables per the alias table: in each file, the first listed candidate present. Weight: that file’s own final weight, in the source table’s Weight column (_LLCPWT or _FINALWT for a main file; a version or landline file carries only its own).
4. Row filter (asked population): keep respondents with any of the 13 ACE variables non-missing. In SAS/R, an XPT blank arrives as missing; codes 7 and 9 are not missing and keep the row. The module-asked flag additionally requires all 11 scored items non-missing (ACEDEPRS, ACEDRINK, ACEDRUGS, ACEPRISN, ACEDIVRC, ACEPUNCH, ACEHURT1, ACESWEAR, ACETOUCH, ACETTHEM, ACEHVSEX).
5. Apply our row drops: state FIPS outside our 54 seeded jurisdictions, or missing/non-positive weight (the provenance banner reports how many rows the seed skipped, for exact reconciliation).
6. Recode per the scoring and outcome tables above, exactly: complete-case ACE-8, divorce code 8 invalid, frequency endorsed at 2+.
7. Estimate: weighted ratios pooling all years, no renormalization. Your unrounded estimate should match our unrounded quotient (worked examples and the aggregates CSV) to well under 5e-5, then round as documented.

Do not expect standard errors to match anything: we publish none. The design variables (_STSTR, _PSU) are not extracted, so nothing on the dashboard carries design-based variance; the n < 30 suppression rule is the only reliability guard. Weighted point estimates are the comparison target.

Fast path: work from our extract

Skip the 32 downloads by using the committed prisma/data/brfss-ace.csv.gz (verify its SHA-256 against the provenance banner). Its header, rendered from the transform that reads it:

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;

A sanity check, not a validation: given the enumerated design differences (year windows, state sets), agreement within a few points is the expected outcome, and exact agreement would itself be suspicious. Every “ours” value is computed live from the current seed (national, all respondents, no filters); published values were verified against the corrected primary sources on the retrieval date shown. Neither source age-adjusts: both report crude weighted estimates (re-read for this on 2026-11-09), as we do here, so no row compares an adjusted figure with a crude one.

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.

1. No variance estimation of any kind

No standard errors, confidence intervals, or design effects appear anywhere; the design variables (_STSTR, _PSU) are never extracted. Every number is a weighted point estimate presented as exact, and the n < 30 suppression rule is the only reliability guard. Do not run significance tests against these values; return to the raw files for design-based variance.

2. Years are pooled with raw weights

Each state contributes every year it fielded the module (1 to 7 years across the 49 participating jurisdictions; the full state-year grid, with the file each state-year was read from, is in coverage.csv). Each file’s weight is calibrated to the whole state’s adults, whichever file a state-year comes from; the respondents who reached the module carry most of that total but not all (interviews that ended before it are excluded), and the state-years are pooled without renormalization, so state comparisons partially reflect when each state ran the module, and weighted totals are not population counts.

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

Every data payload (and this page) is keyed by an opaque version, currently 9: the id of the latest seed run. A reseed (new data, or a transform change that bumps TRANSFORM_VERSION) mints a new id, so a given versioned URL is immutable and two people looking at the same version are looking at identical numbers. The provenance banner’s SHA-256 and transform version pin what this version was built from.

The authoritative change record for the methodology is the git history of the extraction, transform and scoring modules (scripts/process-brfss.ts, src/lib/brfss/variable-mappings.ts, src/lib/brfss/split-sample.ts, src/lib/brfss/transform.ts, src/lib/brfss/scoring.ts, src/lib/queries/sql.ts). Every registry and formula rendered on this page is imported from that same code, so a rename or a changed rule reaches this page by construction rather than by anyone remembering to edit it.

What is checked, and where

Being precise about this matters more here than anywhere else on the page, because it is what a reader is entitled to assume when they take a number on trust:

• Checked as this page renders. Every worked-example ledger recomputes its value from the raw scan row and compares it to the production API value for the same scope; a mismatch replaces the ledger with a failure notice rather than a number. The class breaks, the co-occurrence gap, the suppression boundary table, and every registry table are calls into the production functions themselves, so they cannot disagree with the dashboard.
• Checked in continuous integration. The unit and component suite (npm test), which covers the pure modules behind those functions: scoring, recodes, suppression, formatting, classing, the URL codec, the CSV builders.
• Checked only against a seeded database, and therefore not in CI. The claims that need real data (the worked-example equalities, the coverage footnotes’ empirically-zero cells, the cross-check tolerance bands, and those of the limitations register’s typed figures the database can re-derive) live in *.dbtest.ts and run via npm run test:db. CI has no database and does not run them. They are a release gate, not a per-commit one, so a data-dependent claim on this page can in principle go stale between reseeds; the render-time self-checks above are what stand behind the numbers in the meantime.
• Not re-checked: dated measurements. A few register figures (the item-level physical-abuse panel, the codes 1-3 neglect cut, the _MICHD agreement count) need raw CDC item codes the database does not keep. Each names the extract it was measured on, and the test suite pins a live neighbour where one exists, so a reseed that moves it flags the dated figure for re-measurement.