From 388c462a699d16ffcdb7c71ebfd5c508ad7642a9 Mon Sep 17 00:00:00 2001 From: Ziming Date: Thu, 9 Jul 2026 12:39:07 -0400 Subject: [PATCH 1/4] Include incapacitated adult care expenses in state TANF dependent care deductions Adds the person-level care_expenses input (care for a disabled or incapacitated adult) to 21 state TANF-family cash assistance programs whose regulations cover adult care but which previously only counted childcare_expenses: AK ATAP, AL FA, AZ CA, DC TANF, DE TANF, GA TANF, HI TANF, IL TANF, KY K-TAP, MA TAFDC, MA EAEDC, MD TCA, ME TANF, MN MFIP, MO TA, MT TANF, NH FANF, OK TANF, RI Works, TX TANF, VA TANF, VT Reach Up, and WV Works. Where the regulation covers incapacitated adults in the per-person cap, they are added to the cap population. Every program was verified against its statute/policy manual before editing. NM Works, IL AABD, and TN Families First are verified child-only (or unclear) and left unchanged. Also fixes dead or wrong reference URLs for DE (DSSM 4004.2), MD (COMAR portal), VA, and WV. Part of #8811. Co-Authored-By: Claude Fable 5 --- .../tanf-adult-care-expenses.changed.md | 1 + .../dpa/atap/ak_atap_childcare_deduction.yaml | 24 +++++++++++++++++ .../tanf/al_tanf_countable_earned_income.yaml | 27 +++++++++++++++++++ .../az_tanf_dependent_care_deduction.yaml | 24 +++++++++++++++++ .../income/dc_tanf_childcare_deduction.yaml | 23 ++++++++++++++++ .../de_tanf_dependent_care_deduction.yaml | 23 ++++++++++++++++ .../income/ga_tanf_childcare_deduction.yaml | 24 +++++++++++++++++ .../hi_tanf_dependent_care_deduction.yaml | 25 +++++++++++++++++ .../il_tanf_childcare_deduction.yaml | 23 ++++++++++++++++ .../ky_ktap_dependent_care_disregard.yaml | 23 ++++++++++++++++ ...eaedc_dependent_care_deduction_person.yaml | 24 +++++++++++++++++ ...tafdc_dependent_care_deduction_person.yaml | 24 +++++++++++++++++ .../md_tca_childcare_deduction.yaml | 25 +++++++++++++++++ .../tanf/me_tanf_child_care_deduction.yaml | 23 ++++++++++++++++ .../mn_mfip_dependent_care_deduction.yaml | 23 ++++++++++++++++ .../tanf/mo_tanf_child_care_deduction.yaml | 23 ++++++++++++++++ .../mt_tanf_dependent_care_deduction.yaml | 24 +++++++++++++++++ .../fanf/nh_fanf_child_care_deduction.yaml | 25 +++++++++++++++++ .../ok_tanf_dependent_care_deduction.yaml | 23 ++++++++++++++++ .../ri_works_dependent_care_deduction.yaml | 23 ++++++++++++++++ .../tx_tanf_dependent_care_deduction.yaml | 23 ++++++++++++++++ .../income/va_tanf_childcare_deduction.yaml | 23 ++++++++++++++++ .../vt_reach_up_dependent_care_deduction.yaml | 25 +++++++++++++++++ .../wv_works_countable_earned_income.yaml | 27 +++++++++++++++++++ .../earned/ak_atap_childcare_deduction.py | 15 ++++++++--- .../income/al_tanf_countable_earned_income.py | 10 +++++-- .../az_tanf_dependent_care_deduction.py | 13 +++++---- .../deductions/dc_tanf_childcare_deduction.py | 14 +++++++--- .../de_tanf_dependent_care_deduction.py | 23 ++++++++++------ .../deductions/ga_tanf_childcare_deduction.py | 15 ++++++++--- .../hi_tanf_dependent_care_deduction.py | 21 +++++++++------ .../deductions/il_tanf_childcare_deduction.py | 14 +++++++--- .../ky_ktap_dependent_care_disregard.py | 13 ++++++--- ...a_eaedc_dependent_care_deduction_person.py | 13 +++++++-- ...a_tafdc_dependent_care_deduction_person.py | 13 +++++++-- .../tca/income/md_tca_childcare_deduction.py | 26 +++++++++++------- .../me_tanf_child_care_deduction.py | 23 ++++++++++++---- .../mn_mfip_dependent_care_deduction.py | 14 +++++++--- .../mo_tanf_child_care_deduction.py | 14 +++++++--- .../mt_tanf_dependent_care_deduction.py | 10 +++++-- .../income/nh_fanf_child_care_deduction.py | 21 ++++++++++----- .../ok_tanf_dependent_care_deduction.py | 20 +++++++++----- .../ri_works_dependent_care_deduction.py | 14 +++++++--- .../tx_tanf_dependent_care_deduction.py | 8 +++--- .../income/va_tanf_childcare_deduction.py | 7 +++-- .../vt_reach_up_dependent_care_deduction.py | 6 ++++- .../wv_works_countable_earned_income.py | 9 ++++--- 47 files changed, 794 insertions(+), 94 deletions(-) create mode 100644 changelog.d/tanf-adult-care-expenses.changed.md diff --git a/changelog.d/tanf-adult-care-expenses.changed.md b/changelog.d/tanf-adult-care-expenses.changed.md new file mode 100644 index 00000000000..35a741d6b8e --- /dev/null +++ b/changelog.d/tanf-adult-care-expenses.changed.md @@ -0,0 +1 @@ +Include incapacitated or disabled adult care expenses in the dependent care deductions of 21 state TANF-family cash assistance programs (AK, AL, AZ, DC, DE, GA, HI, IL, KY, MA TAFDC/EAEDC, MD, ME, MN, MO, MT, NH, OK, RI, TX, VA, VT, WV). diff --git a/policyengine_us/tests/policy/baseline/gov/states/ak/dpa/atap/ak_atap_childcare_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/ak/dpa/atap/ak_atap_childcare_deduction.yaml index c64711a08e1..f3d78a988d3 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/ak/dpa/atap/ak_atap_childcare_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/ak/dpa/atap/ak_atap_childcare_deduction.yaml @@ -231,3 +231,27 @@ # Monthly expenses = $0 # Disregard = min($0, $175) = $0 ak_atap_childcare_deduction: 0 + +- name: Case 11, incapacitated parent care expenses count toward the disregard. + period: 2024-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 32 + is_tax_unit_head_or_spouse: true + is_incapable_of_self_care: true + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: AK + output: + # Per 7 AAC 45.485(a)(2)(C): $175/month cap for an incapacitated parent. + # Expenses = 1,200 / 12 = 100/month, below the 175 cap. + ak_atap_childcare_deduction: 100 diff --git a/policyengine_us/tests/policy/baseline/gov/states/al/dhs/tanf/al_tanf_countable_earned_income.yaml b/policyengine_us/tests/policy/baseline/gov/states/al/dhs/tanf/al_tanf_countable_earned_income.yaml index d41b491d4ab..d6f679d922b 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/al/dhs/tanf/al_tanf_countable_earned_income.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/al/dhs/tanf/al_tanf_countable_earned_income.yaml @@ -222,3 +222,30 @@ # Childcare: $200/month # Countable earned: max($315 - $200, 0) = $115 al_tanf_countable_earned_income: 115 + +- name: Edge Case 2, incapacitated adult care costs are deducted. + period: 2024-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + employment_income_before_lsr: 12_000 # $1,000/month + person2: + age: 35 + is_incapable_of_self_care: true + care_expenses: 1_200 # $100/month + person3: + age: 5 + spm_units: + spm_unit: + members: [person1, person2, person3] + households: + household: + members: [person1, person2, person3] + state_code: AL + output: + # Gross earned = $1,000/month; work expense = 30% = $300 + # Incapacitated adult care = 1,200 / 12 = $100/month (no cap) + # Countable = 1,000 - 300 - 100 = $600 + al_tanf_countable_earned_income: 600 diff --git a/policyengine_us/tests/policy/baseline/gov/states/az/hhs/tanf/az_tanf_dependent_care_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/az/hhs/tanf/az_tanf_dependent_care_deduction.yaml index 125dc2bbc8b..85e42de20ae 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/az/hhs/tanf/az_tanf_dependent_care_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/az/hhs/tanf/az_tanf_dependent_care_deduction.yaml @@ -155,3 +155,27 @@ # Child at age 2: $175/month max (not $200) # Expenses ($250/mo) > max ($175), so deduction = $175 az_tanf_dependent_care_deduction: 175 + +- name: Case 7, adult dependent care expenses count toward the deduction. + period: 2024-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 28 + is_tax_unit_dependent: true + is_incapable_of_self_care: true + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: AZ + output: + # Per ARS 46-292: care of an adult dependent household member, + # capped at $175/month. Expenses = 1,200 / 12 = 100/month. + az_tanf_dependent_care_deduction: 100 diff --git a/policyengine_us/tests/policy/baseline/gov/states/dc/dhs/tanf/income/dc_tanf_childcare_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/dc/dhs/tanf/income/dc_tanf_childcare_deduction.yaml index 804e9243951..b0a4e4de7ab 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/dc/dhs/tanf/income/dc_tanf_childcare_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/dc/dhs/tanf/income/dc_tanf_childcare_deduction.yaml @@ -72,3 +72,26 @@ state_code: DC output: dc_tanf_childcare_deduction: [2_100, 2_100] # min(1200, 175*12) + +- name: Case 5, incapacitated adult care expenses count toward the deduction. + period: 2023-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + is_incapable_of_self_care: true + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: DC + output: + # Per DC Code 4-205.11(a)(2): incapacitated adult care capped at + # $175/month. Expenses = 1,200 / 12 = 100/month, below the cap. + dc_tanf_childcare_deduction: 100 diff --git a/policyengine_us/tests/policy/baseline/gov/states/de/dhss/tanf/income/earned/de_tanf_dependent_care_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/de/dhss/tanf/income/earned/de_tanf_dependent_care_deduction.yaml index 90d2a495927..d1aa081328a 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/de/dhss/tanf/income/earned/de_tanf_dependent_care_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/de/dhss/tanf/income/earned/de_tanf_dependent_care_deduction.yaml @@ -207,3 +207,26 @@ # 3 children age 2+: 3 * $175 = $525 # Expenses $800 > $525, capped at $525 de_tanf_dependent_care_deduction: 525 + +- name: Case 11, incapacitated adult care expenses count toward the deduction. + period: 2025-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + is_incapable_of_self_care: true + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: DE + output: + # Per DSSM 4004.2(4): incapacitated adult care capped at $175/month. + # Expenses = 1,200 / 12 = 100/month, below the cap. + de_tanf_dependent_care_deduction: 100 diff --git a/policyengine_us/tests/policy/baseline/gov/states/ga/dfcs/tanf/income/ga_tanf_childcare_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/ga/dfcs/tanf/income/ga_tanf_childcare_deduction.yaml index 0396a0d4221..951ab1d6776 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/ga/dfcs/tanf/income/ga_tanf_childcare_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/ga/dfcs/tanf/income/ga_tanf_childcare_deduction.yaml @@ -315,3 +315,27 @@ # Child is not a dependent, so no deduction # Total max: $0 # min(200, 0) = $0 + +- name: Incapacitated adult care expenses count toward the deduction + period: 2025-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + is_incapable_of_self_care: true + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: GA + output: + # Per PAMMS 1615: $175/month for each individual age two or above, + # including an incapacitated individual in the home. + # Expenses = 1,200 / 12 = 100/month, below the cap. + ga_tanf_childcare_deduction: 100 diff --git a/policyengine_us/tests/policy/baseline/gov/states/hi/dhs/tanf/income/hi_tanf_dependent_care_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/hi/dhs/tanf/income/hi_tanf_dependent_care_deduction.yaml index 5c03b208cb8..0ee6b2e4f70 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/hi/dhs/tanf/income/hi_tanf_dependent_care_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/hi/dhs/tanf/income/hi_tanf_dependent_care_deduction.yaml @@ -319,3 +319,28 @@ # 40 hrs = full-time, $175 per child # $700/month > $525 cap, capped at 3 children × $175 = $525 hi_tanf_dependent_care_deduction: 525 + +- name: Case 13, disabled adult household member care expenses. + period: 2024-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + weekly_hours_worked_before_lsr: 40 + person2: + age: 25 + is_disabled: true + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: HI + output: + # Per State Plan 10.2.1(D): care of a disabled adult household member + # up to $175/month (full-time employment, 40 hours >= 32). + # Expenses = 1,200 / 12 = 100/month, below the cap. + hi_tanf_dependent_care_deduction: 100 diff --git a/policyengine_us/tests/policy/baseline/gov/states/il/dhs/tanf/income/deductions/il_tanf_childcare_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/il/dhs/tanf/income/deductions/il_tanf_childcare_deduction.yaml index 5ba44eb817e..78843880da0 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/il/dhs/tanf/income/deductions/il_tanf_childcare_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/il/dhs/tanf/income/deductions/il_tanf_childcare_deduction.yaml @@ -37,3 +37,26 @@ childcare_expenses: 250 * 12 output: il_tanf_childcare_deduction: 0 + +- name: Case 5, incapacitated adult care expenses count toward the deduction. + period: 2023-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + is_incapable_of_self_care: true + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: IL + output: + # Per 89 Ill. Adm. Code 112.143(b)(1)(C): incapacitated adult care + # at the $175/month age-2+ tier. Expenses = 1,200 / 12 = 100/month. + il_tanf_childcare_deduction: 100 diff --git a/policyengine_us/tests/policy/baseline/gov/states/ky/dcbs/ktap/income/ky_ktap_dependent_care_disregard.yaml b/policyengine_us/tests/policy/baseline/gov/states/ky/dcbs/ktap/income/ky_ktap_dependent_care_disregard.yaml index c5de05535e2..da04e9c457e 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/ky/dcbs/ktap/income/ky_ktap_dependent_care_disregard.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/ky/dcbs/ktap/income/ky_ktap_dependent_care_disregard.yaml @@ -154,3 +154,26 @@ state_code: TX output: ky_ktap_dependent_care_disregard: 0 + +- name: Incapacitated adult care expenses count toward the disregard. + period: 2024-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + is_incapable_of_self_care: true + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: KY + output: + # Per 921 KAR 2:016 Section 5(3)(b)1.b: incapacitated adult living in + # the home, capped at $175/month. Expenses = 1,200 / 12 = 100/month. + ky_ktap_dependent_care_disregard: 100 diff --git a/policyengine_us/tests/policy/baseline/gov/states/ma/dta/tcap/eaedc/dependent_care_deduction/ma_eaedc_dependent_care_deduction_person.yaml b/policyengine_us/tests/policy/baseline/gov/states/ma/dta/tcap/eaedc/dependent_care_deduction/ma_eaedc_dependent_care_deduction_person.yaml index 444e14b42b4..187cbce0b7d 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/ma/dta/tcap/eaedc/dependent_care_deduction/ma_eaedc_dependent_care_deduction_person.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/ma/dta/tcap/eaedc/dependent_care_deduction/ma_eaedc_dependent_care_deduction_person.yaml @@ -85,3 +85,27 @@ state_code: MA output: ma_eaedc_dependent_care_deduction_person: [0, 2_100] + +- name: Incapacitated adult care expenses count toward the deduction. + period: 2023-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + weekly_hours_worked_before_lsr: 40 + person2: + age: 25 + is_incapable_of_self_care: true + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: MA + output: + # Per 106 CMR 704.275(A): incapacitated individual at the older tier, + # $175/month at 40 weekly hours. Expenses = 1,200 / 12 = 100/month. + ma_eaedc_dependent_care_deduction_person: [0, 100] diff --git a/policyengine_us/tests/policy/baseline/gov/states/ma/dta/tcap/tafdc/income/deductions/ma_tafdc_dependent_care_deduction_person.yaml b/policyengine_us/tests/policy/baseline/gov/states/ma/dta/tcap/tafdc/income/deductions/ma_tafdc_dependent_care_deduction_person.yaml index e37937292f5..5bf8f4de4c7 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/ma/dta/tcap/tafdc/income/deductions/ma_tafdc_dependent_care_deduction_person.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/ma/dta/tcap/tafdc/income/deductions/ma_tafdc_dependent_care_deduction_person.yaml @@ -58,3 +58,27 @@ state_code: MA output: ma_tafdc_dependent_care_deduction_person: [0, 2_100] + +- name: Incapacitated adult care expenses count toward the deduction. + period: 2023-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + weekly_hours_worked_before_lsr: 40 + person2: + age: 25 + is_incapable_of_self_care: true + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: MA + output: + # Per 106 CMR 704.275(A): incapacitated individual at the older tier, + # $175/month at 40 weekly hours. Expenses = 1,200 / 12 = 100/month. + ma_tafdc_dependent_care_deduction_person: [0, 100] diff --git a/policyengine_us/tests/policy/baseline/gov/states/md/tca/income/deductions/md_tca_childcare_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/md/tca/income/deductions/md_tca_childcare_deduction.yaml index 1e023ba1a40..4c8a9be0f24 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/md/tca/income/deductions/md_tca_childcare_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/md/tca/income/deductions/md_tca_childcare_deduction.yaml @@ -240,3 +240,28 @@ # 1 child * $100 = $100 cap # Expenses = $300/month, min($300, $100) = $100 md_tca_childcare_deduction: 100 + +- name: Case 12, incapacitated adult care expenses count toward the deduction. + period: 2024-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + monthly_hours_worked: 120 + person2: + age: 35 + is_incapable_of_self_care: true + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: MD + output: + # Per COMAR 07.03.03.13.E(3)(c): care of an incapacitated adult living + # in the home, capped at $200/month (100+ work hours). + # Expenses = 1,200 / 12 = 100/month, below the cap. + md_tca_childcare_deduction: 100 diff --git a/policyengine_us/tests/policy/baseline/gov/states/me/dhhs/tanf/me_tanf_child_care_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/me/dhhs/tanf/me_tanf_child_care_deduction.yaml index fdd18614a45..2830111d99f 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/me/dhhs/tanf/me_tanf_child_care_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/me/dhhs/tanf/me_tanf_child_care_deduction.yaml @@ -117,3 +117,26 @@ state_code: ME output: me_tanf_child_care_deduction: 0 + +- name: Case 6, incapacitated adult care expenses count toward the deduction. + period: 2025-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + is_incapable_of_self_care: true + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: ME + output: + # Per 10-144 CMR ch. 331, Ch. IV, Section B(2)(b): incapacitated adult + # at the $175/month tier. Expenses = 1,200 / 12 = 100/month. + me_tanf_child_care_deduction: 100 diff --git a/policyengine_us/tests/policy/baseline/gov/states/mn/dcyf/mfip/mn_mfip_dependent_care_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/mn/dcyf/mfip/mn_mfip_dependent_care_deduction.yaml index 3e2dc762073..e312dd50198 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/mn/dcyf/mfip/mn_mfip_dependent_care_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/mn/dcyf/mfip/mn_mfip_dependent_care_deduction.yaml @@ -76,3 +76,26 @@ # Expenses: $500/month # Deduction: min(500, 375) = 375 mn_mfip_dependent_care_deduction: 375 + +- name: Case 4, disabled adult care expenses count toward the deduction. + period: 2025-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + is_disabled: true + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: MN + output: + # Per Combined Manual 0018.09: care of a disabled adult in the unit, + # at the $175/month age-2+ tier. Expenses = 1,200 / 12 = 100/month. + mn_mfip_dependent_care_deduction: 100 diff --git a/policyengine_us/tests/policy/baseline/gov/states/mo/dss/tanf/mo_tanf_child_care_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/mo/dss/tanf/mo_tanf_child_care_deduction.yaml index 9b80cbe54b4..db72305ac21 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/mo/dss/tanf/mo_tanf_child_care_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/mo/dss/tanf/mo_tanf_child_care_deduction.yaml @@ -185,3 +185,26 @@ state_code: MO output: mo_tanf_child_care_deduction: 0 + +- name: Incapacitated adult care expenses count toward the deduction + period: 2024-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + is_incapable_of_self_care: true + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: MO + output: + # Per 13 CSR 40-2.120(6)(A)5: incapacitated individual care at the + # $175/month age-2+ tier. Expenses = 1,200 / 12 = 100/month. + mo_tanf_child_care_deduction: 100 diff --git a/policyengine_us/tests/policy/baseline/gov/states/mt/dhs/tanf/income/mt_tanf_dependent_care_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/mt/dhs/tanf/income/mt_tanf_dependent_care_deduction.yaml index 2f9dd5cc3a1..aedaa32bcfe 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/mt/dhs/tanf/income/mt_tanf_dependent_care_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/mt/dhs/tanf/income/mt_tanf_dependent_care_deduction.yaml @@ -144,3 +144,27 @@ # spm_unit2: person3 and person5 → 2 * 200 = 400/month # min(5_000/12, 400) = min(416.67, 400) = 400 mt_tanf_dependent_care_deduction: [400, 400] + +- name: Case 11, incapacitated adult dependent care expenses. + period: 2023-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + is_tax_unit_dependent: true + is_incapable_of_self_care: true + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: MT + output: + # Per TANF manual 602-1: $200/month cap per incapacitated adult. + # Expenses = 1,200 / 12 = 100/month, below the cap. + mt_tanf_dependent_care_deduction: 100 diff --git a/policyengine_us/tests/policy/baseline/gov/states/nh/dhhs/fanf/nh_fanf_child_care_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/nh/dhhs/fanf/nh_fanf_child_care_deduction.yaml index 5774df75b1e..206271cb0d4 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/nh/dhhs/fanf/nh_fanf_child_care_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/nh/dhhs/fanf/nh_fanf_child_care_deduction.yaml @@ -256,3 +256,28 @@ output: # Zero earnings = part-time rate ($100 for under 6) nh_fanf_child_care_deduction: 100 + +- name: Case 13, incapacitated parent care expenses count toward the deduction. + period: 2024-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + employment_income_before_lsr: 6_000 # $500/month, above $377 threshold + person2: + age: 32 + is_tax_unit_head_or_spouse: true + is_incapable_of_self_care: true + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: NH + output: + # Per FAM 603.05: $175/month for each incapacitated parent (full-time + # employment). Expenses = 1,200 / 12 = 100/month, below the cap. + nh_fanf_child_care_deduction: 100 diff --git a/policyengine_us/tests/policy/baseline/gov/states/ok/dhs/tanf/ok_tanf_dependent_care_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/ok/dhs/tanf/ok_tanf_dependent_care_deduction.yaml index 39228cf7943..c03a5668fc1 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/ok/dhs/tanf/ok_tanf_dependent_care_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/ok/dhs/tanf/ok_tanf_dependent_care_deduction.yaml @@ -107,3 +107,26 @@ # Total max: $375 # Expenses ($500/mo) > max ($375), so deduction = $375 ok_tanf_dependent_care_deduction: 375 + +- name: Incapacitated adult care expenses count toward the deduction + period: 2024-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + is_incapable_of_self_care: true + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: OK + output: + # Per OAC 340:10-3-33(b)(3)(B): $175/month for an incapacitated adult. + # Expenses = 1,200 / 12 = 100/month, below the cap. + ok_tanf_dependent_care_deduction: 100 diff --git a/policyengine_us/tests/policy/baseline/gov/states/ri/dhs/works/ri_works_dependent_care_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/ri/dhs/works/ri_works_dependent_care_deduction.yaml index bc477b41dba..508fbaae2b9 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/ri/dhs/works/ri_works_dependent_care_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/ri/dhs/works/ri_works_dependent_care_deduction.yaml @@ -212,3 +212,26 @@ # Total max: $200 + $175 + $175 = $550 # Expenses ($400) < max ($550), so deduction = $400 ri_works_dependent_care_deduction: 400 + +- name: Case 10, incapacitated adult care expenses count toward the deduction. + period: 2024-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + is_incapable_of_self_care: true + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: RI + output: + # Per 218-RICR-20-00-2.15.5(B)(2)(b): $175/month per incapacitated + # adult. Expenses = 1,200 / 12 = 100/month, below the cap. + ri_works_dependent_care_deduction: 100 diff --git a/policyengine_us/tests/policy/baseline/gov/states/tx/tanf/income/deductions/tx_tanf_dependent_care_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/tx/tanf/income/deductions/tx_tanf_dependent_care_deduction.yaml index 17c0a6cbc0f..9a05681d66d 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/tx/tanf/income/deductions/tx_tanf_dependent_care_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/tx/tanf/income/deductions/tx_tanf_dependent_care_deduction.yaml @@ -52,3 +52,26 @@ state_code: TX output: tx_tanf_dependent_care_deduction: 0 + +- name: Case 4, incapacitated adult care expenses count toward the deduction. + period: 2025-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + is_incapable_of_self_care: true + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: TX + output: + # Per 1 TAC 372.409(a)(3): $175/month for an incapacitated adult. + # Expenses = 1,200 / 12 = 100/month, below the cap. + tx_tanf_dependent_care_deduction: 100 diff --git a/policyengine_us/tests/policy/baseline/gov/states/va/dss/tanf/income/va_tanf_childcare_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/va/dss/tanf/income/va_tanf_childcare_deduction.yaml index 0102cc67fe3..9cd9c322fe6 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/va/dss/tanf/income/va_tanf_childcare_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/va/dss/tanf/income/va_tanf_childcare_deduction.yaml @@ -184,3 +184,26 @@ # Actual expenses: $5,000/year # Deduction: min($5,000, $4,500) = $4,500 va_tanf_childcare_deduction: 4_500 + +- name: Case 8, disabled adult care expenses count toward the deduction. + period: 2023-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + is_disabled: true + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: VA + output: + # Per VA TANF Manual 305.3 item 5: incapacitated adult care up to + # $175/month (full-time). Expenses = 1,200 / 12 = 100/month. + va_tanf_childcare_deduction: 100 diff --git a/policyengine_us/tests/policy/baseline/gov/states/vt/dcf/reach_up/vt_reach_up_dependent_care_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/vt/dcf/reach_up/vt_reach_up_dependent_care_deduction.yaml index 45532fdd3dc..dfec8306909 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/vt/dcf/reach_up/vt_reach_up_dependent_care_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/vt/dcf/reach_up/vt_reach_up_dependent_care_deduction.yaml @@ -111,3 +111,28 @@ # 2 participants = $350 max # min($500, $350) = $350 (capped) vt_reach_up_dependent_care_deduction: 350 + +- name: Case 6, disabled adult care expenses count toward the deduction. + period: 2024-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + is_disabled: true + is_incapable_of_self_care: true + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: VT + output: + # Per Reach Up rule 2252.2(a): care of a disabled or seriously ill + # adult household member, capped at $175/month per participant. + # Expenses = 1,200 / 12 = 100/month, below the cap. + vt_reach_up_dependent_care_deduction: 100 diff --git a/policyengine_us/tests/policy/baseline/gov/states/wv/dhhr/works/income/earned/wv_works_countable_earned_income.yaml b/policyengine_us/tests/policy/baseline/gov/states/wv/dhhr/works/income/earned/wv_works_countable_earned_income.yaml index fe11c845801..4983ab13527 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/wv/dhhr/works/income/earned/wv_works_countable_earned_income.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/wv/dhhr/works/income/earned/wv_works_countable_earned_income.yaml @@ -77,3 +77,30 @@ # Raw = 0 - 200 = -$200 # Countable = max(-200, 0) = $0 wv_works_countable_earned_income: 0 + +- name: Case 6, incapacitated adult care costs are deducted. + absolute_error_margin: 0.1 + period: 2025-01 + input: + people: + person1: + age: 30 + tanf_gross_earned_income: 1_000 + person2: + age: 35 + is_incapable_of_self_care: true + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: WV + output: + # Step 1: Gross earned = $1,000/month + # Step 2: After 40% disregard = 1,000 * 0.60 = $600 + # Step 3: Incapacitated adult care = 1,200 / 12 = $100/month (no cap + # per Section 4.5.2.A.2) + # Countable = 600 - 100 = $500 + wv_works_countable_earned_income: 500 diff --git a/policyengine_us/variables/gov/states/ak/dpa/atap/income/earned/ak_atap_childcare_deduction.py b/policyengine_us/variables/gov/states/ak/dpa/atap/income/earned/ak_atap_childcare_deduction.py index 75166467298..1651a091aba 100644 --- a/policyengine_us/variables/gov/states/ak/dpa/atap/income/earned/ak_atap_childcare_deduction.py +++ b/policyengine_us/variables/gov/states/ak/dpa/atap/income/earned/ak_atap_childcare_deduction.py @@ -11,14 +11,21 @@ class ak_atap_childcare_deduction(Variable): defined_for = StateCode.AK def formula(spm_unit, period, parameters): - # Per 7 AAC 45.485: Child care expenses excluded up to: + # Per 7 AAC 45.485(a)(2): care costs excluded up to: # - $200/month per child under age 2 # - $175/month per child age 2 and older + # - $175/month for an incapacitated parent whose needs are + # included in the ATAP determination (subsection (a)(2)(C)) p = parameters(period).gov.states.ak.dpa.atap.income.deductions person = spm_unit.members dependent = person("is_tax_unit_dependent", period) + incapacitated_parent = person("is_tax_unit_head_or_spouse", period) & person( + "is_incapable_of_self_care", period.this_year + ) age = person("age", period.this_year) childcare_expenses = spm_unit("childcare_expenses", period) - max_per_dependent = p.childcare.calc(age) * dependent - total_max_disregard = spm_unit.sum(max_per_dependent) - return min_(childcare_expenses, total_max_disregard) + adult_care_expenses = add(spm_unit, period, ["care_expenses"]) + care_recipient = dependent | incapacitated_parent + max_per_person = p.childcare.calc(age) * care_recipient + total_max_disregard = spm_unit.sum(max_per_person) + return min_(childcare_expenses + adult_care_expenses, total_max_disregard) diff --git a/policyengine_us/variables/gov/states/al/dhs/tanf/income/al_tanf_countable_earned_income.py b/policyengine_us/variables/gov/states/al/dhs/tanf/income/al_tanf_countable_earned_income.py index 6864b4be4a4..c12f24fa070 100644 --- a/policyengine_us/variables/gov/states/al/dhs/tanf/income/al_tanf_countable_earned_income.py +++ b/policyengine_us/variables/gov/states/al/dhs/tanf/income/al_tanf_countable_earned_income.py @@ -25,6 +25,12 @@ def formula(spm_unit, period, parameters): p = parameters(period).gov.states.al.dhs.tanf.income gross_earned = add(spm_unit, period, ["tanf_gross_earned_income"]) work_expense = gross_earned * p.work_expense_rate - # Child care is deducted from earned income per r. 660-2-2-.30(2)(c). + # Per r. 660-2-2-.30(2)(c), the cost (on an as-paid basis) of child + # care or care for an incapacitated adult living in the same home + # and receiving FA is deducted from earned income, with no cap. childcare_expenses = spm_unit("childcare_expenses", period) - return max_(gross_earned - work_expense - childcare_expenses, 0) + adult_care_expenses = add(spm_unit, period, ["care_expenses"]) + return max_( + gross_earned - work_expense - childcare_expenses - adult_care_expenses, + 0, + ) diff --git a/policyengine_us/variables/gov/states/az/hhs/tanf/income/az_tanf_dependent_care_deduction.py b/policyengine_us/variables/gov/states/az/hhs/tanf/income/az_tanf_dependent_care_deduction.py index 8162fe612dd..b95428259f5 100644 --- a/policyengine_us/variables/gov/states/az/hhs/tanf/income/az_tanf_dependent_care_deduction.py +++ b/policyengine_us/variables/gov/states/az/hhs/tanf/income/az_tanf_dependent_care_deduction.py @@ -16,14 +16,17 @@ def formula(spm_unit, period, parameters): person = spm_unit.members age = person("age", period.this_year) + # Per ARS 46-292, the disregard covers the actual amount billed for + # the care of an adult or child dependent household member. childcare_expenses = spm_unit("childcare_expenses", period) + adult_care_expenses = add(spm_unit, period, ["care_expenses"]) - # Calculate eligible deduction for dependent children (based on age) + # Calculate eligible deduction for dependents (based on age) is_dependent = person("is_tax_unit_dependent", period.this_year) - child_amount = p.amounts.calc(age) * is_dependent + dependent_amount = p.amounts.calc(age) * is_dependent # Total eligible deduction - total_eligible = spm_unit.sum(child_amount) + total_eligible = spm_unit.sum(dependent_amount) - # Deduction is capped at actual childcare expenses - return min_(childcare_expenses, total_eligible) + # Deduction is capped at actual care expenses + return min_(childcare_expenses + adult_care_expenses, total_eligible) diff --git a/policyengine_us/variables/gov/states/dc/dhs/tanf/income/deductions/dc_tanf_childcare_deduction.py b/policyengine_us/variables/gov/states/dc/dhs/tanf/income/deductions/dc_tanf_childcare_deduction.py index d1bca13cc95..1eb03440e5b 100644 --- a/policyengine_us/variables/gov/states/dc/dhs/tanf/income/deductions/dc_tanf_childcare_deduction.py +++ b/policyengine_us/variables/gov/states/dc/dhs/tanf/income/deductions/dc_tanf_childcare_deduction.py @@ -16,9 +16,17 @@ def formula(spm_unit, period, parameters): p = parameters(period).gov.states.dc.dhs.tanf.income.deductions.child_care person = spm_unit.members dependent = person("is_tax_unit_dependent", period) + # Per DC Code 4-205.11(a)(2), the deduction covers care of each + # dependent child or an incapacitated adult living in the same + # home and receiving TANF or POWER. + incapacitated_adult = person("is_adult", period.this_year) & person( + "is_incapable_of_self_care", period.this_year + ) age = person("monthly_age", period) childcare_expenses = spm_unit("childcare_expenses", period) - childcare_deduction_person = p.amount.calc(age) * dependent - total_childcare_deduction = spm_unit.sum(childcare_deduction_person) + adult_care_expenses = add(spm_unit, period, ["care_expenses"]) + care_recipient = dependent | incapacitated_adult + care_deduction_person = p.amount.calc(age) * care_recipient + total_care_deduction = spm_unit.sum(care_deduction_person) - return min_(childcare_expenses, total_childcare_deduction) + return min_(childcare_expenses + adult_care_expenses, total_care_deduction) diff --git a/policyengine_us/variables/gov/states/de/dhss/tanf/income/earned/de_tanf_dependent_care_deduction.py b/policyengine_us/variables/gov/states/de/dhss/tanf/income/earned/de_tanf_dependent_care_deduction.py index 252c58cb1c3..e83ab3db311 100644 --- a/policyengine_us/variables/gov/states/de/dhss/tanf/income/earned/de_tanf_dependent_care_deduction.py +++ b/policyengine_us/variables/gov/states/de/dhss/tanf/income/earned/de_tanf_dependent_care_deduction.py @@ -8,25 +8,32 @@ class de_tanf_dependent_care_deduction(Variable): unit = USD definition_period = MONTH reference = ( - "https://www.law.cornell.edu/regulations/delaware/16-Del-Admin-Code-SS-4000-4008", + "https://archive.regulations.delaware.gov/AdminCode/title16/Department%20of%20Health%20and%20Social%20Services/Division%20of%20Social%20Services/Delaware%20Social%20Services%20Manual/4000.pdf#page=6", "https://help.workworldapp.com/wwwebhelp/de_earned_income_disregards_tanf_and_ga.htm", ) defined_for = StateCode.DE def formula(spm_unit, period, parameters): - # Per DSSM 4008: Dependent care up to $200/month for under age 2, - # $175/month for age 2 and older + # Per DSSM 4004.2(4): Dependent care as paid up to $200/month per + # dependent child under age 2 and up to $175/month per dependent + # child or incapacitated adult living in the home and receiving + # TANF. p = parameters(period).gov.states.de.dhss.tanf.income.deductions person = spm_unit.members is_dependent = person("is_tax_unit_dependent", period) + incapacitated_adult = person("is_adult", period.this_year) & person( + "is_incapable_of_self_care", period.this_year + ) age = person("monthly_age", period) - # Calculate maximum deduction per dependent based on age - max_per_dependent = p.dependent_care.calc(age) - total_max = spm_unit.sum(max_per_dependent * is_dependent) + # Calculate maximum deduction per care recipient based on age + care_recipient = is_dependent | incapacitated_adult + max_per_person = p.dependent_care.calc(age) + total_max = spm_unit.sum(max_per_person * care_recipient) - # Cap at actual childcare expenses. + # Cap at actual care expenses. childcare_expenses = spm_unit("childcare_expenses", period) + adult_care_expenses = add(spm_unit, period, ["care_expenses"]) - return min_(childcare_expenses, total_max) + return min_(childcare_expenses + adult_care_expenses, total_max) diff --git a/policyengine_us/variables/gov/states/ga/dfcs/tanf/income/deductions/ga_tanf_childcare_deduction.py b/policyengine_us/variables/gov/states/ga/dfcs/tanf/income/deductions/ga_tanf_childcare_deduction.py index 967f66b390d..2ae4bb698c7 100644 --- a/policyengine_us/variables/gov/states/ga/dfcs/tanf/income/deductions/ga_tanf_childcare_deduction.py +++ b/policyengine_us/variables/gov/states/ga/dfcs/tanf/income/deductions/ga_tanf_childcare_deduction.py @@ -17,15 +17,22 @@ def formula(spm_unit, period, parameters): p = parameters(period).gov.states.ga.dfcs.tanf.income.deductions person = spm_unit.members dependent = person("is_tax_unit_dependent", period) + # PAMMS 1615 also covers "the care of an incapacitated individual + # in the home" at the $175 tier for individuals age two or above. + incapacitated_adult = person("is_adult", period.this_year) & person( + "is_incapable_of_self_care", period.this_year + ) age = person("monthly_age", period) childcare_expenses = spm_unit("childcare_expenses", period) + adult_care_expenses = add(spm_unit, period, ["care_expenses"]) # PAMMS 1615: "$200 monthly for each child under the age of two" # and "$175 monthly for each individual age two or above" # PAMMS 1605: Childcare is an earned income deduction applied # in order after work expense - # Calculate max deduction per dependent based on age - childcare_deduction_person = p.childcare.calc(age) * dependent - total_childcare_deduction = spm_unit.sum(childcare_deduction_person) + # Calculate max deduction per care recipient based on age + care_recipient = dependent | incapacitated_adult + care_deduction_person = p.childcare.calc(age) * care_recipient + total_care_deduction = spm_unit.sum(care_deduction_person) - return min_(childcare_expenses, total_childcare_deduction) + return min_(childcare_expenses + adult_care_expenses, total_care_deduction) diff --git a/policyengine_us/variables/gov/states/hi/dhs/tanf/income/hi_tanf_dependent_care_deduction.py b/policyengine_us/variables/gov/states/hi/dhs/tanf/income/hi_tanf_dependent_care_deduction.py index a05c8b18856..a07aa2f7839 100644 --- a/policyengine_us/variables/gov/states/hi/dhs/tanf/income/hi_tanf_dependent_care_deduction.py +++ b/policyengine_us/variables/gov/states/hi/dhs/tanf/income/hi_tanf_dependent_care_deduction.py @@ -15,25 +15,30 @@ class hi_tanf_dependent_care_deduction(Variable): def formula(spm_unit, period, parameters): p = parameters(period).gov.states.hi.dhs.tanf.deductions.dependent_care - expenses = spm_unit("childcare_expenses", period) + # Per State Plan section 10.2.1(D), the deduction covers the cost + # of care for a disabled adult household member; care of children + # also flows through the same per-person caps. + childcare_expenses = spm_unit("childcare_expenses", period) + adult_care_expenses = add(spm_unit, period, ["care_expenses"]) - # Count children in the unit for the per-child cap + # Count children and disabled adults in the unit for the per-person cap person = spm_unit.members is_child = person("is_child", period.this_year) - num_children = spm_unit.sum(is_child) + is_adult = ~person("is_child", period.this_year) + is_disabled_adult = is_adult & person("is_disabled", period.this_year) + num_care_recipients = spm_unit.sum(is_child | is_disabled_adult) # Determine rate based on MAX of adult hours # If either parent works full-time, use full-time rate - is_adult = ~person("is_child", period.this_year) hours = person("weekly_hours_worked_before_lsr", period.this_year) # Only consider adult hours (children get 0) adult_hours = where(is_adult, hours, 0) max_adult_hours = spm_unit.max(adult_hours) # Full-time = 32+ hours/week - # Rate is $175 (full-time) or $165 (part-time) per child + # Rate is $175 (full-time) or $165 (part-time) per person rate = p.amount.calc(max_adult_hours) - max_deduction = num_children * rate + max_deduction = num_care_recipients * rate - # Deduct actual cost up to max per child - return min_(expenses, max_deduction) + # Deduct actual cost up to max per care recipient + return min_(childcare_expenses + adult_care_expenses, max_deduction) diff --git a/policyengine_us/variables/gov/states/il/dhs/tanf/income/deductions/il_tanf_childcare_deduction.py b/policyengine_us/variables/gov/states/il/dhs/tanf/income/deductions/il_tanf_childcare_deduction.py index dac742cdd01..eec8ddcec38 100644 --- a/policyengine_us/variables/gov/states/il/dhs/tanf/income/deductions/il_tanf_childcare_deduction.py +++ b/policyengine_us/variables/gov/states/il/dhs/tanf/income/deductions/il_tanf_childcare_deduction.py @@ -16,9 +16,17 @@ def formula(spm_unit, period, parameters): p = parameters(period).gov.states.il.dhs.tanf.income.child_care_deduction person = spm_unit.members dependent = person("is_tax_unit_dependent", period) + # Per 89 Ill. Adm. Code 112.143(b)(1)(C), care of an incapacitated + # adult is an exception to direct payment and flows through the + # care deduction at the age-two-or-older tier. + incapacitated_adult = person("is_adult", period.this_year) & person( + "is_incapable_of_self_care", period.this_year + ) age = person("monthly_age", period) childcare_expenses = spm_unit("childcare_expenses", period) - childcare_deduction_person = p.calc(age) * dependent - total_childcare_deduction = spm_unit.sum(childcare_deduction_person) + adult_care_expenses = add(spm_unit, period, ["care_expenses"]) + care_recipient = dependent | incapacitated_adult + care_deduction_person = p.calc(age) * care_recipient + total_care_deduction = spm_unit.sum(care_deduction_person) - return min_(childcare_expenses, total_childcare_deduction) + return min_(childcare_expenses + adult_care_expenses, total_care_deduction) diff --git a/policyengine_us/variables/gov/states/ky/dcbs/ktap/income/ky_ktap_dependent_care_disregard.py b/policyengine_us/variables/gov/states/ky/dcbs/ktap/income/ky_ktap_dependent_care_disregard.py index 52bdac8a695..7e7ee2dfd96 100644 --- a/policyengine_us/variables/gov/states/ky/dcbs/ktap/income/ky_ktap_dependent_care_disregard.py +++ b/policyengine_us/variables/gov/states/ky/dcbs/ktap/income/ky_ktap_dependent_care_disregard.py @@ -15,8 +15,15 @@ def formula(spm_unit, period, parameters): p = parameters(period).gov.states.ky.dcbs.ktap.income.deductions person = spm_unit.members is_dependent = person("is_tax_unit_dependent", period) + # Per 921 KAR 2:016 Section 5(3)(b)1.b, the disregard covers an + # incapacitated adult living in the home and receiving KTAP. + incapacitated_adult = person("is_adult", period.this_year) & person( + "is_incapable_of_self_care", period.this_year + ) age = person("age", period.this_year) - max_per_child = p.dependent_care.calc(age) * is_dependent - total_max_disregard = spm_unit.sum(max_per_child) + care_recipient = is_dependent | incapacitated_adult + max_per_person = p.dependent_care.calc(age) * care_recipient + total_max_disregard = spm_unit.sum(max_per_person) childcare_expenses = spm_unit("childcare_expenses", period) - return min_(childcare_expenses, total_max_disregard) + adult_care_expenses = add(spm_unit, period, ["care_expenses"]) + return min_(childcare_expenses + adult_care_expenses, total_max_disregard) diff --git a/policyengine_us/variables/gov/states/ma/dta/tcap/eaedc/dependent_care_deduction/ma_eaedc_dependent_care_deduction_person.py b/policyengine_us/variables/gov/states/ma/dta/tcap/eaedc/dependent_care_deduction/ma_eaedc_dependent_care_deduction_person.py index fa9b73ea379..0a0514432b7 100644 --- a/policyengine_us/variables/gov/states/ma/dta/tcap/eaedc/dependent_care_deduction/ma_eaedc_dependent_care_deduction_person.py +++ b/policyengine_us/variables/gov/states/ma/dta/tcap/eaedc/dependent_care_deduction/ma_eaedc_dependent_care_deduction_person.py @@ -14,6 +14,12 @@ class ma_eaedc_dependent_care_deduction_person(Variable): def formula(person, period, parameters): dependent = person("ma_eaedc_eligible_dependent", period) + # Per 106 CMR 704.275(A), the deduction also covers an + # incapacitated individual requiring care, at the age-two-or-older + # tier. + incapacitated_adult = person("is_adult", period.this_year) & person( + "is_incapable_of_self_care", period.this_year + ) total_weekly_hours = person.spm_unit.sum( person("weekly_hours_worked_before_lsr", period.this_year) ) @@ -25,6 +31,9 @@ def formula(person, period, parameters): p.amount.younger.calc(total_weekly_hours), p.amount.older.calc(total_weekly_hours), ) - total_amount = amount * dependent - care_expenses = person("pre_subsidy_childcare_expenses", period) + care_recipient = dependent | incapacitated_adult + total_amount = amount * care_recipient + care_expenses = person("pre_subsidy_childcare_expenses", period) + person( + "care_expenses", period + ) return min_(total_amount, care_expenses) diff --git a/policyengine_us/variables/gov/states/ma/dta/tcap/tafdc/income/deductions/ma_tafdc_dependent_care_deduction_person.py b/policyengine_us/variables/gov/states/ma/dta/tcap/tafdc/income/deductions/ma_tafdc_dependent_care_deduction_person.py index ebd80d0bdc6..77674105b1e 100644 --- a/policyengine_us/variables/gov/states/ma/dta/tcap/tafdc/income/deductions/ma_tafdc_dependent_care_deduction_person.py +++ b/policyengine_us/variables/gov/states/ma/dta/tcap/tafdc/income/deductions/ma_tafdc_dependent_care_deduction_person.py @@ -14,6 +14,12 @@ class ma_tafdc_dependent_care_deduction_person(Variable): def formula(person, period, parameters): dependent = person("ma_tafdc_eligible_dependent", period) + # Per 106 CMR 704.275(A), the deduction also covers an + # incapacitated individual requiring care, at the age-two-or-older + # tier. + incapacitated_adult = person("is_adult", period.this_year) & person( + "is_incapable_of_self_care", period.this_year + ) total_weekly_hours = person.spm_unit.sum( person("weekly_hours_worked_before_lsr", period.this_year) ) @@ -25,6 +31,9 @@ def formula(person, period, parameters): p.amount.younger.calc(total_weekly_hours), p.amount.older.calc(total_weekly_hours), ) - total_amount = amount * dependent - care_expenses = person("pre_subsidy_childcare_expenses", period) + care_recipient = dependent | incapacitated_adult + total_amount = amount * care_recipient + care_expenses = person("pre_subsidy_childcare_expenses", period) + person( + "care_expenses", period + ) return min_(total_amount, care_expenses) diff --git a/policyengine_us/variables/gov/states/md/tca/income/md_tca_childcare_deduction.py b/policyengine_us/variables/gov/states/md/tca/income/md_tca_childcare_deduction.py index b94d040fc6b..bb03ebc4860 100644 --- a/policyengine_us/variables/gov/states/md/tca/income/md_tca_childcare_deduction.py +++ b/policyengine_us/variables/gov/states/md/tca/income/md_tca_childcare_deduction.py @@ -8,21 +8,27 @@ class md_tca_childcare_deduction(Variable): unit = USD definition_period = MONTH defined_for = StateCode.MD - reference = "https://dsd.maryland.gov/regulations/Pages/07.03.03.13.aspx" + reference = "https://www.law.cornell.edu/regulations/maryland/COMAR-07-03-03-13" def formula(spm_unit, period, parameters): - # Per COMAR 07.03.03.13.E(3)(c), childcare deduction is capped at - # actual expenses, "not to exceed" per child based on employment - # hours: $200/child for 100+ hours/month, $100/child for <100 hours. + # Per COMAR 07.03.03.13.E(3)(c), the deduction covers payments for + # the care of each child in the assistance unit or an incapacitated + # adult living in the home, capped at actual expenses, "not to + # exceed" per person based on employment hours: $200 for 100+ + # hours/month, $100 for <100 hours. person = spm_unit.members is_child = person("is_child", period.this_year) - num_children = spm_unit.sum(is_child) + incapacitated_adult = person("is_adult", period.this_year) & person( + "is_incapable_of_self_care", period.this_year + ) + num_care_recipients = spm_unit.sum(is_child | incapacitated_adult) monthly_hours = person("monthly_hours_worked", period.this_year) max_monthly_hours = spm_unit.max(monthly_hours) p = parameters(period).gov.states.md.tca.income.deductions - # Maximum deduction per child based on monthly work hours - per_child_cap = p.childcare_expenses.cap.calc(max_monthly_hours) - max_deduction = per_child_cap * num_children - # Actual childcare expenses (capped at regulatory maximum). + # Maximum deduction per care recipient based on monthly work hours + per_person_cap = p.childcare_expenses.cap.calc(max_monthly_hours) + max_deduction = per_person_cap * num_care_recipients + # Actual care expenses (capped at regulatory maximum). childcare_expenses = spm_unit("childcare_expenses", period) - return min_(childcare_expenses, max_deduction) + adult_care_expenses = add(spm_unit, period, ["care_expenses"]) + return min_(childcare_expenses + adult_care_expenses, max_deduction) diff --git a/policyengine_us/variables/gov/states/me/dhhs/tanf/income/deductions/me_tanf_child_care_deduction.py b/policyengine_us/variables/gov/states/me/dhhs/tanf/income/deductions/me_tanf_child_care_deduction.py index 3ccea193a7d..a1f261e4698 100644 --- a/policyengine_us/variables/gov/states/me/dhhs/tanf/income/deductions/me_tanf_child_care_deduction.py +++ b/policyengine_us/variables/gov/states/me/dhhs/tanf/income/deductions/me_tanf_child_care_deduction.py @@ -7,27 +7,40 @@ class me_tanf_child_care_deduction(Variable): label = "Maine TANF child care deduction" unit = USD definition_period = MONTH - reference = "https://www.mainelegislature.org/legis/statutes/22/title22sec3762.html" + reference = ( + "https://www.mainelegislature.org/legis/statutes/22/title22sec3762.html", + "https://www.law.cornell.edu/regulations/maine/C-M-R-10-144-ch-331-IV", + ) defined_for = StateCode.ME def formula(spm_unit, period, parameters): # Per 22 M.R.S. Section 3762(3)(B)(7-D): # Up to $175/month per child # Up to $200/month per child under age 2 or with special needs + # Per 10-144 CMR ch. 331, Ch. IV, Section B(2)(b), the disregard + # also covers each incapacitated adult needing care while the + # recipient works, at the $175 tier. p = parameters(period).gov.states.me.dhhs.tanf.child_care person = spm_unit.members is_child = person("is_child", period.this_year) + incapacitated_adult = person("is_adult", period.this_year) & person( + "is_incapable_of_self_care", period.this_year + ) age = person("age", period.this_year) is_disabled = person("is_disabled", period) # Special needs children get the higher amount (bracket 0 = $200) - max_per_child = where(is_disabled, p.amount.amounts[0], p.amount.calc(age)) + max_per_person = where( + is_child & is_disabled, p.amount.amounts[0], p.amount.calc(age) + ) - # Only children count toward the deduction cap - max_deduction_per_person = max_per_child * is_child + # Children and incapacitated adults count toward the deduction cap + care_recipient = is_child | incapacitated_adult + max_deduction_per_person = max_per_person * care_recipient total_max_deduction = spm_unit.sum(max_deduction_per_person) # Deduction is lesser of actual expenses or maximum. childcare_expenses = spm_unit("childcare_expenses", period) - return min_(childcare_expenses, total_max_deduction) + adult_care_expenses = add(spm_unit, period, ["care_expenses"]) + return min_(childcare_expenses + adult_care_expenses, total_max_deduction) diff --git a/policyengine_us/variables/gov/states/mn/dcyf/mfip/income/earned/mn_mfip_dependent_care_deduction.py b/policyengine_us/variables/gov/states/mn/dcyf/mfip/income/earned/mn_mfip_dependent_care_deduction.py index 2a8d27d79ef..94b6f68647c 100644 --- a/policyengine_us/variables/gov/states/mn/dcyf/mfip/income/earned/mn_mfip_dependent_care_deduction.py +++ b/policyengine_us/variables/gov/states/mn/dcyf/mfip/income/earned/mn_mfip_dependent_care_deduction.py @@ -14,11 +14,19 @@ def formula(spm_unit, period, parameters): # Per MN Stat. 142G.16, Subd. 1(b)(2): # Deduct actual dependent care up to $200/child under 2, $175/child 2+. # Only applies to eligibility test, not benefit calculation. + # Per Combined Manual 0018.09, the deduction also covers care of a + # disabled adult in the unit; the manual states no separate adult + # cap, so we apply the $175 age-two-or-older tier. p = parameters(period).gov.states.mn.dcyf.mfip.income.deductions.dependent_care person = spm_unit.members dependent = person("is_tax_unit_dependent", period) + disabled_adult = person("is_adult", period.this_year) & person( + "is_disabled", period.this_year + ) age = person("monthly_age", period) childcare_expenses = spm_unit("childcare_expenses", period) - max_deduction_per_child = p.calc(age) * dependent - total_max_deduction = spm_unit.sum(max_deduction_per_child) - return min_(childcare_expenses, total_max_deduction) + adult_care_expenses = add(spm_unit, period, ["care_expenses"]) + care_recipient = dependent | disabled_adult + max_deduction_per_person = p.calc(age) * care_recipient + total_max_deduction = spm_unit.sum(max_deduction_per_person) + return min_(childcare_expenses + adult_care_expenses, total_max_deduction) diff --git a/policyengine_us/variables/gov/states/mo/dss/tanf/income/deductions/mo_tanf_child_care_deduction.py b/policyengine_us/variables/gov/states/mo/dss/tanf/income/deductions/mo_tanf_child_care_deduction.py index 531041ed92e..4f5d91ddd23 100644 --- a/policyengine_us/variables/gov/states/mo/dss/tanf/income/deductions/mo_tanf_child_care_deduction.py +++ b/policyengine_us/variables/gov/states/mo/dss/tanf/income/deductions/mo_tanf_child_care_deduction.py @@ -17,8 +17,16 @@ def formula(spm_unit, period, parameters): p = parameters(period).gov.states.mo.dss.tanf.child_care_deduction person = spm_unit.members dependent = person("is_tax_unit_dependent", period) + # Per 13 CSR 40-2.120(6)(A)5, the disregard also covers care of an + # incapacitated individual living in the same home as the dependent + # child, at the $175 age-two-or-older tier. + incapacitated_adult = person("is_adult", period.this_year) & person( + "is_incapable_of_self_care", period.this_year + ) age = person("age", period.this_year) childcare_expenses = spm_unit("childcare_expenses", period) - max_deduction_per_child = p.amount.calc(age) * dependent - total_max_deduction = spm_unit.sum(max_deduction_per_child) - return min_(childcare_expenses, total_max_deduction) + adult_care_expenses = add(spm_unit, period, ["care_expenses"]) + care_recipient = dependent | incapacitated_adult + max_deduction_per_person = p.amount.calc(age) * care_recipient + total_max_deduction = spm_unit.sum(max_deduction_per_person) + return min_(childcare_expenses + adult_care_expenses, total_max_deduction) diff --git a/policyengine_us/variables/gov/states/mt/dhs/tanf/income/deductions/mt_tanf_dependent_care_deduction.py b/policyengine_us/variables/gov/states/mt/dhs/tanf/income/deductions/mt_tanf_dependent_care_deduction.py index 7aec2230271..7632efd5ed9 100644 --- a/policyengine_us/variables/gov/states/mt/dhs/tanf/income/deductions/mt_tanf_dependent_care_deduction.py +++ b/policyengine_us/variables/gov/states/mt/dhs/tanf/income/deductions/mt_tanf_dependent_care_deduction.py @@ -23,8 +23,14 @@ def formula(spm_unit, period, parameters): ) is_eligible_person = is_dependent & (is_child | is_incapable_of_self_care) - dependent_expenses = spm_unit("childcare_expenses", period) + # Per TANF manual 602-1, the disregard covers care for each minor + # child or incapacitated adult, so adult care expenses count too. + childcare_expenses = spm_unit("childcare_expenses", period) + adult_care_expenses = add(spm_unit, period, ["care_expenses"]) dependent_deduction_person = p.amount * is_eligible_person total_dependent_deduction = spm_unit.sum(dependent_deduction_person) - return min_(dependent_expenses, total_dependent_deduction) + return min_( + childcare_expenses + adult_care_expenses, + total_dependent_deduction, + ) diff --git a/policyengine_us/variables/gov/states/nh/dhhs/fanf/income/nh_fanf_child_care_deduction.py b/policyengine_us/variables/gov/states/nh/dhhs/fanf/income/nh_fanf_child_care_deduction.py index 768ac357c8e..40ffc4dbf28 100644 --- a/policyengine_us/variables/gov/states/nh/dhhs/fanf/income/nh_fanf_child_care_deduction.py +++ b/policyengine_us/variables/gov/states/nh/dhhs/fanf/income/nh_fanf_child_care_deduction.py @@ -22,18 +22,25 @@ def formula(spm_unit, period, parameters): # Get child age and status age = person("age", period.this_year) is_child = person("is_child", period) + # Per FAM 603.05, the deduction also covers an incapacitated parent + # living in the employed person's home, at the age-2+ tier. + incapacitated_parent = person("is_tax_unit_head_or_spouse", period) & person( + "is_incapable_of_self_care", period.this_year + ) - # Calculate max deduction per child based on employment status and age + # Calculate max deduction per person based on employment status and age full_time_max = p.full_time.calc(age) part_time_max = p.part_time.calc(age) any_full_time_person = spm_unit.project(any_full_time) - max_per_child = where(any_full_time_person, full_time_max, part_time_max) + max_per_person = where(any_full_time_person, full_time_max, part_time_max) - # Only count children - max_deduction_per_child = max_per_child * is_child - total_max_deduction = spm_unit.sum(max_deduction_per_child) + # Count children and incapacitated parents + care_recipient = is_child | incapacitated_parent + max_deduction_per_person = max_per_person * care_recipient + total_max_deduction = spm_unit.sum(max_deduction_per_person) - # Cap at actual childcare expenses. + # Cap at actual care expenses. childcare_expenses = spm_unit("childcare_expenses", period) + adult_care_expenses = add(spm_unit, period, ["care_expenses"]) - return min_(childcare_expenses, total_max_deduction) + return min_(childcare_expenses + adult_care_expenses, total_max_deduction) diff --git a/policyengine_us/variables/gov/states/ok/dhs/tanf/income/ok_tanf_dependent_care_deduction.py b/policyengine_us/variables/gov/states/ok/dhs/tanf/income/ok_tanf_dependent_care_deduction.py index 0b93a1a19f2..c1d2446ade4 100644 --- a/policyengine_us/variables/gov/states/ok/dhs/tanf/income/ok_tanf_dependent_care_deduction.py +++ b/policyengine_us/variables/gov/states/ok/dhs/tanf/income/ok_tanf_dependent_care_deduction.py @@ -11,21 +11,27 @@ class ok_tanf_dependent_care_deduction(Variable): defined_for = StateCode.OK def formula(spm_unit, period, parameters): - # Per OAC 340:10-3-33(b): Dependent care expenses may be deducted + # Per OAC 340:10-3-33(b)(3): Dependent care expenses may be deducted # up to $200/month for dependents under age 2 - # up to $175/month for dependents age 2 and older + # up to $175/month for dependents age 2 and older or for an + # incapacitated adult included in the TANF assistance unit p = parameters(period).gov.states.ok.dhs.tanf.income person = spm_unit.members # Get dependent status and age in years dependent = person("is_tax_unit_dependent", period) + incapacitated_adult = person("is_adult", period.this_year) & person( + "is_incapable_of_self_care", period.this_year + ) age = person("monthly_age", period) # Returns true age in years - # Calculate maximum deduction per dependent based on age - max_deduction_per_dependent = p.deductions.dependent_care.calc(age) - total_max_deduction = spm_unit.sum(max_deduction_per_dependent * dependent) + # Calculate maximum deduction per care recipient based on age + care_recipient = dependent | incapacitated_adult + max_deduction_per_person = p.deductions.dependent_care.calc(age) + total_max_deduction = spm_unit.sum(max_deduction_per_person * care_recipient) - # Cap at actual childcare expenses. + # Cap at actual care expenses. childcare_expenses = spm_unit("childcare_expenses", period) + adult_care_expenses = add(spm_unit, period, ["care_expenses"]) - return min_(childcare_expenses, total_max_deduction) + return min_(childcare_expenses + adult_care_expenses, total_max_deduction) diff --git a/policyengine_us/variables/gov/states/ri/dhs/works/income/deductions/ri_works_dependent_care_deduction.py b/policyengine_us/variables/gov/states/ri/dhs/works/income/deductions/ri_works_dependent_care_deduction.py index fb7d93605cc..e55991c709e 100644 --- a/policyengine_us/variables/gov/states/ri/dhs/works/income/deductions/ri_works_dependent_care_deduction.py +++ b/policyengine_us/variables/gov/states/ri/dhs/works/income/deductions/ri_works_dependent_care_deduction.py @@ -16,16 +16,22 @@ class ri_works_dependent_care_deduction(Variable): def formula(spm_unit, period, parameters): # Per 218-RICR-20-00-2.15.5(B)(2): Dependent care expenses deducted # up to $200/month for children under age 2 - # up to $175/month for children age 2 and older + # up to $175/month for children age 2 and older or an incapacitated + # adult living in the home and receiving cash assistance p = parameters(period).gov.states.ri.dhs.works.income.dependent_care person = spm_unit.members is_dependent = person("is_tax_unit_dependent", period) + incapacitated_adult = person("is_adult", period.this_year) & person( + "is_incapable_of_self_care", period.this_year + ) age = person("monthly_age", period) - max_per_dependent = p.amount.calc(age) - total_max_deduction = spm_unit.sum(max_per_dependent * is_dependent) + care_recipient = is_dependent | incapacitated_adult + max_per_person = p.amount.calc(age) + total_max_deduction = spm_unit.sum(max_per_person * care_recipient) childcare_expenses = spm_unit("childcare_expenses", period) + adult_care_expenses = add(spm_unit, period, ["care_expenses"]) - return min_(childcare_expenses, total_max_deduction) + return min_(childcare_expenses + adult_care_expenses, total_max_deduction) diff --git a/policyengine_us/variables/gov/states/tx/tanf/income/deductions/tx_tanf_dependent_care_deduction.py b/policyengine_us/variables/gov/states/tx/tanf/income/deductions/tx_tanf_dependent_care_deduction.py index a0c7f0d6c8a..5613d7b2681 100644 --- a/policyengine_us/variables/gov/states/tx/tanf/income/deductions/tx_tanf_dependent_care_deduction.py +++ b/policyengine_us/variables/gov/states/tx/tanf/income/deductions/tx_tanf_dependent_care_deduction.py @@ -14,10 +14,12 @@ class tx_tanf_dependent_care_deduction(Variable): defined_for = StateCode.TX def formula(spm_unit, period, parameters): - # Actual cost of dependent child care, capped at maximum by age - # Per § 372.409 (a)(3): up to $200/month for children under 2, $175/month for children 2+ + # Actual cost of dependent care, capped at maximum by age + # Per § 372.409(a)(3): up to $200/month for children under 2, + # $175/month for children 2+ or an incapacitated adult childcare_expenses = spm_unit("childcare_expenses", period) + adult_care_expenses = add(spm_unit, period, ["care_expenses"]) # Calculate maximum deduction for dependents (children or incapacitated adults) person = spm_unit.members @@ -35,4 +37,4 @@ def formula(spm_unit, period, parameters): total_max_deduction = spm_unit.sum(max_per_person) # Deduction is the lesser of actual expenses or maximum - return min_(childcare_expenses, total_max_deduction) + return min_(childcare_expenses + adult_care_expenses, total_max_deduction) diff --git a/policyengine_us/variables/gov/states/va/dss/tanf/income/va_tanf_childcare_deduction.py b/policyengine_us/variables/gov/states/va/dss/tanf/income/va_tanf_childcare_deduction.py index cbaa1cc9547..5c2a57d17b3 100644 --- a/policyengine_us/variables/gov/states/va/dss/tanf/income/va_tanf_childcare_deduction.py +++ b/policyengine_us/variables/gov/states/va/dss/tanf/income/va_tanf_childcare_deduction.py @@ -8,9 +8,11 @@ class va_tanf_childcare_deduction(Variable): unit = USD definition_period = MONTH defined_for = StateCode.VA - reference = "https://www.dss.virginia.gov/files/division/bp/tanf/manual/300_11-20.pdf#page=56" + reference = "https://www.dss.virginia.gov/media/vdss/benefit-programs/documents/tanfx2fview/tanf/Combined-Full-Manual-07-24_1.pdf#page=175" def formula(spm_unit, period, parameters): + # Per VA TANF Manual section 305.3 item 5, the disregard covers care + # of each child or incapacitated adult in the assistance unit. p = parameters(period).gov.states.va.dss.tanf.income.deductions.dependent_care person = spm_unit.members age = person("age", period.this_year) @@ -20,5 +22,6 @@ def formula(spm_unit, period, parameters): ) care_recipient = dependent | disabled_adult childcare_expenses = spm_unit("childcare_expenses", period) + adult_care_expenses = add(spm_unit, period, ["care_expenses"]) max_deduction = spm_unit.sum(p.full_time.calc(age) * care_recipient) - return min_(childcare_expenses, max_deduction) + return min_(childcare_expenses + adult_care_expenses, max_deduction) diff --git a/policyengine_us/variables/gov/states/vt/dcf/reach_up/income/deductions/vt_reach_up_dependent_care_deduction.py b/policyengine_us/variables/gov/states/vt/dcf/reach_up/income/deductions/vt_reach_up_dependent_care_deduction.py index 907ccbd32c0..edce5846b27 100644 --- a/policyengine_us/variables/gov/states/vt/dcf/reach_up/income/deductions/vt_reach_up_dependent_care_deduction.py +++ b/policyengine_us/variables/gov/states/vt/dcf/reach_up/income/deductions/vt_reach_up_dependent_care_deduction.py @@ -15,10 +15,14 @@ class vt_reach_up_dependent_care_deduction(Variable): def formula(spm_unit, period, parameters): # Per Section 2252.2(c): $175/month max per participant claiming the deduction. # We approximate "participant" as head or spouse since they are the earners. + # Per Section 2252.2(a), the deduction covers care of a household + # member who is a disabled or seriously ill adult, so adult care + # expenses count alongside childcare. p = parameters(period).gov.states.vt.dcf.reach_up.income.deductions person = spm_unit.members head_or_spouse = person("is_tax_unit_head_or_spouse", period) num_participants = spm_unit.sum(head_or_spouse) max_deduction = p.dependent_care * num_participants childcare_expenses = spm_unit("childcare_expenses", period) - return min_(childcare_expenses, max_deduction) + adult_care_expenses = add(spm_unit, period, ["care_expenses"]) + return min_(childcare_expenses + adult_care_expenses, max_deduction) diff --git a/policyengine_us/variables/gov/states/wv/dhhr/works/income/earned/wv_works_countable_earned_income.py b/policyengine_us/variables/gov/states/wv/dhhr/works/income/earned/wv_works_countable_earned_income.py index f259ebe39d4..3276fb14015 100644 --- a/policyengine_us/variables/gov/states/wv/dhhr/works/income/earned/wv_works_countable_earned_income.py +++ b/policyengine_us/variables/gov/states/wv/dhhr/works/income/earned/wv_works_countable_earned_income.py @@ -7,7 +7,7 @@ class wv_works_countable_earned_income(Variable): label = "West Virginia WV Works countable earned income" unit = USD definition_period = MONTH - reference = "https://bfa.wv.gov/media/2766/download?inline#page=586" + reference = "https://bfa.wv.gov/media/39948/download?inline#page=590" defined_for = StateCode.WV def formula(spm_unit, period, parameters): @@ -16,6 +16,9 @@ def formula(spm_unit, period, parameters): gross_earned = add(spm_unit, period, ["tanf_gross_earned_income"]) # Step 2: Subtract 40% (Earned Income Disregard) after_disregard = gross_earned * (1 - p.earned_income_disregard.rate) - # Step 3: Subtract Dependent Care Deduction (no maximum, per Section 4.5.2.A.2) - dependent_care = spm_unit("childcare_expenses", period) + # Step 3: Subtract Dependent Care Deduction (no maximum, per Section + # 4.5.2.A.2, which covers dependent child or incapacitated adult care) + dependent_care = spm_unit("childcare_expenses", period) + add( + spm_unit, period, ["care_expenses"] + ) return max_(after_disregard - dependent_care, 0) From 317c0e18d953469846c6ee623d8d0835c8c6d551 Mon Sep 17 00:00:00 2001 From: Ziming Date: Thu, 9 Jul 2026 13:48:34 -0400 Subject: [PATCH 2/4] Fix KY and MO adult care cap: use age-two-or-older rate for incapacitated adults KY and MO cap the dependent care disregard on an age schedule that zeroes out above age 13 (KY) / 18 (MO), reflecting children aging out of care. Evaluating that schedule at an incapacitated adult's actual age returned a $0 cap, dropping their care expenses. Both regulations give the incapacitated adult the standard age-two-or-older rate ($175), so evaluate the schedule at the age-two threshold for them. Co-Authored-By: Claude Fable 5 --- .../dcbs/ktap/income/ky_ktap_dependent_care_disregard.py | 7 ++++++- .../tanf/income/deductions/mo_tanf_child_care_deduction.py | 7 ++++++- 2 files changed, 12 insertions(+), 2 deletions(-) diff --git a/policyengine_us/variables/gov/states/ky/dcbs/ktap/income/ky_ktap_dependent_care_disregard.py b/policyengine_us/variables/gov/states/ky/dcbs/ktap/income/ky_ktap_dependent_care_disregard.py index 7e7ee2dfd96..b2dbdbcec6c 100644 --- a/policyengine_us/variables/gov/states/ky/dcbs/ktap/income/ky_ktap_dependent_care_disregard.py +++ b/policyengine_us/variables/gov/states/ky/dcbs/ktap/income/ky_ktap_dependent_care_disregard.py @@ -21,8 +21,13 @@ def formula(spm_unit, period, parameters): "is_incapable_of_self_care", period.this_year ) age = person("age", period.this_year) + # Children use their age-based rate; the older-age zero-out reflects + # children aging out of care. An incapacitated adult instead receives + # the standard age-two-or-older rate per 921 KAR 2:016 Section + # 5(3)(b)2, so evaluate the schedule at the age-two boundary for them. + cap_age = where(incapacitated_adult, p.dependent_care.thresholds[1], age) care_recipient = is_dependent | incapacitated_adult - max_per_person = p.dependent_care.calc(age) * care_recipient + max_per_person = p.dependent_care.calc(cap_age) * care_recipient total_max_disregard = spm_unit.sum(max_per_person) childcare_expenses = spm_unit("childcare_expenses", period) adult_care_expenses = add(spm_unit, period, ["care_expenses"]) diff --git a/policyengine_us/variables/gov/states/mo/dss/tanf/income/deductions/mo_tanf_child_care_deduction.py b/policyengine_us/variables/gov/states/mo/dss/tanf/income/deductions/mo_tanf_child_care_deduction.py index 4f5d91ddd23..cf61d431a27 100644 --- a/policyengine_us/variables/gov/states/mo/dss/tanf/income/deductions/mo_tanf_child_care_deduction.py +++ b/policyengine_us/variables/gov/states/mo/dss/tanf/income/deductions/mo_tanf_child_care_deduction.py @@ -24,9 +24,14 @@ def formula(spm_unit, period, parameters): "is_incapable_of_self_care", period.this_year ) age = person("age", period.this_year) + # Children use their age-based rate; the older-age zero-out reflects + # children aging out of care. An incapacitated adult instead receives + # the standard age-two-or-older rate ($175), so evaluate the schedule + # at the age-two boundary for them. + cap_age = where(incapacitated_adult, p.amount.thresholds[1], age) childcare_expenses = spm_unit("childcare_expenses", period) adult_care_expenses = add(spm_unit, period, ["care_expenses"]) care_recipient = dependent | incapacitated_adult - max_deduction_per_person = p.amount.calc(age) * care_recipient + max_deduction_per_person = p.amount.calc(cap_age) * care_recipient total_max_deduction = spm_unit.sum(max_deduction_per_person) return min_(childcare_expenses + adult_care_expenses, total_max_deduction) From 872f2a7b3fecdc08836df0671682d9fb7b16389e Mon Sep 17 00:00:00 2001 From: Ziming Date: Mon, 13 Jul 2026 18:18:47 -0400 Subject: [PATCH 3/4] Remove tax-dependency requirement for incapacitated adults in MT TANF dependent care deduction Mont. Admin. r. 37.78.406(2)(c) covers care for each working member's minor child or incapacitated adult with no dependency requirement, so an incapacitated spouse now qualifies. Add adult-side edge tests: above-cap adult care, non-incapacitated adult, and combined child plus adult care. Co-Authored-By: Claude Fable 5 --- .../mt_tanf_dependent_care_deduction.yaml | 77 ++++++++++++++++++- .../mt_tanf_dependent_care_deduction.py | 7 +- 2 files changed, 81 insertions(+), 3 deletions(-) diff --git a/policyengine_us/tests/policy/baseline/gov/states/mt/dhs/tanf/income/mt_tanf_dependent_care_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/mt/dhs/tanf/income/mt_tanf_dependent_care_deduction.yaml index aedaa32bcfe..4be3454180a 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/mt/dhs/tanf/income/mt_tanf_dependent_care_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/mt/dhs/tanf/income/mt_tanf_dependent_care_deduction.yaml @@ -65,7 +65,7 @@ output: mt_tanf_dependent_care_deduction: 200 -- name: Case 7, incapacitated adult without dependency +- name: Case 7, incapacitated adult without dependency (e.g. a spouse) period: 2023-01 absolute_error_margin: 0.1 input: @@ -75,7 +75,9 @@ is_incapable_of_self_care: true childcare_expenses: 250*12 output: - mt_tanf_dependent_care_deduction: 0 + # Mont. Admin. r. 37.78.406(2)(c) imposes no dependency requirement on + # the incapacitated adult: min(250, 200) = 200. + mt_tanf_dependent_care_deduction: 200 - name: Case 8, incapacitated adult without expenses period: 2023-01 @@ -168,3 +170,74 @@ # Per TANF manual 602-1: $200/month cap per incapacitated adult. # Expenses = 1,200 / 12 = 100/month, below the cap. mt_tanf_dependent_care_deduction: 100 + +- name: Case 12, incapacitated adult care expenses above the cap. + period: 2023-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + is_incapable_of_self_care: true + care_expenses: 3_600 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: MT + output: + # Expenses = 3,600 / 12 = 300/month, above the $200/month cap. + mt_tanf_dependent_care_deduction: 200 + +- name: Case 13, adult care expenses without incapacity are not deducted. + period: 2023-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: MT + output: + # Neither adult is incapable of self-care, so no one is an eligible + # care recipient: min(100, 0) = 0. + mt_tanf_dependent_care_deduction: 0 + +- name: Case 14, combined child care and incapacitated adult care expenses. + period: 2023-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + is_incapable_of_self_care: true + care_expenses: 1_200 + person3: + age: 4 + is_tax_unit_dependent: true + spm_units: + spm_unit: + members: [person1, person2, person3] + childcare_expenses: 3_000 + households: + household: + members: [person1, person2, person3] + state_code: MT + output: + # Child care 3,000 / 12 = 250/month plus adult care 1,200 / 12 = + # 100/month sums to 350/month, below the two-person cap of 2 * $200. + mt_tanf_dependent_care_deduction: 350 diff --git a/policyengine_us/variables/gov/states/mt/dhs/tanf/income/deductions/mt_tanf_dependent_care_deduction.py b/policyengine_us/variables/gov/states/mt/dhs/tanf/income/deductions/mt_tanf_dependent_care_deduction.py index 7632efd5ed9..08d9be71937 100644 --- a/policyengine_us/variables/gov/states/mt/dhs/tanf/income/deductions/mt_tanf_dependent_care_deduction.py +++ b/policyengine_us/variables/gov/states/mt/dhs/tanf/income/deductions/mt_tanf_dependent_care_deduction.py @@ -18,10 +18,15 @@ def formula(spm_unit, period, parameters): is_dependent = person("is_tax_unit_dependent", period.this_year) is_child = person("mt_tanf_eligible_child", period) + is_adult = person("is_adult", period.this_year) is_incapable_of_self_care = person( "is_incapable_of_self_care", period.this_year ) - is_eligible_person = is_dependent & (is_child | is_incapable_of_self_care) + # Mont. Admin. r. 37.78.406(2)(c) imposes no dependency requirement + # on the incapacitated adult, so an incapacitated spouse qualifies. + is_eligible_person = (is_dependent & is_child) | ( + is_adult & is_incapable_of_self_care + ) # Per TANF manual 602-1, the disregard covers care for each minor # child or incapacitated adult, so adult care expenses count too. From 9185b340a2c6b923d7d7caac0e819734b73aed0e Mon Sep 17 00:00:00 2001 From: Ziming Date: Tue, 14 Jul 2026 15:36:01 -0400 Subject: [PATCH 4/4] Address review: VA incapacity condition, negative-filter and cap-pinning tests - VA: switch the adult care mask from is_disabled to is_incapable_of_self_care per Manual 305.3 item 5 ("Incapacitated Adult/Child Care Disregard"), and sweep the VA unit and integration tests accordingly. - Add a negative population-filter test to every capped program (adult without the qualifying condition adds nothing to the cap), including incapacitated non-parent cases for AK/NH and a non-dependent case for AZ. - KY/MO: add above-cap adult cases pinning the age-2+ $175 tier that the cap_age remap targets. - AL/VT/WV: document that the incapacity/disability flags in the new test cases describe the legal scenario while the formulas pool care_expenses without a filter, symmetric with the childcare side. - AZ: drop the inert incapacity flag from the dependent-adult case. Co-Authored-By: Claude Fable 5 --- .../dpa/atap/ak_atap_childcare_deduction.yaml | 26 ++++++++++ .../tanf/al_tanf_countable_earned_income.yaml | 3 ++ .../az_tanf_dependent_care_deduction.yaml | 24 +++++++++- .../income/dc_tanf_childcare_deduction.yaml | 23 +++++++++ .../de_tanf_dependent_care_deduction.yaml | 23 +++++++++ .../income/ga_tanf_childcare_deduction.yaml | 23 +++++++++ .../hi_tanf_dependent_care_deduction.yaml | 23 +++++++++ .../il_tanf_childcare_deduction.yaml | 23 +++++++++ .../ky_ktap_dependent_care_disregard.yaml | 47 +++++++++++++++++++ ...eaedc_dependent_care_deduction_person.yaml | 23 +++++++++ ...tafdc_dependent_care_deduction_person.yaml | 23 +++++++++ .../md_tca_childcare_deduction.yaml | 23 +++++++++ .../tanf/me_tanf_child_care_deduction.yaml | 22 +++++++++ .../mn_mfip_dependent_care_deduction.yaml | 23 +++++++++ .../tanf/mo_tanf_child_care_deduction.yaml | 47 +++++++++++++++++++ .../fanf/nh_fanf_child_care_deduction.yaml | 25 ++++++++++ .../ok_tanf_dependent_care_deduction.yaml | 23 +++++++++ .../ri_works_dependent_care_deduction.yaml | 23 +++++++++ .../tx_tanf_dependent_care_deduction.yaml | 23 +++++++++ .../income/va_tanf_childcare_deduction.yaml | 41 ++++++++++++---- .../gov/states/va/dss/tanf/integration.yaml | 6 +++ .../vt_reach_up_dependent_care_deduction.yaml | 4 ++ .../wv_works_countable_earned_income.yaml | 3 ++ .../income/va_tanf_childcare_deduction.py | 9 ++-- 24 files changed, 520 insertions(+), 13 deletions(-) diff --git a/policyengine_us/tests/policy/baseline/gov/states/ak/dpa/atap/ak_atap_childcare_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/ak/dpa/atap/ak_atap_childcare_deduction.yaml index f3d78a988d3..2db61e99f5c 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/ak/dpa/atap/ak_atap_childcare_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/ak/dpa/atap/ak_atap_childcare_deduction.yaml @@ -255,3 +255,29 @@ # Per 7 AAC 45.485(a)(2)(C): $175/month cap for an incapacitated parent. # Expenses = 1,200 / 12 = 100/month, below the 175 cap. ak_atap_childcare_deduction: 100 + +- name: Case 12, incapacitated non-parent adult does not count toward the disregard. + period: 2024-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 70 + is_tax_unit_head_or_spouse: false + is_tax_unit_dependent: false + is_incapable_of_self_care: true + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: AK + output: + # 7 AAC 45.485(a)(2)(C) covers only an incapacitated PARENT; an + # incapacitated non-parent, non-dependent adult adds nothing to the + # cap: min(100, 0) = 0. + ak_atap_childcare_deduction: 0 diff --git a/policyengine_us/tests/policy/baseline/gov/states/al/dhs/tanf/al_tanf_countable_earned_income.yaml b/policyengine_us/tests/policy/baseline/gov/states/al/dhs/tanf/al_tanf_countable_earned_income.yaml index d6f679d922b..41dc8e99538 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/al/dhs/tanf/al_tanf_countable_earned_income.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/al/dhs/tanf/al_tanf_countable_earned_income.yaml @@ -233,6 +233,9 @@ employment_income_before_lsr: 12_000 # $1,000/month person2: age: 35 + # Describes the legal scenario (r. 660-2-2-.30(2)(c) covers an + # incapacitated adult); the formula pools care_expenses without an + # incapacity filter, symmetric with the childcare side. is_incapable_of_self_care: true care_expenses: 1_200 # $100/month person3: diff --git a/policyengine_us/tests/policy/baseline/gov/states/az/hhs/tanf/az_tanf_dependent_care_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/az/hhs/tanf/az_tanf_dependent_care_deduction.yaml index 85e42de20ae..a3faff46d61 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/az/hhs/tanf/az_tanf_dependent_care_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/az/hhs/tanf/az_tanf_dependent_care_deduction.yaml @@ -166,7 +166,6 @@ person2: age: 28 is_tax_unit_dependent: true - is_incapable_of_self_care: true care_expenses: 1_200 spm_units: spm_unit: @@ -179,3 +178,26 @@ # Per ARS 46-292: care of an adult dependent household member, # capped at $175/month. Expenses = 1,200 / 12 = 100/month. az_tanf_dependent_care_deduction: 100 + +- name: Case 8, non-dependent adult care expenses are not deducted. + period: 2024-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + is_tax_unit_dependent: false + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: AZ + output: + # ARS 46-292(P)(1) covers a DEPENDENT household member; a + # non-dependent adult adds nothing to the cap: min(100, 0) = 0. + az_tanf_dependent_care_deduction: 0 diff --git a/policyengine_us/tests/policy/baseline/gov/states/dc/dhs/tanf/income/dc_tanf_childcare_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/dc/dhs/tanf/income/dc_tanf_childcare_deduction.yaml index b0a4e4de7ab..2884490346b 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/dc/dhs/tanf/income/dc_tanf_childcare_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/dc/dhs/tanf/income/dc_tanf_childcare_deduction.yaml @@ -95,3 +95,26 @@ # Per DC Code 4-205.11(a)(2): incapacitated adult care capped at # $175/month. Expenses = 1,200 / 12 = 100/month, below the cap. dc_tanf_childcare_deduction: 100 + +- name: Case 6, adult care expenses without incapacity are not deducted. + period: 2023-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + is_tax_unit_dependent: false + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: DC + output: + # Person2 is neither a dependent nor incapacitated, so the cap is $0: + # min(100, 0) = 0. + dc_tanf_childcare_deduction: 0 diff --git a/policyengine_us/tests/policy/baseline/gov/states/de/dhss/tanf/income/earned/de_tanf_dependent_care_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/de/dhss/tanf/income/earned/de_tanf_dependent_care_deduction.yaml index d1aa081328a..bfdea1f2136 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/de/dhss/tanf/income/earned/de_tanf_dependent_care_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/de/dhss/tanf/income/earned/de_tanf_dependent_care_deduction.yaml @@ -230,3 +230,26 @@ # Per DSSM 4004.2(4): incapacitated adult care capped at $175/month. # Expenses = 1,200 / 12 = 100/month, below the cap. de_tanf_dependent_care_deduction: 100 + +- name: Case 12, adult care expenses without incapacity are not deducted. + period: 2025-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + is_tax_unit_dependent: false + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: DE + output: + # Person2 is neither a dependent nor incapacitated, so the cap is $0: + # min(100, 0) = 0. + de_tanf_dependent_care_deduction: 0 diff --git a/policyengine_us/tests/policy/baseline/gov/states/ga/dfcs/tanf/income/ga_tanf_childcare_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/ga/dfcs/tanf/income/ga_tanf_childcare_deduction.yaml index 951ab1d6776..27fa5b3f5b8 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/ga/dfcs/tanf/income/ga_tanf_childcare_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/ga/dfcs/tanf/income/ga_tanf_childcare_deduction.yaml @@ -339,3 +339,26 @@ # including an incapacitated individual in the home. # Expenses = 1,200 / 12 = 100/month, below the cap. ga_tanf_childcare_deduction: 100 + +- name: Adult care expenses without incapacity are not deducted + period: 2025-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + is_tax_unit_dependent: false + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: GA + output: + # Person2 is neither a dependent nor incapacitated, so the cap is $0: + # min(100, 0) = 0. + ga_tanf_childcare_deduction: 0 diff --git a/policyengine_us/tests/policy/baseline/gov/states/hi/dhs/tanf/income/hi_tanf_dependent_care_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/hi/dhs/tanf/income/hi_tanf_dependent_care_deduction.yaml index 0ee6b2e4f70..6df22fdedb2 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/hi/dhs/tanf/income/hi_tanf_dependent_care_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/hi/dhs/tanf/income/hi_tanf_dependent_care_deduction.yaml @@ -344,3 +344,26 @@ # up to $175/month (full-time employment, 40 hours >= 32). # Expenses = 1,200 / 12 = 100/month, below the cap. hi_tanf_dependent_care_deduction: 100 + +- name: Case 14, adult care expenses without disability are not deducted. + period: 2024-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + weekly_hours_worked_before_lsr: 40 + person2: + age: 25 + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: HI + output: + # Person2 is neither a child nor a disabled adult, so no care + # recipients: min(100, 0) = 0. + hi_tanf_dependent_care_deduction: 0 diff --git a/policyengine_us/tests/policy/baseline/gov/states/il/dhs/tanf/income/deductions/il_tanf_childcare_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/il/dhs/tanf/income/deductions/il_tanf_childcare_deduction.yaml index 78843880da0..ddc71cb8dbe 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/il/dhs/tanf/income/deductions/il_tanf_childcare_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/il/dhs/tanf/income/deductions/il_tanf_childcare_deduction.yaml @@ -60,3 +60,26 @@ # Per 89 Ill. Adm. Code 112.143(b)(1)(C): incapacitated adult care # at the $175/month age-2+ tier. Expenses = 1,200 / 12 = 100/month. il_tanf_childcare_deduction: 100 + +- name: Case 6, adult care expenses without incapacity are not deducted. + period: 2023-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + is_tax_unit_dependent: false + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: IL + output: + # Person2 is neither a dependent nor incapacitated, so the cap is $0: + # min(100, 0) = 0. + il_tanf_childcare_deduction: 0 diff --git a/policyengine_us/tests/policy/baseline/gov/states/ky/dcbs/ktap/income/ky_ktap_dependent_care_disregard.yaml b/policyengine_us/tests/policy/baseline/gov/states/ky/dcbs/ktap/income/ky_ktap_dependent_care_disregard.yaml index da04e9c457e..347b36d2610 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/ky/dcbs/ktap/income/ky_ktap_dependent_care_disregard.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/ky/dcbs/ktap/income/ky_ktap_dependent_care_disregard.yaml @@ -177,3 +177,50 @@ # Per 921 KAR 2:016 Section 5(3)(b)1.b: incapacitated adult living in # the home, capped at $175/month. Expenses = 1,200 / 12 = 100/month. ky_ktap_dependent_care_disregard: 100 + +- name: Incapacitated adult care expenses above the cap are limited to the age-2+ tier. + period: 2024-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + is_incapable_of_self_care: true + care_expenses: 3_600 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: KY + output: + # Expenses = 3,600 / 12 = 300/month. The incapacitated adult's cap is + # the $175 age-2+ tier (not the $200 under-2 tier, and not the $0 + # older-age bracket): min(300, 175) = 175. + ky_ktap_dependent_care_disregard: 175 + +- name: Adult care expenses without incapacity are not disregarded. + period: 2024-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + is_tax_unit_dependent: false + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: KY + output: + # Person2 is neither a dependent nor incapacitated, so the cap is $0: + # min(100, 0) = 0. + ky_ktap_dependent_care_disregard: 0 diff --git a/policyengine_us/tests/policy/baseline/gov/states/ma/dta/tcap/eaedc/dependent_care_deduction/ma_eaedc_dependent_care_deduction_person.yaml b/policyengine_us/tests/policy/baseline/gov/states/ma/dta/tcap/eaedc/dependent_care_deduction/ma_eaedc_dependent_care_deduction_person.yaml index 187cbce0b7d..0b055cf7a96 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/ma/dta/tcap/eaedc/dependent_care_deduction/ma_eaedc_dependent_care_deduction_person.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/ma/dta/tcap/eaedc/dependent_care_deduction/ma_eaedc_dependent_care_deduction_person.yaml @@ -109,3 +109,26 @@ # Per 106 CMR 704.275(A): incapacitated individual at the older tier, # $175/month at 40 weekly hours. Expenses = 1,200 / 12 = 100/month. ma_eaedc_dependent_care_deduction_person: [0, 100] + +- name: Adult care expenses without incapacity are not deducted. + period: 2023-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + weekly_hours_worked_before_lsr: 40 + person2: + age: 25 + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: MA + output: + # Person2 is neither an eligible dependent nor incapacitated, so the + # per-person cap is $0: min(0, 100) = 0. + ma_eaedc_dependent_care_deduction_person: [0, 0] diff --git a/policyengine_us/tests/policy/baseline/gov/states/ma/dta/tcap/tafdc/income/deductions/ma_tafdc_dependent_care_deduction_person.yaml b/policyengine_us/tests/policy/baseline/gov/states/ma/dta/tcap/tafdc/income/deductions/ma_tafdc_dependent_care_deduction_person.yaml index 5bf8f4de4c7..798455451dc 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/ma/dta/tcap/tafdc/income/deductions/ma_tafdc_dependent_care_deduction_person.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/ma/dta/tcap/tafdc/income/deductions/ma_tafdc_dependent_care_deduction_person.yaml @@ -82,3 +82,26 @@ # Per 106 CMR 704.275(A): incapacitated individual at the older tier, # $175/month at 40 weekly hours. Expenses = 1,200 / 12 = 100/month. ma_tafdc_dependent_care_deduction_person: [0, 100] + +- name: Adult care expenses without incapacity are not deducted. + period: 2023-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + weekly_hours_worked_before_lsr: 40 + person2: + age: 25 + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: MA + output: + # Person2 is neither an eligible dependent nor incapacitated, so the + # per-person cap is $0: min(0, 100) = 0. + ma_tafdc_dependent_care_deduction_person: [0, 0] diff --git a/policyengine_us/tests/policy/baseline/gov/states/md/tca/income/deductions/md_tca_childcare_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/md/tca/income/deductions/md_tca_childcare_deduction.yaml index 4c8a9be0f24..ca619a8ba6b 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/md/tca/income/deductions/md_tca_childcare_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/md/tca/income/deductions/md_tca_childcare_deduction.yaml @@ -265,3 +265,26 @@ # in the home, capped at $200/month (100+ work hours). # Expenses = 1,200 / 12 = 100/month, below the cap. md_tca_childcare_deduction: 100 + +- name: Case 13, adult care expenses without incapacity are not deducted. + period: 2024-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + monthly_hours_worked: 120 + person2: + age: 35 + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: MD + output: + # Person2 is neither a child nor incapacitated, so there are no care + # recipients: min(100, 0) = 0. + md_tca_childcare_deduction: 0 diff --git a/policyengine_us/tests/policy/baseline/gov/states/me/dhhs/tanf/me_tanf_child_care_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/me/dhhs/tanf/me_tanf_child_care_deduction.yaml index 2830111d99f..02c52035bd9 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/me/dhhs/tanf/me_tanf_child_care_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/me/dhhs/tanf/me_tanf_child_care_deduction.yaml @@ -140,3 +140,25 @@ # Per 10-144 CMR ch. 331, Ch. IV, Section B(2)(b): incapacitated adult # at the $175/month tier. Expenses = 1,200 / 12 = 100/month. me_tanf_child_care_deduction: 100 + +- name: Case 7, adult care expenses without incapacity are not deducted. + period: 2025-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: ME + output: + # Person2 is neither a child nor incapacitated, so the cap is $0: + # min(100, 0) = 0. + me_tanf_child_care_deduction: 0 diff --git a/policyengine_us/tests/policy/baseline/gov/states/mn/dcyf/mfip/mn_mfip_dependent_care_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/mn/dcyf/mfip/mn_mfip_dependent_care_deduction.yaml index e312dd50198..1c270f12e59 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/mn/dcyf/mfip/mn_mfip_dependent_care_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/mn/dcyf/mfip/mn_mfip_dependent_care_deduction.yaml @@ -99,3 +99,26 @@ # Per Combined Manual 0018.09: care of a disabled adult in the unit, # at the $175/month age-2+ tier. Expenses = 1,200 / 12 = 100/month. mn_mfip_dependent_care_deduction: 100 + +- name: Case 5, adult care expenses without disability are not deducted. + period: 2025-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + is_tax_unit_dependent: false + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: MN + output: + # Person2 is neither a dependent nor a disabled adult, so the cap is + # $0: min(100, 0) = 0. + mn_mfip_dependent_care_deduction: 0 diff --git a/policyengine_us/tests/policy/baseline/gov/states/mo/dss/tanf/mo_tanf_child_care_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/mo/dss/tanf/mo_tanf_child_care_deduction.yaml index db72305ac21..b65d91fd30d 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/mo/dss/tanf/mo_tanf_child_care_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/mo/dss/tanf/mo_tanf_child_care_deduction.yaml @@ -208,3 +208,50 @@ # Per 13 CSR 40-2.120(6)(A)5: incapacitated individual care at the # $175/month age-2+ tier. Expenses = 1,200 / 12 = 100/month. mo_tanf_child_care_deduction: 100 + +- name: Incapacitated adult care expenses above the cap are limited to the age-2+ tier + period: 2024-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + is_incapable_of_self_care: true + care_expenses: 3_600 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: MO + output: + # Expenses = 3,600 / 12 = 300/month. The incapacitated adult's cap is + # the $175 age-2+ tier (not the $200 under-2 tier, and not the $0 + # over-18 bracket): min(300, 175) = 175. + mo_tanf_child_care_deduction: 175 + +- name: Adult care expenses without incapacity are not deducted + period: 2024-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + is_tax_unit_dependent: false + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: MO + output: + # Person2 is neither a dependent nor incapacitated, so the cap is $0: + # min(100, 0) = 0. + mo_tanf_child_care_deduction: 0 diff --git a/policyengine_us/tests/policy/baseline/gov/states/nh/dhhs/fanf/nh_fanf_child_care_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/nh/dhhs/fanf/nh_fanf_child_care_deduction.yaml index 206271cb0d4..34e54efe9f5 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/nh/dhhs/fanf/nh_fanf_child_care_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/nh/dhhs/fanf/nh_fanf_child_care_deduction.yaml @@ -281,3 +281,28 @@ # Per FAM 603.05: $175/month for each incapacitated parent (full-time # employment). Expenses = 1,200 / 12 = 100/month, below the cap. nh_fanf_child_care_deduction: 100 + +- name: Case 14, incapacitated non-parent adult does not count toward the deduction. + period: 2024-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + employment_income_before_lsr: 6_000 # $500/month, above $377 threshold + person2: + age: 70 + is_tax_unit_head_or_spouse: false + is_incapable_of_self_care: true + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: NH + output: + # FAM 603.05 covers only an incapacitated PARENT; an incapacitated + # non-parent adult adds nothing to the cap: min(100, 0) = 0. + nh_fanf_child_care_deduction: 0 diff --git a/policyengine_us/tests/policy/baseline/gov/states/ok/dhs/tanf/ok_tanf_dependent_care_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/ok/dhs/tanf/ok_tanf_dependent_care_deduction.yaml index c03a5668fc1..5d6cacf5482 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/ok/dhs/tanf/ok_tanf_dependent_care_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/ok/dhs/tanf/ok_tanf_dependent_care_deduction.yaml @@ -130,3 +130,26 @@ # Per OAC 340:10-3-33(b)(3)(B): $175/month for an incapacitated adult. # Expenses = 1,200 / 12 = 100/month, below the cap. ok_tanf_dependent_care_deduction: 100 + +- name: Adult care expenses without incapacity are not deducted + period: 2024-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + is_tax_unit_dependent: false + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: OK + output: + # Person2 is neither a dependent nor incapacitated, so the cap is $0: + # min(100, 0) = 0. + ok_tanf_dependent_care_deduction: 0 diff --git a/policyengine_us/tests/policy/baseline/gov/states/ri/dhs/works/ri_works_dependent_care_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/ri/dhs/works/ri_works_dependent_care_deduction.yaml index 508fbaae2b9..f23bcdb31ee 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/ri/dhs/works/ri_works_dependent_care_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/ri/dhs/works/ri_works_dependent_care_deduction.yaml @@ -235,3 +235,26 @@ # Per 218-RICR-20-00-2.15.5(B)(2)(b): $175/month per incapacitated # adult. Expenses = 1,200 / 12 = 100/month, below the cap. ri_works_dependent_care_deduction: 100 + +- name: Case 11, adult care expenses without incapacity are not deducted. + period: 2024-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + is_tax_unit_dependent: false + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: RI + output: + # Person2 is neither a dependent nor incapacitated, so the cap is $0: + # min(100, 0) = 0. + ri_works_dependent_care_deduction: 0 diff --git a/policyengine_us/tests/policy/baseline/gov/states/tx/tanf/income/deductions/tx_tanf_dependent_care_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/tx/tanf/income/deductions/tx_tanf_dependent_care_deduction.yaml index 9a05681d66d..957a2c3ae3c 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/tx/tanf/income/deductions/tx_tanf_dependent_care_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/tx/tanf/income/deductions/tx_tanf_dependent_care_deduction.yaml @@ -75,3 +75,26 @@ # Per 1 TAC 372.409(a)(3): $175/month for an incapacitated adult. # Expenses = 1,200 / 12 = 100/month, below the cap. tx_tanf_dependent_care_deduction: 100 + +- name: Case 5, adult care expenses without incapacity are not deducted. + period: 2025-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + is_tax_unit_dependent: false + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: TX + output: + # Person2 is neither a dependent nor incapacitated, so the cap is $0: + # min(100, 0) = 0. + tx_tanf_dependent_care_deduction: 0 diff --git a/policyengine_us/tests/policy/baseline/gov/states/va/dss/tanf/income/va_tanf_childcare_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/va/dss/tanf/income/va_tanf_childcare_deduction.yaml index 9cd9c322fe6..6e44d736c14 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/va/dss/tanf/income/va_tanf_childcare_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/va/dss/tanf/income/va_tanf_childcare_deduction.yaml @@ -22,18 +22,18 @@ # Deduction: min($3,000, $2,400) = $2,400 va_tanf_childcare_deduction: 2_400 -- name: Family with mother, disabled father, two children, expenses below max +- name: Family with mother, incapacitated father, two children, expenses below max period: 2023 input: people: person1: is_tax_unit_dependent: false - is_disabled: false + is_incapable_of_self_care: false age: 25 person2: is_tax_unit_dependent: false is_adult: true - is_disabled: true + is_incapable_of_self_care: true age: 25 person3: is_tax_unit_dependent: true @@ -50,7 +50,7 @@ members: [person1, person2, person3, person4] state_code: VA output: - # Max deduction: $200 (child under 2) + $175 (child 2+) + $175 (disabled adult) = $550/month = $6,600/year + # Max deduction: $200 (child under 2) + $175 (child 2+) + $175 (incapacitated adult) = $550/month = $6,600/year # Actual expenses: $4,800/year # Deduction: min($4,800, $6,600) = $4,800 va_tanf_childcare_deduction: 4_800 @@ -110,12 +110,12 @@ person1: is_tax_unit_dependent: false is_adult: true - is_disabled: false + is_incapable_of_self_care: false age: 30 person2: is_tax_unit_dependent: false is_adult: true - is_disabled: false + is_incapable_of_self_care: false age: 28 spm_units: spm_unit: @@ -126,7 +126,7 @@ members: [person1, person2] state_code: VA output: - # No dependents, no disabled adults + # No dependents, no incapacitated adults # Max deduction = $0/year # Deduction: min($3,000, $0) = $0 va_tanf_childcare_deduction: 0 @@ -185,7 +185,7 @@ # Deduction: min($5,000, $4,500) = $4,500 va_tanf_childcare_deduction: 4_500 -- name: Case 8, disabled adult care expenses count toward the deduction. +- name: Case 8, incapacitated adult care expenses count toward the deduction. period: 2023-01 absolute_error_margin: 0.01 input: @@ -194,7 +194,7 @@ age: 30 person2: age: 35 - is_disabled: true + is_incapable_of_self_care: true care_expenses: 1_200 spm_units: spm_unit: @@ -207,3 +207,26 @@ # Per VA TANF Manual 305.3 item 5: incapacitated adult care up to # $175/month (full-time). Expenses = 1,200 / 12 = 100/month. va_tanf_childcare_deduction: 100 + +- name: Case 9, adult care expenses without incapacity are not deducted. + period: 2023-01 + absolute_error_margin: 0.01 + input: + people: + person1: + age: 30 + person2: + age: 35 + is_tax_unit_dependent: false + care_expenses: 1_200 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: VA + output: + # Person2 is neither a dependent nor incapacitated, so the cap is $0: + # min(100, 0) = 0. + va_tanf_childcare_deduction: 0 diff --git a/policyengine_us/tests/policy/baseline/gov/states/va/dss/tanf/integration.yaml b/policyengine_us/tests/policy/baseline/gov/states/va/dss/tanf/integration.yaml index c03e3918078..fb12851ef99 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/va/dss/tanf/integration.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/va/dss/tanf/integration.yaml @@ -347,6 +347,9 @@ age: 40 employment_income_before_lsr: 0 is_disabled: true + # The childcare deduction's adult slot requires incapacity per + # Manual 305.3 item 5. + is_incapable_of_self_care: true person3: is_child: true age: 16 @@ -422,6 +425,9 @@ age: 50 employment_income_before_lsr: 0 is_disabled: true + # The childcare deduction's adult slot requires incapacity per + # Manual 305.3 item 5. + is_incapable_of_self_care: true person3: is_child: true age: 12 diff --git a/policyengine_us/tests/policy/baseline/gov/states/vt/dcf/reach_up/vt_reach_up_dependent_care_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/vt/dcf/reach_up/vt_reach_up_dependent_care_deduction.yaml index dfec8306909..a10c1d143a0 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/vt/dcf/reach_up/vt_reach_up_dependent_care_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/vt/dcf/reach_up/vt_reach_up_dependent_care_deduction.yaml @@ -121,6 +121,10 @@ age: 30 person2: age: 35 + # Describe the legal scenario (Rule 2252.2(a) covers a disabled or + # seriously ill adult); the formula pools care_expenses without a + # disability filter and caps per participant, symmetric with the + # childcare side. is_disabled: true is_incapable_of_self_care: true care_expenses: 1_200 diff --git a/policyengine_us/tests/policy/baseline/gov/states/wv/dhhr/works/income/earned/wv_works_countable_earned_income.yaml b/policyengine_us/tests/policy/baseline/gov/states/wv/dhhr/works/income/earned/wv_works_countable_earned_income.yaml index 4983ab13527..00596d271a2 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/wv/dhhr/works/income/earned/wv_works_countable_earned_income.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/wv/dhhr/works/income/earned/wv_works_countable_earned_income.yaml @@ -88,6 +88,9 @@ tanf_gross_earned_income: 1_000 person2: age: 35 + # Describes the legal scenario (IMM 4.5.2.A.2 covers incapacitated + # adult care); the formula pools care_expenses without an + # incapacity filter, symmetric with the childcare side. is_incapable_of_self_care: true care_expenses: 1_200 spm_units: diff --git a/policyengine_us/variables/gov/states/va/dss/tanf/income/va_tanf_childcare_deduction.py b/policyengine_us/variables/gov/states/va/dss/tanf/income/va_tanf_childcare_deduction.py index 5c2a57d17b3..b330155601b 100644 --- a/policyengine_us/variables/gov/states/va/dss/tanf/income/va_tanf_childcare_deduction.py +++ b/policyengine_us/variables/gov/states/va/dss/tanf/income/va_tanf_childcare_deduction.py @@ -17,10 +17,13 @@ def formula(spm_unit, period, parameters): person = spm_unit.members age = person("age", period.this_year) dependent = person("is_tax_unit_dependent", period) - disabled_adult = person("is_adult", period) & person( - "is_disabled", period.this_year + # The manual's operative condition is incapacity ("Incapacitated + # Adult/Child Care Disregard"), supported by a Medical Evaluation + # form or established by receipt of SSDI or SSI. + incapacitated_adult = person("is_adult", period) & person( + "is_incapable_of_self_care", period.this_year ) - care_recipient = dependent | disabled_adult + care_recipient = dependent | incapacitated_adult childcare_expenses = spm_unit("childcare_expenses", period) adult_care_expenses = add(spm_unit, period, ["care_expenses"]) max_deduction = spm_unit.sum(p.full_time.calc(age) * care_recipient)