diff --git a/changelog.d/pension-credit-carers-income.added.md b/changelog.d/pension-credit-carers-income.added.md new file mode 100644 index 0000000000..3741b5feb6 --- /dev/null +++ b/changelog.d/pension-credit-carers-income.added.md @@ -0,0 +1 @@ +Add `scottish_carer_supplement`, the Scottish Carer Supplement paid with Carer Support Payment from 15 March 2026. `carer_support_payment` is now the Carer Support Payment component only, so totals summed by variable name need both variables. diff --git a/changelog.d/pension-credit-carers-income.fixed.md b/changelog.d/pension-credit-carers-income.fixed.md new file mode 100644 index 0000000000..ecf6d5e92d --- /dev/null +++ b/changelog.d/pension-credit-carers-income.fixed.md @@ -0,0 +1 @@ +Count Carer's Allowance and Carer Support Payment as Pension Credit income (SPC Regs 2002 reg 15(1)), and split the Scottish Carer Supplement out of Carer Support Payment into its own variable so that Pension Credit and Housing Benefit leave it out (SI 2026/246). diff --git a/policyengine_uk/parameters/gov/dwp/pension_credit/guarantee_credit/income.yaml b/policyengine_uk/parameters/gov/dwp/pension_credit/guarantee_credit/income.yaml index fd57b6d800..474274eadb 100644 --- a/policyengine_uk/parameters/gov/dwp/pension_credit/guarantee_credit/income.yaml +++ b/policyengine_uk/parameters/gov/dwp/pension_credit/guarantee_credit/income.yaml @@ -7,6 +7,8 @@ metadata: title: State Pension Credit Act 2002 s. 15(1) - href: https://www.legislation.gov.uk/uksi/2002/1792/regulation/15 title: State Pension Credit Regulations 2002 reg. 15 + - href: https://www.legislation.gov.uk/uksi/2026/246/article/17/made + title: SI 2026/246 art. 17 (Scottish Carer Supplement excepted from reg. 15(1)) unit: list values: 2002-01-01: @@ -18,3 +20,9 @@ values: - pension_credit_deemed_income - esa_contrib - jsa_contrib + # Reg. 15(1) prescribes all social security benefits except those it lists; + # neither of these is listed. carer_support_payment is the Carer Support + # Payment component only: reg. 15(1)(ri) excepts the Scottish Carer + # Supplement, which is a separate variable. + - carers_allowance + - carer_support_payment diff --git a/policyengine_uk/tests/policy/baseline/finance/benefit/family/universal_credit/income/uc_unearned_benefits.yaml b/policyengine_uk/tests/policy/baseline/finance/benefit/family/universal_credit/income/uc_unearned_benefits.yaml index 3841e1e563..c68f3799ec 100644 --- a/policyengine_uk/tests/policy/baseline/finance/benefit/family/universal_credit/income/uc_unearned_benefits.yaml +++ b/policyengine_uk/tests/policy/baseline/finance/benefit/family/universal_credit/income/uc_unearned_benefits.yaml @@ -15,8 +15,8 @@ # - couple standard allowance (one over 25): 666.97 a month = 8,003.64 a year; # - carer element: 209.34 a month = 2,512.08 a year; # - Carer's Allowance and the Carer Support Payment component: 86.45 a week, -# so 86.45 x 52 = 4,495.40 a year; Scottish Carer Supplement 11.70 a week, -# so Carer Support Payment is (86.45 + 11.70) x 52 = 5,103.80 a year; +# so 86.45 x 52 = 4,495.40 a year; the Scottish Carer Supplement is a +# separate 11.70 a week, 11.70 x 52 = 608.40 a year; # - council rent of 6,240 a year is met in full by the housing costs element. # So a couple's maximum amount is 8,003.64 + 6,240 = 14,243.64, or # 16,755.72 with the carer element. @@ -203,10 +203,12 @@ rent: 6_240 output: carers_allowance: [0, 0] - # (86.45 + 11.70) x 52. - carer_support_payment: [5_103.80, 0] - # Capped at a year of Carer's Allowance, 86.45 x 52, which is also the - # carer support payment component without the supplement. + # The carer support payment component, 86.45 x 52. + carer_support_payment: [4_495.40, 0] + # 11.70 x 52. Not unearned income: reg. 66(1) does not list it. + scottish_carer_supplement: [608.40, 0] + # Capped at a year of Carer's Allowance, 86.45 x 52, which the component + # equals. uc_unearned_carer_support_payment: [4_495.40, 0] uc_unearned_income: 4_495.40 uc_maximum_amount: 16_755.72 diff --git a/policyengine_uk/tests/policy/baseline/gov/dwp/pension_credit/pension_credit_carer_income.yaml b/policyengine_uk/tests/policy/baseline/gov/dwp/pension_credit/pension_credit_carer_income.yaml new file mode 100644 index 0000000000..5cfb2eb06e --- /dev/null +++ b/policyengine_uk/tests/policy/baseline/gov/dwp/pension_credit/pension_credit_carer_income.yaml @@ -0,0 +1,356 @@ +# Carers' benefits in Pension Credit income. +# SPC Regs 2002 reg 15(1) prescribes "all social security benefits" as income +# except those it lists. Carer's Allowance and Carer Support Payment are not +# listed. Reg 15(1)(ri) excepts the Scottish Carer Supplement (SI 2026/246 +# art 17(3), from 15 March 2026), and reg 9 does not exclude either benefit +# from Savings Credit qualifying income. +# The carers here have no State Pension, so no overlapping-benefit adjustment +# (reg 15(4)(a)) applies to their Carer's Allowance or Carer Support Payment. +# 2026 rates: CA and CSP 86.45, Scottish Carer Supplement 11.70, standard +# minimum guarantee 238.00 single and 363.25 couple, carer addition 48.15. + +- name: Carer's Allowance counts as Pension Credit income + period: 2026 + absolute_error_margin: 0.01 + input: + people: + carer: + age: 70 + state_pension: 0 + private_pension_income: 7_000 + care_hours: 35 + benunits: + benunit: + members: [carer] + households: + household: + members: [carer] + country: ENGLAND + output: + carers_allowance: 86.45 * 52 + # 7,000 + 4,495.40 is below the personal allowance, so no income tax. + pension_credit_income: 7_000 + 86.45 * 52 + minimum_guarantee: (238 + 48.15) * 52 + guarantee_credit: (238 + 48.15 - 86.45) * 52 - 7_000 + +- name: A reported Carer's Allowance award counts as Pension Credit income + period: 2026 + absolute_error_margin: 0.01 + input: + people: + carer: + age: 70 + state_pension: 0 + private_pension_income: 7_000 + carers_allowance_reported: 1 + care_hours: 0 + benunits: + benunit: + members: [carer] + households: + household: + members: [carer] + country: ENGLAND + output: + carers_allowance: 86.45 * 52 + pension_credit_income: 7_000 + 86.45 * 52 + +- name: Carer Support Payment counts as Pension Credit income, the Scottish Carer Supplement does not + period: 2026 + absolute_error_margin: 0.01 + input: + people: + carer: + age: 70 + state_pension: 0 + private_pension_income: 7_000 + care_hours: 35 + benunits: + benunit: + members: [carer] + households: + household: + members: [carer] + country: SCOTLAND + output: + carers_allowance: 0 + carer_support_payment: 86.45 * 52 + scottish_carer_supplement: 11.70 * 52 + # The supplement is taxable (ITEPA 2003 s.660 Table A, SI 2026/93), so it + # stays in social security income for income tax. + social_security_income: (86.45 + 11.70) * 52 + # 7,000 + 5,103.80 is below the personal allowance, so no income tax. + income_tax: 0 + pension_credit_income: 7_000 + 86.45 * 52 + guarantee_credit: (238 + 48.15 - 86.45) * 52 - 7_000 + +- name: Carer Support Payment counts as Pension Credit income before the Scottish Carer Supplement starts + period: 2025 + absolute_error_margin: 0.01 + input: + people: + carer: + age: 70 + state_pension: 0 + private_pension_income: 7_000 + care_hours: 35 + benunits: + benunit: + members: [carer] + households: + household: + members: [carer] + country: SCOTLAND + output: + carer_support_payment: 83.3 * 52 + scottish_carer_supplement: 0 + pension_credit_income: 7_000 + 83.3 * 52 + +- name: Carer's Allowance counts as Pension Credit income in Scotland before Carer Support Payment + period: 2024 + absolute_error_margin: 0.01 + input: + people: + carer: + age: 70 + state_pension: 0 + private_pension_income: 7_000 + care_hours: 35 + benunits: + benunit: + members: [carer] + households: + household: + members: [carer] + country: SCOTLAND + output: + carers_allowance: 81.9 * 52 + carer_support_payment: 0 + pension_credit_income: 7_000 + 81.9 * 52 + +- name: Carer's Allowance is Savings Credit qualifying income + # Aged 80, so State Pension age was reached before 6 April 2016 and Savings + # Credit is available. Income tax is (10,000 + 4,495.40 - 12,570) x 20%. + # Leaving out Carer's Allowance, qualifying income was below the 208.07 + # threshold (SI 2026/148 art 29(3)) and Savings Credit was nil. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + carer: + age: 80 + state_pension: 0 + private_pension_income: 10_000 + care_hours: 35 + benunits: + benunit: + members: [carer] + households: + household: + members: [carer] + country: ENGLAND + output: + income_tax: (10_000 + 86.45 * 52 - 12_570) * 0.2 + pension_credit_income: 10_000 + 86.45 * 52 - (10_000 + 86.45 * 52 - 12_570) * 0.2 + savings_credit_income: 10_000 + 86.45 * 52 - (10_000 + 86.45 * 52 - 12_570) * 0.2 + guarantee_credit: (238 + 48.15) * 52 - (10_000 + 86.45 * 52 - (10_000 + 86.45 * 52 - 12_570) * 0.2) + # Qualifying income is above the threshold by more than enough, so Savings + # Credit is the maximum, 60% of (standard minimum guarantee - threshold). + savings_credit: 0.6 * (238 - 208.07) * 52 + +- name: Housing Benefit no longer falls where Guarantee Credit used to end for a couple whose partner receives Carer's Allowance + # Before this change, Pension Credit left out the partner's Carer's + # Allowance, so Guarantee Credit ran on to a private pension of 9,700 and the + # Housing Benefit passport ended at 9,800, when HB counted the allowance: + # net income fell by 1,779.24 with the default HB income disregard (2,254.02 + # with the disregard set to 0, as here). Now Guarantee Credit has ended well + # before, and each 100 of private pension adds 100 - 20 tax - 52 HB (65%) + # - 16 CTR. The HB income disregard is set to 0 so that the numbers do not + # depend on it; the couple has no earnings. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + claimant_1: + age: 70 + state_pension: 13_500 + private_pension_income: 9_700 + carer_1: + age: 70 + state_pension: 0 + care_hours: 35 + claimant_2: + age: 70 + state_pension: 13_500 + private_pension_income: 9_800 + carer_2: + age: 70 + state_pension: 0 + care_hours: 35 + benunits: + benunit_1: + members: [claimant_1, carer_1] + housing_benefit_applicable_income_disregard: 0 + benunit_2: + members: [claimant_2, carer_2] + housing_benefit_applicable_income_disregard: 0 + households: + household_1: + members: [claimant_1, carer_1] + country: ENGLAND + region: NORTH_WEST + tenure_type: RENT_FROM_COUNCIL + rent: 8_000 + council_tax: 2_000 + household_2: + members: [claimant_2, carer_2] + country: ENGLAND + region: NORTH_WEST + tenure_type: RENT_FROM_COUNCIL + rent: 8_000 + council_tax: 2_000 + output: + # The claimant's tax is 20% of income above the 12,570 personal allowance, + # less the 252 marriage allowance transferred by the carer: + # 10,630 x 20% - 252 and 10,730 x 20% - 252. + income_tax: [1_874, 0, 1_894, 0] + # 13,500 + private pension + 4,495.40 Carer's Allowance - income tax. + pension_credit_income: [25_821.40, 25_901.40] + # (363.25 + 48.15) x 52. + minimum_guarantee: [21_392.80, 21_392.80] + guarantee_credit: [0, 0] + # HB and CTR applicable amount: couple aged allowance 383.35 plus carer + # premium 48.15, x 52 = 22,438. HB: 8,000 - 65% x (income - 22,438). + housing_benefit: [5_800.79, 5_748.79] + # CTR: 2,000 - 20% x (income - 22,438). + council_tax_benefit: [1_323.32, 1_307.32] + +- name: Net income rises where Guarantee Credit now ends for a couple whose partner receives Carer's Allowance + # Guarantee Credit ends at a private pension of about 4,164 (income 21,392.80 + # = the minimum guarantee). Across 4,100 to 4,200 net income rises by + # 100 - 20 tax - 51.40 Guarantee Credit = 28.60: Housing Benefit and Council + # Tax Reduction stay at their maximum because their income is below the + # applicable amount of 22,438. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + claimant_1: + age: 70 + state_pension: 13_500 + private_pension_income: 4_100 + carer_1: + age: 70 + state_pension: 0 + care_hours: 35 + claimant_2: + age: 70 + state_pension: 13_500 + private_pension_income: 4_200 + carer_2: + age: 70 + state_pension: 0 + care_hours: 35 + benunits: + benunit_1: + members: [claimant_1, carer_1] + housing_benefit_applicable_income_disregard: 0 + benunit_2: + members: [claimant_2, carer_2] + housing_benefit_applicable_income_disregard: 0 + households: + household_1: + members: [claimant_1, carer_1] + country: ENGLAND + region: NORTH_WEST + tenure_type: RENT_FROM_COUNCIL + rent: 8_000 + council_tax: 2_000 + household_2: + members: [claimant_2, carer_2] + country: ENGLAND + region: NORTH_WEST + tenure_type: RENT_FROM_COUNCIL + rent: 8_000 + council_tax: 2_000 + output: + # 13,500 + private pension + 4,495.40 - income tax, where income tax is + # 5,030 x 20% - 252 = 754 and 5,130 x 20% - 252 = 774. + pension_credit_income: [21_341.40, 21_421.40] + # 21,392.80 - 21,341.40. + guarantee_credit: [51.40, 0] + housing_benefit: [8_000, 8_000] + council_tax_benefit: [2_000, 2_000] + +- name: Pension-age Housing Benefit counts Carer Support Payment but not the Scottish Carer Supplement + # HB (SPC) Regs 2006 reg 29(1)(j)(xviiha), inserted by SI 2026/246 art 21(3). + # Income is above the minimum guarantee, so no Guarantee Credit passport. + # Nobody pays income tax: 12,000 and 6,000 + 5,103.80 are each below the + # personal allowance. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + claimant: + age: 70 + state_pension: 0 + private_pension_income: 12_000 + carer: + age: 70 + state_pension: 0 + private_pension_income: 6_000 + care_hours: 35 + benunits: + benunit: + members: [claimant, carer] + housing_benefit_applicable_income_disregard: 0 + households: + household: + members: [claimant, carer] + country: SCOTLAND + region: SCOTLAND + tenure_type: RENT_FROM_COUNCIL + rent: 6_000 + council_tax: 1_500 + output: + # 86.45 x 52 and 11.70 x 52. + carer_support_payment: [0, 4_495.40] + scottish_carer_supplement: [0, 608.40] + income_tax: [0, 0] + pension_credit_income: 18_000 + 86.45 * 52 + guarantee_credit: 0 + housing_benefit_applicable_income: 18_000 + 86.45 * 52 + housing_benefit: 6_000 - 0.65 * (18_000 + 86.45 * 52 - (383.35 + 48.15) * 52) + +- name: The Scottish Carer Supplement stays in benefit totals but not in Housing Benefit income + # A working-age carer in Scotland with no other income. HB Regs 2006 Sch 5 + # para 75 (SI 2026/246 art 20(4)) disregards the supplement, so HB income is + # the Carer Support Payment component alone. The supplement is a benefit and + # taxable income, so every total still includes it: 86.45 x 52 + 11.70 x 52. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + carer: + age: 40 + care_hours: 35 + benunits: + benunit: + members: [carer] + would_claim_uc: false + housing_benefit_applicable_income_disregard: 0 + households: + household: + members: [carer] + country: SCOTLAND + region: SCOTLAND + output: + carer_support_payment: 86.45 * 52 + scottish_carer_supplement: 11.70 * 52 + housing_benefit_applicable_income: 86.45 * 52 + social_security_income: (86.45 + 11.70) * 52 + household_benefits: (86.45 + 11.70) * 52 + hbai_benefits: (86.45 + 11.70) * 52 + hbai_household_net_income: (86.45 + 11.70) * 52 + gov_spending: (86.45 + 11.70) * 52 + pre_budget_change_household_benefits: (86.45 + 11.70) * 52 diff --git a/policyengine_uk/tests/test_pension_credit_carer_income_properties.py b/policyengine_uk/tests/test_pension_credit_carer_income_properties.py new file mode 100644 index 0000000000..6c5b82f21c --- /dev/null +++ b/policyengine_uk/tests/test_pension_credit_carer_income_properties.py @@ -0,0 +1,243 @@ +"""Carers' benefits in Pension Credit income and the Guarantee Credit boundary. + +Pension Credit income left out Carer's Allowance and Carer Support Payment, +although the State Pension Credit Regulations 2002 reg 15(1) prescribe "all +social security benefits" as income except those they list, and neither is +listed. Pension-age Housing Benefit counted both. While Guarantee Credit was +paid, Housing Benefit was passported to its maximum and hid the difference; +when Guarantee Credit ended, Housing Benefit was assessed on the carer's +benefit that Pension Credit had ignored. A pensioner couple whose partner +received Carer's Allowance lost £1,779.24 of net income when private pension +rose from £9,700 to £9,800 in 2026. + +The Scottish Carer Supplement, paid with Carer Support Payment from 15 March +2026, is the opposite case: SPC Regs reg 15(1)(ri) excepts it from Pension +Credit income, and HB (SPC) Regs 2006 reg 29(1)(j)(xviiha) excepts it from +Housing Benefit income. SI 2026/246 arts 17(3) and 21(3) inserted both. It is +taxable (SI 2026/93). + +Invariants, for single people and couples over State Pension age in which one +member is a carer receiving Carer's Allowance (England and Wales) or Carer +Support Payment (Scotland), renting from the council in 2026: + +1. Differential: Pension Credit and pension-age Housing Benefit assess the + same income. Where Guarantee Credit is not paid, Housing Benefit + applicable income plus its income disregard equals Pension Credit income. + The draws have no earnings, no pension contributions and capital of at + most £10,000, so neither tariff income nor the earnings rules apply. +2. Boundary: on the private-pension step where Guarantee Credit ends, + household net income, excluding the TV licence fee, does not fall. The + free TV licence for over-75s on Pension Credit is a genuine statutory + cliff, so it is excluded. +3. Metamorphic: setting the Scottish Carer Supplement to zero changes + Pension Credit income and Housing Benefit applicable income only through + income tax: each plus income tax is unchanged. + +These compare PolicyEngine's own income measures, so they hold whatever +carer's benefit the model pays. The model does not yet apply the +overlapping-benefit reduction of Carer's Allowance and Carer Support Payment +by State Pension (SPC Regs reg 15(4)(a) and (g)). + +Only one member of a couple is drawn as a carer. Two carers in a couple get +two Pension Credit carer additions (SPC Regs reg 6(8)) but, until the couple +carer premium is set to twice the single rate, one Housing Benefit carer +premium, so invariant 2 does not yet hold for them. Disability benefits are +not drawn: with a carer benefit in payment in the benefit unit, Pension Credit +withholds its severe disability addition, but the Housing Benefit severe +disability premium keys on a different disability test. +""" + +import numpy as np +from hypothesis import HealthCheck, given, settings +from hypothesis import strategies as st + +from policyengine_uk import Simulation + +YEAR = 2026 +PENSIONS = np.arange(0, 20_001, 500) +PROPERTY_SETTINGS = settings( + max_examples=12, + deadline=None, + derandomize=True, + suppress_health_check=[HealthCheck.too_slow, HealthCheck.data_too_large], +) +REGIONS = { + "ENGLAND": "NORTH_WEST", + "WALES": "WALES", + "SCOTLAND": "SCOTLAND", +} +NO_SCOTTISH_CARER_SUPPLEMENT = { + "gov.social_security_scotland.carer_support_payment.supplement": { + "2026-01-01.2100-12-31": 0 + } +} + + +def money(high): + return st.floats(0, high, allow_nan=False, allow_infinity=False) + + +@st.composite +def adult(draw): + return dict( + age=draw(st.integers(67, 95)), + state_pension=draw(money(15_000)), + ) + + +@st.composite +def family(draw, countries=tuple(REGIONS)): + adults = [draw(adult()) for _ in range(draw(st.integers(1, 2)))] + return dict( + adults=adults, + carer=draw(st.integers(0, len(adults) - 1)), + # The carer qualifies either by caring hours or by a reported award. + by_hours=draw(st.booleans()), + country=draw(st.sampled_from(countries)), + rent=draw(money(12_000)), + council_tax=draw(money(3_000)), + savings=draw(st.one_of(st.just(0.0), money(10_000))), + ) + + +def situation(families): + """Each family once per private pension on the PENSIONS grid.""" + people, benunits, households = {}, {}, {} + for i, fam in enumerate(families): + for k, pension in enumerate(PENSIONS): + names = [] + for j, a in enumerate(fam["adults"]): + name = f"p{i}_{k}_{j}" + person = { + "age": {YEAR: a["age"]}, + "state_pension": {YEAR: a["state_pension"]}, + # All private pension goes to the first adult. + "private_pension_income": {YEAR: float(pension) * (j == 0)}, + } + if j == fam["carer"]: + if fam["by_hours"]: + person["care_hours"] = {YEAR: 35} + else: + person["carers_allowance_reported"] = {YEAR: 1} + people[name] = person + names.append(name) + benunits[f"b{i}_{k}"] = {"members": names} + households[f"h{i}_{k}"] = { + "members": names, + "country": {YEAR: fam["country"]}, + "region": {YEAR: REGIONS[fam["country"]]}, + "tenure_type": {YEAR: "RENT_FROM_COUNCIL"}, + "rent": {YEAR: fam["rent"]}, + "council_tax": {YEAR: fam["council_tax"]}, + "savings": {YEAR: fam["savings"]}, + } + return {"people": people, "benunits": benunits, "households": households} + + +def grid(families, reform=None): + simulation = Simulation(situation=situation(families), reform=reform) + shape = (len(families), len(PENSIONS)) + + def get(variable): + return np.asarray(simulation.calculate(variable, YEAR)).reshape(shape) + + def by_benunit(variable): + values = simulation.calculate(variable, YEAR, map_to="benunit") + return np.asarray(values).reshape(shape) + + g = { + variable: get(variable) + for variable in [ + "household_net_income", + "tv_licence", + "guarantee_credit", + "pension_credit_income", + "housing_benefit_eligible", + "housing_benefit_applicable_income", + "housing_benefit_applicable_income_disregard", + "housing_benefit", + "council_tax_benefit", + ] + } + for variable in [ + "carers_allowance", + "carer_support_payment", + "scottish_carer_supplement", + "income_tax", + ]: + g[variable] = by_benunit(variable) + return g + + +def assert_carer_benefit_paid(g, i, fam): + carer_benefit = g["carers_allowance"][i] + g["carer_support_payment"][i] + assert np.all(carer_benefit > 0), fam + + +@PROPERTY_SETTINGS +@given(st.lists(family(), min_size=1, max_size=4)) +def test_pension_credit_and_housing_benefit_assess_the_same_carer_income(families): + g = grid(families) + for i, fam in enumerate(families): + assert_carer_benefit_paid(g, i, fam) + hb_income = g["housing_benefit_applicable_income"][i] + # Where Guarantee Credit is not paid, and away from the zero floor on + # Housing Benefit income. + compared = ( + (g["guarantee_credit"][i] <= 0) + & g["housing_benefit_eligible"][i].astype(bool) + & (hb_income > 0) + ) + before_disregard = ( + hb_income + g["housing_benefit_applicable_income_disregard"][i] + ) + pc_income = g["pension_credit_income"][i] + assert np.allclose( + before_disregard[compared], pc_income[compared], atol=0.01 + ), (fam, before_disregard[compared], pc_income[compared]) + + +@PROPERTY_SETTINGS +@given(st.lists(family(), min_size=1, max_size=4)) +def test_net_income_does_not_fall_where_guarantee_credit_ends_for_carers(families): + g = grid(families) + net = g["household_net_income"] + g["tv_licence"] + step = np.diff(net, axis=1) + gc = g["guarantee_credit"] + ends = (gc[:, :-1] > 0) & (gc[:, 1:] <= 0) + for i, fam in enumerate(families): + assert_carer_benefit_paid(g, i, fam) + for k in np.flatnonzero(ends[i]): + assert step[i, k] >= -0.01, ( + fam, + f"private pension {PENSIONS[k]} -> {PENSIONS[k + 1]}", + f"net income change {step[i, k]:.2f}", + f"HB {g['housing_benefit'][i, k]:.2f} -> " + f"{g['housing_benefit'][i, k + 1]:.2f}", + f"CTR {g['council_tax_benefit'][i, k]:.2f} -> " + f"{g['council_tax_benefit'][i, k + 1]:.2f}", + ) + + +@PROPERTY_SETTINGS +@given(st.lists(family(countries=("SCOTLAND",)), min_size=1, max_size=4)) +def test_scottish_carer_supplement_is_not_means_tested_income(families): + g = grid(families) + without = grid(families, reform=NO_SCOTTISH_CARER_SUPPLEMENT) + for i, fam in enumerate(families): + assert np.all(g["scottish_carer_supplement"][i] > 0), fam + assert np.all(without["scottish_carer_supplement"][i] == 0), fam + assert np.allclose( + g["carer_support_payment"][i], + without["carer_support_payment"][i], + ), fam + for variable in ["pension_credit_income", "housing_benefit_applicable_income"]: + with_supplement = g[variable][i] + g["income_tax"][i] + without_supplement = without[variable][i] + without["income_tax"][i] + # Only where the zero floor does not bind in either run. + compared = (g[variable][i] > 0) & (without[variable][i] > 0) + assert np.allclose( + with_supplement[compared], + without_supplement[compared], + atol=0.01, + ), (fam, variable) diff --git a/policyengine_uk/tests/test_uc_unearned_benefits_properties.py b/policyengine_uk/tests/test_uc_unearned_benefits_properties.py index 4a2cba3ae6..c07bf8d808 100644 --- a/policyengine_uk/tests/test_uc_unearned_benefits_properties.py +++ b/policyengine_uk/tests/test_uc_unearned_benefits_properties.py @@ -52,7 +52,7 @@ suppress_health_check=[HealthCheck.too_slow, HealthCheck.data_too_large], ) # 2020 has the temporary standard allowance uplift; 2025 has Carer Support -# Payment without the Scottish Carer Supplement, 2026 with it. +# Payment before the Scottish Carer Supplement starts, 2026 after. YEARS = [2020, 2025, 2026] CSP_YEARS = [2025, 2026] # Contributory ESA is entered as the reported amount, which income tax also diff --git a/policyengine_uk/variables/contrib/policyengine/pre_budget_change_household_benefits.py b/policyengine_uk/variables/contrib/policyengine/pre_budget_change_household_benefits.py index 10db0ea03b..8a432f2794 100644 --- a/policyengine_uk/variables/contrib/policyengine/pre_budget_change_household_benefits.py +++ b/policyengine_uk/variables/contrib/policyengine/pre_budget_change_household_benefits.py @@ -33,6 +33,7 @@ "cost_of_living_support_payment", "energy_bills_rebate", "carer_support_payment", + "scottish_carer_supplement", "disability_basic_income", ] diff --git a/policyengine_uk/variables/gov/dwp/housing_benefit/applicable_income/housing_benefit_applicable_income.py b/policyengine_uk/variables/gov/dwp/housing_benefit/applicable_income/housing_benefit_applicable_income.py index 999da75d2a..8cc368992e 100644 --- a/policyengine_uk/variables/gov/dwp/housing_benefit/applicable_income/housing_benefit_applicable_income.py +++ b/policyengine_uk/variables/gov/dwp/housing_benefit/applicable_income/housing_benefit_applicable_income.py @@ -18,6 +18,10 @@ def formula(benunit, period, parameters): ] PERSONAL_BENEFITS = [ "carers_allowance", + # The Carer Support Payment component only: the Scottish Carer + # Supplement is disregarded (HB Regs 2006 Sch 5 para 75; HB (SPC) + # Regs 2006 reg 29(1)(j)(xviiha)), so scottish_carer_supplement is + # not listed. "carer_support_payment", "esa_contrib", "jsa_contrib", diff --git a/policyengine_uk/variables/gov/dwp/universal_credit/income/uc_unearned_carer_support_payment.py b/policyengine_uk/variables/gov/dwp/universal_credit/income/uc_unearned_carer_support_payment.py index 376fd3c41d..339af47e2c 100644 --- a/policyengine_uk/variables/gov/dwp/universal_credit/income/uc_unearned_carer_support_payment.py +++ b/policyengine_uk/variables/gov/dwp/universal_credit/income/uc_unearned_carer_support_payment.py @@ -12,10 +12,10 @@ class uc_unearned_carer_support_payment(Variable): "from 19 November 2023), so it is capped at a year of Carer's " "Allowance. From 15 March 2026 reg. 2 limits 'carer support payment' " "to the carer support payment component of carer support (S.I. " - "2026/246 art. 25), which excludes the Scottish Carer Supplement. The " - "component is paid at the Carer's Allowance rate, so for a full year " - "of Carer Support Payment the cap also removes the supplement that " - "carer_support_payment currently includes." + "2026/246 art. 25), which excludes the Scottish Carer Supplement. " + "carer_support_payment is that component alone, paid at the Carer's " + "Allowance rate, so the cap does not bind on a full year's award; the " + "supplement is the separate scottish_carer_supplement." ) definition_period = YEAR unit = GBP diff --git a/policyengine_uk/variables/gov/gov_spending.py b/policyengine_uk/variables/gov/gov_spending.py index de9382723c..ca27cf2a72 100644 --- a/policyengine_uk/variables/gov/gov_spending.py +++ b/policyengine_uk/variables/gov/gov_spending.py @@ -50,6 +50,7 @@ "dft_subsidy_spending", "nhs_spending", "carer_support_payment", + "scottish_carer_supplement", "disability_basic_income", ] diff --git a/policyengine_uk/variables/gov/hmrc/income_tax/social_security_income.py b/policyengine_uk/variables/gov/hmrc/income_tax/social_security_income.py index 929ffade0c..269f47493d 100644 --- a/policyengine_uk/variables/gov/hmrc/income_tax/social_security_income.py +++ b/policyengine_uk/variables/gov/hmrc/income_tax/social_security_income.py @@ -16,4 +16,5 @@ class social_security_income(Variable): "esa_contrib_reported", "carers_allowance", "carer_support_payment", + "scottish_carer_supplement", ] diff --git a/policyengine_uk/variables/gov/social_security_scotland/carer_support_payment.py b/policyengine_uk/variables/gov/social_security_scotland/carer_support_payment.py index c44afbffb2..71bb385aac 100644 --- a/policyengine_uk/variables/gov/social_security_scotland/carer_support_payment.py +++ b/policyengine_uk/variables/gov/social_security_scotland/carer_support_payment.py @@ -6,14 +6,17 @@ class carer_support_payment(Variable): entity = Person label = "Carer Support Payment" documentation = ( - "Carer Support Payment replaces Carer's Allowance for " - "eligible carers living in Scotland." + "The Carer Support Payment component of Carer Support, which replaces " + "Carer's Allowance for eligible carers living in Scotland. The " + "Scottish Carer Supplement paid with it from 15 March 2026 is a " + "separate component: see scottish_carer_supplement." ) definition_period = YEAR unit = GBP reference = [ "https://www.mygov.scot/carer-support-payment", "https://www.legislation.gov.uk/asp/2018/9/part/4", + "https://www.legislation.gov.uk/ssi/2023/302/regulation/3", ] def formula(person, period, parameters): @@ -27,5 +30,4 @@ def formula(person, period, parameters): eligible = ( in_scotland & csp_in_effect & (meets_hours | receives_ca) & would_claim ) - weekly_amount = csp.rate + csp.supplement - return eligible * weekly_amount * WEEKS_IN_YEAR + return eligible * csp.rate * WEEKS_IN_YEAR diff --git a/policyengine_uk/variables/gov/social_security_scotland/scottish_carer_supplement.py b/policyengine_uk/variables/gov/social_security_scotland/scottish_carer_supplement.py new file mode 100644 index 0000000000..d5a83e8a4f --- /dev/null +++ b/policyengine_uk/variables/gov/social_security_scotland/scottish_carer_supplement.py @@ -0,0 +1,28 @@ +from policyengine_uk.model_api import * + + +class scottish_carer_supplement(Variable): + value_type = float + entity = Person + label = "Scottish Carer Supplement" + documentation = ( + "Paid for each week in which Carer Support Payment is payable, from 15 " + "March 2026. It is a component of Carer Support separate from the " + "Carer Support Payment component. Pension Credit and Housing Benefit, " + "at pension age and working age, do not count it as income; it is " + "taxable." + ) + definition_period = YEAR + unit = GBP + reference = [ + "https://www.legislation.gov.uk/ssi/2023/302/regulation/14A", + "https://www.legislation.gov.uk/uksi/2026/246/article/17/made", + "https://www.legislation.gov.uk/uksi/2026/246/article/20/made", + "https://www.legislation.gov.uk/uksi/2026/246/article/21/made", + "https://www.legislation.gov.uk/uksi/2026/93/made", + ] + + def formula(person, period, parameters): + receives_csp = person("carer_support_payment", period) > 0 + csp = parameters(period).gov.social_security_scotland.carer_support_payment + return receives_csp * csp.supplement * WEEKS_IN_YEAR diff --git a/policyengine_uk/variables/household/income/hbai_benefits.py b/policyengine_uk/variables/household/income/hbai_benefits.py index 0adf25977d..ac8d146133 100644 --- a/policyengine_uk/variables/household/income/hbai_benefits.py +++ b/policyengine_uk/variables/household/income/hbai_benefits.py @@ -44,4 +44,5 @@ class hbai_benefits(Variable): "bursary_fund_16_to_19", "healthy_start_vouchers", "carer_support_payment", + "scottish_carer_supplement", ] diff --git a/policyengine_uk/variables/household/income/hbai_household_net_income.py b/policyengine_uk/variables/household/income/hbai_household_net_income.py index f3272ebc5b..5061ab23c1 100644 --- a/policyengine_uk/variables/household/income/hbai_household_net_income.py +++ b/policyengine_uk/variables/household/income/hbai_household_net_income.py @@ -49,6 +49,7 @@ "healthy_start_vouchers", "scottish_child_payment", "carer_support_payment", + "scottish_carer_supplement", # Reference for tax-free-childcare: https://assets.publishing.service.gov.uk/media/5e7b191886650c744175d08b/households-below-average-income-1994-1995-2018-2019.pdf ] diff --git a/policyengine_uk/variables/household/income/household_benefits.py b/policyengine_uk/variables/household/income/household_benefits.py index 77f35aaa7d..6344a52c4f 100644 --- a/policyengine_uk/variables/household/income/household_benefits.py +++ b/policyengine_uk/variables/household/income/household_benefits.py @@ -52,6 +52,7 @@ "two_child_limit_payment", "scottish_child_payment", "carer_support_payment", + "scottish_carer_supplement", "disability_basic_income", ]