policyengine-us 1.449.6__py3-none-any.whl → 1.465.0__py3-none-any.whl

policyengine_us/variables/gov/simulation/labor_supply_response/labor_supply_behavioral_response.py

@@ -16,53 +16,68 @@ class labor_supply_behavioral_response(Variable):
         if p.elasticities.income == 0 and p.elasticities.substitution.all == 0:
             return 0
 
-        measurement_branch = simulation.get_branch(
-            "lsr_measurement", clone_system=True
-        )  # A branch without LSRs
-        baseline_branch = simulation.get_branch("baseline").get_branch(
-            "baseline_lsr_measurement", clone_system=True
-        )  # Already created by default
-        baseline_branch.tax_benefit_system.parameters.simulation = (
-            measurement_branch.tax_benefit_system.parameters.simulation
-        )
+        # Guard against re-entry (prevents recursion when branches calculate variables)
+        if (
+            hasattr(simulation, "_lsr_calculating")
+            and simulation._lsr_calculating
+        ):
+            return 0
 
-        # (system with LSRs) <- (system without LSRs used to calculate LSRs)
-        #                      |
-        #                      * -(baseline system without LSRs used to calculate LSRs)
+        # Mark that we're calculating LSR
+        simulation._lsr_calculating = True
 
-        for branch in [measurement_branch, baseline_branch]:
-            branch.tax_benefit_system.neutralize_variable(
-                "employment_income_behavioral_response"
-            )
-            branch.tax_benefit_system.neutralize_variable(
-                "self_employment_income_behavioral_response"
-            )
-            branch.set_input(
-                "employment_income_before_lsr",
-                period,
-                person("employment_income_before_lsr", period),
+        try:
+            measurement_branch = simulation.get_branch(
+                "lsr_measurement", clone_system=True
+            )  # A branch without LSRs
+            baseline_branch = simulation.get_branch("baseline").get_branch(
+                "baseline_lsr_measurement", clone_system=True
+            )  # Already created by default
+            baseline_branch.tax_benefit_system.parameters.simulation = (
+                measurement_branch.tax_benefit_system.parameters.simulation
             )
-            branch.set_input(
-                "self_employment_income_before_lsr",
+
+            # (system with LSRs) <- (system without LSRs used to calculate LSRs)
+            #                      |
+            #                      * -(baseline system without LSRs used to calculate LSRs)
+
+            for branch in [measurement_branch, baseline_branch]:
+                branch.tax_benefit_system.neutralize_variable(
+                    "employment_income_behavioral_response"
+                )
+                branch.tax_benefit_system.neutralize_variable(
+                    "self_employment_income_behavioral_response"
+                )
+                branch.set_input(
+                    "employment_income_before_lsr",
+                    period,
+                    person("employment_income_before_lsr", period),
+                )
+                branch.set_input(
+                    "self_employment_income_before_lsr",
+                    period,
+                    person("self_employment_income_before_lsr", period),
+                )
+
+            response = add(
+                person,
                 period,
-                person("self_employment_income_before_lsr", period),
+                [
+                    "income_elasticity_lsr",
+                    "substitution_elasticity_lsr",
+                ],
             )
+            simulation = person.simulation
+            del simulation.branches["baseline"].branches[
+                "baseline_lsr_measurement"
+            ]
+            del simulation.branches["lsr_measurement"]
 
-        response = add(
-            person,
-            period,
-            [
-                "income_elasticity_lsr",
-                "substitution_elasticity_lsr",
-            ],
-        )
-        simulation = person.simulation
-        del simulation.branches["baseline"].branches[
-            "baseline_lsr_measurement"
-        ]
-        del simulation.branches["lsr_measurement"]
+            simulation.macro_cache_read = False
+            simulation.macro_cache_write = False
 
-        simulation.macro_cache_read = False
-        simulation.macro_cache_write = False
+            return response
 
-        return response
+        finally:
+            # Clear the re-entry guard
+            simulation._lsr_calculating = False

policyengine_us/variables/gov/ssa/revenue/tob_revenue_medicare_hi.py

@@ -0,0 +1,31 @@
+from policyengine_us.model_api import *
+
+
+class tob_revenue_medicare_hi(Variable):
+    value_type = float
+    entity = TaxUnit
+    definition_period = YEAR
+    label = "Medicare HI trust fund revenue from SS benefit taxation (tier 2)"
+    documentation = "Tax revenue from tier 2 (50-85%) Social Security benefit taxation credited to Medicare HI trust fund"
+    unit = USD
+
+    def formula(tax_unit, period, parameters):
+        """
+        Calculate Medicare HI trust fund revenue from tier 2 SS taxation.
+
+        Allocates total TOB revenue to Medicare HI based on tier 2's proportion
+        of total taxable SS.
+        """
+        # Get total TOB revenue
+        total_tob = tax_unit("tob_revenue_total", period)
+
+        # Get tier amounts
+        tier1 = tax_unit("taxable_social_security_tier_1", period)
+        tier2 = tax_unit("taxable_social_security_tier_2", period)
+        total_taxable = tier1 + tier2
+
+        # Allocate total TOB based on tier 2 proportion
+        # Use where to handle division by zero
+        medicare_share = where(total_taxable > 0, tier2 / total_taxable, 0)
+
+        return total_tob * medicare_share

policyengine_us/variables/gov/ssa/revenue/tob_revenue_oasdi.py

@@ -0,0 +1,31 @@
+from policyengine_us.model_api import *
+
+
+class tob_revenue_oasdi(Variable):
+    value_type = float
+    entity = TaxUnit
+    definition_period = YEAR
+    label = "OASDI trust fund revenue from SS benefit taxation (tier 1)"
+    documentation = "Tax revenue from tier 1 (0-50%) Social Security benefit taxation credited to OASDI trust funds"
+    unit = USD
+
+    def formula(tax_unit, period, parameters):
+        """
+        Calculate OASDI trust fund revenue from tier 1 SS taxation.
+
+        Allocates total TOB revenue to OASDI based on tier 1's proportion
+        of total taxable SS.
+        """
+        # Get total TOB revenue
+        total_tob = tax_unit("tob_revenue_total", period)
+
+        # Get tier amounts
+        tier1 = tax_unit("taxable_social_security_tier_1", period)
+        tier2 = tax_unit("taxable_social_security_tier_2", period)
+        total_taxable = tier1 + tier2
+
+        # Allocate total TOB based on tier 1 proportion
+        # Use where to handle division by zero
+        oasdi_share = where(total_taxable > 0, tier1 / total_taxable, 0)
+
+        return total_tob * oasdi_share

policyengine_us/variables/gov/ssa/revenue/tob_revenue_total.py

@@ -0,0 +1,44 @@
+from policyengine_us.model_api import *
+
+
+class tob_revenue_total(Variable):
+    value_type = float
+    entity = TaxUnit
+    definition_period = YEAR
+    label = "Total trust fund revenue from SS benefit taxation"
+    documentation = "Tax revenue from taxation of Social Security benefits using branching methodology"
+    unit = USD
+
+    def formula(tax_unit, period, parameters):
+        """
+        Calculate trust fund revenue using branching + neutralization.
+
+        This is the CORRECT way to isolate TOB revenue, superior to the
+        average effective tax rate approximation.
+        """
+        sim = tax_unit.simulation
+
+        # Calculate income tax WITH taxable SS
+        income_tax_with_ss = tax_unit("income_tax", period)
+
+        # Create branch and neutralize taxable SS
+        branch = sim.get_branch("tob_calc", clone_system=True)
+        branch.tax_benefit_system.neutralize_variable(
+            "tax_unit_taxable_social_security"
+        )
+
+        # Delete all calculated variables to force recalculation
+        for var_name in list(branch.tax_benefit_system.variables.keys()):
+            if var_name not in branch.input_variables:
+                try:
+                    branch.delete_arrays(var_name)
+                except:
+                    pass
+
+        # Recalculate income tax without taxable SS
+        income_tax_without_ss = branch.tax_unit("income_tax", period)
+
+        # Clean up branch
+        del sim.branches["tob_calc"]
+
+        return income_tax_with_ss - income_tax_without_ss

policyengine_us/variables/gov/states/az/tax/income/credits/property_tax_credit/az_property_tax_credit_agi.py

@@ -0,0 +1,53 @@
+from policyengine_us.model_api import *
+
+
+class az_property_tax_credit_agi(Variable):
+    value_type = float
+    entity = TaxUnit
+    label = "Arizona adjusted gross income for property tax credit"
+    unit = USD
+    definition_period = YEAR
+    documentation = (
+        "Adjusted gross income as defined for Arizona property tax credit purposes. "
+        "Per ARS 43-1072(H)(6) and ITR 12-1, this starts with Federal AGI and only "
+        "excludes items specifically listed in ARS 43-1072(I): Social Security, "
+        "railroad retirement, workers compensation, Arizona unemployment, veterans "
+        "disability pensions, welfare, and gifts. Unlike regular Arizona income tax, "
+        "this does NOT exclude pension income, capital gains, or Arizona exemptions."
+    )
+    reference = [
+        "https://www.azleg.gov/ars/43/01072.htm",  # ARS 43-1072
+        "https://azdor.gov/sites/default/files/2023-03/RULINGS_INDV_2012_itr12-1.pdf",  # ITR 12-1
+    ]
+    defined_for = StateCode.AZ
+
+    def formula(tax_unit, period, parameters):
+        # Start with Federal AGI
+        # Per ITR 12-1, income includes wages, interest, business/farm income,
+        # rent/royalty, S-corp/partnership income, alimony, capital gains,
+        # pension/annuity income, and other non-excluded income.
+        federal_agi = tax_unit("adjusted_gross_income", period)
+
+        # Per ARS 43-1072(I) and ITR 12-1 "Items Excluded from Income",
+        # we ONLY exclude Social Security benefits (and other items like
+        # railroad retirement, workers comp, AZ unemployment, veterans
+        # disability pensions, welfare, and gifts - but these are typically
+        # not in Federal AGI anyway).
+        #
+        # Federal AGI only includes the TAXABLE portion of Social Security,
+        # but for property tax credit, ALL Social Security should be excluded.
+        # So we subtract the taxable portion that's in Federal AGI.
+        taxable_social_security = tax_unit(
+            "tax_unit_taxable_social_security", period
+        )
+
+        # NOTE: We do NOT subtract Arizona's regular subtractions here because:
+        # - Pension exclusions (az_public_pension_exclusion,
+        #   az_military_retirement_subtraction) should be INCLUDED per
+        #   ITR 12-1 item (9)
+        # - Capital gains subtraction (az_long_term_capital_gains_subtraction)
+        #   should be INCLUDED per ITR 12-1 item (7)
+        # - US Government interest should be INCLUDED per ITR 12-1 item (2)
+        # - Arizona exemptions (aged, blind) should NOT be subtracted
+
+        return max_(0, federal_agi - taxable_social_security)

policyengine_us/variables/gov/states/ca/chhs/is_ca_medicaid_immigration_status_eligible.py

@@ -4,15 +4,36 @@ from policyengine_us.model_api import *
 class is_ca_medicaid_immigration_status_eligible(Variable):
     value_type = bool
     entity = Person
-    label = "Eligible for California state-funded Medicaid regardless of immigration status"
+    label = "Eligible for California Medi-Cal without satisfactory immigration status"
     definition_period = YEAR
-    reference = [
+    reference = (
         "https://california.public.law/codes/welfare_and_institutions_code_section_14007.8",
-    ]
+    )
+    documentation = """
+    California Welfare and Institutions Code Section 14007.8 provides
+    state-funded Medi-Cal to individuals without satisfactory immigration
+    status based on age brackets. Starting January 1, 2026, new enrollments
+    for adults 19+ are frozen, but existing enrollees retain coverage.
+    """
     defined_for = StateCode.CA
 
     def formula(person, period, parameters):
         p = parameters(period).gov.states.ca.chhs
         age = person("age", period)
         pregnant = person("is_pregnant", period)
-        return p.eligible_regardless_of_immigration_status.calc(age) | pregnant
+        # Standard eligibility based on age or pregnancy
+        standard_eligible = (
+            p.eligible_regardless_of_immigration_status.calc(age) | pregnant
+        )
+        # Continuous coverage only applies after enrollment freeze
+        if p.medi_cal_enrollment_freeze.in_effect:
+            receives_medicaid = person("receives_medicaid", period)
+            # Section 14007.8 is specifically for undocumented immigrants
+            immigration_status = person("immigration_status", period)
+            undocumented = (
+                immigration_status
+                == immigration_status.possible_values.UNDOCUMENTED
+            )
+            continuous_coverage = receives_medicaid & undocumented
+            return standard_eligible | continuous_coverage
+        return standard_eligible

policyengine_us/variables/gov/states/dc/tax/income/credits/dc_ptc.py

@@ -18,15 +18,19 @@ class dc_ptc(Variable):
         retax = add(tax_unit, period, ["real_estate_taxes"])
         p_dc = parameters(period).gov.states.dc.tax.income.credits
         ptax = retax + rent * p_dc.ptc.rent_ratio
+
         elderly_age = p_dc.ptc.min_elderly_age
         head_age = tax_unit("age_head", period)
         spouse_age = tax_unit("age_spouse", period)
         is_elderly = (head_age >= elderly_age) | (spouse_age >= elderly_age)
+
+        # Only positive AGI creates an offset (negative AGI should not reduce offset)
         us_agi = tax_unit("adjusted_gross_income", period)
-        ptax_offset = us_agi * where(
+        positive_agi = max_(0, us_agi)
+        ptax_offset = positive_agi * where(
             is_elderly,
-            p_dc.ptc.fraction_elderly.calc(us_agi, right=True),
-            p_dc.ptc.fraction_nonelderly.calc(us_agi, right=True),
+            p_dc.ptc.fraction_elderly.calc(positive_agi, right=True),
+            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)

policyengine_us/variables/gov/states/ia/tax/income/credits/ia_cdcc.py

@@ -18,6 +18,8 @@ class ia_cdcc(Variable):
     def formula(tax_unit, period, parameters):
         # Iowa matches the potential federal credit
         federal_cdcc = tax_unit("cdcc_potential", period)
-        netinc = add(tax_unit, period, ["ia_net_income"])
+        taxable_income = tax_unit("ia_taxable_income", period)
         p = parameters(period).gov.states.ia.tax.income
-        return federal_cdcc * p.credits.child_care.fraction.calc(netinc)
+        return federal_cdcc * p.credits.child_care.fraction.calc(
+            taxable_income
+        )

policyengine_us/variables/gov/states/il/dhs/aabd/eligibility/il_aabd_immigration_status_eligible_person.py

@@ -18,6 +18,6 @@ class il_aabd_immigration_status_eligible_person(Variable):
         immigration_status_str = immigration_status.decode_to_str()
         has_qualifying_status = np.isin(
             immigration_status_str,
-            p.qualified_noncitizen_status,
+            p.qualified_noncitizen_statuses,
         )
         return has_qualifying_status | is_citizen

policyengine_us/variables/gov/states/il/dhs/aabd/eligibility/il_aabd_non_financial_eligible_person.py

@@ -6,15 +6,33 @@ class il_aabd_non_financial_eligible_person(Variable):
     entity = Person
     definition_period = MONTH
     label = "Eligible person for Illinois Aid to the Aged, Blind or Disabled (AABD)"
-    reference = "https://www.law.cornell.edu/regulations/illinois/title-89/part-113/subpart-B"
+    reference = (
+        "https://www.law.cornell.edu/regulations/illinois/title-89/part-113/subpart-B",
+        "https://www.dhs.state.il.us/page.aspx?item=15910",
+    )
     defined_for = StateCode.IL
 
     def formula(person, period, parameters):
-        aged_or_blind_or_disabled = person(
-            "il_aabd_aged_blind_disabled_person", period
-        )
+        # Per IDHS Policy Manual PM 11-01-00, a person must either:
+        # 1. Receive SSI, OR
+        # 2. Be ineligible for SSI due to income (but meet all other SSI requirements)
+        #
+        # Note: The policy manual only mentions "disabled" for under-65 persons
+        # who are SSI-ineligible due to income, but 89 Ill. Admin. Code 113.40(b)
+        # explicitly states: "The Department will make the determination of
+        # blindness when the client has been denied SSI on the basis of too
+        # much income." So blind persons are also covered.
+        #
+        # is_ssi_eligible checks categorical (aged/blind/disabled), resources,
+        # and immigration status for SSI. If True, person qualifies for IL AABD
+        # regardless of whether they actually receive SSI (income may be too high).
+        ssi_status_eligible = person("is_ssi_eligible", period.this_year)
+
+        # IL AABD has additional qualified noncitizen categories beyond SSI
+        # (e.g., abuse victims, trafficking victims, military families per
+        # 89 Ill. Admin. Code 113.10), so we check IL-specific immigration.
         immigration_status_eligible = person(
             "il_aabd_immigration_status_eligible_person", period
         )
 
-        return aged_or_blind_or_disabled & immigration_status_eligible
+        return ssi_status_eligible & immigration_status_eligible

policyengine_us/variables/gov/states/il/dhs/tanf/eligibility/il_tanf_immigration_status_eligible_person.py

@@ -15,7 +15,7 @@ class il_tanf_immigration_status_eligible_person(Variable):
         immigration_status_str = immigration_status.decode_to_str()
         has_qualifying_status = np.isin(
             immigration_status_str,
-            p.qualified_noncitizen_status,
+            p.qualified_noncitizen_statuses,
         )
         is_citizen = (
             immigration_status == immigration_status.possible_values.CITIZEN

policyengine_us/variables/gov/states/il/hfs/bcc/eligibility/il_bcc_age_eligible.py

@@ -0,0 +1,15 @@
+from policyengine_us.model_api import *
+
+
+class il_bcc_age_eligible(Variable):
+    value_type = bool
+    entity = Person
+    label = "Illinois Health Benefits for Persons with Breast or Cervical Cancer age eligible"
+    definition_period = YEAR
+    reference = ("https://www.dhs.state.il.us/page.aspx?item=33528",)
+    defined_for = StateCode.IL
+
+    def formula(person, period, parameters):
+        p = parameters(period).gov.states.il.hfs.bcc.eligibility
+        age = person("age", period)
+        return age < p.age

policyengine_us/variables/gov/states/il/hfs/bcc/eligibility/il_bcc_eligible.py

@@ -0,0 +1,27 @@
+from policyengine_us.model_api import *
+
+
+class il_bcc_eligible(Variable):
+    value_type = bool
+    entity = Person
+    label = "Illinois Health Benefits for Persons with Breast or Cervical Cancer eligible"
+    definition_period = YEAR
+    reference = (
+        "https://www.dhs.state.il.us/page.aspx?item=33528",
+        "https://www.dhs.state.il.us/page.aspx?item=33527",
+    )
+    defined_for = StateCode.IL
+
+    def formula(person, period, parameters):
+        is_female = person("is_female", period)
+        age_eligible = person("il_bcc_age_eligible", period)
+        immigration_eligible = person(
+            "il_hfs_immigration_status_eligible", period
+        )
+        insurance_eligible = person("il_bcc_insurance_eligible", period)
+        return (
+            is_female
+            & age_eligible
+            & immigration_eligible
+            & insurance_eligible
+        )

policyengine_us/variables/gov/states/il/hfs/bcc/eligibility/il_bcc_insurance_eligible.py

@@ -0,0 +1,29 @@
+from policyengine_us.model_api import *
+
+
+class il_bcc_insurance_eligible(Variable):
+    value_type = bool
+    entity = Person
+    label = "Illinois BCC insurance eligible"
+    definition_period = YEAR
+    reference = (
+        "https://www.dhs.state.il.us/page.aspx?item=33528",
+        "https://www.ilga.gov/legislation/ilcs/documents/030500050K5-2.htm",
+    )
+    defined_for = StateCode.IL
+
+    def formula(person, period, parameters):
+        # Per PM 06-20-02, persons are eligible if they are "uninsured".
+        # A person is NOT uninsured (thus ineligible) if they have:
+        # - Medicaid eligibility through another pathway
+        # - Health coverage that would pay for cancer treatment
+        #
+        # Exceptions that still qualify as "uninsured":
+        # - Coverage with limited benefits
+        # - Coverage where lifetime cap has been met/exceeded
+        # - Coverage that excludes cancer treatment
+        # - Indian Health Service coverage only
+        on_medicaid = person("receives_medicaid", period)
+        has_qualifying_coverage = person("has_bcc_qualifying_coverage", period)
+        has_disqualifying_coverage = on_medicaid | has_qualifying_coverage
+        return ~has_disqualifying_coverage

policyengine_us/variables/gov/states/il/hfs/fpp/eligibility/il_fpp_eligible.py

@@ -0,0 +1,40 @@
+from policyengine_us.model_api import *
+
+
+class il_fpp_eligible(Variable):
+    value_type = bool
+    entity = Person
+    label = "Illinois Family Planning Program eligible"
+    definition_period = YEAR
+    reference = (
+        "https://www.dhs.state.il.us/page.aspx?item=146077",
+        "https://hfs.illinois.gov/medicalclients/familyplanning.html",
+        "https://www.ilga.gov/agencies/JCAR/EntirePart?titlepart=07700635",
+    )
+    defined_for = StateCode.IL
+
+    def formula(person, period, parameters):
+        # Note: Illinois has two Family Planning programs:
+        # 1. Family Planning Presumptive Eligibility (FPPE) - temporary
+        #    coverage, does NOT require citizenship/immigration status
+        # 2. Ongoing Family Planning Program - 1 year coverage, REQUIRES
+        #    US citizenship or qualified immigrant status
+        # This variable models the ongoing program. The only eligibility
+        # difference between the two is the immigration requirement.
+
+        income_eligible = person("il_fpp_income_eligible", period)
+        # Must NOT be pregnant (pregnant individuals should apply for
+        # maternal health programs instead)
+        not_pregnant = ~person("is_pregnant", period)
+        # Use shared IL HFS immigration status check
+        immigration_eligible = person(
+            "il_hfs_immigration_status_eligible", period
+        )
+        # Cannot be enrolled in other non-spenddown full medical coverage
+        not_on_medicaid = ~person("receives_medicaid", period)
+        return (
+            income_eligible
+            & not_pregnant
+            & immigration_eligible
+            & not_on_medicaid
+        )

policyengine_us/variables/gov/states/il/hfs/fpp/eligibility/il_fpp_income_eligible.py

@@ -0,0 +1,18 @@
+from policyengine_us.model_api import *
+
+
+class il_fpp_income_eligible(Variable):
+    value_type = bool
+    entity = Person
+    label = "Illinois Family Planning Program income eligible"
+    definition_period = YEAR
+    reference = (
+        "https://www.dhs.state.il.us/page.aspx?item=146077",
+        "https://hfs.illinois.gov/medicalclients/familyplanning.html",
+    )
+    defined_for = StateCode.IL
+
+    def formula(person, period, parameters):
+        p = parameters(period).gov.states.il.hfs.fpp.eligibility
+        income_level = person("il_fpp_income_level", period)
+        return income_level <= p.income_limit

policyengine_us/variables/gov/states/il/hfs/fpp/il_fpp_income_level.py

@@ -0,0 +1,29 @@
+from policyengine_us.model_api import *
+from policyengine_us.variables.gov.hhs.tax_unit_fpg import fpg
+
+
+class il_fpp_income_level(Variable):
+    value_type = float
+    entity = Person
+    label = "Illinois Family Planning Program income level"
+    unit = "/1"
+    definition_period = YEAR
+    reference = (
+        "https://www.dhs.state.il.us/page.aspx?item=146077",
+        "https://hfs.illinois.gov/medicalclients/familyplanning.html",
+    )
+    defined_for = StateCode.IL
+
+    def formula(person, period, parameters):
+        # Only the applicant's income is counted (not household income)
+        income = person("adjusted_gross_income_person", period)
+
+        # Fixed household size of 2 per IL FPP policy
+        p = parameters(period).gov.states.il.hfs.fpp.eligibility
+
+        # Calculate FPG using fixed household size
+        state_group = person.household("state_group_str", period)
+        fpp_fpg = fpg(p.household_size, state_group, period, parameters)
+
+        # Return income as fraction of FPL
+        return income / fpp_fpg

policyengine_us/variables/gov/states/il/hfs/hbwd/eligibility/il_hbwd_disability_eligible.py

@@ -13,8 +13,12 @@ class il_hbwd_disability_eligible(Variable):
     defined_for = StateCode.IL
 
     def formula(person, period, parameters):
-        # Must meet Social Security Administration's definition of disability
-        is_ssi_disabled = person("is_ssi_disabled", period)
+        # Must meet Social Security Administration's definition of disability.
+        # Per DB101 Illinois "For HBWD, Social Security's disability
+        # rules related to earned income do not apply" - so we use is_disabled
+        # (medical definition) instead of is_ssi_disabled (which includes SGA test).
+        # See: https://il.db101.org/il/programs/health_coverage/how_health/program2b.htm
+        is_disabled = person("is_disabled", period.this_year)
         # Or currently receiving SSDI
         receives_ssdi = person("social_security_disability", period) > 0
-        return is_ssi_disabled | receives_ssdi
+        return is_disabled | receives_ssdi

policyengine_us/variables/gov/states/il/hfs/hbwd/eligibility/il_hbwd_eligible.py

@@ -20,7 +20,7 @@ class il_hbwd_eligible(Variable):
         income_eligible = person("il_hbwd_income_eligible", period)
         asset_eligible = person("il_hbwd_asset_eligible", period)
         immigration_eligible = person(
-            "il_hbwd_immigration_status_eligible", period
+            "il_hfs_immigration_status_eligible", period
         )
 
         return (

policyengine_us/variables/gov/states/il/hfs/{hbwd/eligibility/il_hbwd_immigration_status_eligible.py → il_hfs_immigration_status_eligible.py}

@@ -1,19 +1,16 @@
 from policyengine_us.model_api import *
 
 
-class il_hbwd_immigration_status_eligible(Variable):
+class il_hfs_immigration_status_eligible(Variable):
     value_type = bool
     entity = Person
-    label = "Illinois Health Benefits for Workers with Disabilities immigration status eligible"
-    definition_period = MONTH
-    reference = (
-        "https://www.law.cornell.edu/regulations/illinois/Ill-Admin-Code-tit-89-SS-120.310",
-        "https://www.law.cornell.edu/regulations/illinois/Ill-Admin-Code-tit-89-SS-120.510",
-    )
+    label = "Illinois HFS programs immigration status eligible"
+    definition_period = YEAR
+    reference = "https://www.law.cornell.edu/regulations/illinois/Ill-Admin-Code-tit-89-SS-120.310"
     defined_for = StateCode.IL
 
     def formula(person, period, parameters):
-        p = parameters(period).gov.states.il.hfs.hbwd.eligibility
+        p = parameters(period).gov.states.il.hfs
         immigration_status = person("immigration_status", period)
         is_citizen = (
             immigration_status == immigration_status.possible_values.CITIZEN

policyengine_us/variables/gov/states/il/hfs/mpe/eligibility/il_mpe_income_eligible.py

@@ -0,0 +1,15 @@
+from policyengine_us.model_api import *
+
+
+class il_mpe_income_eligible(Variable):
+    value_type = bool
+    entity = Person
+    label = "Illinois MPE income eligible"
+    definition_period = MONTH
+    reference = "https://www.law.cornell.edu/regulations/illinois/Ill-Admin-Code-tit-89-SS-120.66"
+    defined_for = StateCode.IL
+
+    def formula(person, period, parameters):
+        p = parameters(period).gov.states.il.hfs.mpe.eligibility
+        income_level = person("medicaid_income_level", period.this_year)
+        return income_level <= p.income_limit