From e5e8327c253a793451a24bd8f1556ce7f2826b05 Mon Sep 17 00:00:00 2001 From: Max Ghenis Date: Sat, 10 Oct 2026 06:53:54 -0400 Subject: [PATCH 1/5] Apply District of Columbia, Georgia and Idaho rules for a filer who can be claimed as a dependent A return on which the filer, or on a joint return either spouse, can be claimed as a dependent has no dependents (IRC 152(b)(1)), and a childless filer who can be claimed gets no EITC (IRC 32(c)(1)(A)(ii)(III)). - DC: the Schedule H property tax credit needs a claimant who was not a dependent or is 65 or older (D.C. Code 47-1806.06(k)); one claimant per tax filing unit, so the other spouse can claim it. The childless EITC keeps the IRC 32 bar; the keep child care affordable credit and the child tax credit count no child on such a return. - Georgia: no dependent exemption on such a return (the 2021-2023 personal exemption stays); no low income credit when either filer can be claimed (O.C.G.A. 48-7A-3); the HB 162 surplus refund excludes a filer claimed for 2021 unless that filer had earned income (48-7-20.2(a)). The 2026 child credit keeps its IRC 24(c) child test. - Idaho: the food tax credit leaves out a filer who can be claimed and, on such a return, the dependents (63-3024A); the household and dependent care deduction needs an IRC 21(b)(1) qualifying individual (63-3022D); the 2022 rebate counts each taxpayer but no dependents on such a return. Co-Authored-By: Claude Opus 5.5 --- changelog.d/claimable-filer-dc-ga-id.fixed.md | 1 + .../ptc/dependent_claimant_min_age.yaml | 10 + .../tax/income/ctc/dc_ctc_eligible_child.yaml | 137 +++++++++ .../gov/states/dc/tax/income/dc_cdcc.yaml | 143 +++++++++ .../gov/states/dc/tax/income/dc_eitc.yaml | 154 ++++++++++ .../gov/states/dc/tax/income/dc_kccatc.yaml | 144 ++++++++++ .../gov/states/dc/tax/income/dc_ptc.yaml | 160 +++++++++++ .../dependent_care_credit/ga_cdcc.yaml | 142 +++++++++ .../states/ga/tax/income/credits/ga_ctc.yaml | 138 +++++++++ .../income/credits/ga_low_income_credit.yaml | 129 +++++++++ .../income/credits/ga_surplus_tax_rebate.yaml | 264 +++++++++++++++++ .../tax/income/exemptions/ga_exemptions.yaml | 272 ++++++++++++++++++ .../credits/grocery/id_grocery_credit.yaml | 139 +++++++++ .../id/tax/income/credits/id_2022_rebate.yaml | 128 +++++++++ .../states/id/tax/income/credits/id_ctc.yaml | 137 +++++++++ ..._and_dependent_care_expense_deduction.yaml | 176 ++++++++++++ .../credits/ctc/dc_ctc_eligible_child.py | 14 +- .../states/dc/tax/income/credits/dc_kccatc.py | 10 +- .../states/dc/tax/income/credits/dc_ptc.py | 18 +- .../eitc/dc_eitc_without_qualifying_child.py | 10 + .../credits/ga_low_income_credit_potential.py | 16 +- .../income/credits/ga_surplus_tax_rebate.py | 17 +- .../ga/tax/income/exemptions/ga_exemptions.py | 16 +- .../2022_rebate/id_2022_rebate_floor.py | 17 +- .../credits/grocery/id_grocery_credit.py | 22 +- ...ld_and_dependent_care_expense_deduction.py | 13 +- 26 files changed, 2408 insertions(+), 19 deletions(-) create mode 100644 changelog.d/claimable-filer-dc-ga-id.fixed.md create mode 100644 policyengine_us/parameters/gov/states/dc/tax/income/credits/ptc/dependent_claimant_min_age.yaml diff --git a/changelog.d/claimable-filer-dc-ga-id.fixed.md b/changelog.d/claimable-filer-dc-ga-id.fixed.md new file mode 100644 index 00000000000..e9c9f1dde85 --- /dev/null +++ b/changelog.d/claimable-filer-dc-ga-id.fixed.md @@ -0,0 +1 @@ +Apply District of Columbia, Georgia and Idaho rules for a filer who can be claimed as a dependent: DC's property tax credit claimant, childless EITC, child care and child tax credit children; Georgia's dependent exemption, low income credit and 2023 surplus refund; Idaho's food tax credit, household and dependent care deduction and 2022 rebate. diff --git a/policyengine_us/parameters/gov/states/dc/tax/income/credits/ptc/dependent_claimant_min_age.yaml b/policyengine_us/parameters/gov/states/dc/tax/income/credits/ptc/dependent_claimant_min_age.yaml new file mode 100644 index 00000000000..e9838a442fe --- /dev/null +++ b/policyengine_us/parameters/gov/states/dc/tax/income/credits/ptc/dependent_claimant_min_age.yaml @@ -0,0 +1,10 @@ +description: The District of Columbia allows a person who was a dependent under an income tax law to claim the property tax credit only at or above this age. +values: + 2021-01-01: 65 +metadata: + unit: year + label: DC property tax credit minimum age for a dependent claimant + period: year + reference: + - title: Code of the District of Columbia § 47–1806.06 (k) + href: https://code.dccouncil.gov/us/dc/council/code/sections/47-1806.06 diff --git a/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/ctc/dc_ctc_eligible_child.yaml b/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/ctc/dc_ctc_eligible_child.yaml index a6538e05a6a..88eb59e804f 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/ctc/dc_ctc_eligible_child.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/ctc/dc_ctc_eligible_child.yaml @@ -33,3 +33,140 @@ state_code: DC output: dc_ctc_eligible_child: false + + +- name: 2026 single filer who can be claimed as a dependent, no DC child tax credit child + period: 2026 + input: + people: + filer: + age: 30 + employment_income: 10_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + child: + age: 3 + tax_units: + tax_unit: + members: [filer, child] + households: + household: + members: [filer, child] + state_code: DC + output: + # 47-1806.17(a): a child for whom the taxpayer is allowed a + # deduction under IRC 151; IRC 152(b)(1). + dc_ctc_eligible_child: [false, false] + +- name: 2026 joint return with one spouse who can be claimed as a dependent, no DC child tax credit child (the claimable spouse is the head) + period: 2026 + input: + people: + person_a: + age: 30 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 30 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + child: + age: 3 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + households: + household: + members: [person_a, person_b, child] + state_code: DC + output: + dc_ctc_eligible_child: [false, false, false] + +- name: 2026 joint return with one spouse who can be claimed as a dependent, no DC child tax credit child (the claimable spouse is the spouse) + period: 2026 + input: + people: + person_b: + age: 30 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_a: + age: 30 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + child: + age: 3 + tax_units: + tax_unit: + members: [person_b, person_a, child] + filing_status: JOINT + households: + household: + members: [person_b, person_a, child] + state_code: DC + output: + dc_ctc_eligible_child: [false, false, false] + +- name: 2026 joint return with both spouses claimable as dependents, no DC child tax credit child + period: 2026 + input: + people: + person_a: + age: 30 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 30 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + child: + age: 3 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + households: + household: + members: [person_a, person_b, child] + state_code: DC + output: + dc_ctc_eligible_child: [false, false, false] + +- name: 2026 joint return with neither spouse claimable, no DC child tax credit child + period: 2026 + input: + people: + person_a: + age: 30 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_b: + age: 30 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + child: + age: 3 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + households: + household: + members: [person_a, person_b, child] + state_code: DC + output: + dc_ctc_eligible_child: [false, false, true] diff --git a/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/dc_cdcc.yaml b/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/dc_cdcc.yaml index 79aba76a8b3..6003df9c048 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/dc_cdcc.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/dc_cdcc.yaml @@ -43,3 +43,146 @@ output: dc_cdcc_potential: 320 dc_cdcc: 200 + + +- name: 2025 single filer who can be claimed as a dependent, no DC child care credit for a child under 13 + period: 2025 + input: + people: + filer: + age: 30 + employment_income: 50_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + child: + age: 2 + tax_units: + tax_unit: + members: [filer, child] + tax_unit_childcare_expenses: 1_000 + households: + household: + members: [filer, child] + state_code: DC + output: + # Already zero through the federal child care credit, which no + # longer counts a child under 13 on such a return. + dc_cdcc_potential: 0 + +- name: 2025 joint return with one spouse who can be claimed as a dependent, no DC child care credit for a child under 13 (the claimable spouse is the head) + period: 2025 + input: + people: + person_a: + age: 30 + employment_income: 25_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 30 + employment_income: 25_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + child: + age: 2 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + tax_unit_childcare_expenses: 1_000 + households: + household: + members: [person_a, person_b, child] + state_code: DC + output: + dc_cdcc_potential: 0 + +- name: 2025 joint return with one spouse who can be claimed as a dependent, no DC child care credit for a child under 13 (the claimable spouse is the spouse) + period: 2025 + input: + people: + person_b: + age: 30 + employment_income: 25_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_a: + age: 30 + employment_income: 25_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + child: + age: 2 + tax_units: + tax_unit: + members: [person_b, person_a, child] + filing_status: JOINT + tax_unit_childcare_expenses: 1_000 + households: + household: + members: [person_b, person_a, child] + state_code: DC + output: + dc_cdcc_potential: 0 + +- name: 2025 joint return with both spouses claimable as dependents, no DC child care credit for a child under 13 + period: 2025 + input: + people: + person_a: + age: 30 + employment_income: 25_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 30 + employment_income: 25_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + child: + age: 2 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + tax_unit_childcare_expenses: 1_000 + households: + household: + members: [person_a, person_b, child] + state_code: DC + output: + dc_cdcc_potential: 0 + +- name: 2025 joint return with neither spouse claimable, no DC child care credit for a child under 13 + period: 2025 + input: + people: + person_a: + age: 30 + employment_income: 25_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_b: + age: 30 + employment_income: 25_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + child: + age: 2 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + tax_unit_childcare_expenses: 1_000 + households: + household: + members: [person_a, person_b, child] + state_code: DC + output: + # Federal 20% x 1,000 = 200; DC 32% match = 64. + dc_cdcc_potential: 64 diff --git a/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/dc_eitc.yaml b/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/dc_eitc.yaml index f440ab68ecf..4466b4a7ad3 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/dc_eitc.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/dc_eitc.yaml @@ -809,3 +809,157 @@ dc_eitc_with_qualifying_child: 0 dc_eitc_without_qualifying_child: 600 dc_eitc: 600 + + +- name: 2025 single filer who can be claimed as a dependent, no DC EITC without a qualifying child + period: 2025 + absolute_error_margin: 0.01 + input: + people: + filer: + age: 30 + employment_income: 1_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + tax_units: + tax_unit: + members: [filer] + spm_units: + spm_unit: + members: [filer] + households: + household: + members: [filer] + state_code: DC + output: + # 47-1806.04(f) keeps the IRC 32(c)(1)(A)(ii)(III) bar on a + # childless filer who can be claimed; on a joint return either + # spouse (Publication 596). + dc_eitc_without_qualifying_child: 0 + dc_eitc: 0 + +- name: 2025 joint return with one spouse who can be claimed as a dependent, no DC EITC without a qualifying child (the claimable spouse is the head) + period: 2025 + absolute_error_margin: 0.01 + input: + people: + person_a: + age: 30 + employment_income: 500 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 30 + employment_income: 500 + is_tax_unit_head: false + is_tax_unit_spouse: true + tax_units: + tax_unit: + members: [person_a, person_b] + filing_status: JOINT + spm_units: + spm_unit: + members: [person_a, person_b] + households: + household: + members: [person_a, person_b] + state_code: DC + output: + dc_eitc_without_qualifying_child: 0 + dc_eitc: 0 + +- name: 2025 joint return with one spouse who can be claimed as a dependent, no DC EITC without a qualifying child (the claimable spouse is the spouse) + period: 2025 + absolute_error_margin: 0.01 + input: + people: + person_b: + age: 30 + employment_income: 500 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_a: + age: 30 + employment_income: 500 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + tax_units: + tax_unit: + members: [person_b, person_a] + filing_status: JOINT + spm_units: + spm_unit: + members: [person_b, person_a] + households: + household: + members: [person_b, person_a] + state_code: DC + output: + dc_eitc_without_qualifying_child: 0 + dc_eitc: 0 + +- name: 2025 joint return with both spouses claimable as dependents, no DC EITC without a qualifying child + period: 2025 + absolute_error_margin: 0.01 + input: + people: + person_a: + age: 30 + employment_income: 500 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 30 + employment_income: 500 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + tax_units: + tax_unit: + members: [person_a, person_b] + filing_status: JOINT + spm_units: + spm_unit: + members: [person_a, person_b] + households: + household: + members: [person_a, person_b] + state_code: DC + output: + dc_eitc_without_qualifying_child: 0 + dc_eitc: 0 + +- name: 2025 joint return with neither spouse claimable, no DC EITC without a qualifying child + period: 2025 + absolute_error_margin: 0.01 + input: + people: + person_a: + age: 30 + employment_income: 500 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_b: + age: 30 + employment_income: 500 + is_tax_unit_head: false + is_tax_unit_spouse: true + tax_units: + tax_unit: + members: [person_a, person_b] + filing_status: JOINT + spm_units: + spm_unit: + members: [person_a, person_b] + households: + household: + members: [person_a, person_b] + state_code: DC + output: + # 0.0765 x 1,000 = 76.50 + dc_eitc_without_qualifying_child: 76.5 + dc_eitc: 76.5 diff --git a/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/dc_kccatc.yaml b/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/dc_kccatc.yaml index 486339bc3bf..0bada9624cf 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/dc_kccatc.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/dc_kccatc.yaml @@ -183,3 +183,147 @@ state_code: DC output: dc_kccatc: 800 + + +- name: 2025 single filer who can be claimed as a dependent, no keep child care affordable credit + period: 2025 + input: + people: + filer: + age: 30 + employment_income: 10_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + child: + age: 2 + tax_units: + tax_unit: + members: [filer, child] + tax_unit_childcare_expenses: 2_000 + households: + household: + members: [filer, child] + state_code: DC + output: + # 47-1806.15(d)(1): the child must be claimed as a dependent on + # the federal and District returns; a return with a claimable + # filer has no dependents. + dc_kccatc: 0 + +- name: 2025 joint return with one spouse who can be claimed as a dependent, no keep child care affordable credit (the claimable spouse is the head) + period: 2025 + input: + people: + person_a: + age: 30 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 30 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + child: + age: 2 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + tax_unit_childcare_expenses: 2_000 + households: + household: + members: [person_a, person_b, child] + state_code: DC + output: + dc_kccatc: 0 + +- name: 2025 joint return with one spouse who can be claimed as a dependent, no keep child care affordable credit (the claimable spouse is the spouse) + period: 2025 + input: + people: + person_b: + age: 30 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_a: + age: 30 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + child: + age: 2 + tax_units: + tax_unit: + members: [person_b, person_a, child] + filing_status: JOINT + tax_unit_childcare_expenses: 2_000 + households: + household: + members: [person_b, person_a, child] + state_code: DC + output: + dc_kccatc: 0 + +- name: 2025 joint return with both spouses claimable as dependents, no keep child care affordable credit + period: 2025 + input: + people: + person_a: + age: 30 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 30 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + child: + age: 2 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + tax_unit_childcare_expenses: 2_000 + households: + household: + members: [person_a, person_b, child] + state_code: DC + output: + dc_kccatc: 0 + +- name: 2025 joint return with neither spouse claimable, no keep child care affordable credit + period: 2025 + input: + people: + person_a: + age: 30 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_b: + age: 30 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + child: + age: 2 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + tax_unit_childcare_expenses: 2_000 + households: + household: + members: [person_a, person_b, child] + state_code: DC + output: + # min(2,000, 1,200) + dc_kccatc: 1_200 diff --git a/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/dc_ptc.yaml b/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/dc_ptc.yaml index 0738982c778..561f8262280 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/dc_ptc.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/dc_ptc.yaml @@ -290,3 +290,163 @@ state_code: MN output: dc_ptc: 0 + + +- name: 2025 single filer who can be claimed as a dependent, property tax credit only through a claimant who is not a dependent + period: 2025 + input: + people: + filer: + age: 30 + employment_income: 10_000 + rent: 10_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + tax_units: + tax_unit: + members: [filer] + households: + household: + members: [filer] + state_code: DC + output: + # D.C. Code 47-1806.06(k) bars a claimant who was a dependent, + # unless 65 or older; one claimant per tax filing unit, so the + # spouse who is not a dependent claims it. + # min(0.20 x 10,000 - 3% x 10,000, 1,425) = 1,425 + dc_ptc: 0 + +- name: 2025 joint return with one spouse who can be claimed as a dependent, property tax credit only through a claimant who is not a dependent (the claimable spouse is the head) + period: 2025 + input: + people: + person_a: + age: 30 + employment_income: 5_000 + rent: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 30 + employment_income: 5_000 + rent: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + tax_units: + tax_unit: + members: [person_a, person_b] + filing_status: JOINT + households: + household: + members: [person_a, person_b] + state_code: DC + output: + dc_ptc: 1_425 + +- name: 2025 joint return with one spouse who can be claimed as a dependent, property tax credit only through a claimant who is not a dependent (the claimable spouse is the spouse) + period: 2025 + input: + people: + person_b: + age: 30 + employment_income: 5_000 + rent: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_a: + age: 30 + employment_income: 5_000 + rent: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + tax_units: + tax_unit: + members: [person_b, person_a] + filing_status: JOINT + households: + household: + members: [person_b, person_a] + state_code: DC + output: + dc_ptc: 1_425 + +- name: 2025 joint return with both spouses claimable as dependents, property tax credit only through a claimant who is not a dependent + period: 2025 + input: + people: + person_a: + age: 30 + employment_income: 5_000 + rent: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 30 + employment_income: 5_000 + rent: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + tax_units: + tax_unit: + members: [person_a, person_b] + filing_status: JOINT + households: + household: + members: [person_a, person_b] + state_code: DC + output: + dc_ptc: 0 + +- name: 2025 joint return with neither spouse claimable, property tax credit only through a claimant who is not a dependent + period: 2025 + input: + people: + person_a: + age: 30 + employment_income: 5_000 + rent: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_b: + age: 30 + employment_income: 5_000 + rent: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + tax_units: + tax_unit: + members: [person_a, person_b] + filing_status: JOINT + households: + household: + members: [person_a, person_b] + state_code: DC + output: + dc_ptc: 1_425 + +- name: 2025 single filer aged 65 who can be claimed as a dependent claims the property tax credit + period: 2025 + input: + people: + filer: + age: 65 + employment_income: 10_000 + rent: 10_000 + is_tax_unit_head: true + claimed_as_dependent_on_another_return: true + tax_units: + tax_unit: + members: [filer] + households: + household: + members: [filer] + state_code: DC + output: + # The dependent bar does not apply at 65 or older; the + # elderly fractions start at 70. + dc_ptc: 1_425 diff --git a/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/dependent_care_credit/ga_cdcc.yaml b/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/dependent_care_credit/ga_cdcc.yaml index ad118dc03da..32eefa19b4e 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/dependent_care_credit/ga_cdcc.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/dependent_care_credit/ga_cdcc.yaml @@ -22,3 +22,145 @@ ga_income_tax_before_non_refundable_credits: 1000000 output: ga_cdcc: 0 + + +- name: 2025 single filer who can be claimed as a dependent, no Georgia child care credit for a child under 13 + period: 2025 + input: + people: + filer: + age: 30 + employment_income: 50_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + child: + age: 2 + tax_units: + tax_unit: + members: [filer, child] + tax_unit_childcare_expenses: 1_000 + households: + household: + members: [filer, child] + state_code: GA + output: + # Already zero through the federal credit claimed and allowed. + ga_cdcc_potential: 0 + +- name: 2025 joint return with one spouse who can be claimed as a dependent, no Georgia child care credit for a child under 13 (the claimable spouse is the head) + period: 2025 + input: + people: + person_a: + age: 30 + employment_income: 25_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 30 + employment_income: 25_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + child: + age: 2 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + tax_unit_childcare_expenses: 1_000 + households: + household: + members: [person_a, person_b, child] + state_code: GA + output: + ga_cdcc_potential: 0 + +- name: 2025 joint return with one spouse who can be claimed as a dependent, no Georgia child care credit for a child under 13 (the claimable spouse is the spouse) + period: 2025 + input: + people: + person_b: + age: 30 + employment_income: 25_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_a: + age: 30 + employment_income: 25_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + child: + age: 2 + tax_units: + tax_unit: + members: [person_b, person_a, child] + filing_status: JOINT + tax_unit_childcare_expenses: 1_000 + households: + household: + members: [person_b, person_a, child] + state_code: GA + output: + ga_cdcc_potential: 0 + +- name: 2025 joint return with both spouses claimable as dependents, no Georgia child care credit for a child under 13 + period: 2025 + input: + people: + person_a: + age: 30 + employment_income: 25_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 30 + employment_income: 25_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + child: + age: 2 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + tax_unit_childcare_expenses: 1_000 + households: + household: + members: [person_a, person_b, child] + state_code: GA + output: + ga_cdcc_potential: 0 + +- name: 2025 joint return with neither spouse claimable, no Georgia child care credit for a child under 13 + period: 2025 + input: + people: + person_a: + age: 30 + employment_income: 25_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_b: + age: 30 + employment_income: 25_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + child: + age: 2 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + tax_unit_childcare_expenses: 1_000 + households: + household: + members: [person_a, person_b, child] + state_code: GA + output: + # Federal 20% x 1,000 = 200; Georgia 50% match = 100. + ga_cdcc_potential: 100 diff --git a/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/ga_ctc.yaml b/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/ga_ctc.yaml index 0690ba455ca..c4339b5ba21 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/ga_ctc.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/ga_ctc.yaml @@ -141,3 +141,141 @@ # Georgia uses the IRC 24(c) qualifying-child definition only; whether IRC # 152(b)(1) reaches it is not settled, so the child test is kept. ga_ctc: 250 + + +- name: 2026 single filer who can be claimed as a dependent, Georgia child tax credit kept for an IRC 24(c) qualifying child + period: 2026 + input: + people: + filer: + age: 25 + employment_income: 10_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + child: + age: 3 + tax_units: + tax_unit: + members: [filer, child] + households: + household: + members: [filer, child] + state_code: GA + output: + # O.C.G.A. 48-7-29.27 uses the IRC 24(c) qualifying child only, + # with its own one-claimant rule; it does not require the child + # to be the taxpayer's dependent. + ga_ctc_potential: 250 + +- name: 2026 joint return with one spouse who can be claimed as a dependent, Georgia child tax credit kept for an IRC 24(c) qualifying child (the claimable spouse is the head) + period: 2026 + input: + people: + person_a: + age: 25 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 25 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + child: + age: 3 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + households: + household: + members: [person_a, person_b, child] + state_code: GA + output: + ga_ctc_potential: 250 + +- name: 2026 joint return with one spouse who can be claimed as a dependent, Georgia child tax credit kept for an IRC 24(c) qualifying child (the claimable spouse is the spouse) + period: 2026 + input: + people: + person_b: + age: 25 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_a: + age: 25 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + child: + age: 3 + tax_units: + tax_unit: + members: [person_b, person_a, child] + filing_status: JOINT + households: + household: + members: [person_b, person_a, child] + state_code: GA + output: + ga_ctc_potential: 250 + +- name: 2026 joint return with both spouses claimable as dependents, Georgia child tax credit kept for an IRC 24(c) qualifying child + period: 2026 + input: + people: + person_a: + age: 25 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 25 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + child: + age: 3 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + households: + household: + members: [person_a, person_b, child] + state_code: GA + output: + ga_ctc_potential: 250 + +- name: 2026 joint return with neither spouse claimable, Georgia child tax credit kept for an IRC 24(c) qualifying child + period: 2026 + input: + people: + person_a: + age: 25 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_b: + age: 25 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + child: + age: 3 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + households: + household: + members: [person_a, person_b, child] + state_code: GA + output: + ga_ctc_potential: 250 diff --git a/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/ga_low_income_credit.yaml b/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/ga_low_income_credit.yaml index 2a410aa94df..ae9163798f8 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/ga_low_income_credit.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/ga_low_income_credit.yaml @@ -86,3 +86,132 @@ ga_income_tax_before_non_refundable_credits: 1000000 output: ga_low_income_credit: 16 + + +- name: 2025 single filer who can be claimed as a dependent, no low income credit + period: 2025 + input: + people: + filer: + age: 30 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + tax_units: + tax_unit: + members: [filer] + households: + household: + members: [filer] + state_code: GA + output: + # O.C.G.A. 48-7A-3 and IT-511 Line 17: only a taxpayer who is not + # claimed or eligible to be claimed as a dependent; the joint + # return is barred when either spouse can be claimed. + ga_low_income_credit_potential: 0 + +- name: 2025 joint return with one spouse who can be claimed as a dependent, no low income credit (the claimable spouse is the head) + period: 2025 + input: + people: + person_a: + age: 30 + employment_income: 2_500 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 30 + employment_income: 2_500 + is_tax_unit_head: false + is_tax_unit_spouse: true + tax_units: + tax_unit: + members: [person_a, person_b] + filing_status: JOINT + households: + household: + members: [person_a, person_b] + state_code: GA + output: + ga_low_income_credit_potential: 0 + +- name: 2025 joint return with one spouse who can be claimed as a dependent, no low income credit (the claimable spouse is the spouse) + period: 2025 + input: + people: + person_b: + age: 30 + employment_income: 2_500 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_a: + age: 30 + employment_income: 2_500 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + tax_units: + tax_unit: + members: [person_b, person_a] + filing_status: JOINT + households: + household: + members: [person_b, person_a] + state_code: GA + output: + ga_low_income_credit_potential: 0 + +- name: 2025 joint return with both spouses claimable as dependents, no low income credit + period: 2025 + input: + people: + person_a: + age: 30 + employment_income: 2_500 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 30 + employment_income: 2_500 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + tax_units: + tax_unit: + members: [person_a, person_b] + filing_status: JOINT + households: + household: + members: [person_a, person_b] + state_code: GA + output: + ga_low_income_credit_potential: 0 + +- name: 2025 joint return with neither spouse claimable, no low income credit + period: 2025 + input: + people: + person_a: + age: 30 + employment_income: 2_500 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_b: + age: 30 + employment_income: 2_500 + is_tax_unit_head: false + is_tax_unit_spouse: true + tax_units: + tax_unit: + members: [person_a, person_b] + filing_status: JOINT + households: + household: + members: [person_a, person_b] + state_code: GA + output: + # 2 exemptions x 26 at federal AGI 5,000 + ga_low_income_credit_potential: 52 diff --git a/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/ga_surplus_tax_rebate.yaml b/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/ga_surplus_tax_rebate.yaml index f276f210152..62144458c04 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/ga_surplus_tax_rebate.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/ga_surplus_tax_rebate.yaml @@ -123,3 +123,267 @@ ga_surplus_tax_rebate: 200 ga_refundable_credits: 200 ga_income_tax: 0 + + +- name: 2021 single filer who can be claimed as a dependent, no surplus tax rebate when the claimed filer had no earned income + period: 2021 + input: + people: + filer: + age: 30 + taxable_interest_income: 1_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + tax_units: + tax_unit: + members: [filer] + ga_income_tax_before_non_refundable_credits: 600 + households: + household: + members: [filer] + state_code: GA + output: + # O.C.G.A. 48-7-20.2(a)(1)(B): an individual claimed as a + # dependent for 2021 is excluded unless that individual had + # earned income ((a)(2)); a joint return needs both spouses. + ga_surplus_tax_rebate: 0 + +- name: 2021 joint return with one spouse who can be claimed as a dependent, no surplus tax rebate when the claimed filer had no earned income (the claimable spouse is the head) + period: 2021 + input: + people: + person_a: + age: 30 + taxable_interest_income: 1_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 30 + employment_income: 10_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + tax_units: + tax_unit: + members: [person_a, person_b] + filing_status: JOINT + ga_income_tax_before_non_refundable_credits: 600 + households: + household: + members: [person_a, person_b] + state_code: GA + output: + ga_surplus_tax_rebate: 0 + +- name: 2021 joint return with one spouse who can be claimed as a dependent, no surplus tax rebate when the claimed filer had no earned income (the claimable spouse is the spouse) + period: 2021 + input: + people: + person_b: + age: 30 + employment_income: 10_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_a: + age: 30 + taxable_interest_income: 1_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + tax_units: + tax_unit: + members: [person_b, person_a] + filing_status: JOINT + ga_income_tax_before_non_refundable_credits: 600 + households: + household: + members: [person_b, person_a] + state_code: GA + output: + ga_surplus_tax_rebate: 0 + +- name: 2021 joint return with both spouses claimable as dependents, no surplus tax rebate when the claimed filer had no earned income + period: 2021 + input: + people: + person_a: + age: 30 + taxable_interest_income: 1_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 30 + employment_income: 10_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + tax_units: + tax_unit: + members: [person_a, person_b] + filing_status: JOINT + ga_income_tax_before_non_refundable_credits: 600 + households: + household: + members: [person_a, person_b] + state_code: GA + output: + ga_surplus_tax_rebate: 0 + +- name: 2021 joint return with neither spouse claimable, no surplus tax rebate when the claimed filer had no earned income + period: 2021 + input: + people: + person_a: + age: 30 + taxable_interest_income: 1_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_b: + age: 30 + employment_income: 10_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + tax_units: + tax_unit: + members: [person_a, person_b] + filing_status: JOINT + ga_income_tax_before_non_refundable_credits: 600 + households: + household: + members: [person_a, person_b] + state_code: GA + output: + # min(500, 600) + ga_surplus_tax_rebate: 500 + +- name: 2021 single filer who can be claimed as a dependent, surplus tax rebate kept when the claimed filer had earned income + period: 2021 + input: + people: + filer: + age: 30 + employment_income: 1_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + tax_units: + tax_unit: + members: [filer] + ga_income_tax_before_non_refundable_credits: 600 + households: + household: + members: [filer] + state_code: GA + output: + # (a)(2) restores an individual with 2021 earned income. + ga_surplus_tax_rebate: 250 + +- name: 2021 joint return with one spouse who can be claimed as a dependent, surplus tax rebate kept when the claimed filer had earned income (the claimable spouse is the head) + period: 2021 + input: + people: + person_a: + age: 30 + employment_income: 1_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 30 + employment_income: 1_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + tax_units: + tax_unit: + members: [person_a, person_b] + filing_status: JOINT + ga_income_tax_before_non_refundable_credits: 600 + households: + household: + members: [person_a, person_b] + state_code: GA + output: + ga_surplus_tax_rebate: 500 + +- name: 2021 joint return with one spouse who can be claimed as a dependent, surplus tax rebate kept when the claimed filer had earned income (the claimable spouse is the spouse) + period: 2021 + input: + people: + person_b: + age: 30 + employment_income: 1_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_a: + age: 30 + employment_income: 1_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + tax_units: + tax_unit: + members: [person_b, person_a] + filing_status: JOINT + ga_income_tax_before_non_refundable_credits: 600 + households: + household: + members: [person_b, person_a] + state_code: GA + output: + ga_surplus_tax_rebate: 500 + +- name: 2021 joint return with both spouses claimable as dependents, surplus tax rebate kept when the claimed filer had earned income + period: 2021 + input: + people: + person_a: + age: 30 + employment_income: 1_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 30 + employment_income: 1_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + tax_units: + tax_unit: + members: [person_a, person_b] + filing_status: JOINT + ga_income_tax_before_non_refundable_credits: 600 + households: + household: + members: [person_a, person_b] + state_code: GA + output: + ga_surplus_tax_rebate: 500 + +- name: 2021 joint return with neither spouse claimable, surplus tax rebate kept when the claimed filer had earned income + period: 2021 + input: + people: + person_a: + age: 30 + employment_income: 1_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_b: + age: 30 + employment_income: 1_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + tax_units: + tax_unit: + members: [person_a, person_b] + filing_status: JOINT + ga_income_tax_before_non_refundable_credits: 600 + households: + household: + members: [person_a, person_b] + state_code: GA + output: + ga_surplus_tax_rebate: 500 diff --git a/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/exemptions/ga_exemptions.yaml b/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/exemptions/ga_exemptions.yaml index 61cf87aaaec..a0c1513ecd7 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/exemptions/ga_exemptions.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/exemptions/ga_exemptions.yaml @@ -60,3 +60,275 @@ state_code: GA output: ga_exemptions: 4_000 + + +- name: 2025 single filer who can be claimed as a dependent, no dependent exemption + period: 2025 + input: + people: + filer: + age: 30 + employment_income: 10_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + child: + age: 5 + tax_units: + tax_unit: + members: [filer, child] + households: + household: + members: [filer, child] + state_code: GA + output: + # Georgia follows the federal rules for qualified dependents; + # a return with a claimable filer has none (IRC 152(b)(1)). + ga_exemptions: 0 + +- name: 2025 joint return with one spouse who can be claimed as a dependent, no dependent exemption (the claimable spouse is the head) + period: 2025 + input: + people: + person_a: + age: 30 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 30 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + child: + age: 5 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + households: + household: + members: [person_a, person_b, child] + state_code: GA + output: + ga_exemptions: 0 + +- name: 2025 joint return with one spouse who can be claimed as a dependent, no dependent exemption (the claimable spouse is the spouse) + period: 2025 + input: + people: + person_b: + age: 30 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_a: + age: 30 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + child: + age: 5 + tax_units: + tax_unit: + members: [person_b, person_a, child] + filing_status: JOINT + households: + household: + members: [person_b, person_a, child] + state_code: GA + output: + ga_exemptions: 0 + +- name: 2025 joint return with both spouses claimable as dependents, no dependent exemption + period: 2025 + input: + people: + person_a: + age: 30 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 30 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + child: + age: 5 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + households: + household: + members: [person_a, person_b, child] + state_code: GA + output: + ga_exemptions: 0 + +- name: 2025 joint return with neither spouse claimable, no dependent exemption + period: 2025 + input: + people: + person_a: + age: 30 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_b: + age: 30 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + child: + age: 5 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + households: + household: + members: [person_a, person_b, child] + state_code: GA + output: + ga_exemptions: 4_000 + +- name: 2023 single filer who can be claimed as a dependent, the personal exemption stays but no dependent exemption + period: 2023 + input: + people: + filer: + age: 30 + employment_income: 10_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + child: + age: 5 + tax_units: + tax_unit: + members: [filer, child] + households: + household: + members: [filer, child] + state_code: GA + output: + ga_exemptions: 2_700 + +- name: 2023 joint return with one spouse who can be claimed as a dependent, the personal exemption stays but no dependent exemption (the claimable spouse is the head) + period: 2023 + input: + people: + person_a: + age: 30 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 30 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + child: + age: 5 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + households: + household: + members: [person_a, person_b, child] + state_code: GA + output: + ga_exemptions: 7_400 + +- name: 2023 joint return with one spouse who can be claimed as a dependent, the personal exemption stays but no dependent exemption (the claimable spouse is the spouse) + period: 2023 + input: + people: + person_b: + age: 30 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_a: + age: 30 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + child: + age: 5 + tax_units: + tax_unit: + members: [person_b, person_a, child] + filing_status: JOINT + households: + household: + members: [person_b, person_a, child] + state_code: GA + output: + ga_exemptions: 7_400 + +- name: 2023 joint return with both spouses claimable as dependents, the personal exemption stays but no dependent exemption + period: 2023 + input: + people: + person_a: + age: 30 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 30 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + child: + age: 5 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + households: + household: + members: [person_a, person_b, child] + state_code: GA + output: + ga_exemptions: 7_400 + +- name: 2023 joint return with neither spouse claimable, the personal exemption stays but no dependent exemption + period: 2023 + input: + people: + person_a: + age: 30 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_b: + age: 30 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + child: + age: 5 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + households: + household: + members: [person_a, person_b, child] + state_code: GA + output: + # 7,400 joint personal exemption + 3,000 for the child + ga_exemptions: 10_400 diff --git a/policyengine_us/tests/policy/baseline/gov/states/id/tax/income/credits/grocery/id_grocery_credit.yaml b/policyengine_us/tests/policy/baseline/gov/states/id/tax/income/credits/grocery/id_grocery_credit.yaml index e2f37dd5a10..177e1dfc472 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/id/tax/income/credits/grocery/id_grocery_credit.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/id/tax/income/credits/grocery/id_grocery_credit.yaml @@ -94,3 +94,142 @@ snap: 0 output: id_grocery_credit: 310 + + +- name: 2025 single filer who can be claimed as a dependent, food tax credit only for filers who cannot be claimed + period: 2025 + input: + people: + filer: + age: 30 + employment_income: 10_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + child: + age: 5 + tax_units: + tax_unit: + members: [filer, child] + households: + household: + members: [filer, child] + state_code: ID + output: + # Idaho Code 63-3024A: a credit per taxpayer, spouse and claimed + # dependent; a filer who can be claimed gets none and the return + # has no dependents (IRC 152(b)(1)). The other spouse keeps 155. + id_grocery_credit: 0 + +- name: 2025 joint return with one spouse who can be claimed as a dependent, food tax credit only for filers who cannot be claimed (the claimable spouse is the head) + period: 2025 + input: + people: + person_a: + age: 30 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 30 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + child: + age: 5 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + households: + household: + members: [person_a, person_b, child] + state_code: ID + output: + id_grocery_credit: 155 + +- name: 2025 joint return with one spouse who can be claimed as a dependent, food tax credit only for filers who cannot be claimed (the claimable spouse is the spouse) + period: 2025 + input: + people: + person_b: + age: 30 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_a: + age: 30 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + child: + age: 5 + tax_units: + tax_unit: + members: [person_b, person_a, child] + filing_status: JOINT + households: + household: + members: [person_b, person_a, child] + state_code: ID + output: + id_grocery_credit: 155 + +- name: 2025 joint return with both spouses claimable as dependents, food tax credit only for filers who cannot be claimed + period: 2025 + input: + people: + person_a: + age: 30 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 30 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + child: + age: 5 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + households: + household: + members: [person_a, person_b, child] + state_code: ID + output: + id_grocery_credit: 0 + +- name: 2025 joint return with neither spouse claimable, food tax credit only for filers who cannot be claimed + period: 2025 + input: + people: + person_a: + age: 30 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_b: + age: 30 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + child: + age: 5 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + households: + household: + members: [person_a, person_b, child] + state_code: ID + output: + # 3 x 155 + id_grocery_credit: 465 diff --git a/policyengine_us/tests/policy/baseline/gov/states/id/tax/income/credits/id_2022_rebate.yaml b/policyengine_us/tests/policy/baseline/gov/states/id/tax/income/credits/id_2022_rebate.yaml index 3035b6f4388..36cd40cfa5d 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/id/tax/income/credits/id_2022_rebate.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/id/tax/income/credits/id_2022_rebate.yaml @@ -15,3 +15,131 @@ id_2022_rebate_floor: 0 output: id_2022_rebate: 120 + + +- name: 2020 single filer who can be claimed as a dependent, 2022 rebate floor counts the filers but no dependent + period: 2020 + input: + people: + filer: + age: 30 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + child: + age: 5 + tax_units: + tax_unit: + members: [filer, child] + households: + household: + members: [filer, child] + state_code: ID + output: + # Idaho Code 63-3024B(3): $75 per taxpayer and each dependent; + # a return with a claimable filer has no dependents. + id_2022_rebate: 75 + +- name: 2020 joint return with one spouse who can be claimed as a dependent, 2022 rebate floor counts the filers but no dependent (the claimable spouse is the head) + period: 2020 + input: + people: + person_a: + age: 30 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 30 + is_tax_unit_head: false + is_tax_unit_spouse: true + child: + age: 5 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + households: + household: + members: [person_a, person_b, child] + state_code: ID + output: + id_2022_rebate: 150 + +- name: 2020 joint return with one spouse who can be claimed as a dependent, 2022 rebate floor counts the filers but no dependent (the claimable spouse is the spouse) + period: 2020 + input: + people: + person_b: + age: 30 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_a: + age: 30 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + child: + age: 5 + tax_units: + tax_unit: + members: [person_b, person_a, child] + filing_status: JOINT + households: + household: + members: [person_b, person_a, child] + state_code: ID + output: + id_2022_rebate: 150 + +- name: 2020 joint return with both spouses claimable as dependents, 2022 rebate floor counts the filers but no dependent + period: 2020 + input: + people: + person_a: + age: 30 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 30 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + child: + age: 5 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + households: + household: + members: [person_a, person_b, child] + state_code: ID + output: + id_2022_rebate: 150 + +- name: 2020 joint return with neither spouse claimable, 2022 rebate floor counts the filers but no dependent + period: 2020 + input: + people: + person_a: + age: 30 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_b: + age: 30 + is_tax_unit_head: false + is_tax_unit_spouse: true + child: + age: 5 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + households: + household: + members: [person_a, person_b, child] + state_code: ID + output: + id_2022_rebate: 225 diff --git a/policyengine_us/tests/policy/baseline/gov/states/id/tax/income/credits/id_ctc.yaml b/policyengine_us/tests/policy/baseline/gov/states/id/tax/income/credits/id_ctc.yaml index 9b0596d7c1d..cfb00226b16 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/id/tax/income/credits/id_ctc.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/id/tax/income/credits/id_ctc.yaml @@ -126,3 +126,140 @@ output: # 5 children under 17 * $205 id_ctc: 1025 + + +- name: 2025 single filer who can be claimed as a dependent, no Idaho child tax credit + period: 2025 + input: + people: + filer: + age: 30 + employment_income: 10_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + child: + age: 5 + tax_units: + tax_unit: + members: [filer, child] + households: + household: + members: [filer, child] + state_code: ID + output: + # Already zero through the federal child test: the 2021-2025 + # worksheet requires the child to be the taxpayer's dependent. + id_ctc: 0 + +- name: 2025 joint return with one spouse who can be claimed as a dependent, no Idaho child tax credit (the claimable spouse is the head) + period: 2025 + input: + people: + person_a: + age: 30 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 30 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + child: + age: 5 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + households: + household: + members: [person_a, person_b, child] + state_code: ID + output: + id_ctc: 0 + +- name: 2025 joint return with one spouse who can be claimed as a dependent, no Idaho child tax credit (the claimable spouse is the spouse) + period: 2025 + input: + people: + person_b: + age: 30 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_a: + age: 30 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + child: + age: 5 + tax_units: + tax_unit: + members: [person_b, person_a, child] + filing_status: JOINT + households: + household: + members: [person_b, person_a, child] + state_code: ID + output: + id_ctc: 0 + +- name: 2025 joint return with both spouses claimable as dependents, no Idaho child tax credit + period: 2025 + input: + people: + person_a: + age: 30 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 30 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + child: + age: 5 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + households: + household: + members: [person_a, person_b, child] + state_code: ID + output: + id_ctc: 0 + +- name: 2025 joint return with neither spouse claimable, no Idaho child tax credit + period: 2025 + input: + people: + person_a: + age: 30 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_b: + age: 30 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + child: + age: 5 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + households: + household: + members: [person_a, person_b, child] + state_code: ID + output: + id_ctc: 205 diff --git a/policyengine_us/tests/policy/baseline/gov/states/id/tax/income/deductions/household_and_dependent_care/id_household_and_dependent_care_expense_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/id/tax/income/deductions/household_and_dependent_care/id_household_and_dependent_care_expense_deduction.yaml index 040c1b2e435..bff210ef010 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/id/tax/income/deductions/household_and_dependent_care/id_household_and_dependent_care_expense_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/id/tax/income/deductions/household_and_dependent_care/id_household_and_dependent_care_expense_deduction.yaml @@ -4,6 +4,8 @@ tax_unit_childcare_expenses: 13_000 id_cdcc_limit: 6_000 min_head_spouse_earned: 4_000 + # Idaho Code 63-3022D needs a qualifying individual in the household. + count_cdcc_eligible: 1 state_code: ID output: id_household_and_dependent_care_expense_deduction: 4_000 @@ -14,6 +16,8 @@ tax_unit_childcare_expenses: 13_000 id_cdcc_limit: 6_000 min_head_spouse_earned: 14_000 + # Idaho Code 63-3022D needs a qualifying individual in the household. + count_cdcc_eligible: 1 state_code: ID output: id_household_and_dependent_care_expense_deduction: 12_000 @@ -106,6 +110,8 @@ care_expenses: 3_000 id_cdcc_limit: 6_000 min_head_spouse_earned: 4_000 + # Idaho Code 63-3022D needs a qualifying individual in the household. + count_cdcc_eligible: 1 state_code: ID output: id_household_and_dependent_care_expense_deduction: 3_000 @@ -120,6 +126,8 @@ id_cdcc_limit: 6_000 min_head_spouse_earned: 60_000 dependent_care_assistance_exclusion: 5_000 + # Idaho Code 63-3022D needs a qualifying individual in the household. + count_cdcc_eligible: 1 state_code: ID output: # min(10_000 expenses, max(6_000, 12_000) - 5_000 = 7_000, 60_000) = 7_000. @@ -153,3 +161,171 @@ dependent_care_assistance_exclusion: 4_000 # min(10_000 expenses, max(3_000, 12_000) - 4_000 = 8_000, 38_000) = 8_000. id_household_and_dependent_care_expense_deduction: 8_000 + + +- name: 2025 single filer who can be claimed as a dependent, no household and dependent care deduction for a child under 13 + period: 2025 + input: + people: + filer: + age: 30 + employment_income: 10_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + child: + age: 5 + tax_units: + tax_unit: + members: [filer, child] + tax_unit_childcare_expenses: 1_000 + households: + household: + members: [filer, child] + state_code: ID + output: + # Idaho Code 63-3022D needs an IRC 21(b)(1) qualifying + # individual; a child under 13 is not one on such a return. + id_household_and_dependent_care_expense_deduction: 0 + +- name: 2025 joint return with one spouse who can be claimed as a dependent, no household and dependent care deduction for a child under 13 (the claimable spouse is the head) + period: 2025 + input: + people: + person_a: + age: 30 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 30 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + child: + age: 5 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + tax_unit_childcare_expenses: 1_000 + households: + household: + members: [person_a, person_b, child] + state_code: ID + output: + id_household_and_dependent_care_expense_deduction: 0 + +- name: 2025 joint return with one spouse who can be claimed as a dependent, no household and dependent care deduction for a child under 13 (the claimable spouse is the spouse) + period: 2025 + input: + people: + person_b: + age: 30 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_a: + age: 30 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + child: + age: 5 + tax_units: + tax_unit: + members: [person_b, person_a, child] + filing_status: JOINT + tax_unit_childcare_expenses: 1_000 + households: + household: + members: [person_b, person_a, child] + state_code: ID + output: + id_household_and_dependent_care_expense_deduction: 0 + +- name: 2025 joint return with both spouses claimable as dependents, no household and dependent care deduction for a child under 13 + period: 2025 + input: + people: + person_a: + age: 30 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 30 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + child: + age: 5 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + tax_unit_childcare_expenses: 1_000 + households: + household: + members: [person_a, person_b, child] + state_code: ID + output: + id_household_and_dependent_care_expense_deduction: 0 + +- name: 2025 joint return with neither spouse claimable, no household and dependent care deduction for a child under 13 + period: 2025 + input: + people: + person_a: + age: 30 + employment_income: 5_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_b: + age: 30 + employment_income: 5_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + child: + age: 5 + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + tax_unit_childcare_expenses: 1_000 + households: + household: + members: [person_a, person_b, child] + state_code: ID + output: + # min(1,000, 12,000, 5,000) + id_household_and_dependent_care_expense_deduction: 1_000 + +- name: 2025 single filer who can be claimed as a dependent deducts care for a disabled dependent + period: 2025 + input: + people: + filer: + age: 30 + employment_income: 10_000 + is_tax_unit_head: true + claimed_as_dependent_on_another_return: true + dependent: + age: 14 + is_incapable_of_self_care: true + care_expenses: 1_000 + tax_units: + tax_unit: + members: [filer, dependent] + households: + household: + members: [filer, dependent] + state_code: ID + output: + # IRC 21(b)(1)(B) determines dependency without regard + # to IRC 152(b)(1): min(1,000, 12,000, 10,000). + id_household_and_dependent_care_expense_deduction: 1_000 diff --git a/policyengine_us/variables/gov/states/dc/tax/income/credits/ctc/dc_ctc_eligible_child.py b/policyengine_us/variables/gov/states/dc/tax/income/credits/ctc/dc_ctc_eligible_child.py index 94190df0362..dad9baf2b03 100644 --- a/policyengine_us/variables/gov/states/dc/tax/income/credits/ctc/dc_ctc_eligible_child.py +++ b/policyengine_us/variables/gov/states/dc/tax/income/credits/ctc/dc_ctc_eligible_child.py @@ -7,9 +7,19 @@ class dc_ctc_eligible_child(Variable): label = "Whether the child is eligible for the DC CTC" definition_period = YEAR defined_for = "is_tax_unit_dependent" - reference = "https://code.dccouncil.gov/us/dc/council/code/sections/47-1806.17" + reference = ( + # D.C. Code 47-1806.17(a), (d): a child for whom the taxpayer is allowed + # a deduction under IRC 151, claimed on the federal and District returns. + "https://code.dccouncil.gov/us/dc/council/code/sections/47-1806.17", + "https://www.law.cornell.edu/uscode/text/26/152#b_1", + ) def formula(person, period, parameters): p = parameters(period).gov.states.dc.tax.income.credits.ctc.child age = person("age", period) - return age < p.age_threshold + # A return on which the filer (or, if joint, either spouse) can be + # claimed as a dependent has no dependents (IRC 152(b)(1)). + filer_is_dependent = person.tax_unit( + "head_or_spouse_is_dependent_elsewhere", period + ) + return (age < p.age_threshold) & ~filer_is_dependent diff --git a/policyengine_us/variables/gov/states/dc/tax/income/credits/dc_kccatc.py b/policyengine_us/variables/gov/states/dc/tax/income/credits/dc_kccatc.py index 39102d62c24..7dddc52b427 100644 --- a/policyengine_us/variables/gov/states/dc/tax/income/credits/dc_kccatc.py +++ b/policyengine_us/variables/gov/states/dc/tax/income/credits/dc_kccatc.py @@ -10,6 +10,10 @@ class dc_kccatc(Variable): reference = ( "https://otr.cfo.dc.gov/sites/default/files/dc/sites/otr/publication/attachments/52926_D-40_12.21.21_Final_Rev011122.pdf#page=67", "https://otr.cfo.dc.gov/sites/default/files/dc/sites/otr/publication/attachments/2022_D-40_Booklet_Final_blk_01_23_23_Ordc.pdf#page=59", + # D.C. Code 47-1806.15(a)(3), (d)(1): the child must be claimed as a + # dependent on the taxpayer's federal and District returns. + "https://code.dccouncil.gov/us/dc/council/code/sections/47-1806.15", + "https://www.law.cornell.edu/uscode/text/26/152#b_1", ) defined_for = StateCode.DC @@ -21,7 +25,11 @@ def formula(tax_unit, period, parameters): income_eligible = taxinc <= p.kccatc.income_limit[filing_status] # determine count of KCCATC age eligible children person = tax_unit.members - is_dependent = person("is_tax_unit_dependent", period) + # The child must be the taxpayer's dependent on the federal and District + # returns. A return on which the filer (or, if joint, either spouse) + # can be claimed as a dependent has no dependents (IRC 152(b)(1)). + filer_is_dependent = tax_unit("head_or_spouse_is_dependent_elsewhere", period) + is_dependent = person("is_tax_unit_dependent", period) & ~filer_is_dependent age = person("age", period) kccatc_age_eligible = is_dependent & (age <= p.kccatc.max_age) kccatc_eligible_count = tax_unit.sum(kccatc_age_eligible) diff --git a/policyengine_us/variables/gov/states/dc/tax/income/credits/dc_ptc.py b/policyengine_us/variables/gov/states/dc/tax/income/credits/dc_ptc.py index 81a95c5d8fe..1e9fab462b3 100644 --- a/policyengine_us/variables/gov/states/dc/tax/income/credits/dc_ptc.py +++ b/policyengine_us/variables/gov/states/dc/tax/income/credits/dc_ptc.py @@ -10,6 +10,9 @@ class dc_ptc(Variable): reference = ( "https://otr.cfo.dc.gov/sites/default/files/dc/sites/otr/publication/attachments/52926_D-40_12.21.21_Final_Rev011122.pdf#page=49", "https://otr.cfo.dc.gov/sites/default/files/dc/sites/otr/publication/attachments/2022_D-40_Booklet_Final_blk_01_23_23_Ordc.pdf#page=47", + # D.C. Code 47-1806.06(b)(4) (one claimant per tax filing unit) and (k) + # (no credit for a claimant who was a dependent, unless 65 or older). + "https://code.dccouncil.gov/us/dc/council/code/sections/47-1806.06", ) defined_for = StateCode.DC @@ -33,4 +36,17 @@ def formula(tax_unit, period, parameters): p_dc.ptc.fraction_nonelderly.calc(positive_agi, right=True), ) uncapped_ptc = max_(0, ptax - ptax_offset) - return min_(p_dc.ptc.max, uncapped_ptc) * tax_unit("takes_up_dc_ptc", period) + # D.C. Code 47-1806.06(k): no credit for a claimant who was a dependent + # under any income tax law that year, unless 65 or older. Only one + # claimant per tax filing unit may claim the credit ((b)(4)), so a + # couple can claim it through a spouse who is not such a dependent. + person = tax_unit.members + filer = person("is_tax_unit_head_or_spouse", period) + claimed = person("claimed_as_dependent_on_another_return", period) + old_enough = person("age", period) >= p_dc.ptc.dependent_claimant_min_age + has_claimant = tax_unit.any(filer & (~claimed | old_enough)) + return ( + min_(p_dc.ptc.max, uncapped_ptc) + * tax_unit("takes_up_dc_ptc", period) + * has_claimant + ) diff --git a/policyengine_us/variables/gov/states/dc/tax/income/credits/eitc/dc_eitc_without_qualifying_child.py b/policyengine_us/variables/gov/states/dc/tax/income/credits/eitc/dc_eitc_without_qualifying_child.py index f62c122b95f..c3d5a612b72 100644 --- a/policyengine_us/variables/gov/states/dc/tax/income/credits/eitc/dc_eitc_without_qualifying_child.py +++ b/policyengine_us/variables/gov/states/dc/tax/income/credits/eitc/dc_eitc_without_qualifying_child.py @@ -14,6 +14,11 @@ class dc_eitc_without_qualifying_child(Variable): definition_period = YEAR reference = ( "https://code.dccouncil.gov/us/dc/council/code/sections/47-1806.04", # (f) + # IRC 32(c)(1)(A)(ii)(III): a filer without a qualifying child must not + # be a dependent of another taxpayer. + "https://www.law.cornell.edu/uscode/text/26/32#c_1_A_ii", + # Publication 596: on a joint return, neither spouse may be claimable. + "https://www.irs.gov/pub/irs-prior/p596--2025.pdf#page=18", ) defined_for = StateCode.DC @@ -36,9 +41,14 @@ def formula(tax_unit, period, parameters): age_eligible = is_head_or_spouse & (age >= min_age) & (age <= max_age) # (f)(1)(C) is limited to an individual without a qualifying child. no_qualifying_child = ~tax_unit("dc_eitc_has_qualifying_child", period) + # (f) keeps the IRC 32 framework: a filer without a qualifying child + # must not be a dependent of another taxpayer, and on a joint return + # neither spouse may be (Publication 596). + filer_is_dependent = tax_unit("head_or_spouse_is_dependent_elsewhere", period) us_eligible = ( filer_meets_identification & no_qualifying_child + & ~filer_is_dependent & tax_unit.any(age_eligible) & tax_unit("eitc_investment_income_eligible", period) & eitc_filing_status_eligible(tax_unit, period, parameters) diff --git a/policyengine_us/variables/gov/states/ga/tax/income/credits/ga_low_income_credit_potential.py b/policyengine_us/variables/gov/states/ga/tax/income/credits/ga_low_income_credit_potential.py index 07708fa354f..1b1dae6137f 100644 --- a/policyengine_us/variables/gov/states/ga/tax/income/credits/ga_low_income_credit_potential.py +++ b/policyengine_us/variables/gov/states/ga/tax/income/credits/ga_low_income_credit_potential.py @@ -7,7 +7,14 @@ class ga_low_income_credit_potential(Variable): label = "Georgia low income credit" unit = USD definition_period = YEAR - reference = "https://dor.georgia.gov/document/document/2022-it-511-individual-income-tax-booklet/download" + reference = ( + "https://dor.georgia.gov/document/document/2022-it-511-individual-income-tax-booklet/download", + # 2025 IT-511, Line 17: only if "you are not claimed or eligible to be + # claimed as a dependent on another taxpayer's Federal or Georgia + # income tax return". + "https://dor.georgia.gov/document/document/2025-it-511-individual-income-tax-booklet/download#page=17", + "https://dor.georgia.gov/low-income-tax-credit", + ) defined_for = StateCode.GA def formula(tax_unit, period, parameters): @@ -32,4 +39,9 @@ def formula(tax_unit, period, parameters): total_exemptions = aged_count + exemptions federal_agi = tax_unit("adjusted_gross_income", period) amount_per_exemption = p.amount.calc(federal_agi) - return total_exemptions * amount_per_exemption + # O.C.G.A. 48-7A-3 allows the credit only to a taxpayer who is not + # claimed or eligible to be claimed as a dependent. The return-level + # worksheet counts self, spouse and children, so either spouse being + # claimable bars the joint return. + filer_is_dependent = tax_unit("head_or_spouse_is_dependent_elsewhere", period) + return total_exemptions * amount_per_exemption * ~filer_is_dependent diff --git a/policyengine_us/variables/gov/states/ga/tax/income/credits/ga_surplus_tax_rebate.py b/policyengine_us/variables/gov/states/ga/tax/income/credits/ga_surplus_tax_rebate.py index be635f01bf5..999c6f715d4 100644 --- a/policyengine_us/variables/gov/states/ga/tax/income/credits/ga_surplus_tax_rebate.py +++ b/policyengine_us/variables/gov/states/ga/tax/income/credits/ga_surplus_tax_rebate.py @@ -14,10 +14,9 @@ class ga_surplus_tax_rebate(Variable): defined_for = StateCode.GA # Not modeled: the statutory eligibility conditions in O.C.G.A. # 48-7-20.2(a)-(b) - filing both 2021 and 2022 returns ((a), (b)(1)), - # the nonresident-alien exclusion ((a)(1)(A)), the dependent exclusion - # with its earned-income carve-back ((a)(1)(B), (a)(2)), the estate or - # trust exclusion ((a)(1)(C)), and part-year/nonresident proration - # ((b)(2)) - are all treated as met for a full-year Georgia tax unit. + # the nonresident-alien exclusion ((a)(1)(A)), the estate or trust + # exclusion ((a)(1)(C)), and part-year/nonresident proration ((b)(2)) - + # are all treated as met for a full-year Georgia tax unit. def formula(tax_unit, period, parameters): filing_status = tax_unit("filing_status", period) @@ -26,4 +25,12 @@ def formula(tax_unit, period, parameters): # 48-7-20.2(b)(1)(A): capped at the Form 500 Line 16 liability (tax # before credits); it pays out past a zero balance due. line_16_tax = tax_unit("ga_income_tax_before_non_refundable_credits", period) - return min_(cap, line_16_tax) + # 48-7-20.2(a)(1)(B) and (a)(2): an individual claimed as a dependent + # for 2021 qualifies only if that individual had 2021 earned income. A + # joint return qualifies only if neither spouse is so excluded. + person = tax_unit.members + filer = person("is_tax_unit_head_or_spouse", period) + claimed = person("claimed_as_dependent_on_another_return", period) + own_earnings = person("earned_income", period) > 0 + qualified = ~tax_unit.any(filer & claimed & ~own_earnings) + return min_(cap, line_16_tax) * qualified diff --git a/policyengine_us/variables/gov/states/ga/tax/income/exemptions/ga_exemptions.py b/policyengine_us/variables/gov/states/ga/tax/income/exemptions/ga_exemptions.py index f1d368c4c9c..de30eb3cfab 100644 --- a/policyengine_us/variables/gov/states/ga/tax/income/exemptions/ga_exemptions.py +++ b/policyengine_us/variables/gov/states/ga/tax/income/exemptions/ga_exemptions.py @@ -10,16 +10,22 @@ class ga_exemptions(Variable): definition_period = YEAR reference = ( "https://apps.dor.ga.gov/FillableForms/PDFViewer/Index?form=2022GA500", + # 2025 IT-511, Lines 7a-d: "Georgia follows the Federal rules for + # qualified dependents." + "https://dor.georgia.gov/document/document/2025-it-511-individual-income-tax-booklet/download#page=16", + "https://www.law.cornell.edu/uscode/text/26/152#b_1", "https://advance.lexis.com/documentpage/?pdmfid=1000516&crid=2c053fd5-32c1-4cc1-86b0-36aaade9da5b&pdistocdocslideraccess=true&config=00JAA1MDBlYzczZi1lYjFlLTQxMTgtYWE3OS02YTgyOGM2NWJlMDYKAFBvZENhdGFsb2feed0oM9qoQOMCSJFX5qkd&pddocfullpath=%2Fshared%2Fdocument%2Fstatutes-legislation%2Furn%3AcontentItem%3A6348-G0H1-DYB7-W3JT-00008-00&pdcomponentid=234187&pdtocnodeidentifier=ABWAALAADAAL&ecomp=k2vckkk&prid=4862391c-e031-443f-ad52-ae86c6bb5ce2", ) def formula(tax_unit, period, parameters): p = parameters(period).gov.states.ga.tax.income.exemptions - # Dependent exemptions - dependents = tax_unit( - "tax_unit_dependents", period - ) # Total the number of dependents - dependent_exemptions = dependents * p.dependent + # Dependent exemptions. Georgia follows the federal rules for qualified + # dependents, so a return on which the filer (or, if joint, either + # spouse) can be claimed as a dependent has none (IRC 152(b)(1)). The + # 2021-2023 personal exemption has no such rule. + dependents = tax_unit("tax_unit_dependents", period) + filer_is_dependent = tax_unit("head_or_spouse_is_dependent_elsewhere", period) + dependent_exemptions = where(filer_is_dependent, 0, dependents) * p.dependent # total exemptions if p.personal.availability: diff --git a/policyengine_us/variables/gov/states/id/tax/income/credits/2022_rebate/id_2022_rebate_floor.py b/policyengine_us/variables/gov/states/id/tax/income/credits/2022_rebate/id_2022_rebate_floor.py index fd0e514f6b7..8f020f0a9e2 100644 --- a/policyengine_us/variables/gov/states/id/tax/income/credits/2022_rebate/id_2022_rebate_floor.py +++ b/policyengine_us/variables/gov/states/id/tax/income/credits/2022_rebate/id_2022_rebate_floor.py @@ -7,5 +7,20 @@ class id_2022_rebate_floor(Variable): label = "Idaho 2022 rebate floor" definition_period = YEAR defined_for = StateCode.ID + reference = ( + # Idaho Code 63-3024B(3): "seventy-five dollars ($75.00) per taxpayer and + # each dependent", based on the 2020 return. + "https://legislature.idaho.gov/statutesrules/idstat/Title63/T63CH30/SECT63-3024B/", + "https://www.law.cornell.edu/uscode/text/26/152#b_1", + ) - adds = ["gov.states.id.tax.income.credits.2022_rebate.floor"] + def formula(person, period, parameters): + p = parameters(period).gov.states.id.tax.income.credits["2022_rebate"] + # Each taxpayer counts, even one whom another taxpayer can claim, but a + # return on which the filer (or, if joint, either spouse) can be + # claimed has no dependents (IRC 152(b)(1)). + filer = person("is_tax_unit_head_or_spouse", period) + filer_is_dependent = person.tax_unit( + "head_or_spouse_is_dependent_elsewhere", period + ) + return p.floor * (filer | ~filer_is_dependent) diff --git a/policyengine_us/variables/gov/states/id/tax/income/credits/grocery/id_grocery_credit.py b/policyengine_us/variables/gov/states/id/tax/income/credits/grocery/id_grocery_credit.py index cc88ab65ea5..9fb88ea1a50 100644 --- a/policyengine_us/variables/gov/states/id/tax/income/credits/grocery/id_grocery_credit.py +++ b/policyengine_us/variables/gov/states/id/tax/income/credits/grocery/id_grocery_credit.py @@ -11,6 +11,15 @@ class id_grocery_credit(Variable): reference = ( "https://law.justia.com/codes/idaho/2022/title-63/chapter-30/section-63-3024a/", "https://tax.idaho.gov/wp-content/uploads/forms/EFO00089/EFO00089_12-30-2022.pdf#page=7", + # Idaho Code 63-3024A(1), (4): a credit for the taxpayer, the spouse and + # each IRC 152 dependent claimed on the return, never two for the same + # personal exemption. + "https://legislature.idaho.gov/statutesrules/idstat/Title63/T63CH30/SECT63-3024A/", + # 2025 Form 40 instructions, line 43 and the Food Tax Credit + # Worksheet (yourself, spouse, dependents). + # PDF pages 13-14 + "https://tax.idaho.gov/wp-content/uploads/forms/EIN00046/EIN00046_03-02-2026.pdf#page=13", + "https://www.law.cornell.edu/uscode/text/26/152#b_1", ) def formula(tax_unit, period, parameters): @@ -25,5 +34,16 @@ def formula(tax_unit, period, parameters): ) else: full_amount = person("id_grocery_credit_base", period) - credit_value = full_amount * (qualified_months / MONTHS_IN_YEAR) + # A filer whom another taxpayer can claim gets no credit ("You can't + # claim this credit if someone else, such as a parent, can claim you + # as a dependent"); the other spouse on a joint return keeps theirs. + # A return on which the filer (or, if joint, either spouse) can be + # claimed has no dependents (IRC 152(b)(1)). + filer = person("is_tax_unit_head_or_spouse", period) + claimed = person("claimed_as_dependent_on_another_return", period) + filer_is_dependent = person.tax_unit( + "head_or_spouse_is_dependent_elsewhere", period + ) + eligible = where(filer, ~claimed, ~filer_is_dependent) + credit_value = full_amount * (qualified_months / MONTHS_IN_YEAR) * eligible return tax_unit.sum(credit_value) diff --git a/policyengine_us/variables/gov/states/id/tax/income/subtractions/household_and_dependent_care/id_household_and_dependent_care_expense_deduction.py b/policyengine_us/variables/gov/states/id/tax/income/subtractions/household_and_dependent_care/id_household_and_dependent_care_expense_deduction.py index bfe2b957235..c9a8b88fc65 100644 --- a/policyengine_us/variables/gov/states/id/tax/income/subtractions/household_and_dependent_care/id_household_and_dependent_care_expense_deduction.py +++ b/policyengine_us/variables/gov/states/id/tax/income/subtractions/household_and_dependent_care/id_household_and_dependent_care_expense_deduction.py @@ -8,6 +8,12 @@ class id_household_and_dependent_care_expense_deduction(Variable): unit = USD definition_period = YEAR defined_for = StateCode.ID + reference = ( + # Idaho Code 63-3022D: for an individual who maintains a household that + # includes one or more qualifying individuals under IRC 21(b)(1). + "https://legislature.idaho.gov/statutesrules/idstat/Title63/T63CH30/SECT63-3022D/", + "https://www.law.cornell.edu/uscode/text/26/21#b_1", + ) def formula(tax_unit, period, parameters): p = parameters( @@ -28,8 +34,13 @@ def formula(tax_unit, period, parameters): exclusion = tax_unit("dependent_care_assistance_exclusion", period) limit = max_(limit - exclusion, 0) eligible_capped_expenses = min_(expenses, limit) + # The deduction needs a household member who is an IRC 21(b)(1) + # qualifying individual. A child under 13 is not one when the filer + # (or, if joint, either spouse) can be claimed as a dependent; a + # disabled dependent or spouse still is. + has_qualifying_individual = tax_unit("count_cdcc_eligible", period) > 0 # cap further to the lowest earnings between the taxpayer and spouse - return min_( + return has_qualifying_individual * min_( eligible_capped_expenses, tax_unit("min_head_spouse_earned", period), ) From 255a5716369a52ee9c17c640c4d49e5d6dbf3f75 Mon Sep 17 00:00:00 2001 From: Max Ghenis Date: Sat, 10 Oct 2026 07:20:09 -0400 Subject: [PATCH 2/5] Let either qualifying Georgia spouse claim the low income credit and HB 162 refund; add the property test O.C.G.A. 48-7A-3(a) lets "each resident taxpayer ... who is not claimed or is not otherwise eligible to be claimed as a dependent" claim the low income credit and deems each joint spouse a unit "for purposes of such joint return", so a joint return keeps both spouses' units while one spouse qualifies; such a return still counts no dependents (IRC 152(b)(1)). The HB 162 refund is credited to each qualified taxpayer (48-7-20.2(a), (b)), so a joint return gets the joint amount while one spouse qualifies. The property test checks swap invariance and monotonicity of the changed DC, Georgia and Idaho outputs on Hypothesis and seeded couples. Co-Authored-By: Claude Opus 5.5 --- ...est_claimable_filer_dc_ga_id_invariants.py | 105 ++++++++++++++++++ .../income/credits/ga_low_income_credit.yaml | 55 +++++---- .../income/credits/ga_surplus_tax_rebate.yaml | 51 +++++++-- .../credits/ga_low_income_credit_potential.py | 28 +++-- .../income/credits/ga_surplus_tax_rebate.py | 7 +- 5 files changed, 201 insertions(+), 45 deletions(-) create mode 100644 policyengine_us/tests/core/test_claimable_filer_dc_ga_id_invariants.py diff --git a/policyengine_us/tests/core/test_claimable_filer_dc_ga_id_invariants.py b/policyengine_us/tests/core/test_claimable_filer_dc_ga_id_invariants.py new file mode 100644 index 00000000000..ebad5ce6cce --- /dev/null +++ b/policyengine_us/tests/core/test_claimable_filer_dc_ga_id_invariants.py @@ -0,0 +1,105 @@ +"""District of Columbia, Georgia and Idaho rules for a filer who can be claimed +as a dependent. + +A return on which the filer, or on a joint return either spouse, can be claimed +as a dependent has no dependents (IRC 152(b)(1)). DC's property tax credit +needs a claimant who was not a dependent or is 65 or older; Georgia's low +income credit and 2023 surplus refund need one filer who qualifies; Idaho's +food tax credit leaves out each filer who can be claimed. + +For couples drawn by Hypothesis and a seeded population in these states, with +either, both or neither spouse claimed: + +1. Swap invariance: each output is the same under either head/spouse + labelling. +2. Monotonicity: marking another filer as claimed never raises the outputs in + MONOTONE (amounts not capped by a tax liability that the claim can raise). +3. Identities: a return with a claimable filer has no DC child care or child + tax credit and its Idaho food tax credit is at most one filer's amount; a + return on which every filer can be claimed has no Georgia low income + credit. +""" + +import numpy as np +import pytest +from hypothesis import HealthCheck, given, settings +from hypothesis import strategies as st + +from policyengine_us.tests.core.test_claimable_filer_federal_invariants import ( + check_monotone, + check_swap, +) +from policyengine_us.tests.core.test_dependent_elsewhere_head_spouse_swap_invariance import ( + CLAIM_PATTERNS, + _calc, + _crafted_cases, + _seeded_couples, + adults, + dependents, +) + +STATES = ["DC", "GA", "ID"] +YEARS = [2021, 2023, 2025, 2026] +MONOTONE = [ + "dc_ptc", + "dc_eitc", + "dc_kccatc", + "dc_ctc", + "ga_exemptions", + "ga_low_income_credit_potential", + "ga_ctc_potential", + "id_grocery_credit", + "id_household_and_dependent_care_expense_deduction", +] +OUTPUTS = MONOTONE + ["ga_surplus_tax_rebate", "id_2022_rebate"] + + +@st.composite +def couples(draw): + return { + "state": draw(st.sampled_from(STATES)), + "adults": [draw(adults()), draw(adults())], + "dependents": draw(st.lists(dependents(), max_size=2)), + "claimed": draw(st.sampled_from(CLAIM_PATTERNS)), + } + + +def _identities(sim, year): + claimed_filer = _calc(sim, "head_or_spouse_is_dependent_elsewhere", year) > 0 + for name in ("dc_kccatc", "dc_ctc"): + assert not _calc(sim, name, year)[claimed_filer].any(), ( + f"{name} in {year} is positive on a return with a claimable filer" + ) + # Georgia's low income credit needs one filer who cannot be claimed. + every_filer = _calc(sim, "every_filer_is_dependent_elsewhere", year) > 0 + assert not _calc(sim, "ga_low_income_credit_potential", year)[every_filer].any() + # At most the filer who cannot be claimed keeps a food tax credit. + one_filer = _one_filer_food_amount(sim, year) + grocery = _calc(sim, "id_grocery_credit", year) + assert (grocery[claimed_filer] <= one_filer + 0.01).all() + + +def _one_filer_food_amount(sim, year): + p = sim.tax_benefit_system.parameters(f"{year}-01-01").gov.states.id.tax.income + amount = p.credits.grocery.base.amount + if p.credits.grocery.aged.in_effect: + amount += p.credits.grocery.aged.amount + return amount + + +@settings( + max_examples=2, + deadline=None, + derandomize=True, + suppress_health_check=[HealthCheck.too_slow, HealthCheck.data_too_large], +) +@given(st.sampled_from(YEARS), st.lists(couples(), min_size=6, max_size=12)) +def test_dc_ga_id_claimable_filer_rules_are_label_free(year, units): + check_swap(units, year, OUTPUTS, _identities) + + +@pytest.mark.parametrize("year", YEARS) +def test_dc_ga_id_claimable_filer_rules_seeded_population(year): + units = _seeded_couples(STATES, per_state=3) + _crafted_cases(STATES) + check_swap(units, year, OUTPUTS, _identities) + check_monotone(units, year, MONOTONE, _identities) diff --git a/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/ga_low_income_credit.yaml b/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/ga_low_income_credit.yaml index ae9163798f8..5c2baf6b3a6 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/ga_low_income_credit.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/ga_low_income_credit.yaml @@ -88,7 +88,7 @@ ga_low_income_credit: 16 -- name: 2025 single filer who can be claimed as a dependent, no low income credit +- name: 2025 single filer who can be claimed as a dependent, low income credit only through a spouse who cannot be claimed, with no child units period: 2025 input: people: @@ -98,20 +98,23 @@ is_tax_unit_head: true is_tax_unit_spouse: false claimed_as_dependent_on_another_return: true + child: + age: 5 tax_units: tax_unit: - members: [filer] + members: [filer, child] households: household: - members: [filer] + members: [filer, child] state_code: GA output: - # O.C.G.A. 48-7A-3 and IT-511 Line 17: only a taxpayer who is not - # claimed or eligible to be claimed as a dependent; the joint - # return is barred when either spouse can be claimed. + # O.C.G.A. 48-7A-3(a): each resident taxpayer who is not claimed + # or eligible to be claimed may claim it, and joint spouses are + # each deemed a unit; a return with a claimable filer has no + # dependents (IRC 152(b)(1)): 2 x 26 at federal AGI 5,000. ga_low_income_credit_potential: 0 -- name: 2025 joint return with one spouse who can be claimed as a dependent, no low income credit (the claimable spouse is the head) +- name: 2025 joint return with one spouse who can be claimed as a dependent, low income credit only through a spouse who cannot be claimed, with no child units (the claimable spouse is the head) period: 2025 input: people: @@ -126,18 +129,20 @@ employment_income: 2_500 is_tax_unit_head: false is_tax_unit_spouse: true + child: + age: 5 tax_units: tax_unit: - members: [person_a, person_b] + members: [person_a, person_b, child] filing_status: JOINT households: household: - members: [person_a, person_b] + members: [person_a, person_b, child] state_code: GA output: - ga_low_income_credit_potential: 0 + ga_low_income_credit_potential: 52 -- name: 2025 joint return with one spouse who can be claimed as a dependent, no low income credit (the claimable spouse is the spouse) +- name: 2025 joint return with one spouse who can be claimed as a dependent, low income credit only through a spouse who cannot be claimed, with no child units (the claimable spouse is the spouse) period: 2025 input: people: @@ -152,18 +157,20 @@ is_tax_unit_head: false is_tax_unit_spouse: true claimed_as_dependent_on_another_return: true + child: + age: 5 tax_units: tax_unit: - members: [person_b, person_a] + members: [person_b, person_a, child] filing_status: JOINT households: household: - members: [person_b, person_a] + members: [person_b, person_a, child] state_code: GA output: - ga_low_income_credit_potential: 0 + ga_low_income_credit_potential: 52 -- name: 2025 joint return with both spouses claimable as dependents, no low income credit +- name: 2025 joint return with both spouses claimable as dependents, low income credit only through a spouse who cannot be claimed, with no child units period: 2025 input: people: @@ -179,18 +186,20 @@ is_tax_unit_head: false is_tax_unit_spouse: true claimed_as_dependent_on_another_return: true + child: + age: 5 tax_units: tax_unit: - members: [person_a, person_b] + members: [person_a, person_b, child] filing_status: JOINT households: household: - members: [person_a, person_b] + members: [person_a, person_b, child] state_code: GA output: ga_low_income_credit_potential: 0 -- name: 2025 joint return with neither spouse claimable, no low income credit +- name: 2025 joint return with neither spouse claimable, low income credit only through a spouse who cannot be claimed, with no child units period: 2025 input: people: @@ -204,14 +213,16 @@ employment_income: 2_500 is_tax_unit_head: false is_tax_unit_spouse: true + child: + age: 5 tax_units: tax_unit: - members: [person_a, person_b] + members: [person_a, person_b, child] filing_status: JOINT households: household: - members: [person_a, person_b] + members: [person_a, person_b, child] state_code: GA output: - # 2 exemptions x 26 at federal AGI 5,000 - ga_low_income_credit_potential: 52 + # 3 units x 26 + ga_low_income_credit_potential: 78 diff --git a/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/ga_surplus_tax_rebate.yaml b/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/ga_surplus_tax_rebate.yaml index 62144458c04..29e7a0eb179 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/ga_surplus_tax_rebate.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/ga_surplus_tax_rebate.yaml @@ -125,7 +125,7 @@ ga_income_tax: 0 -- name: 2021 single filer who can be claimed as a dependent, no surplus tax rebate when the claimed filer had no earned income +- name: 2021 single filer who can be claimed as a dependent, surplus tax rebate only through a spouse who qualifies when the claimed filer had no earned income period: 2021 input: people: @@ -145,11 +145,12 @@ state_code: GA output: # O.C.G.A. 48-7-20.2(a)(1)(B): an individual claimed as a - # dependent for 2021 is excluded unless that individual had - # earned income ((a)(2)); a joint return needs both spouses. + # dependent for 2021 is not a qualified taxpayer unless that + # individual had earned income ((a)(2)); the other spouse + # qualifies, and the joint amount is min(500, 600). ga_surplus_tax_rebate: 0 -- name: 2021 joint return with one spouse who can be claimed as a dependent, no surplus tax rebate when the claimed filer had no earned income (the claimable spouse is the head) +- name: 2021 joint return with one spouse who can be claimed as a dependent, surplus tax rebate only through a spouse who qualifies when the claimed filer had no earned income (the claimable spouse is the head) period: 2021 input: people: @@ -174,9 +175,9 @@ members: [person_a, person_b] state_code: GA output: - ga_surplus_tax_rebate: 0 + ga_surplus_tax_rebate: 500 -- name: 2021 joint return with one spouse who can be claimed as a dependent, no surplus tax rebate when the claimed filer had no earned income (the claimable spouse is the spouse) +- name: 2021 joint return with one spouse who can be claimed as a dependent, surplus tax rebate only through a spouse who qualifies when the claimed filer had no earned income (the claimable spouse is the spouse) period: 2021 input: people: @@ -201,9 +202,9 @@ members: [person_b, person_a] state_code: GA output: - ga_surplus_tax_rebate: 0 + ga_surplus_tax_rebate: 500 -- name: 2021 joint return with both spouses claimable as dependents, no surplus tax rebate when the claimed filer had no earned income +- name: 2021 joint return with both spouses claimable as dependents, surplus tax rebate only through a spouse who qualifies when the claimed filer had no earned income period: 2021 input: people: @@ -229,9 +230,9 @@ members: [person_a, person_b] state_code: GA output: - ga_surplus_tax_rebate: 0 + ga_surplus_tax_rebate: 500 -- name: 2021 joint return with neither spouse claimable, no surplus tax rebate when the claimed filer had no earned income +- name: 2021 joint return with neither spouse claimable, surplus tax rebate only through a spouse who qualifies when the claimed filer had no earned income period: 2021 input: people: @@ -387,3 +388,33 @@ state_code: GA output: ga_surplus_tax_rebate: 500 + + +- name: 2021 joint return with both spouses claimed and neither with earned income gets no surplus tax rebate + period: 2021 + input: + people: + person_a: + age: 30 + taxable_interest_income: 1_000 + is_tax_unit_head: true + is_tax_unit_spouse: false + claimed_as_dependent_on_another_return: true + person_b: + age: 30 + taxable_interest_income: 1_000 + is_tax_unit_head: false + is_tax_unit_spouse: true + claimed_as_dependent_on_another_return: true + tax_units: + tax_unit: + members: [person_a, person_b] + filing_status: JOINT + ga_income_tax_before_non_refundable_credits: 600 + households: + household: + members: [person_a, person_b] + state_code: GA + output: + # Neither spouse is a qualified taxpayer. + ga_surplus_tax_rebate: 0 diff --git a/policyengine_us/variables/gov/states/ga/tax/income/credits/ga_low_income_credit_potential.py b/policyengine_us/variables/gov/states/ga/tax/income/credits/ga_low_income_credit_potential.py index 1b1dae6137f..5dbba1754a2 100644 --- a/policyengine_us/variables/gov/states/ga/tax/income/credits/ga_low_income_credit_potential.py +++ b/policyengine_us/variables/gov/states/ga/tax/income/credits/ga_low_income_credit_potential.py @@ -14,6 +14,10 @@ class ga_low_income_credit_potential(Variable): # income tax return". "https://dor.georgia.gov/document/document/2025-it-511-individual-income-tax-booklet/download#page=17", "https://dor.georgia.gov/low-income-tax-credit", + # O.C.G.A. 48-7A-3(a) as amended by HB 1069 (2010), section 5, printed + # page 1172. + "https://dlg.usg.edu/record/dlg_ggpd_y-ga-bl407-b2010-bv-p1-bbk-p1-belec-p-btext", + "https://www.law.cornell.edu/uscode/text/26/152#b_1", ) defined_for = StateCode.GA @@ -22,10 +26,19 @@ def formula(tax_unit, period, parameters): # "multiplied by the number of dependents which the taxpayer is entitled to claim." # The tax form excludes adult dependents: # "Exemptions are self, spouse and natural or legally adopted children" - # Georgia counts its own exemptions (O.C.G.A. 48-7A-3 deems each joint - # spouse a dependent), not the federal count, which leaves out a - # filer who can be claimed as a dependent. - exemptions = tax_unit("tax_unit_size", period) + # O.C.G.A. 48-7A-3(a): "each resident taxpayer ... who is not claimed + # or is not otherwise eligible to be claimed as a dependent" may claim + # the credit, and "A husband and wife filing a joint return shall each + # be deemed a dependent for purposes of such joint return". So Georgia + # counts its own units rather than federal exemptions, and a joint + # return keeps both spouses' units while either spouse can claim. A + # return on which a filer can be claimed has no dependents (Georgia + # follows the federal rules, IRC 152(b)(1)). + size = tax_unit("tax_unit_size", period) + dependents = tax_unit("tax_unit_dependents", period) + filer_is_dependent = tax_unit("head_or_spouse_is_dependent_elsewhere", period) + exemptions = where(filer_is_dependent, size - dependents, size) + eligible = tax_unit("head_spouse_count_not_dependent_elsewhere", period) > 0 p = parameters(period).gov.states.ga.tax.income.credits.low_income # age threshold age_threshold = p.supplement_age_eligibility @@ -39,9 +52,4 @@ def formula(tax_unit, period, parameters): total_exemptions = aged_count + exemptions federal_agi = tax_unit("adjusted_gross_income", period) amount_per_exemption = p.amount.calc(federal_agi) - # O.C.G.A. 48-7A-3 allows the credit only to a taxpayer who is not - # claimed or eligible to be claimed as a dependent. The return-level - # worksheet counts self, spouse and children, so either spouse being - # claimable bars the joint return. - filer_is_dependent = tax_unit("head_or_spouse_is_dependent_elsewhere", period) - return total_exemptions * amount_per_exemption * ~filer_is_dependent + return total_exemptions * amount_per_exemption * eligible diff --git a/policyengine_us/variables/gov/states/ga/tax/income/credits/ga_surplus_tax_rebate.py b/policyengine_us/variables/gov/states/ga/tax/income/credits/ga_surplus_tax_rebate.py index 999c6f715d4..a46bad2671a 100644 --- a/policyengine_us/variables/gov/states/ga/tax/income/credits/ga_surplus_tax_rebate.py +++ b/policyengine_us/variables/gov/states/ga/tax/income/credits/ga_surplus_tax_rebate.py @@ -26,11 +26,12 @@ def formula(tax_unit, period, parameters): # before credits); it pays out past a zero balance due. line_16_tax = tax_unit("ga_income_tax_before_non_refundable_credits", period) # 48-7-20.2(a)(1)(B) and (a)(2): an individual claimed as a dependent - # for 2021 qualifies only if that individual had 2021 earned income. A - # joint return qualifies only if neither spouse is so excluded. + # for 2021 is a qualified taxpayer only if that individual had 2021 + # earned income. The refund is credited to a qualified taxpayer, so a + # joint return gets the joint amount while either spouse qualifies. person = tax_unit.members filer = person("is_tax_unit_head_or_spouse", period) claimed = person("claimed_as_dependent_on_another_return", period) own_earnings = person("earned_income", period) > 0 - qualified = ~tax_unit.any(filer & claimed & ~own_earnings) + qualified = tax_unit.any(filer & (~claimed | own_earnings)) return min_(cap, line_16_tax) * qualified From 39cc805e4a82368f8ab63a9bb089a193c6a3df5e Mon Sep 17 00:00:00 2001 From: Max Ghenis Date: Sat, 10 Oct 2026 07:35:31 -0400 Subject: [PATCH 3/5] Project the claimable-filer flag to members before combining with ages The flag is a tax-unit array and ages are per person; one-return YAML cases broadcast, but a vectorized simulation with several returns does not. Adds a two-return YAML case. Co-Authored-By: Claude Opus 5.5 --- .../gov/states/dc/tax/income/dc_kccatc.yaml | 29 +++++++++++++++++++ .../states/dc/tax/income/credits/dc_kccatc.py | 4 ++- 2 files changed, 32 insertions(+), 1 deletion(-) diff --git a/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/dc_kccatc.yaml b/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/dc_kccatc.yaml index 0bada9624cf..7c841a4ae0d 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/dc_kccatc.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/dc_kccatc.yaml @@ -327,3 +327,32 @@ output: # min(2,000, 1,200) dc_kccatc: 1_200 + +- name: 2025 two returns in one household, only the return whose filer can be claimed loses the keep child care affordable credit + period: 2025 + input: + people: + parent_claimed: + age: 20 + employment_income: 5_000 + claimed_as_dependent_on_another_return: true + child_a: + age: 2 + parent: + age: 30 + employment_income: 5_000 + child_b: + age: 2 + tax_units: + claimed_return: + members: [parent_claimed, child_a] + tax_unit_childcare_expenses: 2_000 + other_return: + members: [parent, child_b] + tax_unit_childcare_expenses: 2_000 + households: + household: + members: [parent_claimed, child_a, parent, child_b] + state_code: DC + output: + dc_kccatc: [0, 1_200] diff --git a/policyengine_us/variables/gov/states/dc/tax/income/credits/dc_kccatc.py b/policyengine_us/variables/gov/states/dc/tax/income/credits/dc_kccatc.py index 7dddc52b427..052bb75741e 100644 --- a/policyengine_us/variables/gov/states/dc/tax/income/credits/dc_kccatc.py +++ b/policyengine_us/variables/gov/states/dc/tax/income/credits/dc_kccatc.py @@ -28,7 +28,9 @@ def formula(tax_unit, period, parameters): # The child must be the taxpayer's dependent on the federal and District # returns. A return on which the filer (or, if joint, either spouse) # can be claimed as a dependent has no dependents (IRC 152(b)(1)). - filer_is_dependent = tax_unit("head_or_spouse_is_dependent_elsewhere", period) + filer_is_dependent = person.tax_unit( + "head_or_spouse_is_dependent_elsewhere", period + ) is_dependent = person("is_tax_unit_dependent", period) & ~filer_is_dependent age = person("age", period) kccatc_age_eligible = is_dependent & (age <= p.kccatc.max_age) From ad6f1e9a9cc3cd0ef6d57fadad50dfc0b7c22efa Mon Sep 17 00:00:00 2001 From: Max Ghenis Date: Sat, 10 Oct 2026 08:34:55 -0400 Subject: [PATCH 4/5] Address review: carry the claimable-filer rules into the GA, DC property tax and KCCATC reforms; fix test fixtures - Georgia's dependent exemption reform, DC's property tax credit reform (both branches) and the DC KCCATC reform's inactive fallback replace the fixed formulas; each now keeps the baseline rule for a claimable filer, with regression cases. The Schedule H claimant rule moves into `dc_ptc_has_eligible_claimant`, shared by the baseline and the reform. - Idaho food tax credit cases set twelve qualified months (low incomes made the household SNAP-eligible, which zeroed every case). - Schedule H cases put the rent on the spouse who can be the claimant, so they hold whether rent is pooled or limited to the claimant's own payments. - The HB 162 refund documents that the single flag stands in for "was claimed". Co-Authored-By: Claude Opus 5.5 --- policyengine_us/reforms/dc_kccatc.py | 9 +++++- .../dc/property_tax/dc_property_tax_reform.py | 7 +++-- .../ga_dependent_exemption_reform.py | 8 +++++- ...est_claimable_filer_dc_ga_id_invariants.py | 10 ++++--- .../gov/states/dc/tax/income/dc_ptc.yaml | 14 ++++------ .../credits/grocery/id_grocery_credit.yaml | 14 ++++++++++ .../tests/policy/contrib/dc_kccatc.yaml | 27 ++++++++++++++++++ .../property_tax/dc_property_tax_credit.yaml | 25 +++++++++++++++++ .../ga/dependent_exemption_reform_test.yaml | 15 ++++++++++ .../states/dc/tax/income/credits/dc_ptc.py | 11 ++------ .../credits/dc_ptc_has_eligible_claimant.py | 28 +++++++++++++++++++ .../income/credits/ga_surplus_tax_rebate.py | 3 ++ 12 files changed, 146 insertions(+), 25 deletions(-) create mode 100644 policyengine_us/variables/gov/states/dc/tax/income/credits/dc_ptc_has_eligible_claimant.py diff --git a/policyengine_us/reforms/dc_kccatc.py b/policyengine_us/reforms/dc_kccatc.py index db3a3563abc..85d1ef79624 100644 --- a/policyengine_us/reforms/dc_kccatc.py +++ b/policyengine_us/reforms/dc_kccatc.py @@ -56,7 +56,14 @@ def formula(tax_unit, period, parameters): income_eligible = taxinc <= p.kccatc.income_limit[filing_status] # determine count of KCCATC age eligible children person = tax_unit.members - is_dependent = person("is_tax_unit_dependent", period) + # As in the baseline formula: no dependents on a return whose + # filer (or, if joint, either spouse) can be claimed. + filer_is_dependent = person.tax_unit( + "head_or_spouse_is_dependent_elsewhere", period + ) + is_dependent = ( + person("is_tax_unit_dependent", period) & ~filer_is_dependent + ) age = person("age", period) kccatc_age_eligible = is_dependent & (age <= p.kccatc.max_age) kccatc_eligible_count = tax_unit.sum(kccatc_age_eligible) diff --git a/policyengine_us/reforms/states/dc/property_tax/dc_property_tax_reform.py b/policyengine_us/reforms/states/dc/property_tax/dc_property_tax_reform.py index 8bc8b12666c..575409634c0 100644 --- a/policyengine_us/reforms/states/dc/property_tax/dc_property_tax_reform.py +++ b/policyengine_us/reforms/states/dc/property_tax/dc_property_tax_reform.py @@ -22,12 +22,15 @@ def formula(tax_unit, period, parameters): # Income based eligibility criteria does not apply when the credit # is phased out. eligible = tax_unit("dc_ptc_eligible", period) + # The reform keeps D.C. Code 47-1806.06(k): no credit through a + # claimant who was a dependent, unless 65 or older. + has_claimant = tax_unit("dc_ptc_has_eligible_claimant", period) if p.phase_out.applies: income_limit = tax_unit("dc_ptc_income_limit", period) income = tax_unit("adjusted_gross_income", period) income_excess = max_(0, income - income_limit) - return max_(0, amount - p.phase_out.rate * income_excess) - return amount * eligible + return max_(0, amount - p.phase_out.rate * income_excess) * has_claimant + return amount * eligible * has_claimant class dc_ptc_eligible(Variable): value_type = bool diff --git a/policyengine_us/reforms/states/ga/dependent_exemption/ga_dependent_exemption_reform.py b/policyengine_us/reforms/states/ga/dependent_exemption/ga_dependent_exemption_reform.py index a481f29abd6..f6d702f7859 100644 --- a/policyengine_us/reforms/states/ga/dependent_exemption/ga_dependent_exemption_reform.py +++ b/policyengine_us/reforms/states/ga/dependent_exemption/ga_dependent_exemption_reform.py @@ -15,7 +15,13 @@ def formula(tax_unit, period, parameters): person = tax_unit.members age = person("age", period) - is_dependent = person("is_tax_unit_dependent", period) + # A return on which the filer (or, if joint, either spouse) can be + # claimed as a dependent has no dependents (IRC 152(b)(1)), as in + # the baseline formula. + filer_is_dependent = person.tax_unit( + "head_or_spouse_is_dependent_elsewhere", period + ) + is_dependent = person("is_tax_unit_dependent", period) & ~filer_is_dependent # Apply age limit if in effect. if p.age_limit.in_effect: diff --git a/policyengine_us/tests/core/test_claimable_filer_dc_ga_id_invariants.py b/policyengine_us/tests/core/test_claimable_filer_dc_ga_id_invariants.py index ebad5ce6cce..de82902d840 100644 --- a/policyengine_us/tests/core/test_claimable_filer_dc_ga_id_invariants.py +++ b/policyengine_us/tests/core/test_claimable_filer_dc_ga_id_invariants.py @@ -14,10 +14,12 @@ labelling. 2. Monotonicity: marking another filer as claimed never raises the outputs in MONOTONE (amounts not capped by a tax liability that the claim can raise). -3. Identities: a return with a claimable filer has no DC child care or child - tax credit and its Idaho food tax credit is at most one filer's amount; a - return on which every filer can be claimed has no Georgia low income - credit. +3. Identities: a return with a claimable filer has no DC keep child care + affordable credit or child tax credit and its Idaho food tax credit is at + most one filer's amount; a return on which every filer can be claimed has + no Georgia low income credit. + +Hypothesis batches check 1 and 3; the seeded population checks 1, 2 and 3. """ import numpy as np diff --git a/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/dc_ptc.yaml b/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/dc_ptc.yaml index 561f8262280..ee8ed760ba9 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/dc_ptc.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/dc_ptc.yaml @@ -313,7 +313,7 @@ output: # D.C. Code 47-1806.06(k) bars a claimant who was a dependent, # unless 65 or older; one claimant per tax filing unit, so the - # spouse who is not a dependent claims it. + # spouse who is not a dependent claims it (and pays the rent). # min(0.20 x 10,000 - 3% x 10,000, 1,425) = 1,425 dc_ptc: 0 @@ -324,14 +324,13 @@ person_a: age: 30 employment_income: 5_000 - rent: 5_000 is_tax_unit_head: true is_tax_unit_spouse: false claimed_as_dependent_on_another_return: true person_b: age: 30 employment_income: 5_000 - rent: 5_000 + rent: 10_000 is_tax_unit_head: false is_tax_unit_spouse: true tax_units: @@ -352,13 +351,12 @@ person_b: age: 30 employment_income: 5_000 - rent: 5_000 + rent: 10_000 is_tax_unit_head: true is_tax_unit_spouse: false person_a: age: 30 employment_income: 5_000 - rent: 5_000 is_tax_unit_head: false is_tax_unit_spouse: true claimed_as_dependent_on_another_return: true @@ -380,14 +378,13 @@ person_a: age: 30 employment_income: 5_000 - rent: 5_000 is_tax_unit_head: true is_tax_unit_spouse: false claimed_as_dependent_on_another_return: true person_b: age: 30 employment_income: 5_000 - rent: 5_000 + rent: 10_000 is_tax_unit_head: false is_tax_unit_spouse: true claimed_as_dependent_on_another_return: true @@ -409,13 +406,12 @@ person_a: age: 30 employment_income: 5_000 - rent: 5_000 is_tax_unit_head: true is_tax_unit_spouse: false person_b: age: 30 employment_income: 5_000 - rent: 5_000 + rent: 10_000 is_tax_unit_head: false is_tax_unit_spouse: true tax_units: diff --git a/policyengine_us/tests/policy/baseline/gov/states/id/tax/income/credits/grocery/id_grocery_credit.yaml b/policyengine_us/tests/policy/baseline/gov/states/id/tax/income/credits/grocery/id_grocery_credit.yaml index 177e1dfc472..ef32848589a 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/id/tax/income/credits/grocery/id_grocery_credit.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/id/tax/income/credits/grocery/id_grocery_credit.yaml @@ -103,11 +103,13 @@ filer: age: 30 employment_income: 10_000 + id_grocery_credit_qualified_months: 12 is_tax_unit_head: true is_tax_unit_spouse: false claimed_as_dependent_on_another_return: true child: age: 5 + id_grocery_credit_qualified_months: 12 tax_units: tax_unit: members: [filer, child] @@ -128,16 +130,19 @@ person_a: age: 30 employment_income: 5_000 + id_grocery_credit_qualified_months: 12 is_tax_unit_head: true is_tax_unit_spouse: false claimed_as_dependent_on_another_return: true person_b: age: 30 employment_income: 5_000 + id_grocery_credit_qualified_months: 12 is_tax_unit_head: false is_tax_unit_spouse: true child: age: 5 + id_grocery_credit_qualified_months: 12 tax_units: tax_unit: members: [person_a, person_b, child] @@ -156,16 +161,19 @@ person_b: age: 30 employment_income: 5_000 + id_grocery_credit_qualified_months: 12 is_tax_unit_head: true is_tax_unit_spouse: false person_a: age: 30 employment_income: 5_000 + id_grocery_credit_qualified_months: 12 is_tax_unit_head: false is_tax_unit_spouse: true claimed_as_dependent_on_another_return: true child: age: 5 + id_grocery_credit_qualified_months: 12 tax_units: tax_unit: members: [person_b, person_a, child] @@ -184,17 +192,20 @@ person_a: age: 30 employment_income: 5_000 + id_grocery_credit_qualified_months: 12 is_tax_unit_head: true is_tax_unit_spouse: false claimed_as_dependent_on_another_return: true person_b: age: 30 employment_income: 5_000 + id_grocery_credit_qualified_months: 12 is_tax_unit_head: false is_tax_unit_spouse: true claimed_as_dependent_on_another_return: true child: age: 5 + id_grocery_credit_qualified_months: 12 tax_units: tax_unit: members: [person_a, person_b, child] @@ -213,15 +224,18 @@ person_a: age: 30 employment_income: 5_000 + id_grocery_credit_qualified_months: 12 is_tax_unit_head: true is_tax_unit_spouse: false person_b: age: 30 employment_income: 5_000 + id_grocery_credit_qualified_months: 12 is_tax_unit_head: false is_tax_unit_spouse: true child: age: 5 + id_grocery_credit_qualified_months: 12 tax_units: tax_unit: members: [person_a, person_b, child] diff --git a/policyengine_us/tests/policy/contrib/dc_kccatc.yaml b/policyengine_us/tests/policy/contrib/dc_kccatc.yaml index c2178274e53..50e616343aa 100644 --- a/policyengine_us/tests/policy/contrib/dc_kccatc.yaml +++ b/policyengine_us/tests/policy/contrib/dc_kccatc.yaml @@ -42,3 +42,30 @@ state_code: DC output: dc_kccatc: 3_000 + +- name: DC KCCATC reform switched off keeps the baseline dependent rule for a filer who can be claimed + period: 2025 + reforms: policyengine_us.reforms.dc_kccatc.dc_kccatc_reform + input: + gov.contrib.dc_kccatc.active: false + people: + parent: {age: 20, employment_income: 10_000, claimed_as_dependent_on_another_return: true} + child: {age: 2} + tax_units: {tax_unit: {members: [parent, child], tax_unit_childcare_expenses: 2_000}} + households: {household: {members: [parent, child], state_code: DC}} + # D.C. Code 47-1806.15(d)(1); IRC 152(b)(1). + output: + dc_kccatc: 0 + +- name: DC KCCATC reform switched off matches the baseline when nobody can be claimed + period: 2025 + reforms: policyengine_us.reforms.dc_kccatc.dc_kccatc_reform + input: + gov.contrib.dc_kccatc.active: false + people: + parent: {age: 20, employment_income: 10_000} + child: {age: 2} + tax_units: {tax_unit: {members: [parent, child], tax_unit_childcare_expenses: 2_000}} + households: {household: {members: [parent, child], state_code: DC}} + output: + dc_kccatc: 1_200 diff --git a/policyengine_us/tests/policy/contrib/states/dc/property_tax/dc_property_tax_credit.yaml b/policyengine_us/tests/policy/contrib/states/dc/property_tax/dc_property_tax_credit.yaml index c0844cea46a..6a6fa1e6719 100644 --- a/policyengine_us/tests/policy/contrib/states/dc/property_tax/dc_property_tax_credit.yaml +++ b/policyengine_us/tests/policy/contrib/states/dc/property_tax/dc_property_tax_credit.yaml @@ -182,3 +182,28 @@ output: dc_ptc_income_limit: 65_600 dc_ptc: 1_160 + +- name: DC property tax reform keeps the dependent claimant bar for a filer under 65 who can be claimed + period: 2025 + reforms: policyengine_us.reforms.states.dc.property_tax.dc_property_tax_reform.dc_property_tax_credit + input: + gov.contrib.states.dc.property_tax.in_effect: true + people: + filer: {age: 30, employment_income: 10_000, claimed_as_dependent_on_another_return: true} + tax_units: {tax_unit: {members: [filer]}} + households: {household: {members: [filer], state_code: DC}} + # D.C. Code 47-1806.06(k). + output: + dc_ptc: 0 + +- name: DC property tax reform pays the same filer when nobody can claim them + period: 2025 + reforms: policyengine_us.reforms.states.dc.property_tax.dc_property_tax_reform.dc_property_tax_credit + input: + gov.contrib.states.dc.property_tax.in_effect: true + people: + filer: {age: 30, employment_income: 10_000} + tax_units: {tax_unit: {members: [filer]}} + households: {household: {members: [filer], state_code: DC}} + output: + dc_ptc: 1_400 diff --git a/policyengine_us/tests/policy/contrib/states/ga/dependent_exemption_reform_test.yaml b/policyengine_us/tests/policy/contrib/states/ga/dependent_exemption_reform_test.yaml index fd067172dc2..6529831f38b 100644 --- a/policyengine_us/tests/policy/contrib/states/ga/dependent_exemption_reform_test.yaml +++ b/policyengine_us/tests/policy/contrib/states/ga/dependent_exemption_reform_test.yaml @@ -94,3 +94,18 @@ output: ga_exemptions: 4_000 ga_dependent_exemption: 4_000 + +- name: GA dependent exemption reform at its defaults keeps no dependent exemption for a filer who can be claimed + period: 2025 + reforms: policyengine_us.reforms.states.ga.dependent_exemption.ga_dependent_exemption_reform.ga_dependent_exemption_reform + input: + gov.contrib.states.ga.dependent_exemption.in_effect: true + people: + parent: {age: 20, employment_income: 10_000, claimed_as_dependent_on_another_return: true} + child1: {age: 5, is_tax_unit_dependent: true} + tax_units: {tax_unit: {members: [parent, child1]}} + households: {household: {members: [parent, child1], state_name: GA}} + # As in the baseline: a return with a claimable filer has no dependents (IRC 152(b)(1)). + output: + ga_exemptions: 0 + ga_dependent_exemption: 0 diff --git a/policyengine_us/variables/gov/states/dc/tax/income/credits/dc_ptc.py b/policyengine_us/variables/gov/states/dc/tax/income/credits/dc_ptc.py index 1e9fab462b3..a73affd0e0f 100644 --- a/policyengine_us/variables/gov/states/dc/tax/income/credits/dc_ptc.py +++ b/policyengine_us/variables/gov/states/dc/tax/income/credits/dc_ptc.py @@ -37,14 +37,9 @@ def formula(tax_unit, period, parameters): ) uncapped_ptc = max_(0, ptax - ptax_offset) # D.C. Code 47-1806.06(k): no credit for a claimant who was a dependent - # under any income tax law that year, unless 65 or older. Only one - # claimant per tax filing unit may claim the credit ((b)(4)), so a - # couple can claim it through a spouse who is not such a dependent. - person = tax_unit.members - filer = person("is_tax_unit_head_or_spouse", period) - claimed = person("claimed_as_dependent_on_another_return", period) - old_enough = person("age", period) >= p_dc.ptc.dependent_claimant_min_age - has_claimant = tax_unit.any(filer & (~claimed | old_enough)) + # under any income tax law that year, unless 65 or older; a couple can + # claim it through a spouse who is not such a dependent ((b)(4)). + has_claimant = tax_unit("dc_ptc_has_eligible_claimant", period) return ( min_(p_dc.ptc.max, uncapped_ptc) * tax_unit("takes_up_dc_ptc", period) diff --git a/policyengine_us/variables/gov/states/dc/tax/income/credits/dc_ptc_has_eligible_claimant.py b/policyengine_us/variables/gov/states/dc/tax/income/credits/dc_ptc_has_eligible_claimant.py new file mode 100644 index 00000000000..d2a4c97b952 --- /dev/null +++ b/policyengine_us/variables/gov/states/dc/tax/income/credits/dc_ptc_has_eligible_claimant.py @@ -0,0 +1,28 @@ +from policyengine_us.model_api import * + + +class dc_ptc_has_eligible_claimant(Variable): + value_type = bool + entity = TaxUnit + label = "DC property tax credit has an eligible claimant" + documentation = ( + "Whether a filer in the tax unit can be the Schedule H claimant: no " + "credit is allowed for a year in which the person claiming it was a " + "dependent under an income tax law, unless that person is 65 or older. " + "Only one claimant per tax filing unit may claim the credit, so a " + "couple can claim it through either spouse." + ) + definition_period = YEAR + reference = ( + # D.C. Code 47-1806.06(b)(4) and (k). + "https://code.dccouncil.gov/us/dc/council/code/sections/47-1806.06", + ) + defined_for = StateCode.DC + + def formula(tax_unit, period, parameters): + p = parameters(period).gov.states.dc.tax.income.credits.ptc + person = tax_unit.members + filer = person("is_tax_unit_head_or_spouse", period) + claimed = person("claimed_as_dependent_on_another_return", period) + old_enough = person("age", period) >= p.dependent_claimant_min_age + return tax_unit.any(filer & (~claimed | old_enough)) diff --git a/policyengine_us/variables/gov/states/ga/tax/income/credits/ga_surplus_tax_rebate.py b/policyengine_us/variables/gov/states/ga/tax/income/credits/ga_surplus_tax_rebate.py index a46bad2671a..c9d5b903af6 100644 --- a/policyengine_us/variables/gov/states/ga/tax/income/credits/ga_surplus_tax_rebate.py +++ b/policyengine_us/variables/gov/states/ga/tax/income/credits/ga_surplus_tax_rebate.py @@ -29,6 +29,9 @@ def formula(tax_unit, period, parameters): # for 2021 is a qualified taxpayer only if that individual had 2021 # earned income. The refund is credited to a qualified taxpayer, so a # joint return gets the joint amount while either spouse qualifies. + # The law excludes an individual actually claimed; the model's single + # flag (can be claimed) stands in for that, so a claimable filer whom + # nobody claimed and who had no earned income gets no refund here. person = tax_unit.members filer = person("is_tax_unit_head_or_spouse", period) claimed = person("claimed_as_dependent_on_another_return", period) From 81ab8e431284bdf910fdcf52572ee14674c23dae Mon Sep 17 00:00:00 2001 From: Max Ghenis Date: Sun, 11 Oct 2026 12:22:23 -0400 Subject: [PATCH 5/5] Read the split claimable / claimed inputs from the settled federal branch The federal branch (#10087) now separates whether another taxpayer can claim a filer (`claimable_as_dependent_on_another_return`) from an actual claim (`claimed_as_dependent_on_another_return`), and adds the Publication 501 filing exception for the Dependent Taxpayer Test (`head_or_spouse_is_dependent_elsewhere_without_filing_exception`). - Rules that a return has no dependents (IRC 152(b)(1)) and the childless EITC bar read the filing-exception helper, as the federal formulas do. - Rules that turn on an actual claim read the claim input: Illinois' 2022 rebate (sec. 212.1, "who is claimed") and Georgia's HB 162 refund ("who was claimed"). - Rules that turn on being claimable read claimability: Georgia's low income credit ("claimed or ... eligible to be claimed") and Idaho's food tax credit ("can claim you"). DC Schedule H's "was a dependent" reads the person-level filing-exception helper. - New cases for a filer who can be claimed but is not, and for the filing exception. Co-Authored-By: Claude Opus 5.5 --- policyengine_us/reforms/dc_kccatc.py | 3 +- .../ga_dependent_exemption_reform.py | 2 +- .../gov/states/dc/tax/income/dc_ptc.yaml | 47 +++++++++++++++++++ .../income/credits/ga_low_income_credit.yaml | 24 ++++++++++ .../income/credits/ga_surplus_tax_rebate.yaml | 25 ++++++++++ .../credits/grocery/id_grocery_credit.yaml | 24 ++++++++++ .../credits/ctc/dc_ctc_eligible_child.py | 2 +- .../states/dc/tax/income/credits/dc_kccatc.py | 2 +- .../credits/dc_ptc_has_eligible_claimant.py | 6 ++- .../eitc/dc_eitc_without_qualifying_child.py | 4 +- .../credits/ctc/ga_ctc_eligible_child.py | 10 ++-- .../credits/ga_low_income_credit_potential.py | 11 ++++- .../income/credits/ga_surplus_tax_rebate.py | 4 +- .../ga/tax/income/exemptions/ga_exemptions.py | 4 +- .../2022_rebate/id_2022_rebate_floor.py | 2 +- .../credits/grocery/id_grocery_credit.py | 6 +-- 16 files changed, 156 insertions(+), 20 deletions(-) diff --git a/policyengine_us/reforms/dc_kccatc.py b/policyengine_us/reforms/dc_kccatc.py index 85d1ef79624..39d1bfaa4eb 100644 --- a/policyengine_us/reforms/dc_kccatc.py +++ b/policyengine_us/reforms/dc_kccatc.py @@ -59,7 +59,8 @@ def formula(tax_unit, period, parameters): # As in the baseline formula: no dependents on a return whose # filer (or, if joint, either spouse) can be claimed. filer_is_dependent = person.tax_unit( - "head_or_spouse_is_dependent_elsewhere", period + "head_or_spouse_is_dependent_elsewhere_without_filing_exception", + period, ) is_dependent = ( person("is_tax_unit_dependent", period) & ~filer_is_dependent diff --git a/policyengine_us/reforms/states/ga/dependent_exemption/ga_dependent_exemption_reform.py b/policyengine_us/reforms/states/ga/dependent_exemption/ga_dependent_exemption_reform.py index f6d702f7859..68fea999af8 100644 --- a/policyengine_us/reforms/states/ga/dependent_exemption/ga_dependent_exemption_reform.py +++ b/policyengine_us/reforms/states/ga/dependent_exemption/ga_dependent_exemption_reform.py @@ -19,7 +19,7 @@ def formula(tax_unit, period, parameters): # claimed as a dependent has no dependents (IRC 152(b)(1)), as in # the baseline formula. filer_is_dependent = person.tax_unit( - "head_or_spouse_is_dependent_elsewhere", period + "head_or_spouse_is_dependent_elsewhere_without_filing_exception", period ) is_dependent = person("is_tax_unit_dependent", period) & ~filer_is_dependent diff --git a/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/dc_ptc.yaml b/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/dc_ptc.yaml index ee8ed760ba9..e7b38145c44 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/dc_ptc.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/dc/tax/income/dc_ptc.yaml @@ -446,3 +446,50 @@ # The dependent bar does not apply at 65 or older; the # elderly fractions start at 70. dc_ptc: 1_425 + + +- name: 2025 single filer who can be claimed is a valid Schedule H claimant when the would-be claimant meets the filing exception + period: 2025 + input: + people: + filer: + age: 30 + is_tax_unit_head: true + employment_income: 10_000 + rent: 10_000 + claimable_as_dependent_on_another_return: true + dependent_claimant_filing_exception: true + tax_units: + tax_unit: + members: [filer] + households: + household: + members: [filer] + state_code: DC + output: + # Not a dependent under the federal income tax law, so + # 47-1806.06(k) does not bar the claim. + dc_ptc: 1_425 + +- name: 2025 single filer who can be claimed but is not claimed cannot claim Schedule H + period: 2025 + input: + people: + filer: + age: 30 + is_tax_unit_head: true + employment_income: 10_000 + rent: 10_000 + claimable_as_dependent_on_another_return: true + claimed_as_dependent_on_another_return: false + tax_units: + tax_unit: + members: [filer] + households: + household: + members: [filer] + state_code: DC + output: + # 47-1806.06(k) turns on being a dependent, not on an + # actual claim; see the PR's readings. + dc_ptc: 0 diff --git a/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/ga_low_income_credit.yaml b/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/ga_low_income_credit.yaml index 5c2baf6b3a6..9d877af5a50 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/ga_low_income_credit.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/ga_low_income_credit.yaml @@ -226,3 +226,27 @@ output: # 3 units x 26 ga_low_income_credit_potential: 78 + + +- name: 2025 single filer who can be claimed but is not claimed gets no low income credit + period: 2025 + input: + people: + filer: + age: 30 + is_tax_unit_head: true + employment_income: 5_000 + claimable_as_dependent_on_another_return: true + claimed_as_dependent_on_another_return: false + tax_units: + tax_unit: + members: [filer] + filing_status: SINGLE + households: + household: + members: [filer] + state_code: GA + output: + # 48-7A-3(a): not claimed or otherwise eligible to be + # claimed. + ga_low_income_credit_potential: 0 diff --git a/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/ga_surplus_tax_rebate.yaml b/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/ga_surplus_tax_rebate.yaml index 29e7a0eb179..e3dfb427ca3 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/ga_surplus_tax_rebate.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/ga/tax/income/credits/ga_surplus_tax_rebate.yaml @@ -418,3 +418,28 @@ output: # Neither spouse is a qualified taxpayer. ga_surplus_tax_rebate: 0 + + +- name: 2021 single filer who can be claimed but is not claimed and has no earned income keeps the surplus tax rebate + period: 2021 + input: + people: + filer: + age: 30 + is_tax_unit_head: true + taxable_interest_income: 1_000 + claimable_as_dependent_on_another_return: true + claimed_as_dependent_on_another_return: false + tax_units: + tax_unit: + members: [filer] + filing_status: SINGLE + ga_income_tax_before_non_refundable_credits: 600 + households: + household: + members: [filer] + state_code: GA + output: + # O.C.G.A. 48-7-20.2(a)(1)(B) excludes an individual who + # was claimed: min(250, 600). + ga_surplus_tax_rebate: 250 diff --git a/policyengine_us/tests/policy/baseline/gov/states/id/tax/income/credits/grocery/id_grocery_credit.yaml b/policyengine_us/tests/policy/baseline/gov/states/id/tax/income/credits/grocery/id_grocery_credit.yaml index ef32848589a..8a204227e23 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/id/tax/income/credits/grocery/id_grocery_credit.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/id/tax/income/credits/grocery/id_grocery_credit.yaml @@ -247,3 +247,27 @@ output: # 3 x 155 id_grocery_credit: 465 + + +- name: 2025 single filer who can be claimed but is not claimed gets no food tax credit + period: 2025 + input: + people: + filer: + age: 30 + is_tax_unit_head: true + employment_income: 10_000 + id_grocery_credit_qualified_months: 12 + claimable_as_dependent_on_another_return: true + claimed_as_dependent_on_another_return: false + tax_units: + tax_unit: + members: [filer] + households: + household: + members: [filer] + state_code: ID + output: + # "You can't claim this credit if someone else ... can + # claim you as a dependent". + id_grocery_credit: 0 diff --git a/policyengine_us/variables/gov/states/dc/tax/income/credits/ctc/dc_ctc_eligible_child.py b/policyengine_us/variables/gov/states/dc/tax/income/credits/ctc/dc_ctc_eligible_child.py index dad9baf2b03..a9453cb5887 100644 --- a/policyengine_us/variables/gov/states/dc/tax/income/credits/ctc/dc_ctc_eligible_child.py +++ b/policyengine_us/variables/gov/states/dc/tax/income/credits/ctc/dc_ctc_eligible_child.py @@ -20,6 +20,6 @@ def formula(person, period, parameters): # A return on which the filer (or, if joint, either spouse) can be # claimed as a dependent has no dependents (IRC 152(b)(1)). filer_is_dependent = person.tax_unit( - "head_or_spouse_is_dependent_elsewhere", period + "head_or_spouse_is_dependent_elsewhere_without_filing_exception", period ) return (age < p.age_threshold) & ~filer_is_dependent diff --git a/policyengine_us/variables/gov/states/dc/tax/income/credits/dc_kccatc.py b/policyengine_us/variables/gov/states/dc/tax/income/credits/dc_kccatc.py index 052bb75741e..f1de6c29a1e 100644 --- a/policyengine_us/variables/gov/states/dc/tax/income/credits/dc_kccatc.py +++ b/policyengine_us/variables/gov/states/dc/tax/income/credits/dc_kccatc.py @@ -29,7 +29,7 @@ def formula(tax_unit, period, parameters): # returns. A return on which the filer (or, if joint, either spouse) # can be claimed as a dependent has no dependents (IRC 152(b)(1)). filer_is_dependent = person.tax_unit( - "head_or_spouse_is_dependent_elsewhere", period + "head_or_spouse_is_dependent_elsewhere_without_filing_exception", period ) is_dependent = person("is_tax_unit_dependent", period) & ~filer_is_dependent age = person("age", period) diff --git a/policyengine_us/variables/gov/states/dc/tax/income/credits/dc_ptc_has_eligible_claimant.py b/policyengine_us/variables/gov/states/dc/tax/income/credits/dc_ptc_has_eligible_claimant.py index d2a4c97b952..6f4cb700e55 100644 --- a/policyengine_us/variables/gov/states/dc/tax/income/credits/dc_ptc_has_eligible_claimant.py +++ b/policyengine_us/variables/gov/states/dc/tax/income/credits/dc_ptc_has_eligible_claimant.py @@ -23,6 +23,8 @@ def formula(tax_unit, period, parameters): p = parameters(period).gov.states.dc.tax.income.credits.ptc person = tax_unit.members filer = person("is_tax_unit_head_or_spouse", period) - claimed = person("claimed_as_dependent_on_another_return", period) + # "was a dependent" under an income tax law: claimable, unless the + # would-be claimant meets the filing exception (Publication 501). + dependent = person("is_dependent_elsewhere_without_filing_exception", period) old_enough = person("age", period) >= p.dependent_claimant_min_age - return tax_unit.any(filer & (~claimed | old_enough)) + return tax_unit.any(filer & (~dependent | old_enough)) diff --git a/policyengine_us/variables/gov/states/dc/tax/income/credits/eitc/dc_eitc_without_qualifying_child.py b/policyengine_us/variables/gov/states/dc/tax/income/credits/eitc/dc_eitc_without_qualifying_child.py index c3d5a612b72..197b63cdf17 100644 --- a/policyengine_us/variables/gov/states/dc/tax/income/credits/eitc/dc_eitc_without_qualifying_child.py +++ b/policyengine_us/variables/gov/states/dc/tax/income/credits/eitc/dc_eitc_without_qualifying_child.py @@ -44,7 +44,9 @@ def formula(tax_unit, period, parameters): # (f) keeps the IRC 32 framework: a filer without a qualifying child # must not be a dependent of another taxpayer, and on a joint return # neither spouse may be (Publication 596). - filer_is_dependent = tax_unit("head_or_spouse_is_dependent_elsewhere", period) + filer_is_dependent = tax_unit( + "head_or_spouse_is_dependent_elsewhere_without_filing_exception", period + ) us_eligible = ( filer_meets_identification & no_qualifying_child diff --git a/policyengine_us/variables/gov/states/ga/tax/income/credits/ctc/ga_ctc_eligible_child.py b/policyengine_us/variables/gov/states/ga/tax/income/credits/ctc/ga_ctc_eligible_child.py index 2017b09d4b3..d1476b8d51a 100644 --- a/policyengine_us/variables/gov/states/ga/tax/income/credits/ctc/ga_ctc_eligible_child.py +++ b/policyengine_us/variables/gov/states/ga/tax/income/credits/ctc/ga_ctc_eligible_child.py @@ -10,6 +10,9 @@ class ga_ctc_eligible_child(Variable): reference = ( "https://legiscan.com/GA/text/HB136/id/3204611/Georgia-2025-HB136-Enrolled.pdf#page=3", "https://www.law.cornell.edu/uscode/text/26/24#c", + # Georgia Department of Revenue, Qualifying Child Credit (tax years + # beginning on or after January 1, 2026). + "https://dor.georgia.gov/qualifying-child-credit", ) def formula(person, period, parameters): @@ -17,9 +20,10 @@ def formula(person, period, parameters): age = person("age", period) # Georgia gives "qualifying child" the meaning of IRC 24(c) only, so # it is not limited to children for whom the federal credit is - # allowed (IRC 24(a), 152(b)(1)). Whether a filer who can be claimed - # as a dependent can claim it is not settled; this keeps the IRC - # 24(c) child test. + # allowed (IRC 24(a), 152(b)(1)): a filer who can be claimed as a + # dependent keeps it for their own qualifying child. O.C.G.A. + # 48-7-29.27 has its own one-claimant rule, and the Department's + # guidance adds no dependency requirement. p_federal = parameters(period).gov.irs.credits.ctc ctc_eligible_child = ( person("is_tax_unit_dependent", period) diff --git a/policyengine_us/variables/gov/states/ga/tax/income/credits/ga_low_income_credit_potential.py b/policyengine_us/variables/gov/states/ga/tax/income/credits/ga_low_income_credit_potential.py index 5dbba1754a2..cb1b4969eb3 100644 --- a/policyengine_us/variables/gov/states/ga/tax/income/credits/ga_low_income_credit_potential.py +++ b/policyengine_us/variables/gov/states/ga/tax/income/credits/ga_low_income_credit_potential.py @@ -36,9 +36,16 @@ def formula(tax_unit, period, parameters): # follows the federal rules, IRC 152(b)(1)). size = tax_unit("tax_unit_size", period) dependents = tax_unit("tax_unit_dependents", period) - filer_is_dependent = tax_unit("head_or_spouse_is_dependent_elsewhere", period) + filer_is_dependent = tax_unit( + "head_or_spouse_is_dependent_elsewhere_without_filing_exception", period + ) exemptions = where(filer_is_dependent, size - dependents, size) - eligible = tax_unit("head_spouse_count_not_dependent_elsewhere", period) > 0 + person = tax_unit.members + filer = person("is_tax_unit_head_or_spouse", period) + excluded = person("claimed_as_dependent_on_another_return", period) | person( + "claimable_as_dependent_on_another_return", period + ) + eligible = tax_unit.any(filer & ~excluded) p = parameters(period).gov.states.ga.tax.income.credits.low_income # age threshold age_threshold = p.supplement_age_eligibility diff --git a/policyengine_us/variables/gov/states/ga/tax/income/credits/ga_surplus_tax_rebate.py b/policyengine_us/variables/gov/states/ga/tax/income/credits/ga_surplus_tax_rebate.py index c9d5b903af6..a64b9f15cf3 100644 --- a/policyengine_us/variables/gov/states/ga/tax/income/credits/ga_surplus_tax_rebate.py +++ b/policyengine_us/variables/gov/states/ga/tax/income/credits/ga_surplus_tax_rebate.py @@ -29,9 +29,7 @@ def formula(tax_unit, period, parameters): # for 2021 is a qualified taxpayer only if that individual had 2021 # earned income. The refund is credited to a qualified taxpayer, so a # joint return gets the joint amount while either spouse qualifies. - # The law excludes an individual actually claimed; the model's single - # flag (can be claimed) stands in for that, so a claimable filer whom - # nobody claimed and who had no earned income gets no refund here. + # The exclusion turns on an actual claim, not on being claimable. person = tax_unit.members filer = person("is_tax_unit_head_or_spouse", period) claimed = person("claimed_as_dependent_on_another_return", period) diff --git a/policyengine_us/variables/gov/states/ga/tax/income/exemptions/ga_exemptions.py b/policyengine_us/variables/gov/states/ga/tax/income/exemptions/ga_exemptions.py index de30eb3cfab..987f3e9e846 100644 --- a/policyengine_us/variables/gov/states/ga/tax/income/exemptions/ga_exemptions.py +++ b/policyengine_us/variables/gov/states/ga/tax/income/exemptions/ga_exemptions.py @@ -24,7 +24,9 @@ def formula(tax_unit, period, parameters): # spouse) can be claimed as a dependent has none (IRC 152(b)(1)). The # 2021-2023 personal exemption has no such rule. dependents = tax_unit("tax_unit_dependents", period) - filer_is_dependent = tax_unit("head_or_spouse_is_dependent_elsewhere", period) + filer_is_dependent = tax_unit( + "head_or_spouse_is_dependent_elsewhere_without_filing_exception", period + ) dependent_exemptions = where(filer_is_dependent, 0, dependents) * p.dependent # total exemptions diff --git a/policyengine_us/variables/gov/states/id/tax/income/credits/2022_rebate/id_2022_rebate_floor.py b/policyengine_us/variables/gov/states/id/tax/income/credits/2022_rebate/id_2022_rebate_floor.py index 8f020f0a9e2..cb3201c785e 100644 --- a/policyengine_us/variables/gov/states/id/tax/income/credits/2022_rebate/id_2022_rebate_floor.py +++ b/policyengine_us/variables/gov/states/id/tax/income/credits/2022_rebate/id_2022_rebate_floor.py @@ -21,6 +21,6 @@ def formula(person, period, parameters): # claimed has no dependents (IRC 152(b)(1)). filer = person("is_tax_unit_head_or_spouse", period) filer_is_dependent = person.tax_unit( - "head_or_spouse_is_dependent_elsewhere", period + "head_or_spouse_is_dependent_elsewhere_without_filing_exception", period ) return p.floor * (filer | ~filer_is_dependent) diff --git a/policyengine_us/variables/gov/states/id/tax/income/credits/grocery/id_grocery_credit.py b/policyengine_us/variables/gov/states/id/tax/income/credits/grocery/id_grocery_credit.py index 9fb88ea1a50..019fd198063 100644 --- a/policyengine_us/variables/gov/states/id/tax/income/credits/grocery/id_grocery_credit.py +++ b/policyengine_us/variables/gov/states/id/tax/income/credits/grocery/id_grocery_credit.py @@ -40,10 +40,10 @@ def formula(tax_unit, period, parameters): # A return on which the filer (or, if joint, either spouse) can be # claimed has no dependents (IRC 152(b)(1)). filer = person("is_tax_unit_head_or_spouse", period) - claimed = person("claimed_as_dependent_on_another_return", period) + claimable = person("claimable_as_dependent_on_another_return", period) filer_is_dependent = person.tax_unit( - "head_or_spouse_is_dependent_elsewhere", period + "head_or_spouse_is_dependent_elsewhere_without_filing_exception", period ) - eligible = where(filer, ~claimed, ~filer_is_dependent) + eligible = where(filer, ~claimable, ~filer_is_dependent) credit_value = full_amount * (qualified_months / MONTHS_IN_YEAR) * eligible return tax_unit.sum(credit_value)