policyengine-uk 2.40.1__py3-none-any.whl → 2.65.6__py3-none-any.whl

policyengine_uk/dynamics/progression.py

@@ -0,0 +1,384 @@
+"""Labour supply progression (intensive margin) dynamics module.
+
+This module handles the intensive margin of labour supply - how people adjust their
+working hours in response to policy changes. It implements the elasticity-based
+methodology from the OBR's labour supply framework.
+
+Reference: https://obr.uk/docs/dlm_uploads/NICS-Cut-Impact-on-Labour-Supply-Note.pdf
+"""
+
+import numpy as np
+import pandas as pd
+from policyengine_uk import Simulation
+
+
+def calculate_derivative(
+    sim: Simulation,
+    target_variable: str = "hbai_household_net_income",
+    input_variable: str = "employment_income",
+    year: int = 2025,
+    count_adults: int = 2,
+    delta: float = 1_000,
+) -> np.ndarray:
+    """Calculate the marginal rate of change of target variable with respect to input variable.
+
+    This function computes numerical derivatives by applying small changes to the input
+    variable and measuring the resulting change in the target variable. This is used
+    to estimate marginal tax rates and benefit withdrawal rates.
+
+    Args:
+        sim: PolicyEngine simulation object
+        target_variable: Variable to measure changes in (typically household_net_income)
+        input_variable: Variable to change (typically employment_income)
+        year: Year for calculation
+        count_adults: Number of adults to apply changes to
+        delta: Size of change to apply for derivative calculation (£)
+
+    Returns:
+        Array of marginal rates clipped between 0 and 1
+    """
+    # Get baseline values for input variable and identify adults
+    input_variable_values = sim.calculate(input_variable, year).copy()
+    adult_index = sim.calculate("adult_index")
+    entity_key = sim.tax_benefit_system.variables[input_variable].entity.key
+
+    # Calculate baseline target values
+    original_target_values = sim.calculate(
+        target_variable, year, map_to=entity_key
+    )
+    new_target_values = original_target_values.copy()
+
+    # Apply delta change to each adult sequentially to calculate marginal effects
+    for i in range(count_adults):
+        gets_pay_rise = adult_index == i + 1
+        new_input_variable_values = input_variable_values.copy()
+        new_input_variable_values[gets_pay_rise] += delta
+        sim.reset_calculations()
+        sim.set_input(input_variable, year, new_input_variable_values)
+        new_target_values[gets_pay_rise] = sim.calculate(
+            target_variable, year, map_to=entity_key
+        )[gets_pay_rise]
+
+    # Calculate marginal rate as change in target per unit change in input
+    rel_marginal_wages = (new_target_values - original_target_values) / delta
+
+    # Set non-adult observations to NaN
+    rel_marginal_wages[
+        ~pd.Series(adult_index).isin(range(1, count_adults + 1))
+    ] = np.nan
+
+    # Reset simulation to original state
+    sim.reset_calculations()
+    sim.set_input(input_variable, year, input_variable_values)
+
+    # Clip to ensure rates are between 0 and 1 (0% to 100% retention)
+    return rel_marginal_wages.round(4)
+
+
+def calculate_relative_income_change(
+    sim: Simulation,
+    target_variable: str = "hbai_household_net_income",
+    year: int = 2025,
+) -> pd.DataFrame:
+    """Calculate relative change in income between baseline and scenario.
+
+    This function compares the target variable values between the baseline
+    simulation and the reform scenario to measure the income effect of the policy.
+
+    Args:
+        sim: PolicyEngine simulation object (should have baseline attribute)
+        target_variable: Variable to measure changes in
+        year: Year for calculation
+
+    Returns:
+        DataFrame with baseline, scenario, relative change, and absolute change columns
+    """
+    # Get income values from baseline and reform scenarios
+    original_target_values = sim.baseline.calculate(
+        target_variable, year, map_to="person"
+    )
+    reformed_target_values = sim.calculate(
+        target_variable, year, map_to="person"
+    )
+    original_target_values = pd.Series(
+        original_target_values, index=reformed_target_values.index
+    )
+
+    # Calculate relative change, handling division by zero
+    rel_change = (
+        reformed_target_values - original_target_values
+    ) / original_target_values
+    rel_change[original_target_values == 0] = np.nan
+
+    # Clip extreme values and fill NaN with 0
+    rel_changes = rel_change.clip(-1, 1).fillna(0)
+
+    return pd.DataFrame(
+        {
+            "baseline": original_target_values,
+            "scenario": reformed_target_values,
+            "rel_change": rel_changes,
+            "abs_change": reformed_target_values - original_target_values,
+        }
+    )
+
+
+def calculate_derivative_change(
+    sim: Simulation,
+    target_variable: str = "hbai_household_net_income",
+    input_variable: str = "employment_income",
+    year: int = 2025,
+    count_adults: int = 2,
+    delta: float = 1_000,
+) -> pd.DataFrame:
+    """Calculate change in marginal rates between baseline and scenario.
+
+    This function computes how marginal tax rates or benefit withdrawal rates
+    change as a result of the policy reform, which drives substitution effects
+    in labour supply responses.
+
+    Args:
+        sim: PolicyEngine simulation object (should have baseline attribute)
+        target_variable: Variable to measure marginal rates for
+        input_variable: Variable to change for derivative calculation
+        year: Year for calculation
+        count_adults: Number of adults to calculate derivatives for
+        delta: Size of change for derivative calculation (£)
+
+    Returns:
+        DataFrame with baseline, scenario, relative change, and absolute change in derivatives
+    """
+    # Calculate marginal rates under baseline and reform scenarios
+    original_deriv = calculate_derivative(
+        sim=sim.baseline,
+        target_variable=target_variable,
+        input_variable=input_variable,
+        year=year,
+        count_adults=count_adults,
+        delta=delta,
+    )
+
+    reformed_deriv = calculate_derivative(
+        sim=sim,
+        target_variable=target_variable,
+        input_variable=input_variable,
+        year=year,
+        count_adults=count_adults,
+        delta=delta,
+    )
+    original_deriv = pd.Series(original_deriv, index=reformed_deriv.index)
+
+    # Calculate relative and absolute changes in marginal rates
+    rel_change = reformed_deriv / original_deriv - 1
+    abs_change = reformed_deriv - original_deriv
+
+    # Clip extreme relative changes to avoid misleading results from small baseline derivatives
+    rel_change = rel_change.clip(-1, 1)
+
+    rel_change[rel_change == np.inf] = 0
+
+    return pd.DataFrame(
+        {
+            "baseline": original_deriv,
+            "scenario": reformed_deriv,
+            "rel_change": rel_change,
+            "abs_change": abs_change,
+        }
+    ).fillna(0)
+
+
+def calculate_labour_substitution_elasticities(
+    sim: Simulation,
+) -> np.ndarray:
+    """Calculate labour supply substitution elasticities by demographic group.
+
+    Uses OBR elasticity estimates to assign substitution elasticities based on
+    gender, marital status, and presence/age of children. These elasticities
+    measure how labour supply responds to changes in marginal tax rates.
+
+    Reference: https://obr.uk/docs/dlm_uploads/NICS-Cut-Impact-on-Labour-Supply-Note.pdf
+
+    Args:
+        sim: PolicyEngine simulation object
+
+    Returns:
+        Array of substitution elasticities for each person
+    """
+    # Get demographic characteristics for elasticity assignment
+    gender = sim.calculate("gender")
+    is_married = sim.calculate("is_married", map_to="person")
+    has_children = sim.calculate("benunit_count_children", map_to="person") > 0
+    youngest_child_age = sim.calculate("youngest_child_age", map_to="person")
+
+    # Initialize elasticity array
+    elasticities = np.zeros(gender.shape, dtype=float)
+
+    # Married or cohabiting women - higher elasticities, especially with young children
+    married_women = (gender == "FEMALE") & is_married
+    elasticities[married_women & ~has_children] = 0.14  # No children
+
+    # Elasticities vary significantly by youngest child's age
+    elasticities[married_women & has_children & (youngest_child_age <= 2)] = (
+        0.301  # 0-2 years
+    )
+    elasticities[
+        married_women
+        & has_children
+        & (youngest_child_age >= 3)
+        & (youngest_child_age <= 4)
+    ] = 0.439  # 3-4 years (highest)
+    elasticities[
+        married_women
+        & has_children
+        & (youngest_child_age >= 5)
+        & (youngest_child_age <= 10)
+    ] = 0.173  # 5-10 years
+    elasticities[married_women & has_children & (youngest_child_age >= 11)] = (
+        0.160  # 11+ years
+    )
+
+    # Lone parents - lower elasticities than married women, reflecting different constraints
+    lone_parents = (gender == "FEMALE") & ~is_married & has_children
+    elasticities[lone_parents & (youngest_child_age <= 4)] = 0.094  # 0-4 years
+    elasticities[
+        lone_parents & (youngest_child_age >= 5) & (youngest_child_age <= 10)
+    ] = 0.128  # 5-10 years
+    elasticities[
+        lone_parents & (youngest_child_age >= 11) & (youngest_child_age <= 18)
+    ] = 0.136  # 11-18 years
+
+    # Men (excluding lone fathers) - moderate, consistent elasticity
+    elasticities[(gender == "MALE") & ~(~is_married & has_children)] = 0.15
+
+    # Single women without children - same as men
+    elasticities[(gender == "FEMALE") & ~is_married & ~has_children] = 0.15
+
+    return elasticities
+
+
+def calculate_labour_net_income_elasticities(
+    sim: Simulation,
+) -> np.ndarray:
+    """Calculate labour supply income elasticities by demographic group.
+
+    Uses OBR elasticity estimates to assign income elasticities based on
+    gender, marital status, and presence/age of children. These elasticities
+    measure how labour supply responds to changes in unearned income.
+
+    Reference: https://obr.uk/docs/dlm_uploads/NICS-Cut-Impact-on-Labour-Supply-Note.pdf
+    Table A2 - Income elasticities
+
+    Args:
+        sim: PolicyEngine simulation object
+
+    Returns:
+        Array of income elasticities for each person (typically negative)
+    """
+    # Get demographic characteristics for elasticity assignment
+    gender = sim.calculate("gender")
+    is_married = sim.calculate("is_married", map_to="person")
+    has_children = sim.calculate("benunit_count_children", map_to="person") > 0
+    youngest_child_age = sim.calculate("youngest_child_age", map_to="person")
+
+    # Initialize elasticity array
+    elasticities = np.zeros(gender.shape, dtype=float)
+
+    # Married or cohabiting women - negative income elasticities (normal good)
+    married_women = (gender == "FEMALE") & is_married
+    elasticities[married_women & ~has_children] = (
+        0.0  # No income effect without children
+    )
+
+    # Stronger negative income effects with younger children
+    elasticities[married_women & has_children & (youngest_child_age <= 2)] = (
+        -0.185
+    )  # 0-2 years
+    elasticities[
+        married_women
+        & has_children
+        & (youngest_child_age >= 3)
+        & (youngest_child_age <= 4)
+    ] = -0.173  # 3-4 years
+    elasticities[
+        married_women
+        & has_children
+        & (youngest_child_age >= 5)
+        & (youngest_child_age <= 10)
+    ] = -0.102  # 5-10 years
+    elasticities[married_women & has_children & (youngest_child_age >= 11)] = (
+        -0.063
+    )  # 11+ years
+
+    # Lone parents - smaller negative income effects than married women
+    lone_parents = (gender == "FEMALE") & ~is_married & has_children
+    elasticities[lone_parents & (youngest_child_age <= 4)] = (
+        -0.037
+    )  # 0-4 years
+    elasticities[
+        lone_parents & (youngest_child_age >= 5) & (youngest_child_age <= 10)
+    ] = -0.075  # 5-10 years
+    elasticities[
+        lone_parents & (youngest_child_age >= 11) & (youngest_child_age <= 18)
+    ] = -0.054  # 11-18 years
+
+    # Men (excluding lone fathers) - small negative income effect
+    elasticities[(gender == "MALE") & ~(~is_married & has_children)] = -0.05
+
+    # Single women without children - same as men
+    elasticities[(gender == "FEMALE") & ~is_married & ~has_children] = -0.05
+
+    return elasticities
+
+
+def calculate_employment_income_change(
+    employment_income: np.ndarray,
+    derivative_changes: pd.DataFrame,
+    income_changes: pd.DataFrame,
+    substitution_elasticities: np.ndarray,
+    income_elasticities: np.ndarray,
+) -> np.ndarray:
+    """Calculate total labour supply response combining substitution and income effects.
+
+    This function implements the Slutsky equation decomposition of labour supply
+    responses into substitution and income effects. The total response is the
+    sum of these two components.
+
+    Args:
+        employment_income: Baseline employment income levels
+        derivative_changes: Changes in marginal rates (substitution effect driver)
+        income_changes: Changes in income levels (income effect driver)
+        substitution_elasticities: Elasticities for substitution effects
+        income_elasticities: Elasticities for income effects
+
+    Returns:
+        Array of employment income changes due to labour supply responses
+    """
+    # Calculate substitution effect: response to changes in marginal rates
+    substitution_response = (
+        employment_income
+        * derivative_changes["wage_rel_change"]
+        * substitution_elasticities
+    )
+
+    # Calculate income effect: response to changes in unearned income
+    income_response = (
+        employment_income
+        * income_changes["income_rel_change"]
+        * income_elasticities
+    )
+
+    # Total labour supply response is sum of substitution and income effects
+    total_response = substitution_response + income_response
+
+    # No response for people with zero employment income
+    total_response[employment_income == 0] = 0
+
+    df = pd.DataFrame(
+        {
+            "substitution_response": substitution_response,
+            "income_response": income_response,
+            "total_response": total_response,
+        }
+    )
+
+    return df.fillna(0)

policyengine_uk/microsimulation.py

@@ -0,0 +1,105 @@
+# Standard library imports
+from typing import List, Optional
+
+# Third-party imports
+import numpy as np
+from microdf import MicroDataFrame, MicroSeries
+
+# PolicyEngine core imports
+from policyengine_core.tracers import SimpleTracer
+
+from .simulation import Simulation
+
+
+class Microsimulation(Simulation):
+    """Extended simulation class with weighting support for microsimulation.
+
+    Provides weighted calculations using survey weights for population-level
+    estimates and statistics.
+    """
+
+    def get_weights(
+        self, variable_name: str, period: str, map_to: Optional[str] = None
+    ) -> np.ndarray:
+        """Get weights for the specified variable's entity.
+
+        Args:
+            variable_name: Name of the variable to get weights for
+            period: Time period for the weights
+            map_to: Optional entity key to map weights to
+
+        Returns:
+            Array of weights for the entity
+        """
+        variable = self.tax_benefit_system.get_variable(variable_name)
+        entity_key = map_to or variable.entity.key
+        weight_variable_name = f"{entity_key}_weight"
+        return self.calculate(
+            weight_variable_name, period, map_to=map_to, unweighted=True
+        )
+
+    def calculate(
+        self,
+        variable_name: str,
+        period: str = None,
+        map_to: str = None,
+        decode_enums: bool = False,
+        unweighted: bool = False,
+    ):
+        tracer: SimpleTracer = self.tracer
+        result = super().calculate(
+            variable_name, period, map_to=map_to, decode_enums=decode_enums
+        )
+
+        if not unweighted and len(tracer.stack) == 0:
+            weights = self.get_weights(variable_name, period, map_to=map_to)
+            return MicroSeries(result, weights=weights)
+
+        return result
+
+    def calculate_dataframe(
+        self,
+        variable_names: List[str],
+        period: Optional[str] = None,
+        map_to: Optional[str] = None,
+        use_weights: bool = True,
+    ) -> MicroDataFrame:
+        """Calculate multiple variables as a weighted DataFrame.
+
+        Args:
+            variable_names: List of variable names to calculate
+            period: Time period for calculation
+            map_to: Optional entity key to map results to
+            use_weights: Whether to apply survey weights
+
+        Returns:
+            MicroDataFrame with calculated values and weights
+        """
+        values = super().calculate_dataframe(variable_names, period, map_to)
+        if not use_weights:
+            return values
+        weights = self.get_weights(variable_names[0], period, map_to=map_to)
+        return MicroDataFrame(values, weights=weights)
+
+    def compare(
+        self,
+        other: "Simulation",
+        variables: list[str] = None,
+        period: str = None,
+        change_only: bool = False,
+    ):
+        """Compare two simulations for a specific variable list.
+
+        Args:
+            other: Another Simulation instance to compare against
+            variables: List of variable names to compare. If None, compares all variables.
+
+        Returns:
+            DataFrame with comparison results
+        """
+        df = super().compare(
+            other, variables=variables, period=period, change_only=change_only
+        )
+        return MicroDataFrame(
+            df, weights=self.get_weights(variables[0], period)
+        )

policyengine_uk/model_api.py

@@ -2,5 +2,6 @@ from policyengine_core.model_api import *
 from policyengine_uk.entities import *
 from policyengine_core import periods
 from microdf import MicroSeries, MicroDataFrame
+from policyengine_uk.utils.scenario import Scenario
 
 GBP = "currency-GBP"

policyengine_uk/parameters/gov/boe/base_rate.yaml

@@ -0,0 +1,34 @@
+description: Bank of England base rate
+metadata:
+  label: BoE base rate
+  unit: /1
+  period: year
+  reference:
+    - title: Bank of England - Bank Rate history
+      href: https://www.bankofengland.co.uk/boeapps/database/Bank-Rate.asp
+    - title: OBR EFO November 2025 - Market expectations for Bank Rate
+      href: https://obr.uk/efo/economic-and-fiscal-outlook-november-2025/
+  documentation: |
+    The Bank of England base rate (Bank Rate).
+    Used in student loan interest calculations for Plans 1 and 4,
+    which charge the lower of RPI or (BoE base rate + 1%).
+
+    Historical values are from Bank of England data.
+    Forecast values (2025+) are based on OBR November 2025 EFO market
+    expectations: Bank Rate expected to fall from 4% to 3.6% by end-2026,
+    then gradually return to 4% by end-2030.
+
+# Historical: Bank of England outturn
+# Forecast: OBR November 2025 EFO market expectations
+values:
+  2020-01-01: 0.001  # 0.1% from March 2020
+  2021-01-01: 0.001  # 0.1% throughout
+  2022-01-01: 0.01   # Rising from 0.25% to 3.5%
+  2023-01-01: 0.0425 # Rising from 3.5% to 5.25%
+  2024-01-01: 0.0525 # 5.25% until August, then 5%
+  2025-01-01: 0.04   # 4% as of Nov 2025
+  2026-01-01: 0.036  # OBR: falls to 3.6% by end-2026
+  2027-01-01: 0.037  # OBR: gradual rise back
+  2028-01-01: 0.038  # OBR: average ~3.8% 2025-2029
+  2029-01-01: 0.039  # OBR: rising toward 4%
+  2030-01-01: 0.04   # OBR: returns to 4% by end-2030

policyengine_uk/parameters/gov/boe/index.yaml

@@ -0,0 +1,2 @@
+metadata:
+  label: Bank of England

policyengine_uk/parameters/gov/contrib/behavioral_responses/employee_salary_sacrifice_reduction_rate.yaml

@@ -0,0 +1,14 @@
+# The percentage by which employees reduce their salary sacrifice pension contributions in response to the cap.
+# - 0 = no adjustment (employees keep high salary sacrifice and pay NI on excess)
+# - 0.5 = employees reduce salary sacrifice by 50% of the excess above cap
+# - 1.0 = employees fully optimize (reduce salary sacrifice to exactly the cap)
+# Most employees would optimize their salary sacrifice to avoid NI charges by reducing it to the cap level.
+description: The percentage by which employees reduce their salary sacrifice pension contributions in response to the salary sacrifice pension cap.
+values:
+  2010-01-01: 1.0  # Default: full optimization (employees reduce to cap level)
+metadata:
+  unit: /1
+  label: Employee salary sacrifice reduction rate in response to cap
+  reference:
+    - title: "Cap on UK salary sacrifice benefits is 'short-term' choice, warn experts"
+      href: https://docs.google.com/document/d/1Rhrfrg7A_oZHudmA775otAn1EE4-YthgeyS9nL-PrE8/edit?tab=t.0

policyengine_uk/parameters/gov/contrib/behavioral_responses/salary_sacrifice_broad_base_haircut_rate.yaml

@@ -0,0 +1,22 @@
+# The rate at which ALL workers' employment income is reduced due to the salary sacrifice cap.
+# When the salary sacrifice cap is active, employers face increased NI costs on excess contributions.
+# They spread these costs across ALL employees (not just affected workers), reducing everyone's pay.
+#
+# Calculation from blog (https://policyengine.org/uk/research/uk-salary-sacrifice-cap):
+# - Total excess above £2,000 cap: £13.8 billion
+# - Employer NI on excess (at 15%): £2.1 billion
+# - Total UK employment income: ~£1.3 trillion
+# - Broad-base haircut rate: £2.1bn / £1.3tn ≈ 0.0016 (0.16%)
+#
+# This is applied to ALL workers' employment income, not just salary sacrificers.
+# The economic logic: employers cannot target only affected workers (who would negotiate
+# to recoup the loss), so they spread the cost across all employees.
+description: Rate at which all workers' employment income is reduced when salary sacrifice cap is active.
+values:
+  2010-01-01: 0.0016
+metadata:
+  unit: /1
+  label: Salary sacrifice broad-base haircut rate
+  reference:
+    - title: PolicyEngine UK Salary Sacrifice Cap Analysis
+      href: https://policyengine.org/uk/research/uk-salary-sacrifice-cap

policyengine_uk/parameters/gov/contrib/cec/state_pension_increase.yaml

@@ -1,6 +1,6 @@
 description: Increase State Pension payments by this percentage.
 values:
-  2000-01-01: 0.0
+  2000-01-01: 0
 metadata:
   unit: /1
   label: State Pension increase

policyengine_uk/parameters/gov/contrib/ubi_center/carbon_tax.yaml

@@ -7,11 +7,11 @@ consumer_incidence:
     name: carbon_tax_consumer_incidence
     unit: /1
   values:
-    2010-01-01: 1.0
+    2010-01-01: 1
 rate:
   description: Price per tonne of carbon emissions
   metadata:
     label: Carbon tax
     unit: currency-GBP
   values:
-    2010-01-01: 0.0
+    2010-01-01: 0

policyengine_uk/parameters/gov/contrib/ubi_center/land_value_tax.yaml

@@ -1,21 +1,21 @@
 rate:
   description: Tax rate on the unimproved value of land
   values:
-    2010-01-01: 0.00
+    2010-01-01: 0
   metadata:
     label: Land value tax
     unit: /1
 household_rate:
   description: Tax rate on the unimproved value of land owned by households
   values:
-    2010-01-01: 0.00
+    2010-01-01: 0
   metadata:
     label: Land value tax (households)
     unit: /1
 corporate_rate:
   description: Tax rate on the unimproved value of land owned by corporations
   values:
-    2010-01-01: 0.00
+    2010-01-01: 0
   metadata:
     label: Land value tax (corporations)
     unit: /1

policyengine_uk/parameters/gov/dcms/bbc/tv_licence/colour.yaml

@@ -1,10 +1,10 @@
 description: Full TV licence for a colour TV, before any discounts are applied.
 values:
-  2017-04-01: 147.00
-  2018-04-01: 150.50
-  2019-04-01: 154.50
-  2020-04-01: 157.50
-  2021-04-01: 159.00
+  2017-04-01: 147
+  2018-04-01: 150.5
+  2019-04-01: 154.5
+  2020-04-01: 157.5
+  2021-04-01: 159
 metadata:
   unit: currency-GBP
   period: year

policyengine_uk/parameters/gov/dfe/education_spending.yaml

@@ -1,6 +1,6 @@
 description: Total spending by the Department for Education (DfE) on state education services (£ billions). Includes both Resource Departmental Expenditure Limit and Capital Departmental Expenditure Limit, but excludes depreciation.
 values:
-  2023-01-01: 88.0
+  2023-01-01: 88
   2024-01-01: 94.9
   2025-01-01: 100.9
 metadata:

policyengine_uk/parameters/gov/dft/rail/fare_index.yaml

@@ -0,0 +1,32 @@
+description: Cumulative index of regulated rail fares under current law. Base year 2020 = 1.0. Reflects the Autumn Budget 2025 fare freeze in 2026.
+values:
+  # Base year
+  2020-01-01: 1.000
+  # 2021: +1.0% (COVID-suppressed)
+  2021-01-01: 1.010
+  # 2022: +3.8%
+  2022-01-01: 1.048
+  # 2023: +5.9%
+  2023-01-01: 1.110
+  # 2024: +4.9%
+  2024-01-01: 1.165
+  # 2025: +4.5% (March 2025 actual)
+  2025-01-01: 1.217
+  # 2026: FROZEN (Autumn Budget 2025 policy)
+  2026-01-01: 1.217
+  # 2027: +4.2% (projected - OBR RPI ~3.2% + 1%, from frozen base)
+  2027-01-01: 1.268
+  # 2028: +3.9% (projected - OBR RPI ~2.9% + 1%)
+  2028-01-01: 1.318
+  # 2029: +3.9% (projected - OBR RPI ~2.9% + 1%)
+  2029-01-01: 1.369
+metadata:
+  unit: /1
+  label: Regulated rail fare index (current law)
+  reference:
+    - title: GOV.UK Rail Fares Freeze Announcement - Autumn Budget 2025
+      href: https://www.gov.uk/government/news/rail-fares-freeze-autumn-budget-2025
+    - title: OBR Economic and Fiscal Outlook March 2025
+      href: https://obr.uk/efo/economic-and-fiscal-outlook-march-2025/
+    - title: Network Rail - How train fares are set
+      href: https://www.networkrail.co.uk/stories/how-train-fares-set/