From 31fd31105a8e6cb58a64c4f86d3834f56f58ef7c Mon Sep 17 00:00:00 2001 From: Max Ghenis Date: Fri, 9 Oct 2026 10:13:55 -0400 Subject: [PATCH 1/4] Apply Virginia's rules for a filer who can be claimed as a dependent - The standard deduction of a filer who can be claimed is computed "only with respect to earned income" (Va. Code 58.1-322.03(1)(b)); on a joint return either spouse being claimable caps the joint deduction at the couple's earned income. - Personal exemptions count only filers who cannot be claimed and, when no filer can be, the dependents (58.1-322.03(2)(a), IRC 151(d)(2), 152(b)(1)). - Aged and blind exemptions go to aged or blind filers, not dependents, and survive claimability (58.1-322.03(2)(b)). - Both Virginia EITC alternatives bar a return on which either spouse can be claimed, as the low-income credit already does (58.1-339.8(B)(1)). Co-Authored-By: Claude Opus 5.5 --- changelog.d/claimable-filer-va.fixed.md | 1 + .../test_claimable_filer_va_invariants.py | 63 ++++++++++ .../va_non_refundable_eitc_if_claimed.yaml | 74 ++++++++++++ .../eitc/va_refundable_eitc_if_claimed.yaml | 73 +++++++++++ .../deductions/va_standard_deduction.yaml | 113 ++++++++++++++++++ .../exemptions/va_aged_blind_exemption.yaml | 49 ++++++++ .../exemptions/va_personal_exemption.yaml | 95 +++++++++++++++ .../eitc/va_non_refundable_eitc_if_claimed.py | 7 +- .../eitc/va_refundable_eitc_if_claimed.py | 6 +- .../deductions/va_standard_deduction.py | 16 ++- .../va_aged_blind_exemption_person.py | 6 +- .../va_personal_exemption_person.py | 17 ++- 12 files changed, 515 insertions(+), 5 deletions(-) create mode 100644 changelog.d/claimable-filer-va.fixed.md create mode 100644 policyengine_us/tests/core/test_claimable_filer_va_invariants.py create mode 100644 policyengine_us/tests/policy/baseline/gov/states/va/tax/income/exemptions/va_aged_blind_exemption.yaml create mode 100644 policyengine_us/tests/policy/baseline/gov/states/va/tax/income/exemptions/va_personal_exemption.yaml diff --git a/changelog.d/claimable-filer-va.fixed.md b/changelog.d/claimable-filer-va.fixed.md new file mode 100644 index 00000000000..377778fe62c --- /dev/null +++ b/changelog.d/claimable-filer-va.fixed.md @@ -0,0 +1 @@ +Apply Virginia's rules for a filer who can be claimed as a dependent: the standard deduction is limited to the filers' earned income (Va. Code 58.1-322.03(1)(b)), personal exemptions follow those allowable federally, and the EITC alternatives are barred (58.1-339.8(B)(1)); the aged and blind exemption now goes only to aged or blind filers. diff --git a/policyengine_us/tests/core/test_claimable_filer_va_invariants.py b/policyengine_us/tests/core/test_claimable_filer_va_invariants.py new file mode 100644 index 00000000000..0231b769c19 --- /dev/null +++ b/policyengine_us/tests/core/test_claimable_filer_va_invariants.py @@ -0,0 +1,63 @@ +"""Virginia rules for a filer who can be claimed as a dependent. + +The standard deduction, personal and aged/blind exemptions and both Virginia +EITC alternatives apply Va. Code 58.1-322.03 and 58.1-339.8(B)(1). + +For couples drawn by Hypothesis and a seeded population in VA, with +either, both or neither spouse claimed, each output is the same under either +head/spouse labelling, and marking another filer as claimed never raises it. +""" + +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, + _crafted_cases, + _seeded_couples, + adults, + dependents, +) + +STATES = ["VA"] +YEARS = [2023, 2025, 2026] +OUTPUTS = [ + "va_standard_deduction", + "va_personal_exemption", + "va_aged_blind_exemption", + "va_refundable_eitc_if_claimed", + "va_non_refundable_eitc_if_claimed", +] + + +@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)), + } + + +@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_va_claimable_filer_rules_are_label_free(year, units): + check_swap(units, year, OUTPUTS) + + +@pytest.mark.parametrize("year", YEARS) +def test_va_claimable_filer_rules_seeded_population(year): + units = _seeded_couples(STATES, per_state=3) + _crafted_cases(STATES) + check_swap(units, year, OUTPUTS) + check_monotone(units, year, OUTPUTS) diff --git a/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/credits/eitc/va_non_refundable_eitc_if_claimed.yaml b/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/credits/eitc/va_non_refundable_eitc_if_claimed.yaml index 4e2e2233f9d..d251a2b6eed 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/credits/eitc/va_non_refundable_eitc_if_claimed.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/credits/eitc/va_non_refundable_eitc_if_claimed.yaml @@ -35,3 +35,77 @@ output: # 2025: 20% of federal EITC va_non_refundable_eitc_if_claimed: 800 + + +- name: 2025 joint return with one claimable spouse gets no nonrefundable Virginia EITC (the claimable spouse is the head) + period: 2025 + input: + people: + person_a: + age: 30 + claimed_as_dependent_on_another_return: true + is_tax_unit_head: true + is_tax_unit_spouse: false + person_b: + age: 30 + is_tax_unit_head: false + is_tax_unit_spouse: true + tax_units: + tax_unit: + members: [person_a, person_b] + filing_status: JOINT + eitc: 1000 + va_low_income_tax_credit: 0 + households: + household: + members: [person_a, person_b] + state_code: VA + output: + va_non_refundable_eitc_if_claimed: 0 + +- name: 2025 joint return with one claimable spouse gets no nonrefundable Virginia EITC (the claimable spouse is the spouse) + period: 2025 + input: + people: + person_b: + age: 30 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_a: + age: 30 + claimed_as_dependent_on_another_return: true + is_tax_unit_head: false + is_tax_unit_spouse: true + tax_units: + tax_unit: + members: [person_b, person_a] + filing_status: JOINT + eitc: 1000 + va_low_income_tax_credit: 0 + households: + household: + members: [person_b, person_a] + state_code: VA + output: + va_non_refundable_eitc_if_claimed: 0 + +- name: 2025 joint return with neither spouse claimable gets the nonrefundable Virginia EITC + period: 2025 + input: + people: + person_a: + age: 30 + person_b: + age: 30 + tax_units: + tax_unit: + members: [person_a, person_b] + filing_status: JOINT + eitc: 1000 + va_low_income_tax_credit: 0 + households: + household: + members: [person_a, person_b] + state_code: VA + output: + va_non_refundable_eitc_if_claimed: 200 diff --git a/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/credits/eitc/va_refundable_eitc_if_claimed.yaml b/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/credits/eitc/va_refundable_eitc_if_claimed.yaml index ca129272ab9..d6ad241e0d0 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/credits/eitc/va_refundable_eitc_if_claimed.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/credits/eitc/va_refundable_eitc_if_claimed.yaml @@ -66,3 +66,76 @@ eitc: 5_000 output: va_refundable_eitc_if_claimed: 0 + + +- name: 2025 joint return with one claimable spouse gets no Virginia EITC (the claimable spouse is the head) + period: 2025 + input: + people: + person_a: + age: 30 + claimed_as_dependent_on_another_return: true + is_tax_unit_head: true + is_tax_unit_spouse: false + person_b: + age: 30 + is_tax_unit_head: false + is_tax_unit_spouse: true + tax_units: + tax_unit: + members: [person_a, person_b] + filing_status: JOINT + eitc: 1000 + households: + household: + members: [person_a, person_b] + state_code: VA + output: + # Va. Code 58.1-339.8(B)(1). + va_refundable_eitc_if_claimed: 0 + +- name: 2025 joint return with one claimable spouse gets no Virginia EITC (the claimable spouse is the spouse) + period: 2025 + input: + people: + person_b: + age: 30 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_a: + age: 30 + claimed_as_dependent_on_another_return: true + is_tax_unit_head: false + is_tax_unit_spouse: true + tax_units: + tax_unit: + members: [person_b, person_a] + filing_status: JOINT + eitc: 1000 + households: + household: + members: [person_b, person_a] + state_code: VA + output: + va_refundable_eitc_if_claimed: 0 + +- name: 2025 joint return with neither spouse claimable gets the Virginia EITC + period: 2025 + input: + people: + person_a: + age: 30 + person_b: + age: 30 + tax_units: + tax_unit: + members: [person_a, person_b] + filing_status: JOINT + eitc: 1000 + households: + household: + members: [person_a, person_b] + state_code: VA + output: + # 20% x $1,000. + va_refundable_eitc_if_claimed: 200 diff --git a/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/deductions/va_standard_deduction.yaml b/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/deductions/va_standard_deduction.yaml index 37d5f9a3f43..e772d238c04 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/deductions/va_standard_deduction.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/deductions/va_standard_deduction.yaml @@ -158,3 +158,116 @@ state_code: VA output: va_standard_deduction: 9_200 + + +- name: 2025 single filer who can be claimed as a dependent has the standard deduction limited to earned income + period: 2025 + input: + people: + filer: + age: 20 + employment_income: 500 + claimed_as_dependent_on_another_return: true + tax_units: + tax_unit: + members: [filer] + households: + household: + members: [filer] + state_code: VA + output: + # Va. Code 58.1-322.03(1)(b): min($8,750, $500). + va_standard_deduction: 500 + +- name: 2025 single filer who can be claimed as a dependent with no earned income has no standard deduction + period: 2025 + input: + people: + filer: + age: 20 + taxable_interest_income: 15000 + claimed_as_dependent_on_another_return: true + tax_units: + tax_unit: + members: [filer] + households: + household: + members: [filer] + state_code: VA + output: + # No federal-style floor or add-on. + va_standard_deduction: 0 + +- name: 2025 joint return with one claimable spouse caps the joint deduction at the couple's earned income (the claimable spouse is the head) + period: 2025 + input: + people: + person_a: + age: 20 + employment_income: 2000 + claimed_as_dependent_on_another_return: true + is_tax_unit_head: true + is_tax_unit_spouse: false + person_b: + age: 22 + employment_income: 10000 + 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: VA + output: + # min($17,500, $2,000 + $10,000). + va_standard_deduction: 12_000 + +- name: 2025 joint return with one claimable spouse caps the joint deduction at the couple's earned income (the claimable spouse is the spouse) + period: 2025 + input: + people: + person_b: + age: 22 + employment_income: 10000 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_a: + age: 20 + employment_income: 2000 + claimed_as_dependent_on_another_return: true + is_tax_unit_head: false + is_tax_unit_spouse: true + tax_units: + tax_unit: + members: [person_b, person_a] + filing_status: JOINT + households: + household: + members: [person_b, person_a] + state_code: VA + output: + va_standard_deduction: 12_000 + +- name: 2025 joint return with neither spouse claimable gets the full joint deduction + period: 2025 + input: + people: + person_a: + age: 20 + employment_income: 2000 + person_b: + age: 22 + employment_income: 10000 + tax_units: + tax_unit: + members: [person_a, person_b] + filing_status: JOINT + households: + household: + members: [person_a, person_b] + state_code: VA + output: + va_standard_deduction: 17_500 diff --git a/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/exemptions/va_aged_blind_exemption.yaml b/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/exemptions/va_aged_blind_exemption.yaml new file mode 100644 index 00000000000..927ea0a472b --- /dev/null +++ b/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/exemptions/va_aged_blind_exemption.yaml @@ -0,0 +1,49 @@ + + +- name: 2025 aged and blind filer who can be claimed as a dependent keeps the aged and blind exemptions + period: 2025 + input: + people: + filer: + age: 70 + is_blind: true + claimed_as_dependent_on_another_return: true + tax_units: + tax_unit: + members: [filer] + households: + household: + members: [filer] + state_code: VA + output: + # Va. Code 58.1-322.03(2)(b) has no dependency bar; 2 x $800. + va_aged_blind_exemption: 1_600 + +- name: 2025 an aged dependent adds no aged exemption + period: 2025 + input: + people: + person_a: + age: 40 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_b: + age: 40 + is_tax_unit_head: false + is_tax_unit_spouse: true + parent: + age: 70 + is_blind: true + is_tax_unit_head: false + is_tax_unit_spouse: false + tax_units: + tax_unit: + members: [person_a, person_b, parent] + filing_status: JOINT + households: + household: + members: [person_a, person_b, parent] + state_code: VA + output: + # The exemption is for "each blind or aged taxpayer". + va_aged_blind_exemption: 0 diff --git a/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/exemptions/va_personal_exemption.yaml b/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/exemptions/va_personal_exemption.yaml new file mode 100644 index 00000000000..165f1579fed --- /dev/null +++ b/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/exemptions/va_personal_exemption.yaml @@ -0,0 +1,95 @@ + + +- name: 2025 single filer who can be claimed as a dependent has no personal exemption + period: 2025 + input: + people: + filer: + age: 20 + claimed_as_dependent_on_another_return: true + tax_units: + tax_unit: + members: [filer] + households: + household: + members: [filer] + state_code: VA + output: + # Va. Code 58.1-322.03(2)(a) counts exemptions allowable for federal purposes; + # IRC 151(d)(2). + va_personal_exemption: 0 + +- name: 2025 joint return with one claimable spouse keeps the other spouse's exemption but no dependents (the claimable spouse is the head) + period: 2025 + input: + people: + person_a: + age: 20 + claimed_as_dependent_on_another_return: true + is_tax_unit_head: true + is_tax_unit_spouse: false + person_b: + age: 22 + 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: VA + output: + # IRC 152(b)(1): such a return has no dependents. + va_personal_exemption: 930 + +- name: 2025 joint return with one claimable spouse keeps the other spouse's exemption but no dependents (the claimable spouse is the spouse) + period: 2025 + input: + people: + person_b: + age: 22 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_a: + age: 20 + claimed_as_dependent_on_another_return: true + is_tax_unit_head: false + is_tax_unit_spouse: 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: VA + output: + va_personal_exemption: 930 + +- name: 2025 joint return with neither spouse claimable counts both spouses and the child + period: 2025 + input: + people: + person_a: + age: 20 + person_b: + age: 22 + 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: VA + output: + # 3 x $930. + va_personal_exemption: 2_790 diff --git a/policyengine_us/variables/gov/states/va/tax/income/credits/eitc/va_non_refundable_eitc_if_claimed.py b/policyengine_us/variables/gov/states/va/tax/income/credits/eitc/va_non_refundable_eitc_if_claimed.py index d588fc1d35e..f2ed240f5bf 100644 --- a/policyengine_us/variables/gov/states/va/tax/income/credits/eitc/va_non_refundable_eitc_if_claimed.py +++ b/policyengine_us/variables/gov/states/va/tax/income/credits/eitc/va_non_refundable_eitc_if_claimed.py @@ -16,4 +16,9 @@ def formula(tax_unit, period, parameters): # The filer can either claim the non-refundable EITC or the low income credit. va_non_refundable_eitc = p.non_refundable * federal_eitc low_income_credit = tax_unit("va_low_income_tax_credit", period) - return max_(va_non_refundable_eitc, low_income_credit) + # Va. Code 58.1-339.8(B)(1) bars a dependent's return from both + # alternatives; either spouse being claimed bars a joint return. + dependent_filer = tax_unit("head_or_spouse_is_dependent_elsewhere", period) + return where( + dependent_filer, 0, max_(va_non_refundable_eitc, low_income_credit) + ) diff --git a/policyengine_us/variables/gov/states/va/tax/income/credits/eitc/va_refundable_eitc_if_claimed.py b/policyengine_us/variables/gov/states/va/tax/income/credits/eitc/va_refundable_eitc_if_claimed.py index 15f1d83b9dc..2addccba775 100644 --- a/policyengine_us/variables/gov/states/va/tax/income/credits/eitc/va_refundable_eitc_if_claimed.py +++ b/policyengine_us/variables/gov/states/va/tax/income/credits/eitc/va_refundable_eitc_if_claimed.py @@ -13,4 +13,8 @@ class va_refundable_eitc_if_claimed(Variable): def formula(tax_unit, period, parameters): federal_eitc = tax_unit("eitc", period) p = parameters(period).gov.states.va.tax.income.credits.eitc.match - return p.refundable * federal_eitc + # Va. Code 58.1-339.8(B)(1): the credit "shall not be allowed against + # such tax of a dependent"; as for the low-income credit, either + # spouse being claimed bars a joint return. + dependent_filer = tax_unit("head_or_spouse_is_dependent_elsewhere", period) + return where(dependent_filer, 0, p.refundable * federal_eitc) diff --git a/policyengine_us/variables/gov/states/va/tax/income/deductions/va_standard_deduction.py b/policyengine_us/variables/gov/states/va/tax/income/deductions/va_standard_deduction.py index adb84e3b680..52d8b709417 100644 --- a/policyengine_us/variables/gov/states/va/tax/income/deductions/va_standard_deduction.py +++ b/policyengine_us/variables/gov/states/va/tax/income/deductions/va_standard_deduction.py @@ -13,4 +13,18 @@ class va_standard_deduction(Variable): def formula(tax_unit, period, parameters): p = parameters(period).gov.states.va.tax.income.deductions filing_status = tax_unit("filing_status", period) - return p.standard[filing_status] + standard = p.standard[filing_status] + # Va. Code 58.1-322.03(1)(b): for an individual who can be claimed as + # a dependent on another taxpayer's return the standard deduction is + # computed "only with respect to earned income" (Form 760 instructions: + # "limited to the amount of your earned income"), with no federal + # floor or add-on. Virginia taxes a joint return on one joint taxable + # income (58.1-324(B)(1)), so either spouse being claimable caps the + # joint deduction at the couple's earned income. + person = tax_unit.members + filer = person("is_tax_unit_head_or_spouse", period) + filer_earned_income = tax_unit.sum( + filer * max_(person("earned_income", period), 0) + ) + dependent_filer = tax_unit("head_or_spouse_is_dependent_elsewhere", period) + return where(dependent_filer, min_(standard, filer_earned_income), standard) diff --git a/policyengine_us/variables/gov/states/va/tax/income/exemptions/va_aged_blind_exemption_person.py b/policyengine_us/variables/gov/states/va/tax/income/exemptions/va_aged_blind_exemption_person.py index 1ffd21007bf..85620d9e28a 100644 --- a/policyengine_us/variables/gov/states/va/tax/income/exemptions/va_aged_blind_exemption_person.py +++ b/policyengine_us/variables/gov/states/va/tax/income/exemptions/va_aged_blind_exemption_person.py @@ -15,4 +15,8 @@ def formula(person, period, parameters): aged_person = person("is_irs_aged", period).astype(int) blind_person = person("is_blind", period).astype(int) aged_blind_count = aged_person + blind_person - return aged_blind_count * p.aged_blind + # Va. Code 58.1-322.03(2)(b) grants the exemption to "each blind or + # aged taxpayer" (the head or spouse), not to dependents, and has no + # bar for a taxpayer whom another taxpayer can claim. + filer = person("is_tax_unit_head_or_spouse", period) + return filer * aged_blind_count * p.aged_blind diff --git a/policyengine_us/variables/gov/states/va/tax/income/exemptions/va_personal_exemption_person.py b/policyengine_us/variables/gov/states/va/tax/income/exemptions/va_personal_exemption_person.py index 009972bca13..41a26d2d2dc 100644 --- a/policyengine_us/variables/gov/states/va/tax/income/exemptions/va_personal_exemption_person.py +++ b/policyengine_us/variables/gov/states/va/tax/income/exemptions/va_personal_exemption_person.py @@ -11,4 +11,19 @@ class va_personal_exemption_person(Variable): reference = "https://law.lis.virginia.gov/vacodefull/title58.1/chapter3/article2/" def formula(person, period, parameters): - return parameters(period).gov.states.va.tax.income.exemptions.personal + # Va. Code 58.1-322.03(2)(a) allows $930 for "each personal exemption + # allowable to the taxpayer for federal income tax purposes". A filer + # whom another taxpayer can claim has none (IRC 151(d)(2)), and a + # return on which the filer (or, if joint, either spouse) can be + # claimed has no dependents (IRC 152(b)(1); the 760 instructions + # allow "the same number of dependent exemptions allowed on your + # federal return"). + filer = person("is_tax_unit_head_or_spouse", period) + claimed = person("claimed_as_dependent_on_another_return", period) + dependent = person("is_tax_unit_dependent", period) + dependent_filer = person.tax_unit( + "head_or_spouse_is_dependent_elsewhere", period + ) + eligible = (filer & ~claimed) | (dependent & ~dependent_filer) + p = parameters(period).gov.states.va.tax.income.exemptions + return eligible * p.personal From fa113285df869d757583623af1c7dd6ac0107842 Mon Sep 17 00:00:00 2001 From: Max Ghenis Date: Sat, 10 Oct 2026 09:46:08 -0400 Subject: [PATCH 2/4] Address the Virginia claimable-filer review - Low-income credit: a blind or aged dependent still bars the credit (Va. Code 58.1-339.8(D)(4)); this came from counting dependents in the aged and blind exemption, which now goes to filers only. - Standard deduction: document the earned income measure used for the limit. - EITC alternatives: cite 58.1-339.8 and the instructions page with the dependent bar. - Tests: blind and aged dependents, person-level personal exemptions, and the aged exemption under both labellings. Co-Authored-By: Claude Opus 5.5 --- changelog.d/claimable-filer-va.fixed.md | 2 +- .../test_claimable_filer_va_invariants.py | 17 ++-- .../va_low_income_tax_credit_eligible.yaml | 77 +++++++++++++++++++ .../exemptions/va_aged_blind_exemption.yaml | 77 +++++++++++++++++++ .../exemptions/va_personal_exemption.yaml | 4 + .../eitc/va_non_refundable_eitc_if_claimed.py | 6 +- .../eitc/va_refundable_eitc_if_claimed.py | 6 +- .../va_low_income_tax_credit_eligible.py | 17 +++- .../deductions/va_standard_deduction.py | 6 +- 9 files changed, 202 insertions(+), 10 deletions(-) diff --git a/changelog.d/claimable-filer-va.fixed.md b/changelog.d/claimable-filer-va.fixed.md index 377778fe62c..a995ceece50 100644 --- a/changelog.d/claimable-filer-va.fixed.md +++ b/changelog.d/claimable-filer-va.fixed.md @@ -1 +1 @@ -Apply Virginia's rules for a filer who can be claimed as a dependent: the standard deduction is limited to the filers' earned income (Va. Code 58.1-322.03(1)(b)), personal exemptions follow those allowable federally, and the EITC alternatives are barred (58.1-339.8(B)(1)); the aged and blind exemption now goes only to aged or blind filers. +Apply Virginia's rules for a filer who can be claimed as a dependent: the standard deduction is limited to the filers' earned income (Va. Code 58.1-322.03(1)(b)), personal exemptions follow those allowable federally, and the EITC alternatives are barred (58.1-339.8(B)(1)); the aged and blind exemption now goes only to aged or blind filers, while a blind or aged dependent still bars the low-income credit (58.1-339.8(D)(4)). diff --git a/policyengine_us/tests/core/test_claimable_filer_va_invariants.py b/policyengine_us/tests/core/test_claimable_filer_va_invariants.py index 0231b769c19..ce7a227beaf 100644 --- a/policyengine_us/tests/core/test_claimable_filer_va_invariants.py +++ b/policyengine_us/tests/core/test_claimable_filer_va_invariants.py @@ -1,11 +1,18 @@ """Virginia rules for a filer who can be claimed as a dependent. -The standard deduction, personal and aged/blind exemptions and both Virginia -EITC alternatives apply Va. Code 58.1-322.03 and 58.1-339.8(B)(1). +The standard deduction is limited to the filers' earned income, personal +exemptions follow those allowable federally, and the EITC alternatives are +barred (Va. Code 58.1-322.03, 58.1-339.8). -For couples drawn by Hypothesis and a seeded population in VA, with -either, both or neither spouse claimed, each output is the same under either -head/spouse labelling, and marking another filer as claimed never raises it. +For couples with either, both or neither spouse claimed: + +1. Swap invariance: each tax-unit output is the same under either head/spouse + labelling (Hypothesis batches and the seeded population). +2. Monotonicity: marking another filer as claimed never raises an output + (seeded population only). + +The outputs are tax-unit totals; which spouse an exemption goes to is checked +by YAML cases on the person-level variables. """ import pytest diff --git a/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/credits/low_income_credit/va_low_income_tax_credit_eligible.yaml b/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/credits/low_income_credit/va_low_income_tax_credit_eligible.yaml index b5cf4a21af1..3bd7df147ab 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/credits/low_income_credit/va_low_income_tax_credit_eligible.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/credits/low_income_credit/va_low_income_tax_credit_eligible.yaml @@ -83,3 +83,80 @@ state_code: VA output: va_low_income_tax_credit_eligible: false + +# Va. Code 58.1-339.8(D)(4): no credit when "any person claimed as a dependent" +# claims the additional exemption for blind or aged taxpayers on their own +# return. The model takes a blind or aged dependent to claim it. +- name: 2025 blind dependent bars the low income tax credit + period: 2025 + input: + people: + parent: + age: 40 + is_tax_unit_head: true + is_tax_unit_spouse: false + child: + age: 16 + is_blind: true + is_tax_unit_head: false + is_tax_unit_spouse: false + tax_units: + tax_unit: + members: [parent, child] + households: + household: + members: [parent, child] + state_code: VA + output: + va_aged_blind_exemption: 0 + va_low_income_tax_credit_eligible: false + +- name: 2025 aged dependent bars the low income tax credit + period: 2025 + input: + people: + person_a: + age: 40 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_b: + age: 40 + is_tax_unit_head: false + is_tax_unit_spouse: true + parent: + age: 70 + is_tax_unit_head: false + is_tax_unit_spouse: false + tax_units: + tax_unit: + members: [person_a, person_b, parent] + filing_status: JOINT + households: + household: + members: [person_a, person_b, parent] + state_code: VA + output: + va_aged_blind_exemption: 0 + va_low_income_tax_credit_eligible: false + +- name: 2025 dependent who is neither blind nor aged does not bar the low income tax credit + period: 2025 + input: + people: + parent: + age: 40 + is_tax_unit_head: true + is_tax_unit_spouse: false + child: + age: 16 + is_tax_unit_head: false + is_tax_unit_spouse: false + tax_units: + tax_unit: + members: [parent, child] + households: + household: + members: [parent, child] + state_code: VA + output: + va_low_income_tax_credit_eligible: true diff --git a/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/exemptions/va_aged_blind_exemption.yaml b/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/exemptions/va_aged_blind_exemption.yaml index 927ea0a472b..d9cc18090ed 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/exemptions/va_aged_blind_exemption.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/exemptions/va_aged_blind_exemption.yaml @@ -47,3 +47,80 @@ output: # The exemption is for "each blind or aged taxpayer". va_aged_blind_exemption: 0 + +- name: 2025 an aged dependent adds no aged exemption (the other spouse is the head) + period: 2025 + input: + people: + person_b: + age: 40 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_a: + age: 40 + is_tax_unit_head: false + is_tax_unit_spouse: true + parent: + age: 70 + is_blind: true + is_tax_unit_head: false + is_tax_unit_spouse: false + tax_units: + tax_unit: + members: [person_b, person_a, parent] + filing_status: JOINT + households: + household: + members: [person_b, person_a, parent] + state_code: VA + output: + va_aged_blind_exemption: 0 + +- name: 2025 aged spouse who can be claimed keeps the aged exemption on a joint return (the claimable spouse is the head) + period: 2025 + input: + people: + person_a: + age: 70 + claimed_as_dependent_on_another_return: true + is_tax_unit_head: true + is_tax_unit_spouse: false + person_b: + age: 40 + 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: VA + output: + # 58.1-322.03(2)(b) has no bar for a taxpayer whom another taxpayer can claim. + va_aged_blind_exemption: 800 + +- name: 2025 aged spouse who can be claimed keeps the aged exemption on a joint return (the claimable spouse is the spouse) + period: 2025 + input: + people: + person_b: + age: 40 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_a: + age: 70 + claimed_as_dependent_on_another_return: true + is_tax_unit_head: false + is_tax_unit_spouse: true + tax_units: + tax_unit: + members: [person_b, person_a] + filing_status: JOINT + households: + household: + members: [person_b, person_a] + state_code: VA + output: + va_aged_blind_exemption: 800 diff --git a/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/exemptions/va_personal_exemption.yaml b/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/exemptions/va_personal_exemption.yaml index 165f1579fed..730d345889a 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/exemptions/va_personal_exemption.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/exemptions/va_personal_exemption.yaml @@ -45,6 +45,8 @@ output: # IRC 152(b)(1): such a return has no dependents. va_personal_exemption: 930 + # Members in order: the claimable spouse, the other spouse, the child. + va_personal_exemption_person: [0, 930, 0] - name: 2025 joint return with one claimable spouse keeps the other spouse's exemption but no dependents (the claimable spouse is the spouse) period: 2025 @@ -71,6 +73,8 @@ state_code: VA output: va_personal_exemption: 930 + # Members in order: the other spouse, the claimable spouse, the child. + va_personal_exemption_person: [930, 0, 0] - name: 2025 joint return with neither spouse claimable counts both spouses and the child period: 2025 diff --git a/policyengine_us/variables/gov/states/va/tax/income/credits/eitc/va_non_refundable_eitc_if_claimed.py b/policyengine_us/variables/gov/states/va/tax/income/credits/eitc/va_non_refundable_eitc_if_claimed.py index f2ed240f5bf..6fb684b18de 100644 --- a/policyengine_us/variables/gov/states/va/tax/income/credits/eitc/va_non_refundable_eitc_if_claimed.py +++ b/policyengine_us/variables/gov/states/va/tax/income/credits/eitc/va_non_refundable_eitc_if_claimed.py @@ -7,7 +7,11 @@ class va_non_refundable_eitc_if_claimed(Variable): label = "Virginia non-refundable EITC if claimed" unit = USD definition_period = YEAR - reference = "https://www.tax.virginia.gov/sites/default/files/vatax-pdf/2022-760-instructions.pdf#page=32" + reference = ( + "https://law.lis.virginia.gov/vacode/title58.1/chapter3/section58.1-339.8/", + # PDF pages 31-32 + "https://www.tax.virginia.gov/sites/default/files/vatax-pdf/2022-760-instructions.pdf#page=31", + ) defined_for = StateCode.VA def formula(tax_unit, period, parameters): diff --git a/policyengine_us/variables/gov/states/va/tax/income/credits/eitc/va_refundable_eitc_if_claimed.py b/policyengine_us/variables/gov/states/va/tax/income/credits/eitc/va_refundable_eitc_if_claimed.py index 2addccba775..0672e073cd3 100644 --- a/policyengine_us/variables/gov/states/va/tax/income/credits/eitc/va_refundable_eitc_if_claimed.py +++ b/policyengine_us/variables/gov/states/va/tax/income/credits/eitc/va_refundable_eitc_if_claimed.py @@ -7,7 +7,11 @@ class va_refundable_eitc_if_claimed(Variable): label = "Virginia refundable earned income tax credit if claimed" unit = USD definition_period = YEAR - reference = "https://www.tax.virginia.gov/sites/default/files/vatax-pdf/2022-760-instructions.pdf#page=32" + reference = ( + "https://law.lis.virginia.gov/vacode/title58.1/chapter3/section58.1-339.8/", + # PDF pages 31-32 + "https://www.tax.virginia.gov/sites/default/files/vatax-pdf/2022-760-instructions.pdf#page=31", + ) defined_for = StateCode.VA def formula(tax_unit, period, parameters): diff --git a/policyengine_us/variables/gov/states/va/tax/income/credits/low_income_credit/va_low_income_tax_credit_eligible.py b/policyengine_us/variables/gov/states/va/tax/income/credits/low_income_credit/va_low_income_tax_credit_eligible.py index 58934026c25..948c14c8545 100644 --- a/policyengine_us/variables/gov/states/va/tax/income/credits/low_income_credit/va_low_income_tax_credit_eligible.py +++ b/policyengine_us/variables/gov/states/va/tax/income/credits/low_income_credit/va_low_income_tax_credit_eligible.py @@ -27,4 +27,19 @@ def formula(tax_unit, period, parameters): "head_or_spouse_is_dependent_elsewhere", period ) - return program_eligible & ~filer_is_dependent_elsewhere + # Criteria 3: Va. Code 58.1-339.8(D)(4) also bars the credit when + # "any person claimed as a dependent" claims the additional exemption + # for blind or aged taxpayers on their own return. The model has no + # input for a dependent's own return, so a blind or aged dependent is + # taken to claim it. (Before, this came from counting dependents in + # va_aged_blind_exemption, which now goes to filers only.) + person = tax_unit.members + dependent = person("is_tax_unit_dependent", period) + aged_or_blind = person("is_irs_aged", period) | person("is_blind", period) + dependent_claims_exemption = tax_unit.any(dependent & aged_or_blind) + + return ( + program_eligible + & ~filer_is_dependent_elsewhere + & ~dependent_claims_exemption + ) diff --git a/policyengine_us/variables/gov/states/va/tax/income/deductions/va_standard_deduction.py b/policyengine_us/variables/gov/states/va/tax/income/deductions/va_standard_deduction.py index 52d8b709417..375534bb789 100644 --- a/policyengine_us/variables/gov/states/va/tax/income/deductions/va_standard_deduction.py +++ b/policyengine_us/variables/gov/states/va/tax/income/deductions/va_standard_deduction.py @@ -20,7 +20,11 @@ def formula(tax_unit, period, parameters): # "limited to the amount of your earned income"), with no federal # floor or add-on. Virginia taxes a joint return on one joint taxable # income (58.1-324(B)(1)), so either spouse being claimable caps the - # joint deduction at the couple's earned income. + # joint deduction at the couple's earned income. Earned income here + # is the model's earned_income (wages and net self-employment + # earnings), with each filer's loss floored at zero; 23VAC10-110-143 + # counts wages, salaries, professional fees and other pay for + # services. person = tax_unit.members filer = person("is_tax_unit_head_or_spouse", period) filer_earned_income = tax_unit.sum( From 6fdc9116974874a340452e8e212f7d0985b4c886 Mon Sep 17 00:00:00 2001 From: Max Ghenis Date: Sat, 10 Oct 2026 13:41:39 -0400 Subject: [PATCH 3/4] Read the split dependency inputs from #10024 in Virginia Dependents' exemptions read the claimable-and-not-within-the-filing-exception helper; the filer's own exemption, the standard deduction limit and the EITC alternatives read claimability. Co-Authored-By: Claude Opus 5.5 --- .../exemptions/va_personal_exemption.yaml | 63 +++++++++++++++++++ .../va_personal_exemption_person.py | 4 +- 2 files changed, 65 insertions(+), 2 deletions(-) diff --git a/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/exemptions/va_personal_exemption.yaml b/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/exemptions/va_personal_exemption.yaml index 730d345889a..d62b373f7a7 100644 --- a/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/exemptions/va_personal_exemption.yaml +++ b/policyengine_us/tests/policy/baseline/gov/states/va/tax/income/exemptions/va_personal_exemption.yaml @@ -97,3 +97,66 @@ output: # 3 x $930. va_personal_exemption: 2_790 + +# Publication 501, Dependent Taxpayer Test: a filer whose would-be claimant is not +# required to file and files no return or only for a refund can claim dependents. +# That filer's own exemption is still zero (IRC 151(d)(2)). +- name: 2025 joint return whose claimable spouse is within the filing exception keeps the child's exemption (the claimable spouse is the head) + period: 2025 + input: + people: + person_a: + age: 20 + claimable_as_dependent_on_another_return: true + dependent_claimant_filing_exception: true + is_tax_unit_head: true + is_tax_unit_spouse: false + person_b: + age: 22 + is_tax_unit_head: false + is_tax_unit_spouse: true + child: + age: 3 + is_tax_unit_head: false + is_tax_unit_spouse: false + tax_units: + tax_unit: + members: [person_a, person_b, child] + filing_status: JOINT + households: + household: + members: [person_a, person_b, child] + state_code: VA + output: + va_personal_exemption: 1860 + va_personal_exemption_person: [0, 930, 930] + +- name: 2025 joint return whose claimable spouse is within the filing exception keeps the child's exemption (the claimable spouse is the spouse) + period: 2025 + input: + people: + person_b: + age: 22 + is_tax_unit_head: true + is_tax_unit_spouse: false + person_a: + age: 20 + claimable_as_dependent_on_another_return: true + dependent_claimant_filing_exception: true + is_tax_unit_head: false + is_tax_unit_spouse: true + child: + age: 3 + is_tax_unit_head: false + is_tax_unit_spouse: false + tax_units: + tax_unit: + members: [person_b, person_a, child] + filing_status: JOINT + households: + household: + members: [person_b, person_a, child] + state_code: VA + output: + va_personal_exemption: 1860 + va_personal_exemption_person: [930, 0, 930] diff --git a/policyengine_us/variables/gov/states/va/tax/income/exemptions/va_personal_exemption_person.py b/policyengine_us/variables/gov/states/va/tax/income/exemptions/va_personal_exemption_person.py index 41a26d2d2dc..651ac52097a 100644 --- a/policyengine_us/variables/gov/states/va/tax/income/exemptions/va_personal_exemption_person.py +++ b/policyengine_us/variables/gov/states/va/tax/income/exemptions/va_personal_exemption_person.py @@ -19,10 +19,10 @@ def formula(person, period, parameters): # allow "the same number of dependent exemptions allowed on your # federal return"). filer = person("is_tax_unit_head_or_spouse", period) - claimed = person("claimed_as_dependent_on_another_return", period) + claimed = person("claimable_as_dependent_on_another_return", period) dependent = person("is_tax_unit_dependent", period) dependent_filer = person.tax_unit( - "head_or_spouse_is_dependent_elsewhere", period + "head_or_spouse_is_dependent_elsewhere_without_filing_exception", period ) eligible = (filer & ~claimed) | (dependent & ~dependent_filer) p = parameters(period).gov.states.va.tax.income.exemptions From f5f0b3199995dd8d0b8cd3677610c6a01964ca90 Mon Sep 17 00:00:00 2001 From: Max Ghenis Date: Sat, 10 Oct 2026 15:26:34 -0400 Subject: [PATCH 4/4] Keep the claimable-filer rules in Virginia's dependent exemption reform The reform recomputed personal exemptions from filing status and structural dependents; it now leaves out a filer who can be claimed and, outside the claimant filing exception, that return's dependents, as the baseline does. Co-Authored-By: Claude Opus 5.5 --- changelog.d/claimable-filer-va.fixed.md | 2 +- .../va_dependent_exemption_reform.py | 30 +++++++--- .../states/va/exemption_reform_test.yaml | 57 +++++++++++++++++++ 3 files changed, 79 insertions(+), 10 deletions(-) diff --git a/changelog.d/claimable-filer-va.fixed.md b/changelog.d/claimable-filer-va.fixed.md index a995ceece50..a8cda0bd26b 100644 --- a/changelog.d/claimable-filer-va.fixed.md +++ b/changelog.d/claimable-filer-va.fixed.md @@ -1 +1 @@ -Apply Virginia's rules for a filer who can be claimed as a dependent: the standard deduction is limited to the filers' earned income (Va. Code 58.1-322.03(1)(b)), personal exemptions follow those allowable federally, and the EITC alternatives are barred (58.1-339.8(B)(1)); the aged and blind exemption now goes only to aged or blind filers, while a blind or aged dependent still bars the low-income credit (58.1-339.8(D)(4)). +Apply Virginia's rules for a filer who can be claimed as a dependent: the standard deduction is limited to the filers' earned income (Va. Code 58.1-322.03(1)(b)), personal exemptions follow those allowable federally (also under the dependent exemption reform), and the EITC alternatives are barred (58.1-339.8(B)(1)); the aged and blind exemption now goes only to aged or blind filers, while a blind or aged dependent still bars the low-income credit (58.1-339.8(D)(4)). diff --git a/policyengine_us/reforms/states/va/dependent_exemption/va_dependent_exemption_reform.py b/policyengine_us/reforms/states/va/dependent_exemption/va_dependent_exemption_reform.py index 99b2918afc3..b4bb5367f2e 100644 --- a/policyengine_us/reforms/states/va/dependent_exemption/va_dependent_exemption_reform.py +++ b/policyengine_us/reforms/states/va/dependent_exemption/va_dependent_exemption_reform.py @@ -16,7 +16,13 @@ def formula(tax_unit, period, parameters): person = tax_unit.members age = person("age", period) - is_dependent = person("is_tax_unit_dependent", period) + # As in the baseline, a return on which the filer (or, if joint, + # either spouse) can be claimed as a dependent has no dependents + # (IRC 152(b)(1)), unless the would-be claimant meets the filing + # exception. + is_dependent = person("is_tax_unit_dependent", period) & ~person.tax_unit( + "head_or_spouse_is_dependent_elsewhere_without_filing_exception", period + ) # Apply age limit if in effect if p.age_limit.in_effect: @@ -83,7 +89,13 @@ class va_older_dependents_count(Variable): def formula(tax_unit, period, parameters): person = tax_unit.members - is_dependent = person("is_tax_unit_dependent", period) + # As in the baseline, a return on which the filer (or, if joint, + # either spouse) can be claimed as a dependent has no dependents + # (IRC 152(b)(1)), unless the would-be claimant meets the filing + # exception. + is_dependent = person("is_tax_unit_dependent", period) & ~person.tax_unit( + "head_or_spouse_is_dependent_elsewhere_without_filing_exception", period + ) total_dependents = tax_unit.sum(is_dependent) eligible_dependent_exemptions = tax_unit( "va_eligible_dependents_count", period @@ -104,14 +116,14 @@ def formula(tax_unit, period, parameters): # Calculate personal exemptions base amount (filer + spouse + older dependents) filing_status = tax_unit("filing_status", period) older_dependents = tax_unit("va_older_dependents_count", period) - personal_count = ( - where( - filing_status == filing_status.possible_values.JOINT, - 2, - 1, - ) - + older_dependents + # As in the baseline, a filer whom another taxpayer can claim has + # no exemption of their own (IRC 151(d)(2)). + filers = where( + tax_unit("head_or_spouse_is_dependent_elsewhere", period), + tax_unit("head_spouse_count_not_dependent_elsewhere", period), + where(filing_status == filing_status.possible_values.JOINT, 2, 1), ) + personal_count = filers + older_dependents personal_exemption_amount = personal_count * p_base # Add dependent exemption (has its own phase-out logic) diff --git a/policyengine_us/tests/policy/contrib/states/va/exemption_reform_test.yaml b/policyengine_us/tests/policy/contrib/states/va/exemption_reform_test.yaml index 345b8cd67b0..3985249f78b 100644 --- a/policyengine_us/tests/policy/contrib/states/va/exemption_reform_test.yaml +++ b/policyengine_us/tests/policy/contrib/states/va/exemption_reform_test.yaml @@ -180,3 +180,60 @@ # 1 personal (930) + 2 eligible dependents (2_000 each = 4_000) = 4_930 # No older dependents since age limit is not in effect va_personal_exemption: 4_930 + +# As in the baseline, a filer who can be claimed as a dependent has no exemption of +# their own (IRC 151(d)(2)) and, outside the claimant filing exception, no +# dependents (IRC 152(b)(1)). +- name: VA exemption reform - claimable single filer has no exemptions + period: 2025 + reforms: policyengine_us.reforms.states.va.dependent_exemption.va_dependent_exemption_reform.va_dependent_exemption_reform + input: + gov.contrib.states.va.dependent_exemption.in_effect: true + gov.contrib.states.va.dependent_exemption.amount: 930 + people: + parent: {age: 40, employment_income: 20_000, claimable_as_dependent_on_another_return: true} + child1: {age: 10, is_tax_unit_dependent: true} + tax_units: {tax_unit: {members: [parent, child1], filing_status: SINGLE}} + households: {household: {members: [parent, child1], state_name: VA}} + output: {va_personal_exemption: 0} + +- name: VA exemption reform - the filing exception keeps the dependent's exemption only + period: 2025 + reforms: policyengine_us.reforms.states.va.dependent_exemption.va_dependent_exemption_reform.va_dependent_exemption_reform + input: + gov.contrib.states.va.dependent_exemption.in_effect: true + gov.contrib.states.va.dependent_exemption.amount: 930 + people: + parent: {age: 40, employment_income: 20_000, claimable_as_dependent_on_another_return: true, dependent_claimant_filing_exception: true} + child1: {age: 10, is_tax_unit_dependent: true} + tax_units: {tax_unit: {members: [parent, child1], filing_status: SINGLE}} + households: {household: {members: [parent, child1], state_name: VA}} + output: {va_personal_exemption: 930} + +- name: VA exemption reform - joint return with one claimable spouse keeps the other spouse only (the claimable spouse is the head) + period: 2025 + reforms: policyengine_us.reforms.states.va.dependent_exemption.va_dependent_exemption_reform.va_dependent_exemption_reform + input: + gov.contrib.states.va.dependent_exemption.in_effect: true + gov.contrib.states.va.dependent_exemption.amount: 930 + people: + person_a: {age: 40, claimable_as_dependent_on_another_return: true, is_tax_unit_head: true, is_tax_unit_spouse: false} + person_b: {age: 40, employment_income: 20_000, is_tax_unit_head: false, is_tax_unit_spouse: true} + child1: {age: 10, is_tax_unit_dependent: true} + tax_units: {tax_unit: {members: [person_a, person_b, child1], filing_status: JOINT}} + households: {household: {members: [person_a, person_b, child1], state_name: VA}} + output: {va_personal_exemption: 930} + +- name: VA exemption reform - joint return with one claimable spouse keeps the other spouse only (the claimable spouse is the spouse) + period: 2025 + reforms: policyengine_us.reforms.states.va.dependent_exemption.va_dependent_exemption_reform.va_dependent_exemption_reform + input: + gov.contrib.states.va.dependent_exemption.in_effect: true + gov.contrib.states.va.dependent_exemption.amount: 930 + people: + person_b: {age: 40, employment_income: 20_000, is_tax_unit_head: true, is_tax_unit_spouse: false} + person_a: {age: 40, claimable_as_dependent_on_another_return: true, is_tax_unit_head: false, is_tax_unit_spouse: true} + child1: {age: 10, is_tax_unit_dependent: true} + tax_units: {tax_unit: {members: [person_b, person_a, child1], filing_status: JOINT}} + households: {household: {members: [person_b, person_a, child1], state_name: VA}} + output: {va_personal_exemption: 930}