diff --git a/changelog.d/2120.fixed.md b/changelog.d/2120.fixed.md new file mode 100644 index 0000000000..a5b29b8b7d --- /dev/null +++ b/changelog.d/2120.fixed.md @@ -0,0 +1 @@ +The model now counts a carer's Universal Credit award with the carer element, where the award comes to at least one penny, when deciding the severe disability premium and the Pension Credit severe disability addition, and in Scotland's working-age council tax reduction it counts such an award for the carer premium from 1 April 2022 (#2120, #2124). diff --git a/policyengine_uk/parameters/gov/local_authorities/scotland/council_tax_reduction/working_age/carer_premium_counts_uc_carer_element.yaml b/policyengine_uk/parameters/gov/local_authorities/scotland/council_tax_reduction/working_age/carer_premium_counts_uc_carer_element.yaml new file mode 100644 index 0000000000..98947fb13a --- /dev/null +++ b/policyengine_uk/parameters/gov/local_authorities/scotland/council_tax_reduction/working_age/carer_premium_counts_uc_carer_element.yaml @@ -0,0 +1,15 @@ +description: Whether Scottish councils pay the working-age Council Tax Reduction carer premium to an applicant or partner whose award of Universal Credit includes the carer element, as well as on entitlement to Carer's Allowance or Carer Support Payment. +values: + 2013-04-01: false + 2022-04-01: true +metadata: + unit: bool + period: year + label: Scottish working-age Council Tax Reduction carer premium counts the Universal Credit carer element + reference: + - title: The Council Tax Reduction (Scotland) Regulations 2021 Sch. 1 para. 6(1)(c) + href: https://www.legislation.gov.uk/ssi/2021/249/schedule/1/paragraph/6 + - title: The Council Tax Reduction (Scotland) Regulations 2021 reg. 1 (in force 1 April 2022) + href: https://www.legislation.gov.uk/ssi/2021/249/regulation/1 + - title: The Council Tax Reduction (Scotland) Regulations 2012 Sch. 1 para. 14 (persons under pension age, to 31 March 2022) + href: https://www.legislation.gov.uk/ssi/2012/303/schedule/1/paragraph/14/2021-04-01 diff --git a/policyengine_uk/tests/policy/baseline/gov/local_authorities/council_tax_reduction/council_tax_reduction_carer_premium.yaml b/policyengine_uk/tests/policy/baseline/gov/local_authorities/council_tax_reduction/council_tax_reduction_carer_premium.yaml new file mode 100644 index 0000000000..4f7b91f1c5 --- /dev/null +++ b/policyengine_uk/tests/policy/baseline/gov/local_authorities/council_tax_reduction/council_tax_reduction_carer_premium.yaml @@ -0,0 +1,423 @@ +# Scottish councils include the carer premium in the working-age council tax +# reduction where the applicant or partner has regular and substantial caring +# responsibilities for a severely disabled person (SSI 2021/249 Sch 1 para +# 5(2)), and the Scottish Ministers count among those responsibilities "an +# award of universal credit which includes the carer element described in +# regulation 29 of the 2013 Regulations" (para 6(1)(c)). No other scheme's +# carer premium has that limb: under the Housing Benefit, English and Welsh +# schedules, DWP and councils test entitlement to Carer's Allowance or Carer +# Support Payment (HB Regs 2006 Sch 3 para 17; WSI 2013/3029 Sch 7 para 14), +# as Scottish councils did for persons under pension age before 1 April 2022 +# (SSI 2012/303 Sch 1 para 14). From 1 April 2022 to 31 March +# 2025 an "award of universal credit" included "a universal credit award with +# a value of zero" (reg 4, as amended by SSI 2022/52 reg 3); from 1 April 2025 +# it "means an award of universal credit made under Part 1 of the 2012 Act" +# (SSI 2025/24 reg 8), and an income that tapers the award to nil leaves no +# award (Welfare Reform Act 2012 s.5(1)(b); UC Regs 2013 reg 17). An income +# that tapers the amount payable below one penny leaves no award to have a +# value of zero in any year: DWP makes no award or the award ends (UC Claims +# and Payments Regs 2013 reg 32A(1)), and the Scottish Government's policy +# note to SSI 2025/24 confines the earlier words to an award a sanction +# reduces to zero. So the model needs an award of at least one penny in every +# year from 2022-23. +# +# Amounts: carer premium £48.15 a week from 1 April 2026 (SSI 2021/249 Sch 1 +# para 5(1), substituted by SSI 2026/56), £46.40 in 2025-26, £45.60 in +# 2024-25 and £38.85 in 2022-23 (para 17, as substituted by SSI 2022/52 reg +# 25(c)(ii); para 5(1) kept £37.70 until SSI 2023/38 amended both from +# 1 April 2023); personal allowance for a single person aged 25 or over +# £95.55 (2026-27) and £77.00 (2022-23); Universal Credit carer element +# £209.34 a month (2026-27), £201.68 (2025-26), £198.31 (2024-25) and £168.81 +# (2022-23), standard allowance £424.90, £400.14, £393.45 and £334.91. + +- name: The issue's Scottish carer aged 40 with 35 hours and no Carer's Allowance claim gets the carer premium + # The award includes the carer element, 209.34 x 12 = 2,512.08, so the + # council includes the carer premium (para 6(1)(c)) and the applicable + # amount comes to (95.55 + 48.15) x 52 = 7,472.40, not 95.55 x 52 = + # 4,968.60. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + carer: + age: 40 + care_hours: 35 + would_claim_carers_allowance: false + benunits: + carer_unit: + members: [carer] + households: + household: + members: [carer] + country: SCOTLAND + region: SCOTLAND + output: + uc_carer_element: 209.34 * 12 + universal_credit: (424.90 + 209.34) * 12 + receives_uc_carer_element: true + is_entitled_to_carer_benefit: false + carer_premium: 0 + council_tax_reduction_carer_premium: 48.15 * 52 + council_tax_reduction_applicable_amount: (95.55 + 48.15) * 52 + council_tax_reduction_working_age_carers: 1 + council_tax_reduction_working_age_adult_premiums: 48.15 * 52 + +- name: The Scottish carer premium for a carer element starts with the 2021 Regulations on 1 April 2022 + # The model reads model year 2022 (2022-23) at 30 April 2022. Carer element + # 168.81 x 12 = 2,025.72; carer premium 38.85 x 52 = 2,020.20; applicable + # amount (77.00 + 38.85) x 52. + period: 2022 + absolute_error_margin: 0.01 + input: + people: + carer: + age: 40 + care_hours: 35 + would_claim_carers_allowance: false + benunits: + carer_unit: + members: [carer] + households: + household: + members: [carer] + country: SCOTLAND + region: SCOTLAND + output: + uc_carer_element: 168.81 * 12 + council_tax_reduction_carer_premium: 38.85 * 52 + council_tax_reduction_applicable_amount: (77.00 + 38.85) * 52 + council_tax_reduction_working_age_carers: 1 + council_tax_reduction_working_age_adult_premiums: 38.85 * 52 + +- name: Before 1 April 2022 the Scottish scheme for persons under pension age tested Carer's Allowance only + # Under SSI 2012/303 Sch 1 para 14, councils included the premium for an + # applicant or partner "entitled to a carer's allowance". The model reads + # model year 2021 (2021-22) at 30 April 2021, so the carer element, 163.73 + # x 12 = 1,964.76, brings no premium. + period: 2021 + absolute_error_margin: 0.01 + input: + people: + carer: + age: 40 + care_hours: 35 + would_claim_carers_allowance: false + benunits: + carer_unit: + members: [carer] + households: + household: + members: [carer] + country: SCOTLAND + region: SCOTLAND + output: + uc_carer_element: 163.73 * 12 + council_tax_reduction_carer_premium: 0 + council_tax_reduction_working_age_carers: 0 + council_tax_reduction_working_age_adult_premiums: 0 + +- name: The same carer in England gets no carer premium for the carer element + # In England the model takes the working-age premiums from the Housing + # Benefit schedule, whose carer premium needs entitlement to Carer's + # Allowance (HB Regs 2006 Sch 3 para 17(1)). + period: 2026 + absolute_error_margin: 0.01 + input: + people: + carer: + age: 40 + care_hours: 35 + would_claim_carers_allowance: false + benunits: + carer_unit: + members: [carer] + households: + household: + members: [carer] + country: ENGLAND + output: + uc_carer_element: 209.34 * 12 + receives_uc_carer_element: true + council_tax_reduction_carer_premium: 0 + council_tax_reduction_applicable_amount: 95.55 * 52 + council_tax_reduction_working_age_carers: 0 + +- name: The same carer in Wales gets no carer premium for the carer element + # Welsh councils include the premium for an applicant or partner "entitled + # to a carer's allowance" (WSI 2013/3029 Sch 7 para 14(1)). + period: 2026 + absolute_error_margin: 0.01 + input: + people: + carer: + age: 40 + care_hours: 35 + would_claim_carers_allowance: false + benunits: + carer_unit: + members: [carer] + households: + household: + members: [carer] + country: WALES + output: + uc_carer_element: 209.34 * 12 + receives_uc_carer_element: true + council_tax_reduction_carer_premium: 0 + council_tax_reduction_applicable_amount: 95.55 * 52 + council_tax_reduction_working_age_carers: 0 + +- name: A Scottish carer whose income tapers the award to nil has no award and no carer premium + # With £20,000 of earnings the award comes to nil, which in 2026 leaves no + # award (Welfare Reform Act 2012 s.5(1)(b); UC Regs 2013 reg 17), and para + # 6(1)(c) does not apply, though the maximum amount still includes the + # carer element. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + carer: + age: 40 + care_hours: 35 + would_claim_carers_allowance: false + employment_income: 20_000 + benunits: + carer_unit: + members: [carer] + households: + household: + members: [carer] + country: SCOTLAND + region: SCOTLAND + output: + uc_carer_element: 209.34 * 12 + universal_credit: 0 + receives_uc_carer_element: false + council_tax_reduction_carer_premium: 0 + council_tax_reduction_working_age_carers: 0 + +- name: In 2024 a Scottish carer whose earnings taper the award to nil has no award and no carer premium + # The same carer in 2024-25. The maximum amount comes to (393.45 + 198.31) + # x 12 = 7,101.12, and the taper, 0.55 x 17,942.66 = 9,868.46 on £20,000 + # of earnings less income tax and National Insurance, takes more, so the + # award comes to nil. Until 31 March 2025 an "award of universal credit" + # included "a universal credit award with a value of zero" (reg 4), but an + # income that fails the financial condition leaves no award to have that + # value (Welfare Reform Act 2012 s.5(1)(b); UC Regs 2013 reg 17), so para + # 6(1)(c) does not apply: no carer premium, where the model would + # otherwise include 45.60 x 52 = 2,371.20. + period: 2024 + absolute_error_margin: 0.01 + input: + people: + carer: + age: 40 + care_hours: 35 + would_claim_carers_allowance: false + employment_income: 20_000 + benunits: + carer_unit: + members: [carer] + households: + household: + members: [carer] + country: SCOTLAND + region: SCOTLAND + output: + uc_carer_element: 198.31 * 12 + uc_maximum_amount: 7_101.12 + uc_earned_income: 17_942.66 + universal_credit: 0 + receives_uc_carer_element: false + is_entitled_to_carer_benefit: false + carer_premium: 0 + council_tax_reduction_carer_premium: 0 + council_tax_reduction_working_age_carers: 0 + +- name: From 1 April 2025 the same Scottish carer's nil award leaves no award + # The same carer in 2025-26. The maximum amount comes to (400.14 + 201.68) + # x 12 = 7,221.84, and the taper again takes more, so the award comes to + # nil. From 1 April 2025 reg 4 defines an award of universal credit as one + # "made under Part 1 of the 2012 Act" (SSI 2025/24 reg 8), and an income + # that tapers it to nil leaves no award, so para 6(1)(c) does not apply: no + # carer premium. Neither of reg 10A's nil awards (a sanction, or a reclaim + # under the UC Claims and Payments Regs 2013 reg 32A) arises. + period: 2025 + absolute_error_margin: 0.01 + input: + people: + carer: + age: 40 + care_hours: 35 + would_claim_carers_allowance: false + employment_income: 20_000 + benunits: + carer_unit: + members: [carer] + households: + household: + members: [carer] + country: SCOTLAND + region: SCOTLAND + output: + uc_carer_element: 201.68 * 12 + universal_credit: 0 + receives_uc_carer_element: false + is_entitled_to_carer_benefit: false + council_tax_reduction_carer_premium: 0 + council_tax_reduction_working_age_carers: 0 + +- name: A Scottish carer with both Carer Support Payment and the carer element gets one premium + # The applicant has regular and substantial caring responsibilities under + # both para 6(1)(a) and (c), and councils include the premium once for an + # applicant with those responsibilities (para 5(2)): 48.15 x 52 = + # 2,503.80, not twice that. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + carer: + age: 40 + care_hours: 35 + would_claim_carers_allowance: true + benunits: + carer_unit: + members: [carer] + households: + household: + members: [carer] + country: SCOTLAND + region: SCOTLAND + output: + receives_carer_benefit: true + receives_uc_carer_element: true + carer_premium: 48.15 * 52 + council_tax_reduction_carer_premium: 48.15 * 52 + council_tax_reduction_working_age_carers: 1 + +- name: Scottish partners caring for the same person get one premium, whichever holds the carer element + # Both care 35 hours. The younger receives Carer Support Payment and the + # joint award includes the carer element for the elder (UC Regs 2013 reg + # 29(3)). Councils include one premium under para 5(3) and (4), in respect + # of the one whose award includes the carer element: 48.15 x 52 = + # 2,503.80. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + elder: + age: 45 + care_hours: 35 + would_claim_carers_allowance: false + younger: + age: 40 + care_hours: 35 + would_claim_carers_allowance: true + benunits: + couple: + members: [elder, younger] + households: + household: + members: [elder, younger] + country: SCOTLAND + region: SCOTLAND + output: + partners_care_for_same_severely_disabled_person: true + receives_carer_benefit: [false, true] + receives_uc_carer_element: [true, false] + council_tax_reduction_carer_premium: 48.15 * 52 + council_tax_reduction_working_age_carers: 1 + +- name: Scottish partners caring for different people get a premium each, one on Carer Support Payment and one with the carer element + # Both care 35 hours, for different people. The younger receives Carer + # Support Payment, and the award includes a carer element for each (UC Regs + # 2013 reg 29(2)). Councils include the premium for each (para 5(2)): the + # elder under para 6(1)(c), the younger under para 6(1)(a), so 2 x 48.15 x + # 52 = 5,007.60. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + elder: + age: 45 + care_hours: 35 + would_claim_carers_allowance: false + younger: + age: 40 + care_hours: 35 + would_claim_carers_allowance: true + benunits: + couple: + members: [elder, younger] + partners_care_for_same_severely_disabled_person: false + households: + household: + members: [elder, younger] + country: SCOTLAND + region: SCOTLAND + output: + is_entitled_to_carer_benefit: [false, true] + receives_uc_carer_element: [true, true] + council_tax_reduction_working_age_carers: 2 + council_tax_reduction_working_age_adult_premiums: 2 * 48.15 * 52 + +- name: A Scottish pensioner's schedule has no carer element limb + # Under Scotland's pension-age scheme, councils test entitlement to Carer's + # Allowance or Carer Support Payment (SSI 2012/319 Sch 1 para 10(1)), and + # the working-age variable keeps the shared premium. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + carer: + age: 70 + care_hours: 35 + would_claim_carers_allowance: false + benunits: + carer_unit: + members: [carer] + households: + household: + members: [carer] + country: SCOTLAND + region: SCOTLAND + output: + council_tax_reduction_pensioner: true + council_tax_reduction_carer_premium: 0 + council_tax_reduction_premiums: 0 + +- name: A dependant's caring does not raise the Scottish carer premium + # Councils include the premium where "an applicant or the applicant's + # partner" has caring responsibilities (para 5(2)). The son receives Carer + # Support Payment for caring for his grandmother, but councils count only + # the applicant and partner, so his parent's family gets no carer premium + # (48.15 x 52 = 2,503.80 if his caring counted). + period: 2026 + absolute_error_margin: 0.01 + input: + people: + parent: + age: 45 + son: + age: 17 + care_hours: 35 + would_claim_carers_allowance: true + grandmother: + age: 80 + aa_category: HIGHER + benunits: + family: + members: [parent, son] + grandmother_unit: + members: [grandmother] + households: + household: + members: [parent, son, grandmother] + country: SCOTLAND + region: SCOTLAND + output: + is_claimant_or_partner: [true, false, true] + receives_carer_benefit: [false, true, false] + carer_premium: [0, 0] + council_tax_reduction_carer_premium: [0, 0] + council_tax_reduction_working_age_carers: [0, 0] diff --git a/policyengine_uk/tests/policy/baseline/household/demographic/uc_carer_element_carer_test.yaml b/policyengine_uk/tests/policy/baseline/household/demographic/uc_carer_element_carer_test.yaml new file mode 100644 index 0000000000..6e62b31464 --- /dev/null +++ b/policyengine_uk/tests/policy/baseline/household/demographic/uc_carer_element_carer_test.yaml @@ -0,0 +1,505 @@ +# DWP and councils count an award of Universal Credit which includes the +# carer element as a carer benefit in the carer condition of the legacy +# severe disability premium (HB Regs 2006 Sch 3 para 14(2)(a)(iii) and (b); +# HB(SPC) Regs 2006 Sch 3 para 6(2)) and of the Pension Credit severe +# disability addition (SPC Regs 2002 Sch I para 1(1)(a)(iii) and (b), with +# para 1(4)): they withhold the premium or addition when a carer "has an +# award of universal credit which includes the carer element in respect of +# caring for" the claimant. DWP includes the carer element for regular and +# substantial caring for a severely disabled person, whether or not the carer +# claims Carer's Allowance (UC Regs 2013 regs 29 and 30(2)). +# +# Amounts for 2026-27 (DWP benefit and pension rates 2026 to 2027; the Social +# Security Benefits Up-rating Order 2026, SI 2026/148): severe disability +# premium and addition £86.05 a week, couple premium £172.10, Carer's Allowance +# £86.45; Universal Credit standard allowance £424.90 a month (single, 25 or +# over) and £666.97 (joint, either 25 or over), carer element £209.34 a month. + +- name: A blind carer's Universal Credit carer element bars the premium of the person they care for + # The council ignores the carer, a blind non-dependant, under the + # non-dependant condition (para 14(4)(b)), and the carer's award bars the + # premium instead. Carer element 209.34 x 12 = 2,512.08; award (424.90 + + # 209.34) x 12 = 7,610.88. Without the award, the council would include the + # premium, 86.05 x 52 = 4,474.60. + period: 2026 + input: + people: + disabled: + age: 50 + pip_dl_category: STANDARD + carer: + age: 40 + is_blind: true + care_hours: 35 + would_claim_carers_allowance: false + benunits: + disabled_unit: + members: [disabled] + would_claim_uc: false + carer_unit: + members: [carer] + households: + household: + members: [disabled, carer] + country: ENGLAND + output: + uc_carer_element: [0, 2_512.08] + universal_credit: [0, 7_610.88] + has_uc_award_with_carer_element: [false, true] + is_cared_for_by_carer_benefit_recipient: [true, false] + severe_disability_premium: [0, 0] + +- name: A partner whose joint award includes the carer element leaves a couple who both qualify the single rate + # The joint award includes a carer element in respect of caring for only + # one of the couple, so the council includes one single rate, 86.05 x 52 = + # 4,474.60, and not the double rate, 172.10 x 52 = 8,949.20, that it + # includes where no one cares for either (para 14(2)(b)(iii)). Joint award + # (666.97 + 209.34) x 12 = 10,515.72. + period: 2026 + input: + people: + claimant: + age: 45 + pip_dl_category: STANDARD + partner: + age: 40 + pip_dl_category: STANDARD + care_hours: 35 + would_claim_carers_allowance: false + benunits: + couple: + members: [claimant, partner] + households: + household: + members: [claimant, partner] + country: ENGLAND + output: + uc_carer_element: 2_512.08 + universal_credit: 10_515.72 + has_uc_award_with_carer_element: [false, true] + is_cared_for_by_carer_benefit_recipient: [true, false] + severe_disability_premium: 4_474.60 + +- name: A son's Universal Credit carer element in another benefit unit bars a pensioner's severe disability addition + # DWP ignores the blind son as a resident (SPC Regs 2002 Sch I para + # 2(2)(b)), and his award with the carer element bars the addition (para + # 1(1)(a)(iii) and (4)). Without the award, DWP would include the addition, + # 86.05 x 52 = 4,474.60, and the council the pension-age Housing Benefit + # premium at the same amount (HB(SPC) Regs 2006 Sch 3 para 6(2)(a)(iii)). + period: 2026 + input: + people: + pensioner: + age: 75 + aa_category: HIGHER + son: + age: 40 + is_blind: true + care_hours: 35 + would_claim_carers_allowance: false + benunits: + pensioner_unit: + members: [pensioner] + son_unit: + members: [son] + households: + household: + members: [pensioner, son] + country: ENGLAND + output: + universal_credit: [0, 7_610.88] + has_uc_award_with_carer_element: [false, true] + is_cared_for_by_carer_benefit_recipient: [true, false] + severe_disability_minimum_guarantee_addition: [0, 0] + pension_age_severe_disability_premium: [0, 0] + +- name: A carer on both Carer's Allowance and Universal Credit counts once + # The carer receives Carer's Allowance, 86.45 x 52 = 4,495.40, and a + # Universal Credit award with the carer element, (424.90 + 209.34) x 12 - + # 4,495.40 = 3,115.48. They care for one person (SSCBA 1992 s.70(7) and + # (7ZA), (7A)), so the couple who both qualify keep one rate of the + # addition, 86.05 x 52 = 4,474.60 (SPC Regs 2002 reg 6(5)), as with the + # allowance alone. + period: 2026 + input: + people: + husband: + age: 78 + aa_category: HIGHER + wife: + age: 76 + aa_category: HIGHER + carer: + age: 40 + is_blind: true + care_hours: 35 + would_claim_carers_allowance: true + benunits: + couple: + members: [husband, wife] + carer_unit: + members: [carer] + households: + household: + members: [husband, wife, carer] + country: ENGLAND + output: + carers_allowance: [0, 0, 4_495.40] + universal_credit: [0, 3_115.48] + receives_carer_benefit: [false, false, true] + has_uc_award_with_carer_element: [false, false, true] + is_cared_for_by_carer_benefit_recipient: [true, false, false] + severe_disability_minimum_guarantee_addition: [4_474.60, 0] + +- name: A partner's carer element adds no second carer where the other partner receives the allowance for the same person + # Both partners care 35 hours; the younger claims Carer's Allowance and the + # joint award includes the carer element for the elder (UC Regs 2013 reg + # 29(3); the model takes the elder). Partners caring for the same severely + # disabled person have one relevant entitlement between them (SSCBA 1992 + # s.70(7ZA) and (7A)), so they care for one person, the disabled child, and + # not also the grandmother in another benefit unit. + period: 2026 + input: + people: + elder: + age: 45 + care_hours: 35 + would_claim_carers_allowance: false + younger: + age: 40 + care_hours: 35 + would_claim_carers_allowance: true + child: + age: 8 + dla_sc_category: MIDDLE + grandmother: + age: 80 + aa_category: HIGHER + benunits: + family: + members: [elder, younger, child] + grandmother_unit: + members: [grandmother] + households: + household: + members: [elder, younger, child, grandmother] + country: ENGLAND + output: + partners_care_for_same_severely_disabled_person: [true, true] + receives_carer_benefit: [false, true, false, false] + has_uc_award_with_carer_element: [true, false, false, false] + is_cared_for_by_carer_benefit_recipient: [false, false, true, false] + +- name: A carer whose income tapers the award to nil has no award and does not bar the premium + # The carer's maximum amount comes to (424.90 + 209.34) x 12 = 7,610.88. + # Earnings of £25,000 less income tax (25,000 - 12,570) x 0.20 = 2,486.00 + # and National Insurance (25,000 - 12,570) x 0.08 = 994.40 leave 21,519.60, + # and with no work allowance the taper takes 0.55 x 21,519.60 = 11,835.78. + # That exceeds the maximum amount, so the award comes to nil, which leaves + # no award (Welfare Reform Act 2012 s.5(1)(b); UC Regs 2013 reg 17). No one + # has an award in respect of caring for the disabled person, who keeps the + # premium, 86.05 x 52 = 4,474.60. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + disabled: + age: 50 + pip_dl_category: STANDARD + carer: + age: 40 + is_blind: true + care_hours: 35 + would_claim_carers_allowance: false + employment_income: 25_000 + benunits: + disabled_unit: + members: [disabled] + would_claim_uc: false + carer_unit: + members: [carer] + households: + household: + members: [disabled, carer] + country: ENGLAND + output: + uc_earned_income: [0, 21_519.60] + universal_credit_pre_benefit_cap: [0, 0] + universal_credit: [0, 0] + receives_uc_carer_element: [false, false] + has_uc_award_with_carer_element: [false, false] + is_cared_for_by_carer_benefit_recipient: [false, false] + severe_disability_premium: [4_474.60, 0] + +- name: A renting carer's housing costs element keeps an award that bars the premium + # The carer of the case above, earning £25,000, rents from the council at + # £6,000 a year. The housing costs element raises the maximum amount to + # 7,610.88 + 6,000 = 13,610.88, and the taper of 11,835.78 leaves an award + # of 1,775.10. The disabled person, on the PIP daily living component, + # brings no non-dependant deduction (UC Regs 2013 Sch 4 para 16(2)(e)). + # The award includes the carer element and bars the premium. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + carer: + age: 40 + is_blind: true + care_hours: 35 + would_claim_carers_allowance: false + employment_income: 25_000 + is_household_head: true + disabled: + age: 50 + pip_dl_category: STANDARD + benunits: + carer_unit: + members: [carer] + disabled_unit: + members: [disabled] + would_claim_uc: false + households: + household: + members: [carer, disabled] + country: ENGLAND + tenure_type: RENT_FROM_COUNCIL + rent: 6_000 + output: + uc_housing_costs_element: [6_000, 0] + universal_credit: [1_775.10, 0] + universal_credit_pre_benefit_cap: [1_775.10, 0] + has_uc_award_with_carer_element: [true, false] + is_cared_for_by_carer_benefit_recipient: [false, true] + severe_disability_premium: [0, 0] + +- name: A son whose income tapers the award to nil does not bar a pensioner's severe disability addition + # The son of the third case earns £20,000: less income tax 1,486.00 and + # National Insurance 594.40, the taper takes 0.55 x 17,919.60 = 9,855.78, + # more than his maximum amount, 7,610.88. He has no award, so the addition + # and the pension-age Housing Benefit premium stay at 86.05 x 52 = + # 4,474.60 (SPC Regs 2002 Sch I para 1(1)(a)(iii); HB(SPC) Regs 2006 Sch 3 + # para 6(2)(a)(iii)). + period: 2026 + absolute_error_margin: 0.01 + input: + people: + pensioner: + age: 75 + aa_category: HIGHER + son: + age: 40 + is_blind: true + care_hours: 35 + would_claim_carers_allowance: false + employment_income: 20_000 + benunits: + pensioner_unit: + members: [pensioner] + son_unit: + members: [son] + households: + household: + members: [pensioner, son] + country: ENGLAND + output: + uc_earned_income: [0, 17_919.60] + universal_credit: [0, 0] + has_uc_award_with_carer_element: [false, false] + is_cared_for_by_carer_benefit_recipient: [false, false] + severe_disability_minimum_guarantee_addition: [4_474.60, 0] + pension_age_severe_disability_premium: [4_474.60, 0] + +- name: The carer test reads a stored award as the award, even without a claim + # The carer of the first case earns £20,000, which tapers the award the + # model would work out to nil, and neither family claims. The case supplies + # Universal Credit instead: nil for the disabled person's family and £100 for + # the carer's. A stored award reads no other variable, so the carer test + # reads it (receives_uc_carer_element): the carer's award includes the + # carer element and bars the premium. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + disabled: + age: 50 + pip_dl_category: STANDARD + carer: + age: 40 + is_blind: true + care_hours: 35 + would_claim_carers_allowance: false + employment_income: 20_000 + benunits: + disabled_unit: + members: [disabled] + claims_universal_credit: false + universal_credit: 0 + carer_unit: + members: [carer] + claims_universal_credit: false + universal_credit: 100 + households: + household: + members: [disabled, carer] + country: ENGLAND + output: + receives_uc_carer_element: [false, true] + has_uc_award_with_carer_element: [false, true] + is_cared_for_by_carer_benefit_recipient: [true, false] + severe_disability_premium: [0, 0] + +- name: Without a Universal Credit claim no one has a carer element award + # The same carer as in the first case, in a family that does not claim + # Universal Credit and does not claim Carer's Allowance: no one has an award + # in respect of caring for the disabled person, who keeps the premium, + # 86.05 x 52 = 4,474.60. + period: 2026 + input: + people: + disabled: + age: 50 + pip_dl_category: STANDARD + carer: + age: 40 + is_blind: true + care_hours: 35 + would_claim_carers_allowance: false + benunits: + disabled_unit: + members: [disabled] + would_claim_uc: false + carer_unit: + members: [carer] + would_claim_uc: false + households: + household: + members: [disabled, carer] + country: ENGLAND + output: + has_uc_award_with_carer_element: [false, false] + is_cared_for_by_carer_benefit_recipient: [false, false] + severe_disability_premium: [4_474.60, 0] + +- name: A blind carer whose award comes to nil with a small housing costs element does not bar a pensioner's addition + # The household head, aged 35 and blind, has a limited capability for work + # determination, cares 35 hours a week for a pensioner aged 75 in another + # benefit unit, claims no Carer's Allowance, earns £25,000 and pays the + # council £600 a year in rent. The pensioner receives Attendance Allowance + # at the higher rate, 114.60 x 52 = 5,959.20, and £10,000 of State Pension. + # + # The carer's Universal Credit. Income tax (25,000 - 12,570) x 0.20 = + # 2,486.00 and National Insurance (25,000 - 12,570) x 0.08 = 994.40 leave + # earned income of 21,519.60. The award includes the carer element: the + # carer has no limited capability for work-related activity (UC Regs 2013 + # reg 29(4)). The pensioner brings no non-dependant deduction (Sch 4 para + # 16(2)(d)). The maximum amount comes to (424.90 + 209.34) x 12 + 600 = + # 8,210.88. With a housing costs element, DWP applies the lower work + # allowance, 427 x 12 = 5,124.00 (reg 22(2)(b)), and the taper takes + # 0.55 x (21,519.60 - 5,124.00) = 9,017.58, more than the maximum amount. + # The model caps the reduction at the maximum amount, so the award comes + # to nil and the carer has no award (Welfare Reform Act 2012 s.5(1)(b); + # reg 17). + # + # The pensioner's addition. She receives Attendance Allowance (SPC Regs + # 2002 Sch I para 1(1)(a)(i)); DWP ignores the blind carer as a resident + # (para 2(2)(b)); and no one has an award including the carer element in + # respect of caring for her (para 1(1)(a)(iii) and (4)). So DWP includes + # the addition, 86.05 x 52 = 4,474.60. + # + # Pension Credit. The minimum guarantee comes to 238.00 x 52 + 4,474.60 = + # 16,850.60. Her income for Pension Credit is the State Pension, 10,000 + # (the model counts no Attendance Allowance), so guarantee credit comes to + # 16,850.60 - 10,000 = 6,850.60. Her qualifying income, 10,000 / 52 = + # 192.31 a week, falls short of the savings credit threshold of 208.07, so + # savings credit comes to nil. + # + # Household net income. Earnings 25,000, plus State Pension 10,000, + # Attendance Allowance 5,959.20, Pension Credit 6,850.60, Winter Fuel + # Payment 200 (aged under 80, lower rate) and the Household Energy Payment + # 100 (England, the model's default band D), less income tax 2,486.00 and + # National Insurance 994.40: 44,629.40. Were the carer counted, the + # addition would fall to nil and Pension Credit to 16,850.60 - 4,474.60 - + # 10,000 = 2,376.00, and household net income to 40,154.80. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + carer: + age: 35 + is_blind: true + uc_limited_capability_for_work: true + care_hours: 35 + would_claim_carers_allowance: false + employment_income: 25_000 + is_household_head: true + pensioner: + age: 75 + aa_category: HIGHER + state_pension: 10_000 + benunits: + carer_unit: + members: [carer] + pensioner_unit: + members: [pensioner] + households: + household: + members: [carer, pensioner] + country: ENGLAND + tenure_type: RENT_FROM_COUNCIL + rent: 600 + output: + uc_earned_income_before_work_allowance: [21_519.60, 0] + uc_earned_income: [16_395.60, 0] + uc_maximum_amount: [8_210.88, 0] + uc_work_allowance: [5_124, 0] + uc_income_reduction: [8_210.88, 0] + universal_credit_pre_benefit_cap: [0, 0] + has_uc_award_with_carer_element: [false, false] + is_cared_for_by_carer_benefit_recipient: [false, false] + severe_disability_minimum_guarantee_addition: [0, 4_474.60] + minimum_guarantee: [12_376, 16_850.60] + savings_credit: [0, 0] + pension_credit: [0, 6_850.60] + household_net_income: 44_629.40 + +- name: In Northern Ireland a son's award including the carer element bars a pensioner's addition + # SR 2016/236 reg 31(7) inserted the Universal Credit words into SPC Regs + # (NI) 2003 Sch 1 para 1(1)(a)(iii), with para 1(4) defining the award by + # reference to UC Regs (NI) 2016 reg 30. The model reads the same + # parameters in Northern Ireland: Universal Credit standard allowance + # 424.90 and carer element 209.34 a month (gov.dwp.universal_credit), and + # the addition 86.05 a week + # (gov.dwp.pension_credit.guarantee_credit.severe_disability.addition). + # The pensioner, aged 75, receives Attendance Allowance at the higher rate. + # Her blind son, aged 40, cares 35 hours a week, claims no Carer's + # Allowance and has no income, so his award comes to (424.90 + 209.34) x + # 12 = 7,610.88 and includes the carer element, 209.34 x 12 = 2,512.08. + # DWP ignores him as a resident (para 2(2)(b)), but his award bars the + # addition, which would otherwise come to 86.05 x 52 = 4,474.60. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + pensioner: + age: 75 + aa_category: HIGHER + son: + age: 40 + is_blind: true + care_hours: 35 + would_claim_carers_allowance: false + benunits: + pensioner_unit: + members: [pensioner] + son_unit: + members: [son] + households: + household: + members: [pensioner, son] + country: NORTHERN_IRELAND + output: + uc_carer_element: [0, 2_512.08] + universal_credit_pre_benefit_cap: [0, 7_610.88] + has_uc_award_with_carer_element: [false, true] + is_cared_for_by_carer_benefit_recipient: [true, false] + severe_disability_minimum_guarantee_addition: [0, 0] diff --git a/policyengine_uk/tests/test_uc_carer_element_award_properties.py b/policyengine_uk/tests/test_uc_carer_element_award_properties.py new file mode 100644 index 0000000000..2528e93b13 --- /dev/null +++ b/policyengine_uk/tests/test_uc_carer_element_award_properties.py @@ -0,0 +1,887 @@ +"""Universal Credit carer-element awards as a carer benefit. + +HB Regs 2006 Sch 3 para 14(2)(a)(iii) and (b) (with the IS, JSA, ESA, +pension-age Housing Benefit and council tax reduction schedules) and SPC Regs +2002 Sch I para 1(1) and (4) withhold the severe disability premium and the +Pension Credit severe disability addition where someone "has an award of +universal credit which includes the carer element in respect of caring for" +the claimant or partner. Scotland's working-age council tax reduction (SSI +2021/249 Sch 1 paras 5 and 6(1)(c), from 1 April 2022) pays the carer premium +to an applicant or partner with such an award. + +The severe disability carer test (has_uc_award_with_carer_element) reads the +award before the benefit cap, universal_credit_pre_benefit_cap, since the cap +reads Pension Credit, or the award itself where the simulation stores it. +Scotland's carer premium reads the positive award (receives_uc_carer_element) +in every year. Each example simulates the households as drawn, and again with +has_uc_award_with_carer_element supplied as false for everyone, which leaves +receives_carer_benefit as the attribution's only source of carers. +carer_premium gives the Scottish premium's counterpart without the limb. + +Invariants, on generated households under baseline law: + +1. No change without a carer element: where no one has + has_uc_award_with_carer_element or receives_uc_carer_element, the + attribution, the severe disability premiums and the addition equal their + values without the limb, and the Scottish premium equals carer_premium, + exactly. +2. Never raises: no carer element raises the severe disability premium (the + shared, council tax reduction and pension-age premiums) or the Pension + Credit addition. +3. Never lowers, and only in Scotland: council_tax_reduction_carer_premium + never falls below carer_premium, and differs from it only for a Scottish + working-age family. +4. Bounds: the Scottish premium comes to a whole number of weekly amounts, at most + the number of claimants and partners, and at most one where partners care + for the same person; a person with both an allowance and a carer element + counts once. council_tax_reduction_working_age_carers, which Scotland's + working-age award reads, gives the same count unless the household head + applies alone. +5. The carer test is the award: has_uc_award_with_carer_element equals + receives_uc_carer_element for every person, and + universal_credit_pre_benefit_cap comes to more than nil wherever + universal_credit does, and for every family whose award includes the + carer element in respect of someone, exactly where universal_credit does. + The equality also holds where the simulation stores the award. +6. Attribution: the attribution makes no one their own carer, everyone it + counts as cared for meets Carer's Allowance's severe disability test, and + no household has more people cared for than carers (carer benefit + recipients and carer element holders). +7. No cycle: every reader calculates on one simulation, whichever the test + requests first, and also where the simulation stores the award. +8. The cut: the non-dependant deduction's Pension Credit exemption reads the + non-dependant family's Pension Credit in a branch with every housing costs + element set to nil, where the carer test reads the award without housing + costs. test_the_non_dependant_branch_reads_the_award_without_housing_costs + pins that reading in three request orders, for a household where the + branch's result changes no exemption, and + test_the_branch_decides_a_blind_partners_exemption pins a household where + the branch's result decides one. + +A reform that makes is_uc_eligible read Pension Credit would cycle through the +attribution, which reads eligibility; these tests do not cover reforms. +""" + +import numpy as np +import pytest +from hypothesis import HealthCheck, example, given, settings +from hypothesis import strategies as st + +from policyengine_uk import Simulation + +YEAR = 2026 +WEEKS = 52 +CARER_PREMIUM = 48.15 +PROPERTY_SETTINGS = settings( + max_examples=5, + deadline=None, + derandomize=True, + suppress_health_check=[HealthCheck.too_slow, HealthCheck.data_too_large], +) + +SEVERE_READERS = ( + "severe_disability_premium", + "severe_disability_premium_before_non_dependant_test", + "council_tax_reduction_severe_disability_premium", + "pension_age_severe_disability_premium", + "severe_disability_minimum_guarantee_addition", +) +CARER_READERS = ( + "carer_premium", + "council_tax_reduction_carer_premium", + "council_tax_reduction_premiums", +) +BENUNIT_READERS = SEVERE_READERS + CARER_READERS +PERSON_READERS = ( + "is_cared_for_by_carer_benefit_recipient", + "has_uc_award_with_carer_element", + "receives_uc_carer_element", +) +# Every reader of the attribution or the carer element award, and the +# programmes that read them, for the cycle check. +ALL_READERS = BENUNIT_READERS + ( + "is_cared_for_by_carer_benefit_recipient", + "has_uc_award_with_carer_element", + "receives_uc_carer_element", + "universal_credit_pre_benefit_cap", + "universal_credit", + "pension_credit", + "housing_benefit", + "income_support", + "council_tax_reduction", + "council_tax_reduction_working_age_carers", + "household_net_income", +) + + +DISABILITY = { + "none": {}, + "pip_standard": {"pip_dl_category": "STANDARD"}, + "aa_higher": {"aa_category": "HIGHER"}, + "dla_middle": {"dla_sc_category": "MIDDLE"}, +} + + +@st.composite +def adult(draw, age): + return dict( + age=draw(age), + disability=draw(st.sampled_from(["none", "none", "pip_standard", "aa_higher"])), + blind=draw(st.sampled_from([False, False, True])), + # Draw the qualifying hours with or without a Carer's Allowance claim: + # DWP includes the Universal Credit carer element without a claim and + # above the allowance's earnings limit (UC Regs 2013 reg 30(1)(a)(i) + # and (2)). + care_hours=draw(st.sampled_from([0, 35, 35])), + would_claim_carers_allowance=draw(st.booleans()), + earnings=draw(st.sampled_from([0, 0, 8_000, 25_000])), + ) + + +@st.composite +def benefit_unit(draw): + # Working-age or pension-age adults, partners within ten years of each + # other, so no adult reads as the other's child. + eldest = draw(st.integers(20, 80)) + ages = st.integers(max(18, eldest - 10), eldest) + adults = [draw(adult(st.just(eldest)))] + adults += draw(st.lists(adult(ages), max_size=1)) + children = draw( + st.lists( + st.fixed_dictionaries( + dict( + age=st.integers(0, 15), + disability=st.sampled_from(["none", "dla_middle"]), + ) + ), + max_size=1, + ) + ) + return dict(adults=adults, children=children) + + +@st.composite +def households(draw): + # DWP includes housing costs for renters and deducts an amount for each + # non-dependant in another benefit unit. + tenure, rent = draw( + st.sampled_from( + [ + ("OWNED_OUTRIGHT", 0), + ("RENT_PRIVATELY", 6_000), + ("RENT_PRIVATELY", 12_000), + ("RENT_FROM_COUNCIL", 6_000), + ] + ) + ) + return dict( + country=draw(st.sampled_from(["ENGLAND", "SCOTLAND", "WALES"])), + tenure=tenure, + rent=rent, + units=draw(st.lists(benefit_unit(), min_size=1, max_size=3)), + ) + + +def situation(population, without_limb=()): + """One situation; households in without_limb have no carer element award.""" + people, benunits, hh = {}, {}, {} + for h, household in enumerate(population): + members = [] + for u, unit in enumerate(household["units"]): + unit_members = [] + for a, p in enumerate(unit["adults"]): + name = f"h{h}_u{u}_a{a}" + people[name] = { + "age": {YEAR: p["age"]}, + "is_blind": {YEAR: p["blind"]}, + "care_hours": {YEAR: p["care_hours"]}, + "would_claim_carers_allowance": { + YEAR: p["would_claim_carers_allowance"] + }, + "employment_income": {YEAR: p["earnings"]}, + "is_claimant_or_partner": {YEAR: True}, + **{k: {YEAR: v} for k, v in DISABILITY[p["disability"]].items()}, + } + if h in without_limb: + people[name]["has_uc_award_with_carer_element"] = {YEAR: False} + unit_members.append(name) + for c, p in enumerate(unit["children"]): + name = f"h{h}_u{u}_c{c}" + people[name] = { + "age": {YEAR: p["age"]}, + "is_claimant_or_partner": {YEAR: False}, + **{k: {YEAR: v} for k, v in DISABILITY[p["disability"]].items()}, + } + unit_members.append(name) + benunits[f"h{h}_u{u}"] = {"members": unit_members} + members += unit_members + hh[f"h{h}"] = {"members": members, "country": {YEAR: household["country"]}} + if "tenure" in household: + hh[f"h{h}"]["tenure_type"] = {YEAR: household["tenure"]} + hh[f"h{h}"]["rent"] = {YEAR: household["rent"]} + return {"people": people, "benunits": benunits, "households": hh} + + +def with_and_without_limb(population, variables): + """Each variable for the households as drawn, and without the limb. + + Without the limb, a second simulation supplies + has_uc_award_with_carer_element as false for everyone: a variable supplied + for some people takes its default, not its formula, for the rest. + """ + sim = Simulation(situation=situation(population)) + sim_without = Simulation( + situation=situation(population, without_limb=range(len(population))) + ) + return sim, { + v: ( + np.asarray(sim.calculate(v, YEAR)), + np.asarray(sim_without.calculate(v, YEAR)), + ) + for v in variables + } + + +def household_index(sim, entity): + """The household each benefit unit or person belongs to, by position.""" + population = sim.populations[entity] + names = population.ids + return np.array([int(str(name).split("_")[0][1:]) for name in names]) + + +def single(age=40, **inputs): + return dict( + dict( + age=age, + disability="none", + blind=False, + care_hours=0, + would_claim_carers_allowance=False, + earnings=0, + ), + **inputs, + ) + + +EXAMPLES = [ + # A blind carer's Universal Credit carer element, in another benefit + # unit, bars the disabled person's premium. + dict( + country="ENGLAND", + units=[ + dict(adults=[single(50, disability="pip_standard")], children=[]), + dict(adults=[single(40, blind=True, care_hours=35)], children=[]), + ], + ), + # The same carer earning enough to taper the award to nil. + dict( + country="ENGLAND", + units=[ + dict(adults=[single(50, disability="pip_standard")], children=[]), + dict( + adults=[single(40, blind=True, care_hours=35, earnings=25_000)], + children=[], + ), + ], + ), + # The Scottish carer of the issue, aged 40 with 35 hours and no claim. + dict(country="SCOTLAND", units=[dict(adults=[single(care_hours=35)], children=[])]), + # A Scottish couple, one claiming the allowance, both caring. + dict( + country="SCOTLAND", + units=[ + dict( + adults=[ + single(45, care_hours=35), + single(40, care_hours=35, would_claim_carers_allowance=True), + ], + children=[dict(age=6, disability="dla_middle")], + ) + ], + ), + # A pensioner whose son, on a qualifying benefit, cares for her. + dict( + country="WALES", + units=[ + dict(adults=[single(75, disability="aa_higher")], children=[]), + dict( + adults=[single(40, disability="pip_standard", care_hours=35)], + children=[], + ), + ], + ), +] + + +def test_issue_households_read_the_carer_element_award(): + # In #2120 the blind carer's award includes the carer element, 209.34 x + # 12, so the disabled person has no severe disability premium (86.05 x 52 + # without it). In #2124 the Scottish carer's applicable amount includes + # the carer premium, (95.55 + 48.15) x 52, not 95.55 x 52. + sim = Simulation(situation=situation(EXAMPLES[:1] + EXAMPLES[2:3])) + severe = sim.calculate("severe_disability_premium", YEAR) + carer_element = sim.calculate("uc_carer_element", YEAR) + applicable = sim.calculate("council_tax_reduction_applicable_amount", YEAR) + # Benefit units: the disabled person, the blind carer, the Scottish carer. + assert carer_element == pytest.approx([0, 209.34 * 12, 209.34 * 12]) + assert severe[0] == 0 + assert applicable[2] == pytest.approx((95.55 + 48.15) * WEEKS) + + +@PROPERTY_SETTINGS +@given(st.lists(households(), min_size=1, max_size=4)) +@example(EXAMPLES) +def test_the_carer_element_limb_moves_only_its_readers_and_only_one_way(population): + variables = SEVERE_READERS + ( + "carer_premium", + "council_tax_reduction_carer_premium", + "council_tax_reduction_working_age_carers", + "council_tax_reduction_head_applies_alone", + "council_tax_reduction_pensioner", + "partners_care_for_same_severely_disabled_person", + "is_cared_for_by_carer_benefit_recipient", + "is_severely_disabled_for_carers_allowance", + "has_uc_award_with_carer_element", + "receives_uc_carer_element", + "receives_carer_benefit", + "is_claimant_or_partner", + "universal_credit_pre_benefit_cap", + "universal_credit", + "uc_carer_element", + ) + sim, values = with_and_without_limb(population, variables) + drawn = {v: pair[0] for v, pair in values.items()} + without = {v: pair[1] for v, pair in values.items()} + n_benunits = len(drawn["carer_premium"]) + benunit_household = household_index(sim, "benunit") + person_household = household_index(sim, "person") + + # 5. The carer test is the award: the award before the cap is positive + # wherever the final award is, and exactly where it is for a family whose + # award includes the carer element, so the two tests agree. + award = drawn["universal_credit_pre_benefit_cap"] + final = drawn["universal_credit"] + assert not ((final > 0) & ~(award > 0)).any() + carer_family = drawn["uc_carer_element"] > 0 + assert ((award > 0) == (final > 0))[carer_family].all() + has_award = drawn["has_uc_award_with_carer_element"] + positive_award = drawn["receives_uc_carer_element"] + assert (has_award == positive_award).all() + + # 1. No change without a carer element, household by household. + touched = list(set(person_household[has_award | positive_award])) + untouched_units = ~np.isin(benunit_household, touched) + untouched_people = ~np.isin(person_household, touched) + for v in SEVERE_READERS: + assert (drawn[v][untouched_units] == without[v][untouched_units]).all(), v + cared_for = drawn["is_cared_for_by_carer_benefit_recipient"] + cared_for_without = without["is_cared_for_by_carer_benefit_recipient"] + assert (cared_for[untouched_people] == cared_for_without[untouched_people]).all() + ctr = drawn["council_tax_reduction_carer_premium"] + shared = drawn["carer_premium"] + assert (ctr[untouched_units] == shared[untouched_units]).all() + + # 2. A carer element never raises the severe disability premium or the + # addition, and never removes anyone from the cared-for set. + for v in SEVERE_READERS: + assert (drawn[v] <= without[v]).all(), v + assert not (cared_for_without & ~cared_for).any() + + # 3. The Scottish premium never lowers the carer premium and moves it + # only in Scotland at working age. + assert (ctr >= shared).all() + countries = sim.calculate("country", YEAR) + if hasattr(countries, "decode_to_str"): + countries = countries.decode_to_str() + country = dict(zip(sim.populations["household"].ids, np.asarray(countries))) + scottish = np.array([country[f"h{h}"] == "SCOTLAND" for h in benunit_household]) + scottish_working_age = scottish & ~drawn["council_tax_reduction_pensioner"] + assert (ctr[~scottish_working_age] == shared[~scottish_working_age]).all() + + # 4. Whole weekly amounts, at most one per claimant or partner, one where + # partners care for the same person. + weekly = ctr / (CARER_PREMIUM * WEEKS) + assert np.allclose(weekly, np.round(weekly)) + benunit_position = { + name: i for i, name in enumerate(sim.populations["benunit"].ids) + } + person_benunit = [ + benunit_position[name.rsplit("_", 1)[0]] + for name in sim.populations["person"].ids + ] + claimants = np.bincount( + person_benunit, weights=drawn["is_claimant_or_partner"], minlength=n_benunits + ) + assert (np.round(weekly) <= claimants).all() + same_person = drawn["partners_care_for_same_severely_disabled_person"] + assert (np.round(weekly[same_person]) <= 1).all() + # Scotland's working-age award counts carers with its own variable. It + # assesses the applicant and partner, who are the claimant and partner + # unless the household head applies alone. + counted = scottish_working_age & ~drawn["council_tax_reduction_head_applies_alone"] + carers = drawn["council_tax_reduction_working_age_carers"] + assert (carers[counted] == np.round(weekly[counted])).all() + + # 6. Everyone cared for meets Carer's Allowance's severe disability test; no + # household has more people cared for than carers, and the attribution + # never counts a lone carer as cared for. + assert not (cared_for & ~drawn["is_severely_disabled_for_carers_allowance"]).any() + carer = drawn["receives_carer_benefit"] | has_award + for h in np.unique(person_household): + in_h = person_household == h + assert cared_for[in_h].sum() <= carer[in_h].sum() + if carer[in_h].sum() == 1: + assert not (cared_for & carer)[in_h].any() + + +READER_ORDERS = st.permutations(ALL_READERS) + + +@settings( + max_examples=3, + deadline=None, + derandomize=True, + suppress_health_check=[HealthCheck.too_slow, HealthCheck.data_too_large], +) +@given(st.lists(households(), min_size=1, max_size=3), READER_ORDERS) +@example(EXAMPLES, ALL_READERS) +@example(EXAMPLES, tuple(reversed(ALL_READERS))) +def test_every_reader_calculates_on_one_simulation_in_any_order(population, order): + # A CycleError, or the recursion it guards, would fail this test. + sim = Simulation(situation=situation(population)) + for variable in order: + values = np.asarray(sim.calculate(variable, YEAR)) + assert np.isfinite(values.astype(float)).all(), variable + + +def stored_award_situation(stored=True): + """The issue's blind carer on £20,000, which tapers the award the model + works out to nil, with neither family claiming; the situation supplies + the award instead: nil for the disabled person's family, £100 for the carer's.""" + sim_situation = situation( + [ + dict( + country="ENGLAND", + units=[ + dict(adults=[single(50, disability="pip_standard")], children=[]), + dict( + adults=[single(40, blind=True, care_hours=35, earnings=20_000)], + children=[], + ), + ], + ) + ] + ) + for unit, award in (("h0_u0", 0), ("h0_u1", 100)): + sim_situation["benunits"][unit]["claims_universal_credit"] = {YEAR: False} + if stored: + sim_situation["benunits"][unit]["universal_credit"] = {YEAR: award} + return sim_situation + + +@pytest.mark.parametrize("order", [ALL_READERS, tuple(reversed(ALL_READERS))]) +def test_a_stored_award_is_the_award_and_reads_no_cycle(order): + # A stored award reads no other variable, so the carer test reads it: the + # carer's £100 award includes the carer element and bars the disabled + # person's premium, 86.05 x 52 = 4,474.60 without it. Every reader then + # calculates on the one simulation (invariants 5 and 7). + sim = Simulation(situation=stored_award_situation()) + for variable in order: + values = np.asarray(sim.calculate(variable, YEAR)) + assert np.isfinite(values.astype(float)).all(), variable + has_award = sim.calculate("has_uc_award_with_carer_element", YEAR) + receives = sim.calculate("receives_uc_carer_element", YEAR) + assert receives.tolist() == [False, True] + assert has_award.tolist() == receives.tolist() + assert sim.calculate("is_cared_for_by_carer_benefit_recipient", YEAR).tolist() == [ + True, + False, + ] + assert sim.calculate("severe_disability_premium", YEAR).tolist() == [0, 0] + # Without the stored award neither family claims, so no one has an award. + unstored = Simulation(situation=stored_award_situation(stored=False)) + assert not unstored.calculate("has_uc_award_with_carer_element", YEAR).any() + assert unstored.calculate("severe_disability_premium", YEAR)[0] == pytest.approx( + 86.05 * WEEKS + ) + + +def test_a_reform_that_abolishes_universal_credit_leaves_no_carer_element_award(): + # A neutralized award reads no other variable and comes to nil, so no one + # has an award, and the issue's blind carer does not bar the premium. + from policyengine_core.reforms import Reform + + class AbolishUniversalCredit(Reform): + def apply(self): + self.neutralize_variable("universal_credit") + + sim = Simulation(situation=situation(EXAMPLES[:1]), reform=AbolishUniversalCredit) + assert not sim.calculate("has_uc_award_with_carer_element", YEAR).any() + assert sim.calculate("severe_disability_premium", YEAR)[0] == pytest.approx( + 86.05 * WEEKS + ) + + +def require(condition, message): + # Raise RuntimeError when a premise fails, so a failure names the premise + # apart from the premium assertion. + if not condition: + raise RuntimeError(message) + + +def non_dependant_situation(): + """A carer (40) who rents jointly with the disabled person (50) she cares + for, each liable for half of £12,000, and a blind non-dependant (30) + earning £20,000. The carer earns £27,000.""" + people = { + "carer": { + "age": {YEAR: 40}, + "care_hours": {YEAR: 35}, + "would_claim_carers_allowance": {YEAR: False}, + "employment_income": {YEAR: 27_000}, + "is_household_head": {YEAR: True}, + }, + "disabled": {"age": {YEAR: 50}, "pip_dl_category": {YEAR: "STANDARD"}}, + "non_dependant": { + "age": {YEAR: 30}, + "is_blind": {YEAR: True}, + "employment_income": {YEAR: 20_000}, + }, + } + benunits = { + "carer_unit": {"members": ["carer"], "share_of_household_rent": {YEAR: 0.5}}, + "disabled_unit": { + "members": ["disabled"], + "would_claim_uc": {YEAR: False}, + "liable_for_share_of_household_rent": {YEAR: True}, + "share_of_household_rent": {YEAR: 0.5}, + "severe_disability_premium_joint_occupier_exclusion_applies": {YEAR: True}, + }, + "non_dependant_unit": { + "members": ["non_dependant"], + "would_claim_uc": {YEAR: False}, + }, + } + household = { + "members": ["carer", "disabled", "non_dependant"], + "country": {YEAR: "ENGLAND"}, + "tenure_type": {YEAR: "RENT_PRIVATELY"}, + "rent": {YEAR: 12_000}, + } + return {"people": people, "benunits": benunits, "households": {"h": household}} + + +def tax_free_childcare_situation(): + """A blind carer (35) earning £60,000 with a child (3) in £12,000 of + childcare, and the disabled person (60) she cares for in another family + of the household.""" + people = { + "carer": { + "age": {YEAR: 35}, + "is_blind": {YEAR: True}, + "care_hours": {YEAR: 35}, + "would_claim_carers_allowance": {YEAR: False}, + "employment_income": {YEAR: 60_000}, + }, + "child": {"age": {YEAR: 3}, "childcare_expenses": {YEAR: 12_000}}, + "disabled": {"age": {YEAR: 60}, "pip_dl_category": {YEAR: "STANDARD"}}, + } + benunits = { + "carer_unit": {"members": ["carer", "child"]}, + "disabled_unit": {"members": ["disabled"], "would_claim_uc": {YEAR: False}}, + } + household = { + "members": ["carer", "child", "disabled"], + "country": {YEAR: "ENGLAND"}, + } + return {"people": people, "benunits": benunits, "households": {"h": household}} + + +def test_a_non_dependant_deduction_that_takes_the_award_to_nil_leaves_no_award(): + # DWP's deduction for the non-dependant (UC Regs 2013 Sch 4 paras 13 and + # 16; blindness brings no exemption, and para 15 does not exempt the + # carer as a renter) takes the carer's award to nil, so she has no award + # (Welfare Reform Act 2012 s.5(1)(b); reg 17). DWP does not count the + # disabled person, a joint tenant, as her non-dependant (para 9(2)(d)), + # the council does not count her as his (HB Regs 2006 reg 3(2)(d)), and a + # blind non-dependant does not bar the premium (Sch 3 para 14(4)). So he + # keeps the premium in law. + sim = Simulation(situation=non_dependant_situation()) + award = sim.calculate("universal_credit_pre_benefit_cap", YEAR) + deductions = sim.calculate("uc_non_dep_deductions", YEAR) + without_deduction = non_dependant_situation() + without_deduction["benunits"]["carer_unit"]["uc_non_dep_deductions"] = {YEAR: 0} + award_without = Simulation(situation=without_deduction).calculate( + "universal_credit_pre_benefit_cap", YEAR + ) + require(award[0] == 0 and deductions[0] > 0, "the carer's award is not nil") + require(award_without[0] > 0, "the deduction does not take it to nil") + assert not sim.calculate("has_uc_award_with_carer_element", YEAR).any() + severe = sim.calculate("severe_disability_premium", YEAR) + assert severe[1] == pytest.approx(86.05 * WEEKS) + + +def test_a_family_that_takes_tax_free_childcare_instead_has_no_award(): + # The family gets more from the Tax-Free Childcare top-up than from the + # award, so it takes no award (forgoes_universal_credit_for_tax_free_ + # childcare). No one then has an award in respect of caring for the + # disabled person, so he keeps the premium in law. + sim = Simulation(situation=tax_free_childcare_situation()) + forgoes = sim.calculate("forgoes_universal_credit_for_tax_free_childcare", YEAR) + award = sim.calculate("universal_credit_pre_benefit_cap", YEAR) + maximum = sim.calculate("uc_maximum_amount", YEAR) + reduction = sim.calculate("uc_income_reduction", YEAR) + require(forgoes[0] and award[0] == 0, "the family claims") + require(maximum[0] > reduction[0], "the award would come to nil anyway") + assert not sim.calculate("has_uc_award_with_carer_element", YEAR).any() + severe = sim.calculate("severe_disability_premium", YEAR) + assert severe[1] == pytest.approx(86.05 * WEEKS) + + +def small_housing_situation(): + """A blind carer (35) earning £25,000, whom DWP has determined to have + limited capability for work, rents from the council at £600 a year; the + disabled person (60) she cares for lives in another family of the + household.""" + people = { + "carer": { + "age": {YEAR: 35}, + "is_blind": {YEAR: True}, + "care_hours": {YEAR: 35}, + "would_claim_carers_allowance": {YEAR: False}, + "employment_income": {YEAR: 25_000}, + "uc_limited_capability_for_work": {YEAR: True}, + "is_household_head": {YEAR: True}, + }, + "disabled": {"age": {YEAR: 60}, "pip_dl_category": {YEAR: "STANDARD"}}, + } + benunits = { + "carer_unit": {"members": ["carer"]}, + "disabled_unit": {"members": ["disabled"], "would_claim_uc": {YEAR: False}}, + } + household = { + "members": ["carer", "disabled"], + "country": {YEAR: "ENGLAND"}, + "tenure_type": {YEAR: "RENT_FROM_COUNCIL"}, + "rent": {YEAR: 600}, + } + return {"people": people, "benunits": benunits, "households": {"h": household}} + + +def test_small_housing_costs_with_a_work_allowance_leave_no_award(): + # DWP has determined that the carer has limited capability for work, so + # her award has a work allowance (UC Regs 2013 reg 22(1)(b)), and she + # gets the carer element with it: DWP gives the LCWRA element in its + # place only for limited capability for work and work-related activity + # (reg 29(4)), and ignores the allowance's earnings limit and the missing + # claim (reg 30(1)(a)(i) and (2)). Her award has a housing costs element of + # £600, so DWP applies the lower work allowance, £427 a month (reg + # 22(2)(b)). The taper then exceeds the maximum amount, and the award + # comes to nil (Welfare Reform Act 2012 s.5(1)(b); reg 17), although an + # award with no housing costs element and the higher work allowance, + # £710 a month, would leave £461.10. The council + # ignores the blind carer as a resident (HB Regs 2006 Sch 3 para + # 14(4)(b)), and with no award she does not bar the premium (para + # 14(2)(a)(iii)). So the disabled person keeps the premium in law. + sim = Simulation(situation=small_housing_situation()) + award = sim.calculate("universal_credit_pre_benefit_cap", YEAR) + housing = sim.calculate("uc_housing_costs_element", YEAR) + allowance = sim.calculate("uc_work_allowance", YEAR) + deductions = sim.calculate("uc_non_dep_deductions", YEAR) + forgoes = sim.calculate("forgoes_universal_credit_for_tax_free_childcare", YEAR) + lcwra = sim.calculate("uc_LCWRA_element", YEAR) + carer_element = sim.calculate("uc_carer_element", YEAR) + require(award[0] == 0, "the carer's award is not nil") + require(housing[0] > 0 and allowance[0] == 427 * 12, "no lower work allowance") + require(deductions[0] == 0 and not forgoes[0], "another route takes it to nil") + require(lcwra[0] == 0 and carer_element[0] > 0, "the award has no carer element") + assert not sim.calculate("has_uc_award_with_carer_element", YEAR).any() + severe = sim.calculate("severe_disability_premium", YEAR) + assert severe[1] == pytest.approx(86.05 * WEEKS) + + +def veteran_situation(pension_credit=None, veteran_exempt=None, blind_partner=False): + """A blind carer (40) earning £20,000 rents from the council at £6,000 a + year as household head and cares 35 hours a week for a veteran (70) in + another family of the household, who receives armed forces independence + payment and £13,000 of State Pension. The carer claims alone, so UC Regs + 2013 Sch 4 para 15(1)(a) and (2)(a) exempt the carer, a blind single + renter, from every non-dependant deduction + (uc_non_dep_deductions_renter_exempt). pension_credit, if given, supplies + the veteran family's uc_non_dep_receives_pension_credit, which the model + otherwise reads from a branch. veteran_exempt, if given, supplies the + veteran's uc_non_dep_deduction_exempt. blind_partner adds the veteran's + blind partner (68), who receives no disability benefit, and raises the + veteran's State Pension to £21,000.""" + people = { + "carer": { + "age": {YEAR: 40}, + "is_blind": {YEAR: True}, + "care_hours": {YEAR: 35}, + "would_claim_carers_allowance": {YEAR: False}, + "employment_income": {YEAR: 20_000}, + "is_household_head": {YEAR: True}, + }, + "veteran": { + "age": {YEAR: 70}, + "armed_forces_independence_payment": {YEAR: 150 * WEEKS}, + "state_pension": {YEAR: 13_000}, + }, + } + benunits = { + "carer_unit": {"members": ["carer"]}, + "veteran_unit": {"members": ["veteran"], "would_claim_uc": {YEAR: False}}, + } + if pension_credit is not None: + benunits["veteran_unit"]["uc_non_dep_receives_pension_credit"] = { + YEAR: pension_credit + } + if veteran_exempt is not None: + people["veteran"]["uc_non_dep_deduction_exempt"] = {YEAR: veteran_exempt} + household = { + "members": ["carer", "veteran"], + "country": {YEAR: "ENGLAND"}, + "tenure_type": {YEAR: "RENT_FROM_COUNCIL"}, + "rent": {YEAR: 6_000}, + } + if blind_partner: + people["veteran"]["state_pension"] = {YEAR: 21_000} + people["partner"] = {"age": {YEAR: 68}, "is_blind": {YEAR: True}} + benunits["veteran_unit"]["members"].append("partner") + household["members"].append("partner") + return {"people": people, "benunits": benunits, "households": {"h": household}} + + +@pytest.mark.parametrize( + "first", ["universal_credit", "pension_credit", "has_uc_award_with_carer_element"] +) +def test_the_non_dependant_branch_reads_the_award_without_housing_costs(first): + # The carer's award: income tax 1,486.00 and National Insurance 594.40 + # leave earned income of 17,919.60, and the taper, 0.55 x 17,919.60 = + # 9,855.78, leaves (424.90 + 209.34) x 12 + 6,000 - 9,855.78 = 3,755.10 + # with no non-dependant deduction. The award includes the carer element, + # so the veteran, whom DWP and the model treat as severely disabled + # through armed forces independence payment, gets no severe disability + # addition. The veteran pays income tax of 86.00 and keeps 12,914.00 of + # State Pension, which exceeds the standard minimum guarantee of 238.00 + # x 52 = 12,376.00, so the veteran gets no Pension Credit. + # + # uc_non_dep_receives_pension_credit reads the veteran's Pension Credit + # in a branch with every housing costs element set to nil. There the + # carer's award, 7,610.88 - 9,855.78, comes to nil, the veteran gets the + # addition (DWP ignores a blind resident, SPC Regs 2002 Sch I para + # 2(2)(b)) and Pension Credit of (238.00 + 86.05) x 52 - 12,914.00 = + # 3,936.60, so the branch returns true. + # + # In law DWP deducts nothing for this household, on two grounds. UC Regs + # 2013 Sch 4 para 15(1)(a) and (2)(a) exempt the carer, a blind single + # renter, from every deduction. Para 16(2)(d) exempts the veteran, who + # receives "attendance allowance" under head (f) of reg 2's definition, + # armed forces independence payment. The model holds both grounds + # (uc_non_dep_deductions_renter_exempt and + # uc_receives_attendance_allowance), so the model's award and the law's + # agree at 3,755.10, and the branch's result changes neither. This test + # pins the model's figures, whichever variable the simulation requests + # first. + sim = Simulation(situation=veteran_situation()) + sim.calculate(first, YEAR) + assert sim.calculate("has_uc_award_with_carer_element", YEAR).tolist() == [ + True, + False, + ] + assert sim.calculate("pension_credit", YEAR).tolist() == [0, 0] + assert sim.calculate("uc_non_dep_receives_pension_credit", YEAR).tolist() == [ + False, + True, + ] + assert sim.calculate("uc_non_dep_deductions", YEAR)[0] == 0 + award = sim.calculate("universal_credit_pre_benefit_cap", YEAR) + assert award[0] == pytest.approx(3_755.10, abs=0.01) + # The branch's result set to its value in law, false, since the veteran + # gets no Pension Credit: the model still exempts the veteran through + # armed forces independence payment and deducts nothing. + law = Simulation(situation=veteran_situation(pension_credit=False)) + assert law.calculate("uc_non_dep_deduction_exempt", YEAR).tolist() == [ + False, + True, + ] + assert law.calculate("uc_non_dep_deductions", YEAR)[0] == 0 + law_award = law.calculate("universal_credit_pre_benefit_cap", YEAR) + assert law_award[0] == pytest.approx(3_755.10, abs=0.01) + assert law.calculate("has_uc_award_with_carer_element", YEAR)[0] + assert law.calculate("pension_credit", YEAR)[1] == 0 + # With the veteran's exemption supplied as false, the carer's own para 15 + # exemption still leaves no deduction and an award of 3,755.10 that + # includes the carer element, so the carer test and the veteran's nil + # Pension Credit do not change. + counterfactual = Simulation(situation=veteran_situation(veteran_exempt=False)) + assert counterfactual.calculate("uc_non_dep_deductions", YEAR)[0] == 0 + counterfactual_award = counterfactual.calculate( + "universal_credit_pre_benefit_cap", YEAR + ) + assert counterfactual_award[0] == pytest.approx(3_755.10, abs=0.01) + assert counterfactual.calculate("has_uc_award_with_carer_element", YEAR)[0] + assert counterfactual.calculate("pension_credit", YEAR)[1] == 0 + + +def test_the_branch_decides_a_blind_partners_exemption(): + # The veteran of the test above, now with £21,000 of State Pension and a + # blind partner (68) who receives no disability benefit. Para 16(2) + # exempts the veteran through armed forces independence payment but + # lists no blindness, so only the family's Pension Credit can exempt the + # partner, and the branch's result decides the partner's exemption. + # + # The veteran pays income tax of (21,000 - 12,570) x 0.20 - 1,260 x 0.20 + # = 1,434.00, with the partner's marriage allowance, and the couple keep + # 19,566.00, which exceeds the couple's standard minimum guarantee of + # 363.25 x 52 = 18,889.00, so the couple get no Pension Credit. In the + # branch, the carer's award comes to nil, and SPC Regs 2002 Sch I para + # 1(1)(c) gives the couple the addition (the veteran receives armed + # forces independence payment, the partner is blind, and DWP ignores the + # blind carer as a resident under para 2(2)(b)): Pension Credit comes to + # (363.25 + 86.05) x 52 - 19,566.00 = 3,797.60, the branch returns true, + # and the model exempts the partner. + # + # In law the couple get no Pension Credit, so para 16 does not exempt the + # partner, and DWP still deducts nothing, because para 15(1)(a) and (2)(a) + # exempt the carer, a blind single renter, from every deduction; the + # carer's award comes to 3,755.10, includes the carer element and leaves + # the couple without the addition. The model applies para 15 too, so with + # the branch's result supplied at its value in law, false, the partner + # loses the exemption and the model still deducts nothing. + sim = Simulation(situation=veteran_situation(blind_partner=True)) + assert sim.calculate("has_uc_award_with_carer_element", YEAR).tolist() == [ + True, + False, + False, + ] + assert sim.calculate("pension_credit", YEAR).tolist() == [0, 0] + assert sim.calculate("uc_non_dep_receives_pension_credit", YEAR).tolist() == [ + False, + True, + ] + assert sim.calculate("uc_non_dep_deduction_exempt", YEAR).tolist() == [ + False, + True, + True, + ] + assert sim.calculate("uc_non_dep_deductions", YEAR)[0] == 0 + award = sim.calculate("universal_credit_pre_benefit_cap", YEAR) + assert award[0] == pytest.approx(3_755.10, abs=0.01) + branch = Simulation(situation=veteran_situation(blind_partner=True)) + branch.set_input("uc_housing_costs_element", YEAR, [0, 0]) + assert branch.calculate("pension_credit", YEAR)[1] == pytest.approx( + 3_797.60, abs=0.01 + ) + flag_false = Simulation( + situation=veteran_situation(pension_credit=False, blind_partner=True) + ) + assert flag_false.calculate("uc_non_dep_deduction_exempt", YEAR).tolist() == [ + False, + True, + False, + ] + assert flag_false.calculate("uc_non_dep_deductions", YEAR)[0] == 0 + flag_false_award = flag_false.calculate("universal_credit_pre_benefit_cap", YEAR) + assert flag_false_award[0] == pytest.approx(3_755.10, abs=0.01) + assert flag_false.calculate("has_uc_award_with_carer_element", YEAR)[0] diff --git a/policyengine_uk/utils/supplied_inputs.py b/policyengine_uk/utils/supplied_inputs.py index 743457b074..a5d5f05ab6 100644 --- a/policyengine_uk/utils/supplied_inputs.py +++ b/policyengine_uk/utils/supplied_inputs.py @@ -109,6 +109,7 @@ "trading_loss", "uc_carer_element", "uc_LCWRA_element", + "universal_credit", "universal_childcare_entitlement", } ) diff --git a/policyengine_uk/variables/gov/dwp/pension_credit/guarantee_credit/minimum_guarantee/additional/severe_disability_minimum_guarantee_addition.py b/policyengine_uk/variables/gov/dwp/pension_credit/guarantee_credit/minimum_guarantee/additional/severe_disability_minimum_guarantee_addition.py index 56cf7b0bca..daa584b612 100644 --- a/policyengine_uk/variables/gov/dwp/pension_credit/guarantee_credit/minimum_guarantee/additional/severe_disability_minimum_guarantee_addition.py +++ b/policyengine_uk/variables/gov/dwp/pension_credit/guarantee_credit/minimum_guarantee/additional/severe_disability_minimum_guarantee_addition.py @@ -24,11 +24,17 @@ class severe_disability_minimum_guarantee_addition(Variable): "modelled: the hospital-patient deeming (para 1(2)(b)-(bd)) " "and backdating (para 1(2)(a), (c)); sight regained within 28 weeks " "(para 1(3)); polygamous marriages; and the para 2 and 3 exceptions " - "listed on is_counted_resident_for_severe_disability_addition. Whom " - "a carer benefit is paid for caring for is attributed by " - "is_cared_for_by_carer_benefit_recipient, which the legacy severe " - "disability premium shares. Blindness " - "(is_blind) is not in the survey data, so in microsimulation the " + "listed on is_counted_resident_for_severe_disability_addition. " + "is_cared_for_by_carer_benefit_recipient attributes each carer " + "benefit to the person it is paid for caring for, and the legacy " + "severe disability premium shares it. The attribution counts an award of " + "Universal Credit which includes the carer element (para 1(4)), which " + "has_uc_award_with_carer_element reads from the carer's award: a " + "carer whose award comes to nil has no award and does not bar the " + "addition. The model applies the same rule in Northern Ireland, " + "where SR 2016/236 reg 31(7) inserted the same words into SPC Regs " + "(NI) 2003 Sch 1 para 1, with the same amount parameter. " + "Blindness (is_blind) is not in the survey data, so in microsimulation the " "blind-partner route never applies and a blind resident is counted." ) entity = BenUnit @@ -40,6 +46,9 @@ class severe_disability_minimum_guarantee_addition(Variable): "https://www.legislation.gov.uk/uksi/2002/1792/schedule/I/paragraph/2", "https://www.legislation.gov.uk/uksi/2002/1792/schedule/I/paragraph/3", "https://www.legislation.gov.uk/uksi/2002/1792/regulation/6", + "https://www.legislation.gov.uk/nisr/2003/28/schedule/1/paragraph/1", + "https://www.legislation.gov.uk/nisr/2016/236/regulation/31", + "https://www.legislation.gov.uk/nisr/2016/216/regulation/30", ) def formula(benunit, period, parameters): diff --git a/policyengine_uk/variables/gov/dwp/universal_credit/carer_element/has_uc_award_with_carer_element.py b/policyengine_uk/variables/gov/dwp/universal_credit/carer_element/has_uc_award_with_carer_element.py new file mode 100644 index 0000000000..4bb7d495a5 --- /dev/null +++ b/policyengine_uk/variables/gov/dwp/universal_credit/carer_element/has_uc_award_with_carer_element.py @@ -0,0 +1,92 @@ +from policyengine_uk.model_api import * +from policyengine_uk.utils.supplied_inputs import stored_as_input + + +def award_reads_no_other_variable(simulation, period): + """Whether reading universal_credit for this period reads no other + variable: a reform neutralized it, or an input or a scenario stored its + value for the period.""" + variable = simulation.tax_benefit_system.get_variable("universal_credit") + return variable.is_neutralized or stored_as_input( + simulation.populations["benunit"], "universal_credit", period + ) + + +class has_uc_award_with_carer_element(Variable): + value_type = bool + entity = Person + label = "has a Universal Credit award with the carer element" + documentation = ( + "Whether this person has an award of Universal Credit which includes " + "the carer element (Universal Credit Regulations 2013 reg 29) in " + "respect of them: the carer condition of the legacy severe disability " + "premium (HB Regs 2006 Sch 3 para 14(2)(a)(iii) and (b)) and of the " + "Pension Credit severe disability addition (SPC Regs 2002 Sch I para " + "1(1) and (4)), through is_cared_for_by_carer_benefit_recipient. " + "An award needs an amount payable of at least one penny (Welfare " + "Reform Act 2012 s.5(1)(b) and (2)(b); UC Regs 2013 reg 17), so the " + "model counts a claimant in respect of whom the award includes the " + "carer element (uc_carer_element_included_for_claimant) only where " + "the family's award before the benefit cap " + "(universal_credit_pre_benefit_cap) comes to more than nil. That " + "award comes to nil where income tapers it to nil, after any " + "non-dependant deduction and with the work allowance that the " + "housing costs element sets, and where the family takes Tax-Free " + "Childcare instead (forgoes_universal_credit_for_tax_free_childcare). " + "The model reads the award before the cap, not universal_credit, " + "because the benefit cap reads Child Tax Credit, whose income reads " + "Pension Credit, whose addition reads this variable. The two agree " + "for an award that includes the carer element: DWP exempts it from " + "the cap (UC Regs 2013 reg 83(1)(j)), and debt deductions leave at " + "least one penny payable. The housing costs element reads the " + "non-dependant deduction. Its exemption for a non-dependant family " + "on Pension Credit (uc_non_dep_receives_pension_credit) calculates " + "that family's Pension Credit in a branch with every housing costs " + "element set to nil, and in that branch this variable reads the " + "award without housing costs. The branch decides only that " + "exemption. A member of the non-dependant family gains or loses it " + "through this variable only where the family gets Pension Credit " + "with the severe disability addition and none without it, and the " + "member has no other exemption: a blind partner under SPC Sch I para " + "1(1)(c) who receives no qualifying benefit. There the model reads " + "that member's exemption from the award without housing costs. For " + "the family to get the addition, DWP must ignore the renter as a " + "resident (SPC Sch I para 2(2)); a single renter whom DWP ignores as " + "blind or for a qualifying benefit gets UC Regs 2013 Sch 4 para 15's " + "exemption from every deduction, which the model does not hold. " + "Where an input or a scenario stores universal_credit for " + "the period, or a reform neutralizes it, reading it cannot cycle, so " + "this reads the award itself (receives_uc_carer_element). The model " + "applies the same rule in Northern Ireland, whose legislation uses " + "the same words: Welfare Reform (Northern Ireland) Order 2015 art. " + "10, UC Regs (NI) 2016 regs 17 and 30, SPC Regs (NI) 2003 Sch 1 para " + "1 as SR 2016/236 reg 31(7) amended it, and HB Regs (NI) 2006 Sch 4 " + "para 14(2)(a)(iii)." + ) + definition_period = YEAR + reference = ( + "https://www.legislation.gov.uk/uksi/2013/376/regulation/29", + "https://www.legislation.gov.uk/ukpga/2012/5/section/5", + "https://www.legislation.gov.uk/uksi/2013/376/regulation/17", + "https://www.legislation.gov.uk/uksi/2013/376/schedule/4/paragraph/16", + "https://www.legislation.gov.uk/uksi/2006/213/schedule/3/paragraph/14", + "https://www.legislation.gov.uk/uksi/2002/1792/schedule/I/paragraph/1", + "https://www.legislation.gov.uk/nisi/2015/2006/article/10", + "https://www.legislation.gov.uk/nisr/2016/216/regulation/17", + "https://www.legislation.gov.uk/nisr/2016/216/regulation/30", + "https://www.legislation.gov.uk/nisr/2016/216/schedule/4/paragraph/15", + "https://www.legislation.gov.uk/nisr/2003/28/schedule/1/paragraph/1", + "https://www.legislation.gov.uk/nisr/2016/236/regulation/31", + "https://www.legislation.gov.uk/nisr/2006/405/schedule/4/paragraph/14", + ) + + def formula(person, period, parameters): + if award_reads_no_other_variable(person.simulation, period): + return person("receives_uc_carer_element", period) + benunit = person.benunit + # The award before the cap: DWP exempts a carer-element award from + # the cap, and universal_credit's cap reads Pension Credit. + award = benunit("universal_credit_pre_benefit_cap", period) + includes_carer_element = benunit("uc_carer_element", period) > 0 + included = person("uc_carer_element_included_for_claimant", period) + return included & includes_carer_element & (award > 0) diff --git a/policyengine_uk/variables/gov/dwp/universal_credit/housing_costs_element/non_dep_deduction/uc_non_dep_receives_pension_credit.py b/policyengine_uk/variables/gov/dwp/universal_credit/housing_costs_element/non_dep_deduction/uc_non_dep_receives_pension_credit.py index a28fc45c2c..cfe0c00332 100644 --- a/policyengine_uk/variables/gov/dwp/universal_credit/housing_costs_element/non_dep_deduction/uc_non_dep_receives_pension_credit.py +++ b/policyengine_uk/variables/gov/dwp/universal_credit/housing_costs_element/non_dep_deduction/uc_non_dep_receives_pension_credit.py @@ -10,23 +10,28 @@ class uc_non_dep_receives_pension_credit(Variable): documentation = ( "Whether a family not liable for rent receives Pension Credit, for the " "Universal Credit non-dependant housing contribution exemption. Such " - "a family's own Universal Credit housing element is zero. Calculating " - "its Pension Credit in a branch with that element fixed at zero " - "therefore preserves its entitlement, including legacy-closure " - "routing, take-up, explicit inputs and frozen Pension Credit reforms. " - "It avoids evaluating a renter's own Pension Credit while calculating " - "their Universal Credit housing element. Results for families liable " - "for the household's rent (benunit_is_liable_for_household_rent) are " - "disregarded because none of their members is a non-dependant. A " - "boarder's or lodger's family is not ruled out: where a member other " - "than its claimant or partner pays, the claimant and partner can be " - "non-dependants, and keep the exemption when the family receives " - "Pension Credit. For that family the branch fixes " - "the family's Universal Credit housing element, which may cover the " - "rent it pays the householder, at nil, and computes its Pension " - "Credit there. A family whose members are all over the qualifying " - "age claims no Universal " - "Credit, so the branch gives its actual Pension Credit." + "a family's own Universal Credit housing element is zero. The formula " + "calculates its Pension Credit in a branch with every family's " + "housing costs element set to nil, which keeps the family's " + "legacy-closure routing, take-up, explicit inputs and frozen Pension " + "Credit reforms. Where the family's severe disability addition reads " + "a renter's Universal Credit award that includes the carer element, " + "the branch reads that award without housing costs, so the branch's " + "Pension Credit can differ from the family's own. The branch avoids " + "evaluating a renter's own Pension Credit while calculating their " + "Universal Credit housing element. The formula ignores the branch " + "result for a family liable for the household's rent " + "(benunit_is_liable_for_household_rent), none of whose members is a " + "non-dependant. A boarder's or lodger's family is not ruled out: where " + "a member other than its claimant or partner pays, the claimant and " + "partner can be non-dependants, and keep the exemption when the " + "family receives Pension Credit. For that family " + "the branch fixes the family's Universal Credit housing element, " + "which may cover the rent it pays the householder, at nil, and " + "computes its Pension Credit there. A family whose members are all " + "over the qualifying age claims no Universal Credit, so apart from " + "that reading of a renter's award the branch gives its actual Pension " + "Credit." ) definition_period = YEAR reference = ( @@ -36,9 +41,11 @@ class uc_non_dep_receives_pension_credit(Variable): def formula(benunit, period, parameters): # A non-dependant is not liable for the rent (Sch 4 para 9(2)(d)), - # so their own housing element is already zero. This branch keeps - # their actual Pension Credit calculation while breaking the cycle - # through the renter's UC entitlement and pension-age route. + # so their own housing element is already zero. The branch keeps + # their Pension Credit calculation and breaks the cycle through the + # renter's UC entitlement and pension-age route. Where their severe + # disability addition reads a renter's carer element, the branch + # reads the renter's award without housing costs. simulation = benunit.simulation # Income tax is independent of the UC housing element. Calculate # the earnings counterfactuals on the parent so this branch and diff --git a/policyengine_uk/variables/gov/local_authorities/council_tax_reduction/council_tax_reduction_carer_premium.py b/policyengine_uk/variables/gov/local_authorities/council_tax_reduction/council_tax_reduction_carer_premium.py new file mode 100644 index 0000000000..5ff87710cc --- /dev/null +++ b/policyengine_uk/variables/gov/local_authorities/council_tax_reduction/council_tax_reduction_carer_premium.py @@ -0,0 +1,109 @@ +from policyengine_uk.model_api import * +from policyengine_uk.variables.household.demographic.country import Country + + +class council_tax_reduction_carer_premium(Variable): + value_type = float + entity = BenUnit + label = "Working-age CTR carer premium" + documentation = ( + "The carer premium in a working-age Council Tax Reduction applicable " + "amount. Outside Scotland's working-age scheme it equals carer_premium. " + "In Scotland's scheme (SSI 2021/249 Sch 1 paras 5 and 6, from 1 April " + "2022) councils pay it in respect of each applicant or partner who " + "has regular and substantial caring responsibilities for a severely " + "disabled person. The Scottish Ministers define those in para 6(1) " + "as (a) receiving Carer's Allowance or Carer Support Payment, (b) " + "being entitled to an allowance that DWP or Social Security Scotland " + "reduces to nil under the overlapping benefits rules, or (c) having " + "an award of Universal Credit which includes the carer element. " + "carer_premium tests limbs (a) and (b) " + "(is_entitled_to_carer_benefit). For limb (c), the Scottish Ministers " + "defined an award of Universal Credit from 1 April 2022 to include " + '"a universal credit award with a value of zero" (reg 4, as SSI ' + '2022/52 reg 3 amended it), and from 1 April 2025 as "an award of ' + 'universal credit made under Part 1 of the 2012 Act" (SSI 2025/24 ' + "reg 8). An income that tapers the amount payable below one penny " + "fails a financial condition of entitlement (Welfare Reform Act 2012 " + "s.5(1)(b); UC Regs 2013 reg 17), so DWP makes no award or the award " + "ends (UC Claims and Payments Regs 2013 reg 32A(1)), and there is no " + "award to have a value of zero. The Scottish Government's policy " + "note to SSI 2025/24 confines the earlier words to an award a " + "sanction reduces to zero, and the Scottish Ministers inserted reg " + "10A to bring part of the earnings case in from 1 April 2025. So in " + "every year from 2022-23 the model reads limb (c) from the award " + "itself (receives_uc_carer_element): an award of at least one penny " + "that includes the carer element in respect of this claimant. For " + "an award that earnings end, its last assessment period and any " + "reclaim months from 2022-23 to 2024-25 remain arguable; the model " + "cannot tell that award from a first claim, on which DWP makes no " + "award. From 1 April " + "2025 the Scottish Ministers also count two nil awards as awards (reg " + "10A): one a sanction reduces to nil, and one whose claimant the " + "Secretary of State treats as reclaiming after earnings end it (UC " + "Claims and Payments Regs 2013 reg 32A). The model has neither " + "sanctions nor reclaims, so it pays no premium for those, nor for " + "a sanctioned nil award from 2022-23 to 2024-25. A person " + "with both an allowance and a carer element qualifies once: councils " + "include the premium for each applicant or partner who qualifies " + "(paras 5(2) and (3)), not for each award. Partners caring for the " + "same severely disabled person " + "get one premium (para 5(3) and (4); " + "partners_care_for_same_severely_disabled_person), as in " + "carer_premium. Councils give it, under para 5(4), in respect of the " + "one whose Universal Credit award includes the carer element first, " + "then one in receipt of an allowance, then one entitled to an " + "allowance reduced to nil; that choice does not change the amount. " + "Before 1 April 2022 councils paid the premium to persons under " + "pension age on entitlement to Carer's Allowance only (SSI 2012/303 " + "Sch 1 para 14; carer_premium_counts_uc_carer_element). Scotland's " + "working-age award reads council_tax_reduction_working_age_carers, " + "which applies the same test to the applicant and partner." + ) + definition_period = YEAR + unit = GBP + reference = ( + "https://www.legislation.gov.uk/ssi/2021/249/schedule/1/paragraph/5", + "https://www.legislation.gov.uk/ssi/2021/249/schedule/1/paragraph/6", + "https://www.legislation.gov.uk/ssi/2021/249/regulation/1", + "https://www.legislation.gov.uk/ssi/2021/249/regulation/4/2022-04-01", + "https://www.legislation.gov.uk/ssi/2022/52/regulation/3/made", + "https://www.legislation.gov.uk/ssi/2021/249/regulation/4/2025-04-01", + "https://www.legislation.gov.uk/ssi/2025/24/regulation/8/made", + "https://www.legislation.gov.uk/ssi/2021/249/regulation/10A", + "https://www.legislation.gov.uk/ssi/2012/303/schedule/1/paragraph/14/2021-04-01", + "https://www.legislation.gov.uk/uksi/2013/376/regulation/29", + "https://www.legislation.gov.uk/ukpga/2012/5/section/5", + "https://www.legislation.gov.uk/uksi/2013/376/regulation/17", + "https://www.legislation.gov.uk/uksi/2013/380/regulation/32A", + ) + + def formula(benunit, period, parameters): + carer_premium = benunit("carer_premium", period) + scotland = parameters( + period + ).gov.local_authorities.scotland.council_tax_reduction.working_age + if not scotland.carer_premium_counts_uc_carer_element: + return carer_premium + scottish_working_age = ( + benunit.household("country", period) == Country.SCOTLAND + ) & ~benunit("council_tax_reduction_pensioner", period) + person = benunit.members + claimant_or_partner = person("is_claimant_or_partner", period) + # SSI 2021/249 Sch 1 para 6(1)(c): an award of Universal Credit which + # includes the carer element. An earnings nil case has no award in + # any year (Welfare Reform Act 2012 s.5(1)(b); reg 4 and reg 10A). + carer_element_award = person("receives_uc_carer_element", period) + # Para 6(1)(a) and (b), as in carer_premium, or (c). + caring = person("is_entitled_to_carer_benefit", period) | carer_element_award + qualifying_carers = benunit.sum(claimant_or_partner & caring) + same_person = benunit("partners_care_for_same_severely_disabled_person", period) + qualifying_carers = where( + same_person, min_(qualifying_carers, 1), qualifying_carers + ) + amount = parameters(period).gov.dwp.carer_premium.single + return where( + scottish_working_age, + qualifying_carers * amount * WEEKS_IN_YEAR, + carer_premium, + ) diff --git a/policyengine_uk/variables/gov/local_authorities/council_tax_reduction/council_tax_reduction_premiums.py b/policyengine_uk/variables/gov/local_authorities/council_tax_reduction/council_tax_reduction_premiums.py index 912f2d7b63..4e449893da 100644 --- a/policyengine_uk/variables/gov/local_authorities/council_tax_reduction/council_tax_reduction_premiums.py +++ b/policyengine_uk/variables/gov/local_authorities/council_tax_reduction/council_tax_reduction_premiums.py @@ -24,6 +24,9 @@ class council_tax_reduction_premiums(Variable): "her non-dependant (everyone else in the household, since she has no " "partner or children, unless they receive a qualifying benefit or are " "blind); and the carer premium if she is entitled to a carer benefit. " + "At working age the benefit unit's carer premium comes from " + "council_tax_reduction_carer_premium, which in Scotland also counts " + "an award of Universal Credit which includes the carer element. " "Whom a carer benefit is paid for caring for comes from " "is_cared_for_by_carer_benefit_recipient, which gives a carer in her " "own benefit unit to her but a carer in another benefit unit only to " @@ -42,15 +45,18 @@ class council_tax_reduction_premiums(Variable): "https://www.legislation.gov.uk/wsi/2013/3029/schedule/1/paragraph/1", "https://www.legislation.gov.uk/uksi/2006/213/schedule/3", "https://www.legislation.gov.uk/uksi/2006/214/schedule/3", + "https://www.legislation.gov.uk/ssi/2021/249/schedule/1/paragraph/6", ) def formula(benunit, period, parameters): pensioner = benunit("council_tax_reduction_pensioner", period) # The working-age severe disability premium takes Council Tax # Reduction's own family test (council_tax_reduction_severe_disability_ - # premium, which differs from the shared premium in Scotland), and the - # enhanced disability premium the scheme's own condition - # (council_tax_reduction_enhanced_disability_premium). + # premium), and the working-age carer premium its own caring test + # (council_tax_reduction_carer_premium); both differ from the shared + # premiums only in Scotland. The enhanced disability premium takes the + # scheme's own condition (council_tax_reduction_enhanced_disability_ + # premium). benefit_unit_premiums = where( pensioner, benunit("pension_age_benefits_premiums", period), @@ -62,6 +68,10 @@ def formula(benunit, period, parameters): + ( benunit("council_tax_reduction_enhanced_disability_premium", period) - benunit("enhanced_disability_premium", period) + ) + + ( + benunit("council_tax_reduction_carer_premium", period) + - benunit("carer_premium", period) ), ) head_applies_alone = benunit("council_tax_reduction_head_applies_alone", period) @@ -94,6 +104,10 @@ def head_has(condition): ) & (others_counted == 0) ) * disability.severe_single + # A head who applies alone holds no Universal Credit award of her own + # (the benefit unit's claimant and partner hold its award), so + # Scotland's carer element limb (council_tax_reduction_carer_premium) + # never reaches her. carer_premium = ( head_has(person("is_entitled_to_carer_benefit", period)) * carer.single ) diff --git a/policyengine_uk/variables/gov/local_authorities/council_tax_reduction/working_age/council_tax_reduction_working_age_carers.py b/policyengine_uk/variables/gov/local_authorities/council_tax_reduction/working_age/council_tax_reduction_working_age_carers.py index 4ae02293f5..64fc812874 100644 --- a/policyengine_uk/variables/gov/local_authorities/council_tax_reduction/working_age/council_tax_reduction_working_age_carers.py +++ b/policyengine_uk/variables/gov/local_authorities/council_tax_reduction/working_age/council_tax_reduction_working_age_carers.py @@ -16,12 +16,14 @@ class council_tax_reduction_working_age_carers(Variable): "carer premium: entitled to Carer's Allowance or, in Scotland, Carer " "Support Payment, whether or not an overlapping benefit reduces the " "payment to nil; partners caring for the same severely disabled " - "person count once. In Scotland an award of Universal Credit that " - "includes the carer element also qualifies; when no one in the family " - "is entitled to a carer benefit, it counts as one carer." + "person count once. In Scotland from 1 April 2022 an applicant or " + "partner whose Universal Credit award includes the carer element in " + "respect of them also qualifies (receives_uc_carer_element), once " + "even with a carer benefit as well." ) definition_period = YEAR reference = ( + "https://www.legislation.gov.uk/ssi/2021/249/schedule/1/paragraph/5", "https://www.legislation.gov.uk/ssi/2021/249/schedule/1/paragraph/6", "https://www.legislation.gov.uk/wsi/2013/3029/schedule/7/paragraph/14", ) @@ -29,18 +31,22 @@ class council_tax_reduction_working_age_carers(Variable): def formula(benunit, period, parameters): person = benunit.members claimant_or_partner = working_age_applicant_or_partner(person, period) - entitled = person("is_entitled_to_carer_benefit", period) - carers = benunit.sum(claimant_or_partner & entitled) + caring = person("is_entitled_to_carer_benefit", period) + scottish_scheme = parameters( + period + ).gov.local_authorities.scotland.council_tax_reduction.working_age + if scottish_scheme.carer_premium_counts_uc_carer_element: + # An award of Universal Credit that includes the carer element + # (SSI 2021/249 Sch 1 para 6(1)(c)) brings in the claimant it is + # included for; uc_carer_element alone is the potential element. + # A person with a carer benefit as well counts once (para 5(2)). + scotland = is_scotland_scheme(benunit.household("country", period)) + caring = caring | ( + benunit.project(scotland) & person("receives_uc_carer_element", period) + ) + carers = benunit.sum(claimant_or_partner & caring) # Partners caring for the same severely disabled person get one # premium (SSI 2021/249 Sch 1 para 5(3)-(4); SSCBA s.70(7ZA) allows # one Carer's Allowance per cared-for person), as in carer_premium. same_person = benunit("partners_care_for_same_severely_disabled_person", period) - carers = where(same_person, min_(carers, 1), carers) - scotland = is_scotland_scheme(benunit.household("country", period)) - # An award of Universal Credit that includes the carer element - # (SSI 2021/249 Sch 1 para 6(1)(c)); uc_carer_element alone is the - # potential element. - uc_carer_element = (benunit("uc_carer_element", period) > 0) & benunit( - "council_tax_reduction_working_age_has_universal_credit", period - ) - return carers + (scotland & uc_carer_element & (carers == 0)) + return where(same_person, min_(carers, 1), carers) diff --git a/policyengine_uk/variables/household/demographic/carer_premium.py b/policyengine_uk/variables/household/demographic/carer_premium.py index fa9c6e1d24..6ba97fc802 100644 --- a/policyengine_uk/variables/household/demographic/carer_premium.py +++ b/policyengine_uk/variables/household/demographic/carer_premium.py @@ -25,7 +25,10 @@ class carer_premium(Variable): "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." + "from reported awards. In Scotland's working-age council tax " + "reduction, councils also pay it for an award of Universal Credit " + "which includes the carer element (council_tax_reduction_carer_premium); " + "no other scheme's carer premium has that limb." ) definition_period = YEAR reference = ( @@ -57,8 +60,10 @@ def formula(benunit, period, parameters): # tests caring responsibilities and pays each partner who qualifies. # Para 6(1) defines those as (a) receiving either allowance, (b) being # entitled to one reduced to nil by the overlapping benefits rules, or - # (c) a Universal Credit award with the carer element; the model - # applies (a) and (b) but not (c) (#2124). + # (c) a Universal Credit award with the carer element. This variable + # applies (a) and (b), which every scheme shares; Scottish working-age + # council tax reduction reads council_tax_reduction_carer_premium, + # which adds (c). claimant_or_partner = benunit.members("is_claimant_or_partner", period) entitled = benunit.members("is_entitled_to_carer_benefit", period) qualifying_carers = benunit.sum(claimant_or_partner & entitled) diff --git a/policyengine_uk/variables/household/demographic/is_cared_for_by_carer_benefit_recipient.py b/policyengine_uk/variables/household/demographic/is_cared_for_by_carer_benefit_recipient.py index 6772dfa69b..80bc7d9619 100644 --- a/policyengine_uk/variables/household/demographic/is_cared_for_by_carer_benefit_recipient.py +++ b/policyengine_uk/variables/household/demographic/is_cared_for_by_carer_benefit_recipient.py @@ -7,17 +7,21 @@ class is_cared_for_by_carer_benefit_recipient(Variable): label = "Someone receives a carer benefit for caring for this person" documentation = ( "Someone is entitled to and in receipt of Carer's Allowance or Carer " - "Support Payment in respect of caring for this person: the carer " + "Support Payment, or has an award of Universal Credit which includes " + "the carer element, in respect of caring for this person: the carer " "condition of the legacy severe disability premium (HB Regs 2006 Sch 3 " "para 14(2)(a)(iii) and (2)(b); IS, ESA and JSA alike) and of the " "Pension Credit severe disability addition (SPC Regs 2002 Sch I para " - "1(1)). The data say who receives a carer benefit but not whom they " - "care for, so each award is attributed. A carer benefit is paid for " - "caring for a person who is severely disabled for Carer's Allowance " - "(is_severely_disabled_for_carers_allowance), a carer has one award " - "(SSCBA 1992 s.70(7)), and only one person is paid for caring for the " - "same severely disabled person (s.70(7ZA) to (7ZC); both rules were " - "in s.70(7) before 16 November 2023). No one is their own carer. A " + "1(1) and (4)). The data say who receives a carer benefit but not whom " + "they care for, so the model attributes each award. DWP and Social " + "Security Scotland pay a carer benefit or carer element for caring " + "for a person severely disabled for Carer's Allowance " + "(is_severely_disabled_for_carers_allowance; UC Regs 2013 reg 30), a " + "carer has one award (SSCBA 1992 s.70(7)), and only " + "one person has an allowance or a carer element for caring for the " + "same severely disabled person (s.70(7ZA) to (7ZC) and (7A); before " + "16 November 2023, s.70(7) contained both rules). The model makes no " + "one their own carer. A " "carer cares for someone in their own benefit unit if they can: a " "claimant or partner first, then another member such as a disabled " "child. Every other carer in the household, including one left over " @@ -35,20 +39,32 @@ class is_cared_for_by_carer_benefit_recipient(Variable): "pays the single rate instead of the double rate. Where not " "everyone can have a carer, those who are not carers themselves come " "first, then person order; the number cared for in a benefit unit " - "does not depend on that choice. Carers outside the household are not " - "observed, and nor is a carer whose allowance runs on for up to eight " - "weeks after the person they cared for has died (s.70(1A)). A " - "Universal Credit award that includes the carer element also counts " - "in law but is not attributed here: " - "reading Universal Credit would be circular, because the Universal " - "Credit non-dependant deduction exemption reads Pension Credit. Such a " - "carer living in the household already bars both the premium and the " - "addition through their residence conditions unless their presence " - "is ignored. Receipt is receives_carer_benefit: a positive Carer's " - "Allowance or Carer Support Payment after the overlapping-benefit " - "adjustment. A carer whose award an overlapping benefit, such as a " - "higher State Pension, reduces to nil is entitled but not in receipt, " - "so is not attributed." + "does not depend on that choice. The model does not observe carers " + "outside the household, nor a carer whose allowance runs on for up to " + "eight weeks after the person they cared for has died (s.70(1A)). The " + "model reads receipt from receives_carer_benefit: a positive Carer's " + "Allowance or Carer " + "Support Payment after the overlapping-benefit adjustment. A carer " + "whose allowance an overlapping benefit, such as a higher State " + "Pension, reduces to nil keeps the entitlement but receives nothing, " + "so the model does not attribute the allowance. " + "has_uc_award_with_carer_element gives " + "a carer element award from the family's award before the benefit " + "cap: a carer whose award comes to nil, whether income tapers it to " + "nil or the family takes Tax-Free Childcare instead, has no award " + "(Welfare Reform Act 2012 s.5(1)(b); UC Regs 2013 reg 17), and the " + "model attributes none. The model applies the same attribution in " + "Northern Ireland (SPC Regs (NI) 2003 Sch 1 para 1(1) and (4), as SR " + "2016/236 reg 31(7) amended it; HB Regs (NI) 2006 Sch 4 para 14(2); " + "SR 2016/236 regs 26, 28, 35 and 36 insert the same words in Northern " + "Ireland's Income Support, Jobseeker's Allowance, pension-age Housing " + "Benefit and ESA schemes). A carer with both an allowance and a " + "carer element " + "counts once. Partners who care for the same severely disabled person " + "(partners_care_for_same_severely_disabled_person) have one relevant " + "entitlement between them (s.70(7ZA) and (7A)), so where one of them " + "receives a carer benefit, the other's carer element adds no second " + "carer." ) definition_period = YEAR reference = ( @@ -58,12 +74,35 @@ class is_cared_for_by_carer_benefit_recipient(Variable): "https://www.legislation.gov.uk/uksi/1987/1967/schedule/2/paragraph/13", "https://www.legislation.gov.uk/uksi/2008/794/schedule/4/paragraph/6", "https://www.legislation.gov.uk/uksi/1996/207/schedule/1/paragraph/15", + "https://www.legislation.gov.uk/uksi/2013/376/regulation/29", + "https://www.legislation.gov.uk/uksi/2013/376/regulation/30", + "https://www.legislation.gov.uk/ukpga/2012/5/section/5", + "https://www.legislation.gov.uk/uksi/2013/376/regulation/17", + "https://www.legislation.gov.uk/nisr/2003/28/schedule/1/paragraph/1", + "https://www.legislation.gov.uk/nisr/2016/236/regulation/31", + "https://www.legislation.gov.uk/nisr/2006/405/schedule/4/paragraph/14", + "https://www.legislation.gov.uk/nisr/2016/216/regulation/30", + "https://www.legislation.gov.uk/nisi/2015/2006/article/10", + "https://www.legislation.gov.uk/nisr/2016/216/regulation/17", ) def formula(person, period, parameters): claimant_or_partner = person("is_claimant_or_partner", period) could_be_cared_for = person("is_severely_disabled_for_carers_allowance", period) - carer = person("receives_carer_benefit", period) + receives = person("receives_carer_benefit", period) + # An award of Universal Credit which includes the carer element counts + # as a carer too. A partner's carer element adds no second carer for + # a couple caring for the same person where one of them receives a + # carer benefit: they have one relevant entitlement between them + # (SSCBA 1992 s.70(7ZA) and (7A)). + same_person = person.benunit( + "partners_care_for_same_severely_disabled_person", period + ) + partner_receives = person.benunit.any(claimant_or_partner & receives) + carer_element = person("has_uc_award_with_carer_element", period) & ~( + same_person & partner_receives + ) + carer = receives | carer_element age = person("age", period) # Who takes a carer when not everyone can: someone who is not a carer # themselves, then person order (get_rank breaks ties by position). diff --git a/policyengine_uk/variables/household/demographic/pension_age_severe_disability_premium.py b/policyengine_uk/variables/household/demographic/pension_age_severe_disability_premium.py index 5a41077d36..65913bcb92 100644 --- a/policyengine_uk/variables/household/demographic/pension_age_severe_disability_premium.py +++ b/policyengine_uk/variables/household/demographic/pension_age_severe_disability_premium.py @@ -19,9 +19,11 @@ class pension_age_severe_disability_premium(Variable): "its amounts and its documented assumptions: where only one partner " "qualifies and the other is blind, the qualifying partner is taken to " "claim, as a couple may agree under HB(SPC) reg 63(1) and the CTR " - "schemes (England SI 2012/2885 Sch 8 para 4(1)); carers are attributed " - "by is_cared_for_by_carer_benefit_recipient, which does not count " - "Universal Credit carer-element awards. The Pension Credit severe " + "schemes (England SI 2012/2885 Sch 8 para 4(1)). " + "is_cared_for_by_carer_benefit_recipient attributes carers, and " + "counts a Universal Credit award with the carer element only where " + "the carer's award comes to more than nil " + "(has_uc_award_with_carer_element). The Pension Credit severe " "disability addition has the same conditions apart from its wider " "residence exceptions, but its own amount parameter, so a Pension " "Credit reform does not move this premium." diff --git a/policyengine_uk/variables/household/demographic/severe_disability_premium.py b/policyengine_uk/variables/household/demographic/severe_disability_premium.py index d748f85fb4..658c8eeb5f 100644 --- a/policyengine_uk/variables/household/demographic/severe_disability_premium.py +++ b/policyengine_uk/variables/household/demographic/severe_disability_premium.py @@ -19,11 +19,14 @@ class severe_disability_premium(Variable): "for caring for them. A couple who both qualify get the double rate " "when no carer benefit is paid for either of them, the single rate " "when one is paid for only one of them, and nothing when carers are " - "paid for both. Whom a carer benefit is paid for caring for is " - "attributed by is_cared_for_by_carer_benefit_recipient, shared with " - "the Pension Credit severe disability addition; the law also counts " - "a Universal Credit award with the carer element, which the model " - "does not. Not modelled: a carer's " + "paid for both. is_cared_for_by_carer_benefit_recipient attributes " + "each carer benefit to the person it is paid for caring for, and the " + "Pension Credit severe disability addition shares it. The attribution " + "counts an award of Universal Credit which includes the carer " + "element (has_uc_award_with_carer_element). A carer whose award " + "comes to nil, after any non-dependant deduction or because the " + "family takes Tax-Free Childcare instead, does not bar the premium. " + "Not modelled: a carer's " "allowance or carer element that would be paid but for a loss of " "benefit restriction under section 6B or 7 of the Social Security " "Fraud Act 2001 also counts (HB Regs 2006 Sch 3 para 14(7), IS Regs "