policyengine-us 1.360.0__py3-none-any.whl → 1.437.0__py3-none-any.whl

policyengine_us/variables/gov/local/ca/riv/general_relief/eligibility/ca_riv_general_relief_income_eligible.py

@@ -0,0 +1,18 @@
+from policyengine_us.model_api import *
+
+
+class ca_riv_general_relief_income_eligible(Variable):
+    value_type = bool
+    entity = SPMUnit
+    label = "Eligible for the Riverside County General Relief due to income"
+    definition_period = MONTH
+    defined_for = "in_riv"
+
+    def formula(spm_unit, period, parameters):
+        countable_income = spm_unit(
+            "ca_riv_general_relief_countable_income", period
+        )
+        needs_standards = spm_unit(
+            "ca_riv_general_relief_needs_standards", period
+        )
+        return countable_income <= needs_standards

policyengine_us/variables/gov/local/ca/riv/general_relief/eligibility/ca_riv_general_relief_ineligible_person.py

@@ -0,0 +1,25 @@
+from policyengine_us.model_api import *
+
+
+class ca_riv_general_relief_ineligible_person(Variable):
+    value_type = bool
+    entity = Person
+    label = "Ineligible person for the Riverside County General Relief"
+    definition_period = MONTH
+    defined_for = "in_riv"
+
+    def formula(person, period, parameters):
+        receives_ssi_or_tanf = (
+            add(person.spm_unit, period, ["ssi", "ca_tanf"]) > 0
+        )
+        immigration_status_eligible = person(
+            "ca_riv_general_relief_immigration_status_eligible", period
+        )
+        meets_work_requirement = person(
+            "ca_riv_general_relief_meets_work_requirements", period
+        )
+        return (
+            receives_ssi_or_tanf
+            | ~immigration_status_eligible
+            | ~meets_work_requirement
+        )

policyengine_us/variables/gov/local/ca/riv/general_relief/eligibility/ca_riv_general_relief_meets_work_requirements.py

@@ -0,0 +1,43 @@
+from policyengine_us.model_api import *
+
+
+class ca_riv_general_relief_meets_work_requirements(Variable):
+    value_type = bool
+    entity = Person
+    label = "Meets work requirements for the Riverside County General Relief"
+    definition_period = MONTH
+    defined_for = "in_riv"
+
+    def formula(person, period, parameters):
+        p = parameters(
+            period
+        ).gov.local.ca.riv.general_relief.work_exempted_age
+        # Person who is actively searching for jobs also qualify for work requirements
+        is_working = (
+            add(
+                person, period, ["employment_income", "self_employment_income"]
+            )
+            > 0
+        )
+        # Check if person is a qualifying secondary school student
+        age = person("monthly_age", period)
+        is_full_time_student = person("is_full_time_student", period)
+        in_secondary_school = person("is_in_secondary_school", period)
+        is_qualifying_secondary_student = (
+            is_full_time_student & in_secondary_school
+        )
+        # Age-based exemptions have different thresholds based on student status:
+        # - Full-time secondary students: exempt if younger than threshold
+        # - Non-students: exempt if older than threshold (senior citizens)
+        work_exempted_due_to_age = where(
+            is_qualifying_secondary_student,
+            age < p.younger,  # Student exemption: too young
+            age >= p.older,  # Senior exemption: too old
+        )
+        # Incapacitated or need to caring full time for a member of household
+        has_incapable_of_self_care = person.spm_unit.any(
+            person("is_incapable_of_self_care", period)
+        )
+        return (
+            is_working | work_exempted_due_to_age | has_incapable_of_self_care
+        )

policyengine_us/variables/gov/local/ca/riv/general_relief/eligibility/ca_riv_general_relief_property_eligible.py

@@ -0,0 +1,16 @@
+from policyengine_us.model_api import *
+
+
+class ca_riv_general_relief_property_eligible(Variable):
+    value_type = bool
+    entity = SPMUnit
+    label = "Meets property limit for Riverside County General Relief"
+    definition_period = YEAR
+    defined_for = "in_riv"
+
+    def formula(spm_unit, period, parameters):
+        p = parameters(period).gov.local.ca.riv.general_relief.property
+        total_property_value = spm_unit(
+            "ca_riv_general_relief_countable_property_value", period
+        )
+        return total_property_value < p.limit

policyengine_us/variables/gov/local/ca/riv/general_relief/income/ca_riv_general_relief_countable_income.py

@@ -0,0 +1,16 @@
+from policyengine_us.model_api import *
+
+
+class ca_riv_general_relief_countable_income(Variable):
+    value_type = float
+    entity = SPMUnit
+    unit = USD
+    label = "Riverside County General Relief countable income"
+    definition_period = MONTH
+    defined_for = "in_riv"
+
+    # This value cannot be negative because the exclusion is calculated
+    # as a fraction of the excluded person's income, determined by
+    # household size and the number of applicants.
+    adds = ["ca_riv_general_relief_countable_income_person"]
+    subtracts = ["ca_riv_general_relief_excluded_income"]

policyengine_us/variables/gov/local/ca/riv/general_relief/income/ca_riv_general_relief_countable_income_person.py

@@ -0,0 +1,14 @@
+from policyengine_us.model_api import *
+
+
+class ca_riv_general_relief_countable_income_person(Variable):
+    value_type = float
+    entity = Person
+    unit = USD
+    label = "Person's countable income before proration"
+    definition_period = MONTH
+
+    adds = [
+        "ca_riv_general_relief_net_earned_income",
+        "ca_riv_general_relief_unearned_income",
+    ]

policyengine_us/variables/gov/local/ca/riv/general_relief/income/ca_riv_general_relief_excluded_income.py

@@ -0,0 +1,22 @@
+from policyengine_us.model_api import *
+
+
+class ca_riv_general_relief_excluded_income(Variable):
+    value_type = float
+    entity = Person
+    unit = USD
+    label = "Income amount excluded from ineligible household members due to proration under Riverside County General Relief Program"
+    definition_period = MONTH
+    defined_for = "ca_riv_general_relief_ineligible_person"
+
+    def formula(person, period, parameters):
+        income = person(
+            "ca_riv_general_relief_countable_income_person", period
+        )
+        spm_unit = person.spm_unit
+        needs_unit_size = spm_unit("spm_unit_size", period)
+        budget_unit_size = spm_unit(
+            "ca_riv_general_relief_budget_unit_size", period
+        )
+        exclusion_rate = (needs_unit_size - budget_unit_size) / needs_unit_size
+        return exclusion_rate * income

policyengine_us/variables/gov/local/ca/riv/general_relief/income/ca_riv_general_relief_unearned_income.py

@@ -0,0 +1,12 @@
+from policyengine_us.model_api import *
+
+
+class ca_riv_general_relief_unearned_income(Variable):
+    value_type = float
+    entity = Person
+    unit = USD
+    label = "Riverside County General Relief unearned income per person"
+    definition_period = MONTH
+    defined_for = "in_riv"
+
+    adds = "gov.local.ca.riv.general_relief.income.sources.unearned"

policyengine_us/variables/gov/local/ca/riv/general_relief/income/earned/ca_riv_general_relief_earned_income.py

@@ -0,0 +1,12 @@
+from policyengine_us.model_api import *
+
+
+class ca_riv_general_relief_earned_income(Variable):
+    value_type = float
+    entity = Person
+    unit = USD
+    label = "Riverside County General Relief earned income per person"
+    definition_period = MONTH
+    defined_for = "in_riv"
+
+    adds = "gov.local.ca.riv.general_relief.income.sources.earned"

policyengine_us/variables/gov/local/ca/riv/general_relief/income/earned/ca_riv_general_relief_earned_income_deductions.py

@@ -0,0 +1,12 @@
+from policyengine_us.model_api import *
+
+
+class ca_riv_general_relief_earned_income_deductions(Variable):
+    value_type = float
+    entity = Person
+    unit = USD
+    label = "Riverside County General Relief earned income deductions"
+    definition_period = MONTH
+    defined_for = "in_riv"
+
+    adds = "gov.local.ca.riv.general_relief.income.deductions.sources"

policyengine_us/variables/gov/local/ca/riv/general_relief/income/earned/ca_riv_general_relief_net_earned_income.py

@@ -0,0 +1,17 @@
+from policyengine_us.model_api import *
+
+
+class ca_riv_general_relief_net_earned_income(Variable):
+    value_type = float
+    entity = Person
+    unit = USD
+    label = "Riverside County GA net earned income after deductions"
+    definition_period = MONTH
+
+    def formula(person, period, parameters):
+        earned = person("ca_riv_general_relief_earned_income", period)
+        deductions = person(
+            "ca_riv_general_relief_earned_income_deductions", period
+        )
+
+        return max_(earned - deductions, 0)

policyengine_us/variables/gov/local/ca/riv/general_relief/payment/ca_riv_general_relief_needs_standards.py

@@ -0,0 +1,24 @@
+from policyengine_us.model_api import *
+
+
+class ca_riv_general_relief_needs_standards(Variable):
+    value_type = float
+    entity = SPMUnit
+    unit = USD
+    label = "Riverside County General Relief needs standards"
+    definition_period = MONTH
+    defined_for = "in_riv"
+
+    def formula(spm_unit, period, parameters):
+        p = parameters(period).gov.local.ca.riv.general_relief.needs_standards
+        size = spm_unit("ca_riv_general_relief_budget_unit_size", period)
+        capped_size = clip(size, 1, 5)
+        # Verify the housing cost using the DPSS 1140, GA Housing Information/Verification,
+        # or any other sufficient verification, such as lease agreement
+        housing_expense = spm_unit("housing_cost", period)
+        capped_housing_benefit = min_(housing_expense, p.housing[capped_size])
+        return (
+            capped_housing_benefit
+            + p.food[capped_size]
+            + p.personal_needs[capped_size]
+        )

policyengine_us/variables/gov/local/ca/riv/general_relief/payment/ca_riv_general_relief_special_needs_amount.py

@@ -0,0 +1,14 @@
+from policyengine_us.model_api import *
+
+
+class ca_riv_general_relief_special_needs_amount(Variable):
+    value_type = float
+    entity = SPMUnit
+    unit = USD
+    label = "Riverside County General Relief special needs amount"
+    definition_period = YEAR
+    defined_for = "in_riv"
+
+    adds = [
+        "gov.local.ca.riv.general_relief.needs_standards.special_needs.transportation"
+    ]

policyengine_us/variables/gov/local/ca/riv/general_relief/property/ca_riv_general_relief_countable_property_value.py

@@ -0,0 +1,12 @@
+from policyengine_us.model_api import *
+
+
+class ca_riv_general_relief_countable_property_value(Variable):
+    value_type = float
+    entity = Person
+    unit = USD
+    label = "Riverside County General Relief countable property value"
+    definition_period = YEAR
+    defined_for = "in_riv"
+
+    adds = "gov.local.ca.riv.general_relief.property.sources"

policyengine_us/variables/gov/local/ca/riv/general_relief/property/ca_riv_general_relief_countable_vehicle_value.py

@@ -0,0 +1,19 @@
+from policyengine_us.model_api import *
+
+
+class ca_riv_general_relief_countable_vehicle_value(Variable):
+    value_type = float
+    entity = SPMUnit
+    unit = USD
+    label = "Riverside County General Relief countable vehicle value"
+    definition_period = YEAR
+    defined_for = "in_riv"
+
+    def formula(spm_unit, period, parameters):
+        p = parameters(
+            period
+        ).gov.local.ca.riv.general_relief.property.vehicle_exemption
+        total_vehicle_value = spm_unit.household(
+            "household_vehicles_value", period
+        )
+        return max_(total_vehicle_value - p.amount, 0)

policyengine_us/variables/gov/local/tx/harris/in_harris_county_tx.py

@@ -0,0 +1,12 @@
+from policyengine_us.model_api import *
+
+
+class in_harris_county_tx(Variable):
+    value_type = bool
+    entity = Household
+    definition_period = YEAR
+    label = "Is in Harris County, Texas"
+
+    def formula(household, period, parameters):
+        county = household("county_str", period)
+        return county == "HARRIS_COUNTY_TX"

policyengine_us/variables/gov/local/tx/harris/rides/tx_harris_rides_eligible.py

@@ -0,0 +1,22 @@
+from policyengine_us.model_api import *
+
+
+class tx_harris_rides_eligible(Variable):
+    value_type = bool
+    entity = Person
+    definition_period = YEAR
+    label = "Harris County RIDES eligibility"
+    reference = "https://rides.harriscountytx.gov/Registration/Registration-Information"
+    defined_for = "in_harris_county_tx"
+
+    def formula(person, period, parameters):
+        p = parameters(period).gov.local.tx.harris.rides
+
+        # Age eligibility
+        age = person("age", period)
+        age_eligible = age >= p.age_threshold
+
+        # Disability eligibility
+        has_disability = person("is_disabled", period)
+
+        return age_eligible | has_disability

policyengine_us/variables/gov/local/tx/harris/rides/tx_harris_rides_subsidy.py

@@ -0,0 +1,26 @@
+from policyengine_us.model_api import *
+
+
+class tx_harris_rides_subsidy(Variable):
+    value_type = float
+    entity = Person
+    definition_period = YEAR
+    label = "Harris County RIDES transportation subsidy"
+    reference = "https://rides.harriscountytx.gov/"
+    unit = USD
+    defined_for = "tx_harris_rides_eligible"
+
+    def formula(person, period, parameters):
+        p = parameters(period).gov.local.tx.harris.rides
+
+        # Get estimated transportation costs
+        # In a real implementation, this would be based on actual trip data
+        # For now, we'll use a simplified estimate
+        transportation_costs = person(
+            "pre_subsidy_transportation_expense", period
+        )
+
+        # RIDES subsidizes 60% of trip costs (customer pays 40%)
+        subsidy_rate = 1 - p.customer_payment_rate
+
+        return transportation_costs * subsidy_rate

policyengine_us/variables/gov/ssa/ssi/eligibility/income/deemed/from_ineligible_spouse/is_ssi_spousal_deeming_applies.py

@@ -0,0 +1,41 @@
+from policyengine_us.model_api import *
+
+
+class is_ssi_spousal_deeming_applies(Variable):
+    value_type = bool
+    entity = Person
+    label = "SSI spousal deeming applies"
+    definition_period = YEAR
+    reference = "https://www.law.cornell.edu/cfr/text/20/416.1163"
+    defined_for = "is_ssi_eligible_individual"
+    documentation = """
+    Returns True when spousal deeming applies according to 20 CFR §416.1163.
+
+    Spousal deeming applies when:
+    1. Person is an eligible individual (not part of an eligible couple)
+    2. Spouse is ineligible (not aged/blind/disabled)
+    3. Spouse's leftover income (after child allocations) exceeds the difference
+       between couple FBR and individual FBR
+
+    When deeming applies, the benefit calculation uses the couple FBR instead
+    of the individual FBR, recognizing that two people have higher expenses.
+    """
+
+    def formula(person, period, parameters):
+        # Get spouse's deemed income (after child allocations)
+        spouse_deemed_income = add(
+            person,
+            period,
+            [
+                "ssi_earned_income_deemed_from_ineligible_spouse",
+                "ssi_unearned_income_deemed_from_ineligible_spouse",
+            ],
+        )
+
+        # Compare to FBR differential (couple rate - individual rate)
+        p = parameters(period).gov.ssa.ssi.amount
+        diff = (p.couple - p.individual) * MONTHS_IN_YEAR
+
+        # Deeming applies when spouse's deemed income exceeds the differential
+        # Note: regulation says "not more than" means ≤, so we use > for deeming
+        return spouse_deemed_income > diff

policyengine_us/variables/gov/ssa/ssi/eligibility/income/deemed/from_ineligible_spouse/ssi_income_deemed_from_ineligible_spouse.py

@@ -22,37 +22,37 @@ class ssi_income_deemed_from_ineligible_spouse(Variable):
     unit = USD
 
     def formula(person, period, parameters):
-        # 1. Sum leftover spouse earned/unearned (post-child allocations).
+        # 1. Check if spousal deeming applies (avoids duplicating threshold logic)
+        deeming_applies = person("is_ssi_spousal_deeming_applies", period)
+
+        # 2. If deeming applies, calculate deemed amount using "difference" approach:
+        #    (couple combined countable) - (individual alone countable)
+
+        # Get spouse's leftover income (post-child allocations)
         spouse_earned = person(
             "ssi_earned_income_deemed_from_ineligible_spouse", period
         )
         spouse_unearned = person(
             "ssi_unearned_income_deemed_from_ineligible_spouse", period
         )
-        leftover_spouse = spouse_earned + spouse_unearned
-
-        # 2. Compare leftover to FBR difference
-        p = parameters(period).gov.ssa.ssi.amount
-        diff = (p.couple - p.individual) * MONTHS_IN_YEAR
-        if_leftover_exceeds = leftover_spouse > diff
-
-        # 3. If leftover <= diff => no deeming
-        #    If leftover > diff => difference of incomes approach
-        #    (couple combined) - (individual alone).
-        #   (a) individual's own income
-        indiv_earned = person("ssi_earned_income", period)
-        indiv_unearned = person("ssi_unearned_income", period)
+
+        # Get individual's own income
+        individual_earned = person("ssi_earned_income", period)
+        individual_unearned = person("ssi_unearned_income", period)
+
+        # Calculate individual's countable income (alone)
         alone_countable = _apply_ssi_exclusions(
-            indiv_earned, indiv_unearned, parameters, period
+            individual_earned, individual_unearned, parameters, period
         )
 
-        #   (b) couple combined income
+        # Calculate couple's combined countable income
         couple_countable = _apply_ssi_exclusions(
-            indiv_earned + spouse_earned,
-            indiv_unearned + spouse_unearned,
+            individual_earned + spouse_earned,
+            individual_unearned + spouse_unearned,
             parameters,
             period,
         )
 
-        deemed_if_exceeds = max_(0, couple_countable - alone_countable)
-        return if_leftover_exceeds * deemed_if_exceeds
+        # Deemed amount is the difference (only when deeming applies)
+        deemed_amount = max_(0, couple_countable - alone_countable)
+        return deeming_applies * deemed_amount

policyengine_us/variables/gov/ssa/ssi/eligibility/income/ssi_countable_income.py

@@ -53,22 +53,27 @@ class ssi_countable_income(Variable):
             period,
         )
 
-        # Add any spousal deemed income
+        # Check if both spouses are eligible
+        both_eligible = person("ssi_marital_both_eligible", period)
+
+        # Add spousal deemed income (only relevant when one spouse is ineligible)
         spousal_deemed = person(
             "ssi_income_deemed_from_ineligible_spouse", period
         )
 
-        # If this person is the spouse whose income is being deemed away, do not double-count it
-        # (has_donated_income ensures a spouse who "gave" their income to the other doesn't keep it)
-        has_donated_income = (
-            person.marital_unit.sum(spousal_deemed) > spousal_deemed
-        )
-
-        # Only apply countable income for an SSI-eligible individual
-        is_eligible = person("is_ssi_eligible_individual", period)
+        # Check if person is eligible (either as individual OR as eligible spouse)
+        is_eligible_individual = person("is_ssi_eligible_individual", period)
+        is_eligible_spouse = person("is_ssi_eligible_spouse", period)
+        is_eligible = is_eligible_individual | is_eligible_spouse
 
+        # Calculate final countable income
         return where(
-            has_donated_income | ~is_eligible,
+            ~is_eligible,
             0,
-            personal_countable + spousal_deemed,
+            where(
+                both_eligible,
+                personal_countable / 2,  # Each eligible spouse gets half
+                personal_countable
+                + spousal_deemed,  # Single or with ineligible spouse
+            ),
         )

policyengine_us/variables/gov/ssa/ssi/is_ssi_eligible.py

@@ -8,6 +8,13 @@ class is_ssi_eligible(Variable):
     definition_period = YEAR
 
     def formula(person, period, parameters):
+        abd_person = person("is_ssi_aged_blind_disabled", period)
         meets_resource_test = person("meets_ssi_resource_test", period)
-        eligible = person("is_ssi_eligible_individual", period)
-        return meets_resource_test & eligible
+        is_qualified_noncitizen = person("is_ssi_qualified_noncitizen", period)
+        immigration_status = person("immigration_status", period)
+        is_citizen = (
+            immigration_status == immigration_status.possible_values.CITIZEN
+        )
+        meets_immigration_status = is_qualified_noncitizen | is_citizen
+
+        return abd_person & meets_resource_test & meets_immigration_status

policyengine_us/variables/gov/ssa/ssi/ssi.py

@@ -13,4 +13,25 @@ class ssi(Variable):
     def formula(person, period, parameters):
         if parameters(period).gov.ssa.ssi.abolish_ssi:
             return 0
-        return max_(0, person("uncapped_ssi", period))
+
+        uncapped = person("uncapped_ssi", period)
+
+        # Apply floor: SSI cannot be negative
+        benefit = max_(0, uncapped)
+
+        # Apply cap when spousal deeming: cannot exceed individual FBR
+        # per 20 CFR §416.1163
+        # This cap is necessary when spouse's gross income is just above $483:
+        # - Deeming applies (uses couple FBR)
+        # - After exclusions, countable may be low
+        # - Benefit could exceed individual FBR without this cap
+        deeming_applies = person("is_ssi_spousal_deeming_applies", period)
+        p = parameters(period).gov.ssa.ssi.amount
+        individual_max = p.individual * MONTHS_IN_YEAR
+        capped_benefit = min_(benefit, individual_max)
+
+        return where(
+            deeming_applies,
+            capped_benefit,
+            benefit,
+        )

policyengine_us/variables/gov/ssa/ssi/ssi_amount_if_eligible.py

@@ -10,12 +10,38 @@ class ssi_amount_if_eligible(Variable):
     reference = "https://www.law.cornell.edu/uscode/text/42/1382#b"
 
     def formula(person, period, parameters):
-        ssi = parameters(period).gov.ssa.ssi.amount
-        return (
-            where(
-                person("ssi_claim_is_joint", period),
-                ssi.couple,
-                ssi.individual,
-            )
-            * MONTHS_IN_YEAR
+        p = parameters(period).gov.ssa.ssi.amount
+        is_dependent = person("is_tax_unit_dependent", period)
+
+        # Three scenarios for adults:
+        # 1. Both spouses eligible (joint claim) → couple rate / 2
+        # 2. One eligible, no deeming → individual rate
+        # 3. One eligible, deeming applies → couple rate (capped in ssi)
+        #
+        # Note: In scenario 3, deeming applies when spouse's GROSS income > $483.
+        # Income exclusions are applied to the COMBINED income afterwards.
+        # This means countable income can be much lower than $483, and the
+        # benefit can exceed individual FBR, requiring the cap in ssi.
+
+        is_joint_claim = person("ssi_claim_is_joint", period)
+        deeming_applies = person("is_ssi_spousal_deeming_applies", period)
+
+        # Determine FBR to use based on scenario
+        individual_or_deeming_amount = where(
+            deeming_applies,
+            p.couple,  # Scenario 3: Deeming applies - use couple rate!
+            p.individual,  # Scenario 2: No deeming
+        )
+
+        head_or_spouse_amount = where(
+            is_joint_claim,
+            p.couple / 2,  # Scenario 1: Both eligible
+            individual_or_deeming_amount,
+        )
+
+        # Adults amount is based on scenario (see above)
+        # Dependents always use individual amount.
+        ssi_per_month = where(
+            is_dependent, p.individual, head_or_spouse_amount
         )
+        return ssi_per_month * MONTHS_IN_YEAR

policyengine_us/variables/gov/ssa/ssi/ssi_claim_is_joint.py

@@ -6,17 +6,10 @@ class ssi_claim_is_joint(Variable):
     entity = Person
     label = "SSI claim is joint"
     definition_period = YEAR
-    defined_for = "is_ssi_eligible_individual"
 
     def formula(person, period, parameters):
-        # The simplest way: if you're in a marital_unit with 2 people,
-        # and you are an SSI-eligible individual,
-        # we say it's 'joint' no matter how much is actually deemed.
-        #
-        # Note: In the PolicyEngine codebase, marital units by definition only
-        # include spouses (max of 2 people), not dependents or children.
-        # Dependents would be in the same tax_unit or family, but not the same
-        # marital_unit. Marital units are defined in entities.py as:
-        # "An unmarried person, or a married and co-habiting couple."
-        num_in_marriage = person.marital_unit.nb_persons()
-        return num_in_marriage == 2
+        abd_person = person("is_ssi_aged_blind_disabled", period)
+        is_head_or_spouse = person("is_tax_unit_head_or_spouse", period)
+        eligible_person = abd_person & is_head_or_spouse
+
+        return person.marital_unit.sum(eligible_person) > 1

policyengine_us/variables/gov/states/ar/tax/income/credits/ar_additional_tax_credit_for_qualified_individuals.py

@@ -0,0 +1,12 @@
+from policyengine_us.model_api import *
+
+
+class ar_additional_tax_credit_for_qualified_individuals(Variable):
+    value_type = float
+    entity = TaxUnit
+    label = "Arkansas additional tax credit for qualified individuals"
+    unit = USD
+    definition_period = YEAR
+    defined_for = StateCode.AR
+
+    adds = ["ar_additional_tax_credit_for_qualified_individuals_person"]