policyengine-us 1.458.0__py3-none-any.whl → 1.471.0__py3-none-any.whl

policyengine_us/variables/gov/hhs/medicare/savings_programs/category/is_qi_eligible.py

@@ -0,0 +1,33 @@
+from policyengine_us.model_api import *
+
+
+class is_qi_eligible(Variable):
+    value_type = bool
+    entity = Person
+    label = "Qualifying Individual (QI) eligible"
+    definition_period = MONTH
+    reference = (
+        "https://www.law.cornell.edu/cfr/text/42/435.123",
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+    )
+
+    def formula(person, period, parameters):
+        # QI requires income above 120% FPL but at or below 135% FPL
+        p = parameters(
+            period
+        ).gov.hhs.medicare.savings_programs.eligibility.income
+
+        medicare_eligible = person("is_medicare_eligible", period.this_year)
+        asset_eligible = person("msp_asset_eligible", period)
+
+        fpg = person("msp_fpg", period)
+        countable_income = person("msp_countable_income", period)
+
+        slmb_income_limit = fpg * p.slmb.fpl_limit
+        qi_income_limit = fpg * p.qi.fpl_limit
+
+        income_above_slmb = countable_income > slmb_income_limit
+        income_at_or_below_qi = countable_income <= qi_income_limit
+        income_eligible = income_above_slmb & income_at_or_below_qi
+
+        return medicare_eligible & income_eligible & asset_eligible

policyengine_us/variables/gov/hhs/medicare/savings_programs/category/is_qmb_eligible.py

@@ -0,0 +1,28 @@
+from policyengine_us.model_api import *
+
+
+class is_qmb_eligible(Variable):
+    value_type = bool
+    entity = Person
+    label = "Qualified Medicare Beneficiary (QMB) eligible"
+    definition_period = MONTH
+    reference = (
+        "https://www.law.cornell.edu/cfr/text/42/435.121",
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+    )
+
+    def formula(person, period, parameters):
+        # QMB requires income at or below 100% FPL
+        p = parameters(
+            period
+        ).gov.hhs.medicare.savings_programs.eligibility.income
+
+        medicare_eligible = person("is_medicare_eligible", period.this_year)
+        asset_eligible = person("msp_asset_eligible", period)
+
+        fpg = person("msp_fpg", period)
+        countable_income = person("msp_countable_income", period)
+        qmb_income_limit = fpg * p.qmb.fpl_limit
+        income_eligible = countable_income <= qmb_income_limit
+
+        return medicare_eligible & income_eligible & asset_eligible

policyengine_us/variables/gov/hhs/medicare/savings_programs/category/is_slmb_eligible.py

@@ -0,0 +1,33 @@
+from policyengine_us.model_api import *
+
+
+class is_slmb_eligible(Variable):
+    value_type = bool
+    entity = Person
+    label = "Specified Low-Income Medicare Beneficiary (SLMB) eligible"
+    definition_period = MONTH
+    reference = (
+        "https://www.law.cornell.edu/cfr/text/42/435.122",
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+    )
+
+    def formula(person, period, parameters):
+        # SLMB requires income above 100% FPL but at or below 120% FPL
+        p = parameters(
+            period
+        ).gov.hhs.medicare.savings_programs.eligibility.income
+
+        medicare_eligible = person("is_medicare_eligible", period.this_year)
+        asset_eligible = person("msp_asset_eligible", period)
+
+        fpg = person("msp_fpg", period)
+        countable_income = person("msp_countable_income", period)
+
+        qmb_income_limit = fpg * p.qmb.fpl_limit
+        slmb_income_limit = fpg * p.slmb.fpl_limit
+
+        income_above_qmb = countable_income > qmb_income_limit
+        income_at_or_below_slmb = countable_income <= slmb_income_limit
+        income_eligible = income_above_qmb & income_at_or_below_slmb
+
+        return medicare_eligible & income_eligible & asset_eligible

policyengine_us/variables/gov/hhs/medicare/savings_programs/category/msp_category.py

@@ -0,0 +1,33 @@
+from policyengine_us.model_api import *
+
+
+class MSPCategory(Enum):
+    NONE = "None"
+    QMB = "Qualified Medicare Beneficiary"
+    SLMB = "Specified Low-Income Medicare Beneficiary"
+    QI = "Qualifying Individual"
+
+
+class msp_category(Variable):
+    value_type = Enum
+    possible_values = MSPCategory
+    default_value = MSPCategory.NONE
+    entity = Person
+    label = "Medicare Savings Program category"
+    definition_period = MONTH
+    reference = (
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+        "https://www.law.cornell.edu/cfr/text/42/435.121",
+    )
+
+    def formula(person, period, parameters):
+        qmb = person("is_qmb_eligible", period)
+        slmb = person("is_slmb_eligible", period)
+        qi = person("is_qi_eligible", period)
+
+        # Priority: QMB > SLMB > QI (QMB is most comprehensive)
+        return select(
+            [qmb, slmb, qi],
+            [MSPCategory.QMB, MSPCategory.SLMB, MSPCategory.QI],
+            default=MSPCategory.NONE,
+        )

policyengine_us/variables/gov/hhs/medicare/savings_programs/eligibility/msp_asset_eligible.py

@@ -0,0 +1,26 @@
+from policyengine_us.model_api import *
+
+
+class msp_asset_eligible(Variable):
+    value_type = bool
+    entity = Person
+    label = "Medicare Savings Program asset eligible"
+    definition_period = MONTH
+    reference = (
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+        "https://www.medicareinteractive.org/understanding-medicare/"
+        "cost-saving-programs/medicare-savings-programs-qmb-slmb-qi/"
+        "medicare-savings-program-income-and-asset-limits",
+    )
+
+    def formula(person, period, parameters):
+        p = parameters(period).gov.hhs.medicare.savings_programs.eligibility
+        state_code = person.household("state_code_str", period)
+        # Check if asset test applies (some states have eliminated it)
+        asset_test_applies = p.asset.applies[state_code]
+        # If asset test doesn't apply, everyone is asset-eligible
+        cash_assets = person.spm_unit("spm_unit_cash_assets", period.this_year)
+        married = person.spm_unit("spm_unit_is_married", period)
+        asset_limit = where(married, p.asset.couple, p.asset.individual)
+        meets_asset_test = cash_assets <= asset_limit
+        return where(asset_test_applies, meets_asset_test, True)

policyengine_us/variables/gov/hhs/medicare/savings_programs/eligibility/msp_eligible.py

@@ -0,0 +1,20 @@
+from policyengine_us.model_api import *
+
+
+class msp_eligible(Variable):
+    value_type = bool
+    entity = Person
+    label = "Medicare Savings Program eligible"
+    definition_period = MONTH
+    reference = (
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+        "https://www.law.cornell.edu/cfr/text/42/435.121",
+    )
+
+    def formula(person, period, parameters):
+        # Must be Medicare eligible
+        medicare_eligible = person("is_medicare_eligible", period.this_year)
+        income_eligible = person("msp_income_eligible", period)
+        asset_eligible = person("msp_asset_eligible", period)
+
+        return medicare_eligible & income_eligible & asset_eligible

policyengine_us/variables/gov/hhs/medicare/savings_programs/eligibility/msp_income_eligible.py

@@ -0,0 +1,26 @@
+from policyengine_us.model_api import *
+
+
+class msp_income_eligible(Variable):
+    value_type = bool
+    entity = Person
+    label = "Medicare Savings Program income eligible"
+    definition_period = MONTH
+    reference = (
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+        "https://www.law.cornell.edu/cfr/text/42/435.121",
+    )
+
+    def formula(person, period, parameters):
+        # Income eligible if under the QI threshold (135% FPL)
+        # which is the highest threshold for standard MSP levels
+        p = parameters(
+            period
+        ).gov.hhs.medicare.savings_programs.eligibility.income.qi
+        fpg = person("msp_fpg", period)
+        countable_income = person("msp_countable_income", period)
+
+        # Use QI threshold (135% FPL) as the outer bound
+        qi_income_limit = fpg * p.fpl_limit
+
+        return countable_income <= qi_income_limit

policyengine_us/variables/gov/hhs/medicare/savings_programs/income/msp_countable_income.py

@@ -0,0 +1,35 @@
+from policyengine_us.model_api import *
+from policyengine_us.variables.gov.ssa.ssi.eligibility.income._apply_ssi_exclusions import (
+    _apply_ssi_exclusions,
+)
+
+
+class msp_countable_income(Variable):
+    value_type = float
+    entity = Person
+    unit = USD
+    label = "Medicare Savings Program countable monthly income"
+    definition_period = MONTH
+    reference = (
+        "https://www.law.cornell.edu/uscode/text/42/1396d#p",
+        "https://secure.ssa.gov/apps10/poms.nsf/lnx/0501715010",
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+    )
+    documentation = """
+    MSP countable income uses SSI methodology per 42 U.S.C. 1396d(p)(1)(B),
+    which specifies income "determined under section 1382a" (SSI rules).
+    This applies the standard SSI exclusions:
+    1. $20 general income exclusion (from unearned first)
+    2. $65 earned income exclusion
+    3. 50% of remaining earned income excluded
+    """
+
+    def formula(person, period, parameters):
+        # MSP uses SSI income methodology per 42 U.S.C. 1396d(p)(1)(B)
+        earned = person("ssi_earned_income", period.this_year)
+        unearned = person("ssi_unearned_income", period.this_year)
+        # Apply SSI exclusions ($20 general, $65 earned, 50% remaining)
+        annual_countable = _apply_ssi_exclusions(
+            earned, unearned, parameters, period.this_year
+        )
+        return annual_countable / MONTHS_IN_YEAR

policyengine_us/variables/gov/hhs/medicare/savings_programs/income/msp_fpg.py

@@ -0,0 +1,40 @@
+from policyengine_us.model_api import *
+
+
+class msp_fpg(Variable):
+    value_type = float
+    entity = Person
+    unit = USD
+    label = "MSP Federal Poverty Guideline"
+    definition_period = YEAR
+    reference = (
+        "https://www.law.cornell.edu/uscode/text/42/1396d#p",
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+    )
+    documentation = """
+    The Federal Poverty Guideline used for MSP eligibility is based on
+    individual or couple status, not the full household/SPM unit size.
+    Per 42 U.S.C. 1396d(p), MSP income limits are based on the federal
+    poverty line for a family of the size involved.
+
+    Note: Published Medicare.gov limits are $20/month higher than raw FPL
+    because they include the $20 general income exclusion in the threshold.
+    Our implementation applies the $20 exclusion to income instead, which
+    is mathematically equivalent: (income - $20) <= FPL == income <= (FPL + $20)
+    """
+
+    def formula(person, period, parameters):
+        # MSP uses individual (1 person) or couple (2 persons) FPG,
+        # not the full SPM unit size.
+        # Note: These are raw FPL values. Published limits are $20 higher
+        # because we apply the $20 exclusion to income (msp_countable_income)
+        # rather than adding it to the threshold.
+        married = person.spm_unit("spm_unit_is_married", period)
+        state_group = person.household("state_group_str", period)
+        p = parameters(period).gov.hhs.fpg
+        p1 = p.first_person[state_group]
+        pn = p.additional_person[state_group]
+        # 1 person if single, 2 persons if married
+        individual_fpg = p1
+        couple_fpg = p1 + pn
+        return where(married, couple_fpg, individual_fpg)

policyengine_us/variables/gov/hhs/medicare/savings_programs/msp.py

@@ -0,0 +1,15 @@
+from policyengine_us.model_api import *
+
+
+class msp(Variable):
+    value_type = float
+    entity = Person
+    unit = USD
+    label = "Medicare Savings Program benefit"
+    definition_period = MONTH
+    reference = (
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+    )
+    defined_for = "msp_eligible"
+
+    adds = ["msp_benefit_value"]

policyengine_us/variables/gov/hhs/medicare/savings_programs/msp_benefit_value.py

@@ -0,0 +1,37 @@
+from policyengine_us.model_api import *
+from policyengine_us.variables.gov.hhs.medicare.savings_programs.category.msp_category import (
+    MSPCategory,
+)
+
+
+class msp_benefit_value(Variable):
+    value_type = float
+    entity = Person
+    unit = USD
+    label = "Medicare Savings Program estimated monthly benefit value"
+    definition_period = MONTH
+    reference = (
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+    )
+    defined_for = "msp_eligible"
+
+    def formula(person, period, parameters):
+        category = person("msp_category", period)
+
+        # Get premiums (automatically disaggregated from annual to monthly)
+        part_a_premium = person("base_part_a_premium", period)
+        part_b_premium = person("base_part_b_premium", period)
+
+        # Benefit depends on category:
+        # QMB: Part A + Part B premiums (plus deductibles/copays, not modeled)
+        # SLMB: Part B premium only
+        # QI: Part B premium only
+        is_qmb = category == MSPCategory.QMB
+        is_slmb = category == MSPCategory.SLMB
+        is_qi = category == MSPCategory.QI
+
+        return (
+            is_qmb * (part_a_premium + part_b_premium)
+            + is_slmb * part_b_premium
+            + is_qi * part_b_premium
+        )

policyengine_us/variables/gov/irs/income/taxable_income/adjusted_gross_income/irs_gross_income/social_security/taxable_social_security_tier_1.py

@@ -0,0 +1,58 @@
+from policyengine_us.model_api import *
+
+
+class taxable_social_security_tier_1(Variable):
+    value_type = float
+    entity = TaxUnit
+    definition_period = YEAR
+    label = "Taxable Social Security (tier 1)"
+    documentation = "Taxable Social Security from 0-50% taxation tier, credited to OASDI trust funds"
+    unit = USD
+    reference = "https://www.law.cornell.edu/uscode/text/26/86#a_1"
+
+    def formula(tax_unit, period, parameters):
+        p = parameters(period).gov.irs.social_security.taxability
+        gross_ss = tax_unit("tax_unit_social_security", period)
+        combined_income = tax_unit(
+            "tax_unit_combined_income_for_social_security_taxability", period
+        )
+        filing_status = tax_unit("filing_status", period)
+        status = filing_status.possible_values
+        separate = filing_status == status.SEPARATE
+        cohabitating = tax_unit("cohabitating_spouses", period)
+
+        base_amount = where(
+            separate & cohabitating,
+            p.threshold.base.separate_cohabitating,
+            p.threshold.base.main[filing_status],
+        )
+        adjusted_base_amount = where(
+            separate & cohabitating,
+            p.threshold.adjusted_base.separate_cohabitating,
+            p.threshold.adjusted_base.main[filing_status],
+        )
+
+        under_first_threshold = combined_income < base_amount
+        under_second_threshold = combined_income < adjusted_base_amount
+
+        combined_income_excess = tax_unit(
+            "tax_unit_ss_combined_income_excess", period
+        )
+
+        # Tier 1 amount (IRC §86(a)(1))
+        amount_under_paragraph_1 = min_(
+            p.rate.base.benefit_cap * gross_ss,
+            p.rate.base.excess * combined_income_excess,
+        )
+
+        # Bracket amount when in tier 2 (IRC §86(a)(2)(A)(ii))
+        bracket_amount = min_(
+            amount_under_paragraph_1,
+            p.rate.additional.bracket * (adjusted_base_amount - base_amount),
+        )
+
+        return select(
+            [under_first_threshold, under_second_threshold],
+            [0, amount_under_paragraph_1],
+            default=bracket_amount,
+        )

policyengine_us/variables/gov/irs/income/taxable_income/adjusted_gross_income/irs_gross_income/social_security/taxable_social_security_tier_2.py

@@ -0,0 +1,17 @@
+from policyengine_us.model_api import *
+
+
+class taxable_social_security_tier_2(Variable):
+    value_type = float
+    entity = TaxUnit
+    definition_period = YEAR
+    label = "Taxable Social Security (tier 2)"
+    documentation = "Taxable Social Security from 50-85% taxation tier, credited to Medicare HI trust fund"
+    unit = USD
+    reference = "https://www.law.cornell.edu/uscode/text/26/86#a_2"
+
+    # tier_2 = total_taxable - tier_1 capped at 0
+    def formula(tax_unit, period, parameters):
+        tier_1 = tax_unit("taxable_social_security_tier_1", period)
+        total_taxable = tax_unit("tax_unit_taxable_social_security", period)
+        return max_(total_taxable - tier_1, 0)

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/employer_medicare_tax_income_tax_revenue.py

@@ -0,0 +1,58 @@
+from policyengine_us.model_api import *
+
+
+class employer_medicare_tax_income_tax_revenue(Variable):
+    value_type = float
+    entity = TaxUnit
+    definition_period = YEAR
+    label = "Income tax revenue from taxing employer Medicare contributions"
+    documentation = (
+        "Marginal income tax revenue attributable to including employer "
+        "Medicare contributions in taxable income. This revenue "
+        "is credited to the Medicare HI trust fund."
+    )
+    unit = USD
+
+    def formula(tax_unit, period, parameters):
+        """
+        Calculate Medicare HI trust fund revenue from employer Medicare taxation.
+
+        Method:
+        1. Get current income_tax (with BOTH SS + Medicare in AGI from reform)
+        2. Branch: Neutralize employer_medicare_tax, recalculate income_tax
+        3. Medicare revenue = current_tax - tax_without_medicare
+
+        This isolates the marginal tax contribution from employer Medicare by
+        neutralizing the source variable, letting the reform formula
+        naturally exclude Medicare when calculating gross income.
+        """
+        sim = tax_unit.simulation
+
+        # Check if reform is active
+        p = parameters(period).gov.contrib.crfb.tax_employer_payroll_tax
+        if not p.in_effect:
+            return tax_unit.empty_array()
+
+        # Current tax (with reform - both SS and Medicare in AGI)
+        tax_full = tax_unit("income_tax", period)
+
+        # === Branch: Tax WITHOUT employer Medicare (neutralize source) ===
+        branch = sim.get_branch("without_employer_medicare", clone_system=True)
+
+        # Neutralize the source variable - reform formula will pick up 0 for Medicare
+        branch.tax_benefit_system.neutralize_variable("employer_medicare_tax")
+
+        # Clear cached calculations
+        input_vars = set(branch.input_variables)
+        for var_name in list(branch.tax_benefit_system.variables.keys()):
+            if var_name not in input_vars:
+                try:
+                    branch.delete_arrays(var_name)
+                except:
+                    pass
+
+        tax_without_medicare = branch.tax_unit("income_tax", period)
+        del sim.branches["without_employer_medicare"]
+
+        # Medicare revenue = tax with full reform - tax without Medicare
+        return max_(tax_full - tax_without_medicare, 0)

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

@@ -0,0 +1,60 @@
+from policyengine_us.model_api import *
+
+
+class employer_ss_tax_income_tax_revenue(Variable):
+    value_type = float
+    entity = TaxUnit
+    definition_period = YEAR
+    label = "Income tax revenue from taxing employer SS contributions"
+    documentation = (
+        "Marginal income tax revenue attributable to including employer "
+        "Social Security contributions in taxable income. This revenue "
+        "is credited to the OASDI trust funds."
+    )
+    unit = USD
+
+    def formula(tax_unit, period, parameters):
+        """
+        Calculate OASDI trust fund revenue from employer SS taxation.
+
+        Method:
+        1. Get current income_tax (with BOTH SS + Medicare in AGI from reform)
+        2. Branch: Neutralize employer_social_security_tax, recalculate income_tax
+        3. SS revenue = current_tax - tax_without_ss
+
+        This isolates the marginal tax contribution from employer SS by
+        neutralizing the source variable, letting the reform formula
+        naturally exclude SS when calculating gross income.
+        """
+        sim = tax_unit.simulation
+
+        # Check if reform is active
+        p = parameters(period).gov.contrib.crfb.tax_employer_payroll_tax
+        if not p.in_effect:
+            return tax_unit.empty_array()
+
+        # Current tax (with reform - both SS and Medicare in AGI)
+        tax_full = tax_unit("income_tax", period)
+
+        # === Branch: Tax WITHOUT employer SS (neutralize source) ===
+        branch = sim.get_branch("without_employer_ss", clone_system=True)
+
+        # Neutralize the source variable - reform formula will pick up 0 for SS
+        branch.tax_benefit_system.neutralize_variable(
+            "employer_social_security_tax"
+        )
+
+        # Clear cached calculations
+        input_vars = set(branch.input_variables)
+        for var_name in list(branch.tax_benefit_system.variables.keys()):
+            if var_name not in input_vars:
+                try:
+                    branch.delete_arrays(var_name)
+                except:
+                    pass
+
+        tax_without_ss = branch.tax_unit("income_tax", period)
+        del sim.branches["without_employer_ss"]
+
+        # SS revenue = tax with full reform - tax without SS
+        return max_(tax_full - tax_without_ss, 0)