diff --git a/changelog.d/legacy-carer-premium-claimant-only.added.md b/changelog.d/legacy-carer-premium-claimant-only.added.md new file mode 100644 index 000000000..cd1ea9b76 --- /dev/null +++ b/changelog.d/legacy-carer-premium-claimant-only.added.md @@ -0,0 +1 @@ +- Add `partners_care_for_same_severely_disabled_person` (benefit unit). Two people caring for the same severely disabled person cannot both be entitled to Carer's Allowance (SSCBA s.70(7ZA)) or Carer Support Payment (SSI 2023/302 reg 5(3)), so they get one carer premium. Unless it is supplied, partners are treated as caring for the same person unless both have a reported Carer's Allowance or Carer Support Payment award (`carers_allowance_reported`), since caring hours cannot show who is cared for. diff --git a/changelog.d/legacy-carer-premium-claimant-only.fixed.md b/changelog.d/legacy-carer-premium-claimant-only.fixed.md new file mode 100644 index 000000000..7f662bc6d --- /dev/null +++ b/changelog.d/legacy-carer-premium-claimant-only.fixed.md @@ -0,0 +1,3 @@ +- Pay the legacy carer premium only for the claimant and partner, and once for each of them who qualifies (IS Regs 1987 Sch 2 paras 14ZA(1) and 15(7), with the matching Housing Benefit and council tax reduction schedules). A caring child or young person no longer gives the family the premium. A couple who both have Carer's Allowance awards get two premiums rather than one; a couple who care for the same severely disabled person, or who both qualify on caring hours alone, get one. The premium enters the Income Support, Housing Benefit and council tax reduction applicable amounts. +- Correct the 2025-26 carer premium to £46.40 a week. +- Open the Income Support carer route (IS Regs 1987 Sch 1B para 4) only through the claimant or partner, not through a dependent child or young person who cares. diff --git a/changelog.d/legacy-carer-premium-claimant-only.removed.md b/changelog.d/legacy-carer-premium-claimant-only.removed.md new file mode 100644 index 000000000..3417ff402 --- /dev/null +++ b/changelog.d/legacy-carer-premium-claimant-only.removed.md @@ -0,0 +1 @@ +- Remove the `gov.dwp.carer_premium.couple` parameter. It held the single rate, while the law pays the per-person amount (`gov.dwp.carer_premium.single`) once for each qualifying claimant and partner. Reforms should change `gov.dwp.carer_premium.single`. diff --git a/policyengine_uk/parameters/gov/dwp/carer_premium/couple.yaml b/policyengine_uk/parameters/gov/dwp/carer_premium/couple.yaml deleted file mode 100644 index 96100f88b..000000000 --- a/policyengine_uk/parameters/gov/dwp/carer_premium/couple.yaml +++ /dev/null @@ -1,17 +0,0 @@ -description: Carer premium for two qualifying carers for legacy benefits. -values: - 2010-01-01: 37.5 - 2023-04-01: 42.75 - 2024-04-01: - value: 45.6 - reference: - - title: Benefits Uprating 2024/25 | Commons Library Briefing - href: https://researchbriefings.files.parliament.uk/documents/CBP-9872/CBP-9872.pdf - 2025-04-01: 46.38 - 2026-04-01: 48.15 -metadata: - period: week - label: Legacy benefit carer premium (two carers) - uprating: gov.benefit_uprating_cpi - unit: currency-GBP - reference: https://www.mariecurie.org.uk/help/support/benefits-entitlements/carers/premium diff --git a/policyengine_uk/parameters/gov/dwp/carer_premium/single.yaml b/policyengine_uk/parameters/gov/dwp/carer_premium/single.yaml index fe1e590f9..21077c4d3 100644 --- a/policyengine_uk/parameters/gov/dwp/carer_premium/single.yaml +++ b/policyengine_uk/parameters/gov/dwp/carer_premium/single.yaml @@ -1,4 +1,4 @@ -description: Carer premium for one qualifying carer, for legacy benefits. +description: Carer premium for each claimant or partner who qualifies, for legacy benefits. A couple who both qualify receive it twice. values: 2015-04-01: 34.6 2016-04-01: 34.6 @@ -9,18 +9,24 @@ values: 2021-04-01: 37.7 2022-04-01: 38.85 2023-04-01: 42.75 - 2024-04-01: + 2024-04-01: value: 45.6 reference: - title: Benefits Uprating 2024/25 | Commons Library Briefing href: https://researchbriefings.files.parliament.uk/documents/CBP-9872/CBP-9872.pdf - 2025-04-01: 46.38 + 2025-04-01: + value: 46.4 + reference: + - title: Income Support (General) Regulations 1987 Sch. 2 para. 15(7), as in force from 7 April 2025 + href: https://www.legislation.gov.uk/uksi/1987/1967/schedule/2/2025-04-07 2026-04-01: 48.15 metadata: period: week - label: Legacy benefit carer premium (one carer) + label: Legacy benefit carer premium (per qualifying claimant or partner) uprating: gov.benefit_uprating_cpi unit: currency-GBP - reference: + reference: - title: Benefits Uprating 2022/23 href: https://researchbriefings.files.parliament.uk/documents/CBP-9439/CBP-9439.pdf + - title: Income Support (General) Regulations 1987 Sch. 2 para. 15(7) (in respect of each person who qualifies) + href: https://www.legislation.gov.uk/uksi/1987/1967/schedule/2/paragraph/15 diff --git a/policyengine_uk/tests/policy/baseline/finance/benefit/care.yaml b/policyengine_uk/tests/policy/baseline/finance/benefit/care.yaml index 2b42e68c7..5a0177040 100644 --- a/policyengine_uk/tests/policy/baseline/finance/benefit/care.yaml +++ b/policyengine_uk/tests/policy/baseline/finance/benefit/care.yaml @@ -8,30 +8,6 @@ num_carers: 1 carer_premium: 37.5 * 52 -- name: Two carers in a benefit unit receive the couple rate - period: 2020 - absolute_error_margin: 0 - input: - num_carers: 2 - output: - carer_premium: 37.5 * 52 - -- name: Three carers in a benefit unit stay at the couple rate (regression for #420) - period: 2020 - absolute_error_margin: 0 - input: - num_carers: 3 - output: - carer_premium: 37.5 * 52 - -- name: No carers in a benefit unit receive no premium - period: 2020 - absolute_error_margin: 0 - input: - num_carers: 0 - output: - carer_premium: 0 - - name: Carer from 35 hours a week without Carer's Allowance (regulation 30 UC Regs 2013) period: 2025 absolute_error_margin: 0 diff --git a/policyengine_uk/tests/policy/baseline/finance/benefit/carer_premium.yaml b/policyengine_uk/tests/policy/baseline/finance/benefit/carer_premium.yaml new file mode 100644 index 000000000..aa31e49e9 --- /dev/null +++ b/policyengine_uk/tests/policy/baseline/finance/benefit/carer_premium.yaml @@ -0,0 +1,380 @@ +# Carer premium for the legacy means-tested benefits. +# IS Regs 1987 Sch 2 para 14ZA(1): "the condition is that the claimant or his +# partner is, or both of them are, entitled to a carer's allowance ... or +# carer support payment". Para 15(7): "£48.15 in respect of each person who +# satisfied the condition specified in paragraph 14ZA" (from 6 April 2026; +# £46.40 from 7 April 2025). The same condition and per-person amount are in +# JSA Regs 1996 Sch 1 para 17 and Part IV (8), ESA Regs 2008 Sch 4 paras 8 and +# 11(3), HB Regs 2006 Sch 3 para 17 and Part 4 (8), HB (SPC) Regs 2006 Sch 3 +# paras 9 and 12(4), and the English and Welsh council tax reduction rules. +# The model uses the rate in force on 30 April of the simulation year, so +# 2025 uses £46.40 and 2026 uses £48.15; the premium is weekly x 52. +# Two people caring for the same severely disabled person cannot both be +# entitled to Carer's Allowance (SSCBA s.70(7ZA)) or Carer Support Payment +# (SSI 2023/302 reg 5(3)), so they satisfy the condition once. Unless supplied, +# partners are treated as caring for the same person unless both have a +# reported Carer's Allowance or Carer Support Payment award +# (carers_allowance_reported carries both); the cases below with two premiums +# therefore give both partners a reported award. + +- name: Carer premium for a single claimant entitled to Carer's Allowance + period: 2026 + absolute_error_margin: 0.01 + input: + people: + claimant: + age: 40 + receives_carer_benefit: true + benunits: + family: + members: [claimant] + output: + carer_premium: 48.15 * 52 + +- name: Carer premium once when only the partner cares + period: 2026 + absolute_error_margin: 0.01 + input: + people: + claimant: + age: 40 + partner: + age: 38 + care_hours: 35 + benunits: + family: + members: [claimant, partner] + output: + is_claimant_or_partner: [true, true] + carer_premium: 48.15 * 52 + +- name: Carer premium twice when the claimant and partner both have Carer's Allowance awards (para 15(7)) + period: 2026 + absolute_error_margin: 0.01 + input: + people: + claimant: + age: 40 + carers_allowance_reported: 4_000 + partner: + age: 38 + carers_allowance_reported: 4_000 + benunits: + family: + members: [claimant, partner] + output: + partners_care_for_same_severely_disabled_person: false + carer_premium: 2 * 48.15 * 52 + +- name: Carer premium twice for two caring partners at the April 2025 rate + period: 2025 + absolute_error_margin: 0.01 + input: + people: + claimant: + age: 40 + carers_allowance_reported: 4_000 + partner: + age: 38 + carers_allowance_reported: 4_000 + benunits: + family: + members: [claimant, partner] + output: + carer_premium: 2 * 46.40 * 52 + +- name: No carer premium for a qualifying young person who cares + period: 2026 + absolute_error_margin: 0 + input: + people: + parent: + age: 45 + is_parent: true + young_person: + age: 17 + is_in_non_advanced_education: true + care_hours: 35 + benunits: + family: + members: [parent, young_person] + output: + is_claimant_or_partner: [true, false] + is_child_or_young_person_for_legacy_benefits: [false, true] + is_carer_for_benefits: [false, true] + num_carers: 1 + carer_premium: 0 + +- name: No carer premium for a child under 16 who cares + period: 2026 + absolute_error_margin: 0 + input: + people: + parent: + age: 35 + is_parent: true + child: + age: 14 + care_hours: 40 + benunits: + family: + members: [parent, child] + output: + is_claimant_or_partner: [true, false] + carer_premium: 0 + +- name: Lone parent carer with a caring young person gets one premium + period: 2026 + absolute_error_margin: 0.01 + input: + people: + parent: + age: 45 + is_parent: true + receives_carer_benefit: true + young_person: + age: 18 + is_in_non_advanced_education: true + care_hours: 35 + benunits: + family: + members: [parent, young_person] + output: + num_carers: 2 + carer_premium: 48.15 * 52 + +- name: Two caring partners and a caring young person get two premiums (was #420) + period: 2026 + absolute_error_margin: 0.01 + input: + people: + claimant: + age: 45 + is_parent: true + carers_allowance_reported: 4_000 + partner: + age: 44 + is_parent: true + carers_allowance_reported: 4_000 + young_person: + age: 17 + is_in_non_advanced_education: true + care_hours: 35 + benunits: + family: + members: [claimant, partner, young_person] + output: + num_carers: 3 + carer_premium: 2 * 48.15 * 52 + +- name: Two caring partners' premiums enter the working-age applicable amounts + period: 2026 + absolute_error_margin: 0.01 + input: + people: + claimant: + age: 40 + carers_allowance_reported: 4_000 + partner: + age: 38 + carers_allowance_reported: 4_000 + benunits: + family: + members: [claimant, partner] + disability_premium: 0 + enhanced_disability_premium: 0 + severe_disability_premium: 0 + output: + benefits_premiums: 2 * 48.15 * 52 + # Council tax reduction applicable amount: the model's couple allowance + # (HB Regs 2006 Sch 3 para 1(3)(b), £150.15) plus two premiums. + council_tax_reduction_applicable_amount: (150.15 + 2 * 48.15) * 52 + +- name: Pension-age couple who both receive Carer's Allowance get two premiums in Housing Benefit + period: 2026 + absolute_error_margin: 0.01 + input: + people: + claimant: + age: 75 + carers_allowance_reported: 4_000 + partner: + age: 73 + carers_allowance_reported: 4_000 + benunits: + family: + members: [claimant, partner] + disability_premium: 0 + enhanced_disability_premium: 0 + severe_disability_premium: 0 + output: + carer_premium: 2 * 48.15 * 52 + # HB (SPC) Regs 2006 Sch 3 para 1(2)(b): £383.35 for a couple with a + # member who reached pensionable age before 1 April 2021; para 9 and + # para 12(4): £48.15 for each of them. + housing_benefit_applicable_amount: (383.35 + 2 * 48.15) * 52 + +- name: One premium when both partners care for the same severely disabled person (SSCBA s.70(7ZA)) + period: 2026 + absolute_error_margin: 0.01 + input: + people: + claimant: + age: 40 + care_hours: 35 + partner: + age: 38 + care_hours: 40 + benunits: + family: + members: [claimant, partner] + partners_care_for_same_severely_disabled_person: true + output: + carer_premium: 48.15 * 52 + +- name: Two premiums when the partners are supplied as caring for different people + period: 2026 + absolute_error_margin: 0.01 + input: + people: + claimant: + age: 40 + care_hours: 35 + partner: + age: 38 + care_hours: 40 + benunits: + family: + members: [claimant, partner] + partners_care_for_same_severely_disabled_person: false + output: + carer_premium: 2 * 48.15 * 52 + +- name: A 17-year-old partner supplied as the partner counts + period: 2026 + absolute_error_margin: 0.01 + input: + people: + claimant: + age: 18 + is_claimant_or_partner: true + partner: + age: 17 + is_claimant_or_partner: true + care_hours: 35 + benunits: + family: + members: [claimant, partner] + output: + carer_premium: 48.15 * 52 + +- name: Partners who both care by hours alone are treated as caring for the same person + period: 2026 + absolute_error_margin: 0.01 + input: + people: + claimant: + age: 40 + care_hours: 35 + partner: + age: 38 + care_hours: 40 + benunits: + family: + members: [claimant, partner] + output: + is_carer_for_benefits: [true, true] + partners_care_for_same_severely_disabled_person: true + carer_premium: 48.15 * 52 + +- name: Partners supplied beyond two each count, unless they care for the same person + period: 2026 + absolute_error_margin: 0.01 + input: + people: + a1: + age: 50 + is_claimant_or_partner: true + carers_allowance_reported: 4_000 + a2: + age: 45 + is_claimant_or_partner: true + carers_allowance_reported: 4_000 + a3: + age: 40 + is_claimant_or_partner: true + carers_allowance_reported: 4_000 + b1: + age: 50 + is_claimant_or_partner: true + carers_allowance_reported: 4_000 + b2: + age: 45 + is_claimant_or_partner: true + carers_allowance_reported: 4_000 + b3: + age: 40 + is_claimant_or_partner: true + carers_allowance_reported: 4_000 + benunits: + family_a: + members: [a1, a2, a3] + family_b: + members: [b1, b2, b3] + partners_care_for_same_severely_disabled_person: true + households: + household_a: + members: [a1, a2, a3] + household_b: + members: [b1, b2, b3] + output: + # 3 x 48.15 x 52 and 48.15 x 52. + carer_premium: [7_511.40, 2_503.80] + +- name: A reported award the person would not claim does not count towards two awards + period: 2026 + absolute_error_margin: 0.01 + input: + people: + claimant: + age: 40 + carers_allowance_reported: 4_000 + partner: + age: 38 + carers_allowance_reported: 4_000 + would_claim_carers_allowance: false + benunits: + family: + members: [claimant, partner] + output: + is_carer_for_benefits: [true, false] + partners_care_for_same_severely_disabled_person: true + carer_premium: 48.15 * 52 + +# The property tests' generator keeps a partner within 15 years of an adult +# under 20, because the model presumes someone under 20 who is at least 16 +# years younger than the eldest adult to be that adult's child. +- name: An 18-year-old 15 years younger than the other adult is a partner; 16 years younger is presumed a child + period: 2026 + input: + people: + a18: + age: 18 + a33: + age: 33 + b18: + age: 18 + b34: + age: 34 + benunits: + couple_a: + members: [a18, a33] + couple_b: + members: [b18, b34] + households: + household_a: + members: [a18, a33] + household_b: + members: [b18, b34] + output: + is_claimant_or_partner: [true, true, false, true] diff --git a/policyengine_uk/tests/policy/baseline/finance/benefit/family/income_support/income_support_carer_route.yaml b/policyengine_uk/tests/policy/baseline/finance/benefit/family/income_support/income_support_carer_route.yaml new file mode 100644 index 000000000..b17f87ee0 --- /dev/null +++ b/policyengine_uk/tests/policy/baseline/finance/benefit/family/income_support/income_support_carer_route.yaml @@ -0,0 +1,85 @@ +# Income Support carer route. SSCBA 1992 s.124(1)(e): a person is entitled +# to Income Support if "he falls within a prescribed category of person". +# IS Regs 1987 reg 4ZA(1) prescribes the persons in Schedule 1B, and Sch 1B +# para 4 includes "A person (the carer)" regularly and substantially caring +# for a disabled person or entitled to Carer's Allowance. A couple choose +# which of them claims (Claims and Payments Regs 1987 reg 4(3)), so either +# partner's caring qualifies; a child's or young person's caring does not. + +- name: IS carer route for a single claimant who cares + period: 2025 + input: + people: + claimant: + age: 40 + care_hours: 35 + income_support_reported: 1000 + benunits: + family: + members: [claimant] + esa_income: 0 + income_support_assessable_capital: 0 + output: + income_support_eligible: true + +- name: IS carer route when the partner is the carer + period: 2025 + input: + people: + claimant: + age: 40 + income_support_reported: 1000 + partner: + age: 38 + receives_carer_benefit: true + benunits: + family: + members: [claimant, partner] + esa_income: 0 + income_support_assessable_capital: 0 + output: + is_claimant_or_partner: [true, true] + income_support_eligible: true + +- name: IS carer route does not open through a qualifying young person's caring + period: 2025 + input: + people: + parent: + age: 45 + is_parent: true + income_support_reported: 1000 + young_person: + age: 17 + is_in_non_advanced_education: true + care_hours: 35 + benunits: + family: + members: [parent, young_person] + esa_income: 0 + income_support_assessable_capital: 0 + output: + is_lone_parent: true + is_carer_for_benefits: [false, true] + income_support_eligible: false + +- name: IS carer route does not open through a child's caring + period: 2025 + input: + people: + claimant: + age: 40 + income_support_reported: 1000 + partner: + age: 39 + child: + age: 12 + care_hours: 40 + benunits: + family: + members: [claimant, partner, child] + esa_income: 0 + income_support_assessable_capital: 0 + output: + is_claimant_or_partner: [true, true, false] + income_support_eligible: false diff --git a/policyengine_uk/tests/test_legacy_carer_premium_properties.py b/policyengine_uk/tests/test_legacy_carer_premium_properties.py new file mode 100644 index 000000000..4884d0cf9 --- /dev/null +++ b/policyengine_uk/tests/test_legacy_carer_premium_properties.py @@ -0,0 +1,215 @@ +"""The legacy carer premium and the Income Support carer route follow only the +claimant and partner. + +IS Regs 1987 Sch 2 para 14ZA(1) (and the JSA, ESA, HB and CTR equivalents) +give the carer premium where "the claimant or his partner is, or both of them +are" entitled to Carer's Allowance or Carer Support Payment, and para 15(7) +pays it "in respect of each person who satisfied the condition". Two people +caring for the same severely disabled person cannot both be entitled (SSCBA +s.70(7ZA); SSI 2023/302 reg 5(3)). The Income Support carer route (Sch 1B +para 4, reg 4ZA, SSCBA s.124(1)(e)) likewise needs the claimant to be the +carer, and a couple choose which of them claims. + +Invariants, for any family of a claimant, an optional partner and up to three +dependent children or qualifying young persons: + +- a dependant's caring never changes carer_premium or income_support_eligible; +- carer_premium is the per-person amount, weekly x 52, times the number of + caring claimants and partners, capped at one when they are treated as + caring for the same person; it is 0, one amount or two; +- unless supplied, partners are treated as caring for the same person unless + both are carers with a reported Carer's Allowance award; +- supplying "same person" never raises the premium and caps it at one amount; +- caring by the claimant or partner never removes Income Support eligibility + or lowers the premium, and below pension age it always opens the IS route. + +Adults are 18 to 85, so pension-age families are covered. No adult under 20 +is 16 or more years younger than the other adult, whom the model would then +presume to be their parent. + +Each example builds every family twice in one simulation, in separate +households and benefit units: once as drawn and once with a changed caring +pattern. +""" + +import numpy as np +from hypothesis import HealthCheck, example, given, settings +from hypothesis import strategies as st + +from policyengine_uk import Simulation + +YEAR = 2026 +WEEKS = 52 +AWARD = 4_000 + + +@st.composite +def carer_inputs(draw): + # Either route to is_carer_for_benefits through the model's Carer's + # Allowance: a reported award, or the qualifying hours of care. + return { + "carers_allowance_reported": draw(st.sampled_from([0, AWARD])), + "care_hours": draw(st.sampled_from([0, 20, 34, 35, 50])), + } + + +@st.composite +def families(draw): + n_dependants = draw(st.integers(0, 3)) + dependants = [] + for _ in range(n_dependants): + if draw(st.booleans()): + dependant = {"age": draw(st.integers(0, 15))} + else: + # A qualifying young person: 16-19 in non-advanced education. + dependant = { + "age": draw(st.integers(16, 19)), + "current_education": "UPPER_SECONDARY", + } + dependants.append({**dependant, **draw(carer_inputs())}) + eldest_dependant = max([d["age"] for d in dependants], default=0) + head_age = draw(st.integers(max(18, eldest_dependant + 16), 85)) + has_parent_flag = n_dependants > 0 + head = { + "age": head_age, + "is_parent": has_parent_flag, + "income_support_reported": 1_000, + **draw(carer_inputs()), + } + family = [head] + if draw(st.booleans()): + # Within 15 years of the head in both directions when either could be + # under 20, so neither is presumed the other's child. + oldest_partner = 85 if head_age >= 20 else head_age + 15 + family.append( + { + "age": draw(st.integers(max(18, head_age - 15), oldest_partner)), + "is_parent": has_parent_flag, + **draw(carer_inputs()), + } + ) + return family + dependants, len(family) + + +def situation(units, same_person=None): + people, benunits, households = {}, {}, {} + for i, family in enumerate(units): + names = [] + for j, inputs in enumerate(family): + name = f"p{i}_{j}" + people[name] = {k: {YEAR: v} for k, v in inputs.items()} + names.append(name) + benunits[f"b{i}"] = { + "members": names, + "esa_income": {YEAR: 0}, + "income_support_assessable_capital": {YEAR: 0}, + } + if same_person is not None: + benunits[f"b{i}"]["partners_care_for_same_severely_disabled_person"] = { + YEAR: bool(same_person[i]) + } + households[f"h{i}"] = {"members": names} + return {"people": people, "benunits": benunits, "households": households} + + +NOT_CARING = {"carers_allowance_reported": 0, "care_hours": 0} +CARING = {"carers_allowance_reported": AWARD, "care_hours": 35} + +SETTINGS = settings( + max_examples=15, + deadline=None, + derandomize=True, + suppress_health_check=[HealthCheck.too_slow, HealthCheck.data_too_large], +) + +# The generator's age boundary: an 18-year-old head with a partner 15 years +# older is drawn; 16 years older is not (the model would presume a child). +BOUNDARY = [ + { + "age": 18, + "is_parent": False, + "income_support_reported": 1_000, + **CARING, + }, + {"age": 33, "is_parent": False, **CARING}, +] + + +@SETTINGS +@given(st.lists(families(), min_size=1, max_size=6)) +@example(drawn=[(BOUNDARY, 2)]) +def test_dependants_caring_never_changes_premium_or_is_eligibility(drawn): + units = [family for family, _ in drawn] + adults = [n for _, n in drawn] + without = [ + family[:n] + [{**member, **NOT_CARING} for member in family[n:]] + for family, n in zip(units, adults) + ] + sim = Simulation(situation=situation(units + without)) + flags = sim.calculate("is_claimant_or_partner", YEAR) + carers = sim.calculate("is_carer_for_benefits", YEAR) + reported = sim.calculate("carers_allowance_reported", YEAR) > 0 + offsets = np.cumsum([0] + [len(f) for f in units + without]) + for i, n in enumerate(adults): + # The generator's construction, checked against the model: the first + # n members are the claimant and partner, the rest are dependants. + members = flags[offsets[i] : offsets[i + 1]] + assert members[:n].all() and not members[n:].any(), units[i] + premium = sim.calculate("carer_premium", YEAR) + eligible = sim.calculate("income_support_eligible", YEAR) + same_person = sim.calculate("partners_care_for_same_severely_disabled_person", YEAR) + amount = sim.tax_benefit_system.parameters(YEAR).gov.dwp.carer_premium.single + k = len(units) + for i, n in enumerate(adults): + assert abs(premium[i] - premium[k + i]) < 0.01, units[i] + assert eligible[i] == eligible[k + i], units[i] + adult_slice = slice(offsets[i], offsets[i] + n) + assert same_person[i] == ((reported & carers)[adult_slice].sum() < 2), units[i] + qualifying = carers[adult_slice].sum() + if same_person[i]: + qualifying = min(qualifying, 1) + assert abs(premium[i] - qualifying * amount * WEEKS) < 0.01, units[i] + assert 0 <= premium[i] <= 2 * amount * WEEKS + 0.01, units[i] + + +@SETTINGS +@given(st.lists(families(), min_size=1, max_size=6), st.data()) +def test_claimant_or_partner_caring_never_removes_is_eligibility(drawn, data): + units = [family for family, _ in drawn] + adults = [n for _, n in drawn] + # Make one of the claimant and partner a carer with a reported award. + with_caring = [] + for family, n in zip(units, adults): + who = data.draw(st.integers(0, n - 1)) + with_caring.append( + [ + {**member, **CARING} if j == who else member + for j, member in enumerate(family) + ] + ) + sim = Simulation(situation=situation(units + with_caring)) + eligible = sim.calculate("income_support_eligible", YEAR) + premium = sim.calculate("carer_premium", YEAR) + sp_age = sim.calculate("is_SP_age", YEAR) + offsets = np.cumsum([0] + [len(f) for f in units + with_caring]) + k = len(units) + for i in range(k): + assert eligible[k + i] >= eligible[i], units[i] + if not sp_age[offsets[k + i] : offsets[k + i + 1]].any(): + assert eligible[k + i], units[i] + assert premium[k + i] >= premium[i] - 0.01, units[i] + + +@SETTINGS +@given(st.lists(families(), min_size=1, max_size=6)) +def test_caring_for_the_same_person_pays_at_most_one_premium(drawn): + units = [family for family, _ in drawn] + k = len(units) + sim = Simulation( + situation=situation(units + units, same_person=[False] * k + [True] * k) + ) + premium = sim.calculate("carer_premium", YEAR) + amount = sim.tax_benefit_system.parameters(YEAR).gov.dwp.carer_premium.single + for i in range(k): + assert premium[k + i] <= premium[i] + 0.01, units[i] + assert abs(premium[k + i] - min(premium[i], amount * WEEKS)) < 0.01, units[i] diff --git a/policyengine_uk/variables/gov/dwp/income_support_eligible.py b/policyengine_uk/variables/gov/dwp/income_support_eligible.py index c0f6715ff..ee9e0be81 100644 --- a/policyengine_uk/variables/gov/dwp/income_support_eligible.py +++ b/policyengine_uk/variables/gov/dwp/income_support_eligible.py @@ -6,7 +6,12 @@ class income_support_eligible(Variable): entity = BenUnit label = "Whether eligible for Income Support" definition_period = YEAR - reference = "https://www.legislation.gov.uk/uksi/1987/1967/schedule/1B" + reference = ( + "https://www.legislation.gov.uk/uksi/1987/1967/schedule/1B", + "https://www.legislation.gov.uk/uksi/1987/1967/regulation/4ZA", + "https://www.legislation.gov.uk/ukpga/1992/4/section/124", + "https://www.legislation.gov.uk/uksi/1987/1968/regulation/4", + ) def formula(benunit, period, parameters): IS = parameters(period).gov.dwp.income_support @@ -18,14 +23,21 @@ def formula(benunit, period, parameters): ) lone_parent = benunit("is_lone_parent", period) lone_parent_with_young_child = lone_parent & youngest_child_5_or_under - has_carers = add(benunit, period, ["is_carer_for_benefits"]) > 0 + # Sch 1B para 4 prescribes the carer, and SSCBA s.124(1)(e) requires + # the claimant to fall within a prescribed category. A couple choose + # which of them claims (Claims and Payments Regs 1987 reg 4(3)), so + # either partner's caring qualifies; a child's or young person's + # caring does not. + claimant_or_partner = benunit.members("is_claimant_or_partner", period) + carer = benunit.members("is_carer_for_benefits", period) + claimant_or_partner_cares = benunit.any(claimant_or_partner & carer) none_SP_age = ~benunit.any(benunit.members("is_SP_age", period)) has_esa_income = benunit("esa_income", period) > 0 already_claiming = add(benunit, period, ["income_support_reported"]) > 0 capital = benunit("income_support_assessable_capital", period) limit = IS.means_test.capital.limit return ( - (has_carers | lone_parent_with_young_child) + (claimant_or_partner_cares | lone_parent_with_young_child) & none_SP_age & ~has_esa_income & already_claiming diff --git a/policyengine_uk/variables/household/demographic/carer_premium.py b/policyengine_uk/variables/household/demographic/carer_premium.py index b1f93386e..7b624c9c2 100644 --- a/policyengine_uk/variables/household/demographic/carer_premium.py +++ b/policyengine_uk/variables/household/demographic/carer_premium.py @@ -5,15 +5,64 @@ class carer_premium(Variable): value_type = float entity = BenUnit label = "Carer premium" + documentation = ( + "The legacy benefits' carer premium: one amount for each claimant or " + "partner who qualifies. The model treats a person as qualifying when " + "is_carer_for_benefits holds (a carer benefit, or at least the Carer's " + "Allowance qualifying hours of care), its proxy for entitlement to " + "Carer's Allowance or Carer Support Payment. A child or young person " + "in the family who cares does not qualify the family. A couple who " + "both qualify get the amount twice if they care for different people, " + "and once if they care for the same severely disabled person " + "(partners_care_for_same_severely_disabled_person, which by default " + "treats them as caring for the same person unless both have a " + "reported Carer's Allowance or Carer Support Payment award). Members " + "flagged as claimant or partner " + "beyond two (for example the partners of a polygamous marriage, " + "supplied as inputs) each count, except that caring for the same " + "person caps the benefit unit at one amount. The premium enters the " + "Income Support, Housing Benefit and council tax reduction applicable " + "amounts; the model takes income-based JSA and income-related ESA " + "from reported awards." + ) definition_period = YEAR - reference = "The Social Security Amendment (Carer Premium) Regulations 2002" + reference = ( + "https://www.legislation.gov.uk/uksi/1987/1967/schedule/2/paragraph/14ZA", + "https://www.legislation.gov.uk/uksi/1987/1967/schedule/2/paragraph/15", + "https://www.legislation.gov.uk/uksi/1996/207/schedule/1/paragraph/17", + "https://www.legislation.gov.uk/uksi/2008/794/schedule/4/paragraph/8", + "https://www.legislation.gov.uk/uksi/2006/213/schedule/3/paragraph/17", + "https://www.legislation.gov.uk/uksi/2006/214/schedule/3/paragraph/9", + "https://www.legislation.gov.uk/uksi/2012/2885/schedule/2/paragraph/9", + "https://www.legislation.gov.uk/wsi/2013/3029/schedule/2/paragraph/9", + "https://www.legislation.gov.uk/wsi/2013/3029/schedule/7/paragraph/14", + "https://www.legislation.gov.uk/ssi/2012/319/schedule/1/paragraph/10", + "https://www.legislation.gov.uk/ssi/2021/249/schedule/1/paragraph/5", + "https://www.legislation.gov.uk/ukpga/1992/4/section/70", + "https://www.legislation.gov.uk/ssi/2023/302/regulation/5", + ) unit = GBP def formula(benunit, period, parameters): - carers = benunit("num_carers", period.this_year) - CP = parameters(period).gov.dwp.carer_premium - weekly_premium = select( - [carers >= 2, carers == 1], - [CP.couple, CP.single], + # IS Regs 1987 Sch 2 para 14ZA(1): "the claimant or his partner is, or + # both of them are, entitled to a carer's allowance ... or carer + # support payment". Para 15(7) pays the premium "in respect of each + # person who satisfied the condition". The JSA, ESA and HB schedules, + # the English, Welsh and Scottish pension-age council tax reduction + # schedules and Welsh working-age council tax reduction (WSI 2013/3029 + # Sch 7 para 14) use the same condition and amount; Scottish + # working-age council tax reduction (SSI 2021/249 Sch 1 para 5) tests + # caring responsibilities and pays each partner who qualifies. + claimant_or_partner = benunit.members("is_claimant_or_partner", period) + carer = benunit.members("is_carer_for_benefits", period) + qualifying_carers = benunit.sum(claimant_or_partner & carer) + # Two people caring for the same severely disabled person cannot both + # be entitled to Carer's Allowance (SSCBA s.70(7ZA)) or Carer Support + # Payment (SSI 2023/302 reg 5(3)); SSI 2021/249 Sch 1 para 5(3)-(4) + # pays one premium in that case too. + same_person = benunit("partners_care_for_same_severely_disabled_person", period) + qualifying_carers = where( + same_person, min_(qualifying_carers, 1), qualifying_carers ) - return weekly_premium * WEEKS_IN_YEAR + amount = parameters(period).gov.dwp.carer_premium.single + return qualifying_carers * amount * WEEKS_IN_YEAR diff --git a/policyengine_uk/variables/household/demographic/partners_care_for_same_severely_disabled_person.py b/policyengine_uk/variables/household/demographic/partners_care_for_same_severely_disabled_person.py new file mode 100644 index 000000000..e312b9e49 --- /dev/null +++ b/policyengine_uk/variables/household/demographic/partners_care_for_same_severely_disabled_person.py @@ -0,0 +1,36 @@ +from policyengine_uk.model_api import * + + +class partners_care_for_same_severely_disabled_person(Variable): + value_type = bool + entity = BenUnit + label = "Claimant and partner care for the same severely disabled person" + documentation = ( + "Whether the claimant and partner who both care are caring for the " + "same severely disabled person. In law only one of them can then be " + "entitled to Carer's Allowance (SSCBA 1992 s.70(7ZA)) or Carer " + "Support Payment (SSI 2023/302 reg 5(3)), so only one satisfies the " + "legacy carer premium condition, and Scottish working-age council tax " + "reduction pays one premium (SSI 2021/249 Sch 1 para 5(3)-(4)). " + "Unless supplied, it is true unless at least two of the claimant and " + "partner are carers with a reported Carer's Allowance or Carer " + "Support Payment award (carers_allowance_reported, the model's " + "reported-receipt input for both): two awards mean two different " + "people cared for, while caring hours cannot show who is cared for. " + "With more than two members supplied as claimant or partner, two " + "awards make the default false for all of them. The " + "model's carers_allowance and carer_support_payment are paid on " + "caring hours or a reported award, and do not read this variable." + ) + definition_period = YEAR + reference = ( + "https://www.legislation.gov.uk/ukpga/1992/4/section/70", + "https://www.legislation.gov.uk/ssi/2023/302/regulation/5", + "https://www.legislation.gov.uk/ssi/2021/249/schedule/1/paragraph/5", + ) + + def formula(benunit, period, parameters): + claimant_or_partner = benunit.members("is_claimant_or_partner", period) + reported_award = benunit.members("carers_allowance_reported", period) > 0 + carer = benunit.members("is_carer_for_benefits", period) + return benunit.sum(claimant_or_partner & carer & reported_award) < 2