Sync from GitHub (main)

src/sentinel/risk_models/__init__.py

@@ -9,6 +9,7 @@ from sentinel.risk_models.llpi import LLPiRiskModel
 from sentinel.risk_models.mrat import MRATRiskModel
 from sentinel.risk_models.pcpt import PCPTRiskModel
 from sentinel.risk_models.plcom2012 import PLCOm2012RiskModel
+from sentinel.risk_models.prostate_mortality import ProstateMortalityRiskModel
 from sentinel.risk_models.qcancer import QCancerRiskModel
 
 RISK_MODELS = [
@@ -19,6 +20,7 @@ RISK_MODELS = [
     CRCProRiskModel,
     ExtendedPBCGRiskModel,
     PCPTRiskModel,
+    ProstateMortalityRiskModel,
     QCancerRiskModel,
     ClausRiskModel,
     MRATRiskModel,

src/sentinel/risk_models/prostate_mortality.py

@@ -0,0 +1,223 @@
+"""Prostate cancer mortality prediction model.
+
+This module implements a prostate cancer-specific mortality (PCSM) and
+non-prostate cancer mortality (NPCM) prediction model for men diagnosed
+with non-metastatic prostate cancer. The model uses competing risks
+methodology to predict mortality outcomes at specified time horizons.
+"""
+
+from math import exp, log
+from typing import Annotated
+
+from pydantic import Field
+
+from sentinel.risk_models.base import RiskModel
+from sentinel.user_input import (
+    ProstateBiopsyCoresInvolved,
+    ProstateCancerTreatment,
+    PSATest,
+    Sex,
+    UserInput,
+)
+
+
+class ProstateMortalityRiskModel(RiskModel):
+    """Predict prostate cancer-specific and non-prostate cancer mortality."""
+
+    def __init__(self) -> None:
+        super().__init__("prostate_mortality")
+
+    REQUIRED_INPUTS: dict[str, tuple[type, bool]] = {
+        "demographics.age_years": (Annotated[int, Field(ge=35, le=95)], True),
+        "demographics.sex": (Sex, True),
+        "clinical_tests.psa": (PSATest, True),
+        "personal_medical_history.prostate_cancer_grade_group": (
+            Annotated[int, Field(ge=1, le=5)],
+            True,
+        ),
+        "personal_medical_history.prostate_cancer_t_stage": (
+            Annotated[int, Field(ge=1, le=4)],
+            True,
+        ),
+        "personal_medical_history.charlson_comorbidity_score": (
+            Annotated[int, Field(ge=0, le=1)],
+            False,
+        ),
+        "personal_medical_history.prostate_cancer_treatment": (
+            ProstateCancerTreatment,
+            False,
+        ),
+        "personal_medical_history.prostate_biopsy_cores_involved": (
+            ProstateBiopsyCoresInvolved,
+            False,
+        ),
+    }
+
+    def absolute_risk(self, user: UserInput, years: int = 15) -> dict[str, float]:
+        """Compute prostate cancer-specific and non-prostate cancer mortality.
+
+        Args:
+            user: The user profile with clinical data.
+            years: Time horizon for predictions (default: 15 years).
+
+        Returns:
+            Dictionary with mortality percentages for PCSM, NPCM, and overall.
+
+        Raises:
+            ValueError: If PSA value is missing or out of range.
+        """
+        if user.clinical_tests.psa is None:
+            raise ValueError("PSA test is required.")
+
+        age = float(user.demographics.age_years)
+        psa = user.clinical_tests.psa.value_ng_ml
+
+        if psa < 0 or psa > 100:
+            raise ValueError("PSA must be between 0 and 100 ng/mL.")
+
+        grade_group = user.personal_medical_history.prostate_cancer_grade_group
+        t_stage = user.personal_medical_history.prostate_cancer_t_stage
+        charlson = user.personal_medical_history.charlson_comorbidity_score or 0
+
+        treatment_map = {
+            ProstateCancerTreatment.CONSERVATIVE: 0,
+            ProstateCancerTreatment.RADICAL: 1,
+            ProstateCancerTreatment.ADT_ALONE: 3,
+            None: 0,
+        }
+        treatment = treatment_map[
+            user.personal_medical_history.prostate_cancer_treatment
+        ]
+
+        biopsy_map = {
+            ProstateBiopsyCoresInvolved.UNKNOWN: 0,
+            ProstateBiopsyCoresInvolved.LESS_THAN_50_PERCENT: 1,
+            ProstateBiopsyCoresInvolved.FIFTY_PERCENT_OR_MORE: 2,
+            None: 0,
+        }
+        biopsy50 = biopsy_map[
+            user.personal_medical_history.prostate_biopsy_cores_involved
+        ]
+
+        pi_pcsm = (
+            0.0026005 * ((age / 10) ** 3 - 341.155151)
+            + 0.185959 * (log((psa + 1) / 100) + 1.636423432)
+            + 0.1614922 * (1 if t_stage == 2 else 0)
+            + 0.39767881 * (1 if t_stage == 3 else 0)
+            + 0.6330977 * (1 if t_stage == 4 else 0)
+            + 0.2791641 * (1 if grade_group == 2 else 0)
+            + 0.5464889 * (1 if grade_group == 3 else 0)
+            + 0.7411321 * (1 if grade_group == 4 else 0)
+            + 1.367963 * (1 if grade_group == 5 else 0)
+            + -0.6837094 * (1 if treatment == 1 else 0)
+            + 0.9084921 * (1 if treatment == 3 else 0)
+            + -0.617722958 * (1 if biopsy50 == 1 else 0)
+            + 0.579225231 * (1 if biopsy50 == 2 else 0)
+        )
+
+        pi_npcm = 0.1226666 * (age - 69.87427439) + 0.6382002 * (
+            1 if charlson == 1 else 0
+        )
+
+        time_days = 365 * years
+
+        pcsm_at_t = 1 - exp(
+            -exp(pi_pcsm)
+            * exp(-16.40532 + 1.653947 * log(time_days) + 1.89e-12 * (time_days**3))
+        )
+        npcm_at_t = 1 - exp(
+            -exp(pi_npcm)
+            * exp(-12.4841 + 1.32274 * log(time_days) + 2.90e-12 * (time_days**3))
+        )
+
+        pcs_survival = 1 - pcsm_at_t
+        npc_survival = 1 - npcm_at_t
+        overall_mortality = 1 - pcs_survival * npc_survival
+        pca_proportion = (
+            pcsm_at_t / (npcm_at_t + pcsm_at_t) if (npcm_at_t + pcsm_at_t) > 0 else 0
+        )
+        predicted_pcsm = pca_proportion * overall_mortality
+        predicted_npcm = (1 - pca_proportion) * overall_mortality
+
+        return {
+            "pcsm": predicted_pcsm * 100.0,
+            "npcm": predicted_npcm * 100.0,
+            "overall": overall_mortality * 100.0,
+        }
+
+    def compute_score(self, user: UserInput) -> str:
+        """Compute the mortality prediction score.
+
+        Args:
+            user: The user profile.
+
+        Returns:
+            Formatted string with 15-year mortality predictions.
+        """
+        is_valid, errors = self.validate_inputs(user)
+        if not is_valid:
+            return f"N/A: Invalid inputs - {'; '.join(errors)}"
+
+        if user.demographics.sex != Sex.MALE:
+            return "N/A: Prostate mortality model applies to male patients only."
+
+        try:
+            risk = self.absolute_risk(user, years=15)
+        except ValueError as exc:
+            return f"N/A: {exc}"
+
+        return (
+            f"15-year PCSM: {risk['pcsm']:.1f}%, "
+            f"NPCM: {risk['npcm']:.1f}%, "
+            f"Overall: {risk['overall']:.1f}%"
+        )
+
+    def cancer_type(self) -> str:
+        """Return the cancer type handled by this model.
+
+        Returns:
+            Cancer type label.
+        """
+        return "prostate"
+
+    def description(self) -> str:
+        """Return a description of the model.
+
+        Returns:
+            Human-readable model description.
+        """
+        return (
+            "The Predict Prostate model estimates prostate cancer-specific mortality (PCSM) "
+            "and non-prostate cancer mortality (NPCM) for men diagnosed with non-metastatic "
+            "prostate cancer. The model uses competing risks methodology to account for death "
+            "from other causes and provides personalized mortality predictions at 15 years "
+            "based on age, PSA, grade group, T stage, comorbidities, and treatment."
+        )
+
+    def interpretation(self) -> str:
+        """Return interpretation guidelines for the score.
+
+        Returns:
+            User-facing interpretation guidance.
+        """
+        return (
+            "Outputs three percentages: prostate cancer-specific mortality (PCSM), "
+            "non-prostate cancer mortality (NPCM), and overall mortality at 15 years. "
+            "These predictions help inform treatment decisions by comparing conservative "
+            "management with radical treatment outcomes. Results should be interpreted "
+            "alongside clinical judgment and patient preferences."
+        )
+
+    def references(self) -> list[str]:
+        """Return academic references for the model.
+
+        Returns:
+            List of references.
+        """
+        return [
+            "Thurtle D, Bratt O, Stattin P, et al. Comparative performance and external validation "
+            "of the multivariable Predict Prostate tool for non-metastatic prostate cancer: "
+            "a study in 69,206 men from Prostate Cancer data Base Sweden (PCBaSe). "
+            "BMC Med. 2019;17:144.",
+            "Predict Prostate: https://prostate.predict.cam/tool",
+        ]

src/sentinel/user_input.py

@@ -360,13 +360,13 @@ class PSATest(StrictBaseModel):
     """PSA (Prostate-Specific Antigen) test result.
 
     Attributes:
-        value_ng_ml: PSA value in ng/mL (valid range: 0-50)
+        value_ng_ml: PSA value in ng/mL (valid range: 0-100)
         date: Date when test was performed
     """
 
     value_ng_ml: float = Field(
         ge=0,
-        le=50,
+        le=100,
         description="PSA value in ng/mL",
         examples=[2.5, 4.0, 8.5],
     )
@@ -545,6 +545,34 @@ class NSAIDUse(str, Enum):
     FORMER = "former"
 
 
+class ProstateCancerTreatment(str, Enum):
+    """Primary treatment types for prostate cancer.
+
+    Attributes:
+        CONSERVATIVE: Conservative management or active surveillance
+        RADICAL: Radical treatment (surgery or radiotherapy)
+        ADT_ALONE: Androgen deprivation therapy alone
+    """
+
+    CONSERVATIVE = "conservative"
+    RADICAL = "radical"
+    ADT_ALONE = "adt_alone"
+
+
+class ProstateBiopsyCoresInvolved(str, Enum):
+    """Percentage of prostate biopsy cores involved with cancer.
+
+    Attributes:
+        UNKNOWN: Unknown or not included
+        LESS_THAN_50_PERCENT: Less than 50% of cores involved
+        FIFTY_PERCENT_OR_MORE: 50% or more of cores involved
+    """
+
+    UNKNOWN = "unknown"
+    LESS_THAN_50_PERCENT = "less_than_50_percent"
+    FIFTY_PERCENT_OR_MORE = "50_percent_or_more"
+
+
 # ---------------------------------------------------------------------------
 # Dermatologic Enums (All converted to str, Enum)
 # ---------------------------------------------------------------------------
@@ -1060,6 +1088,37 @@ class PersonalMedicalHistory(StrictBaseModel):
         description="History of prior PSA screening tests (before current test)",
         examples=[True, False],
     )
+    prostate_cancer_grade_group: int | None = Field(
+        None,
+        ge=1,
+        le=5,
+        description="Histological grade group at diagnosis (1-5)",
+        examples=[1, 2, 3, 4, 5],
+    )
+    prostate_cancer_t_stage: int | None = Field(
+        None,
+        ge=1,
+        le=4,
+        description="Clinical T stage at diagnosis (1-4)",
+        examples=[1, 2, 3, 4],
+    )
+    charlson_comorbidity_score: int | None = Field(
+        None,
+        ge=0,
+        le=1,
+        description="Charlson comorbidity score (0=none, 1=one or more comorbidities)",
+        examples=[0, 1],
+    )
+    prostate_cancer_treatment: ProstateCancerTreatment | None = Field(
+        None,
+        description="Primary treatment received (conservative, radical, or ADT alone)",
+        examples=["conservative", "radical", "adt_alone"],
+    )
+    prostate_biopsy_cores_involved: ProstateBiopsyCoresInvolved | None = Field(
+        None,
+        description="Percentage of biopsy cores with cancer",
+        examples=["unknown", "less_than_50_percent", "50_percent_or_more"],
+    )
 
 
 # ---------------------------------------------------------------------------

tests/test_risk_models/test_prostate_mortality_model.py

@@ -0,0 +1,412 @@
+"""Tests for the Prostate Cancer Mortality prediction model.
+
+Web calculator available at: https://prostate.predict.cam/tool
+
+NOTE: This implementation is based on the Stata reference code from the published
+model. There are discrepancies with the current web calculator, particularly for
+cases with comorbidities (charlson=1), suggesting the web calculator may use an
+updated version or different calibration. Our implementation matches the Stata
+code exactly.
+"""
+
+import pytest
+
+from sentinel.risk_models.prostate_mortality import ProstateMortalityRiskModel
+from sentinel.user_input import (
+    Anthropometrics,
+    ClinicalTests,
+    Demographics,
+    Ethnicity,
+    Lifestyle,
+    PersonalMedicalHistory,
+    ProstateCancerTreatment,
+    PSATest,
+    Sex,
+    SmokingHistory,
+    SmokingStatus,
+    UserInput,
+)
+
+
+def create_test_user(
+    age: int,
+    psa: float,
+    grade_group: int,
+    t_stage: int,
+    charlson: int = 0,
+    treatment: ProstateCancerTreatment = ProstateCancerTreatment.CONSERVATIVE,
+    ethnicity: Ethnicity = Ethnicity.WHITE,
+) -> UserInput:
+    """Create a test user with specified prostate cancer parameters.
+
+    Args:
+        age: Patient age in years.
+        psa: PSA value in ng/mL.
+        grade_group: Histological grade group (1-5).
+        t_stage: Clinical T stage (1-4).
+        charlson: Charlson comorbidity score (0-1).
+        treatment: Primary treatment received.
+        ethnicity: Patient ethnicity.
+
+    Returns:
+        UserInput instance configured for prostate mortality testing.
+    """
+    return UserInput(
+        demographics=Demographics(
+            age_years=age,
+            sex=Sex.MALE,
+            ethnicity=ethnicity,
+            anthropometrics=Anthropometrics(height_cm=175.0, weight_kg=80.0),
+        ),
+        lifestyle=Lifestyle(
+            smoking=SmokingHistory(status=SmokingStatus.NEVER, pack_years=0.0),
+        ),
+        personal_medical_history=PersonalMedicalHistory(
+            prostate_cancer_grade_group=grade_group,
+            prostate_cancer_t_stage=t_stage,
+            charlson_comorbidity_score=charlson,
+            prostate_cancer_treatment=treatment,
+        ),
+        family_history=[],
+        clinical_tests=ClinicalTests(
+            psa=PSATest(value_ng_ml=psa),
+        ),
+    )
+
+
+GROUND_TRUTH_CASES = [
+    {
+        "name": "low_risk_young",
+        "age": 55,
+        "psa": 5.0,
+        "grade_group": 1,
+        "t_stage": 1,
+        "charlson": 0,
+        "treatment": ProstateCancerTreatment.CONSERVATIVE,
+        "expected_pcsm_15yr": 7.0,
+        "expected_npcm_15yr": 8.0,
+        "expected_overall_15yr": 15.0,
+    },
+    {
+        "name": "medium_risk_example",
+        "age": 65,
+        "psa": 11.0,
+        "grade_group": 4,
+        "t_stage": 2,
+        "charlson": 0,
+        "treatment": ProstateCancerTreatment.CONSERVATIVE,
+        "expected_pcsm_15yr": 19.0,
+        "expected_npcm_15yr": 26.0,
+        "expected_overall_15yr": 45.0,
+    },
+    {
+        "name": "moderate_risk",
+        "age": 60,
+        "psa": 8.0,
+        "grade_group": 3,
+        "t_stage": 2,
+        "charlson": 0,
+        "treatment": ProstateCancerTreatment.CONSERVATIVE,
+        "expected_pcsm_15yr": 15.0,
+        "expected_npcm_15yr": 15.0,
+        "expected_overall_15yr": 30.0,
+    },
+]
+
+
+class TestProstateMortalityRiskModel:
+    """Test suite for ProstateMortalityRiskModel."""
+
+    def setup_method(self) -> None:
+        """Set up test fixtures."""
+        self.model = ProstateMortalityRiskModel()
+
+    def test_metadata(self) -> None:
+        """Test model metadata including name, cancer type, and references."""
+        assert self.model.name == "prostate_mortality"
+        assert self.model.cancer_type() == "prostate"
+        assert "Predict Prostate" in self.model.description()
+        assert "PCSM" in self.model.description()
+        assert "mortality" in self.model.interpretation().lower()
+        assert len(self.model.references()) > 0
+        assert any("predict" in ref.lower() for ref in self.model.references())
+
+    def test_absolute_risk_basic(self) -> None:
+        """Test basic absolute risk calculation returns valid percentages."""
+        user = UserInput(
+            demographics=Demographics(
+                age_years=65,
+                sex=Sex.MALE,
+                ethnicity=Ethnicity.WHITE,
+                anthropometrics=Anthropometrics(height_cm=175.0, weight_kg=80.0),
+            ),
+            lifestyle=Lifestyle(
+                smoking=SmokingHistory(status=SmokingStatus.NEVER, pack_years=0.0),
+            ),
+            personal_medical_history=PersonalMedicalHistory(
+                prostate_cancer_grade_group=2,
+                prostate_cancer_t_stage=1,
+                charlson_comorbidity_score=0,
+            ),
+            family_history=[],
+            clinical_tests=ClinicalTests(
+                psa=PSATest(value_ng_ml=5.0),
+            ),
+        )
+        risks = self.model.absolute_risk(user, years=15)
+        assert risks["pcsm"] > 0
+        assert risks["npcm"] > 0
+        assert risks["overall"] > 0
+        assert risks["pcsm"] < 100
+        assert risks["npcm"] < 100
+        assert risks["overall"] <= 100
+
+    @pytest.mark.parametrize("case", GROUND_TRUTH_CASES, ids=lambda case: case["name"])
+    def test_ground_truth_cases(self, case) -> None:
+        """Test model predictions against validated web calculator results.
+
+        Args:
+            case: Test case dictionary with patient parameters and expected results.
+        """
+        if case["expected_pcsm_15yr"] is None:
+            pytest.skip("TODO: Fill in expected values from web calculator")
+
+        user = create_test_user(
+            age=case["age"],
+            psa=case["psa"],
+            grade_group=case["grade_group"],
+            t_stage=case["t_stage"],
+            charlson=case["charlson"],
+            treatment=case["treatment"],
+            ethnicity=case.get("ethnicity", Ethnicity.WHITE),
+        )
+
+        risks = self.model.absolute_risk(user, years=15)
+        assert risks["pcsm"] == pytest.approx(case["expected_pcsm_15yr"], abs=4.0)
+        assert risks["npcm"] == pytest.approx(case["expected_npcm_15yr"], abs=4.0)
+        assert risks["overall"] == pytest.approx(case["expected_overall_15yr"], abs=4.0)
+
+    def test_compute_score_with_male_user_input(self) -> None:
+        """Test compute_score returns formatted string for valid male user."""
+        user = UserInput(
+            demographics=Demographics(
+                age_years=65,
+                sex=Sex.MALE,
+                ethnicity=Ethnicity.WHITE,
+                anthropometrics=Anthropometrics(height_cm=175.0, weight_kg=80.0),
+            ),
+            lifestyle=Lifestyle(
+                smoking=SmokingHistory(status=SmokingStatus.NEVER, pack_years=0.0),
+            ),
+            personal_medical_history=PersonalMedicalHistory(
+                prostate_cancer_grade_group=2,
+                prostate_cancer_t_stage=1,
+                charlson_comorbidity_score=0,
+                prostate_cancer_treatment=ProstateCancerTreatment.CONSERVATIVE,
+            ),
+            family_history=[],
+            clinical_tests=ClinicalTests(
+                psa=PSATest(value_ng_ml=5.0),
+            ),
+        )
+
+        score = self.model.compute_score(user)
+        assert "PCSM" in score
+        assert "NPCM" in score
+        assert "Overall" in score
+        assert "%" in score
+
+    def test_compute_score_rejects_female_user(self) -> None:
+        """Test model correctly rejects female patients."""
+        user = UserInput(
+            demographics=Demographics(
+                age_years=65,
+                sex=Sex.FEMALE,
+                ethnicity=Ethnicity.WHITE,
+                anthropometrics=Anthropometrics(height_cm=165.0, weight_kg=70.0),
+            ),
+            lifestyle=Lifestyle(
+                smoking=SmokingHistory(status=SmokingStatus.NEVER, pack_years=0.0),
+            ),
+            personal_medical_history=PersonalMedicalHistory(
+                prostate_cancer_grade_group=2,
+                prostate_cancer_t_stage=1,
+            ),
+            family_history=[],
+            clinical_tests=ClinicalTests(
+                psa=PSATest(value_ng_ml=5.0),
+            ),
+        )
+
+        score = self.model.compute_score(user)
+        assert "N/A" in score
+        assert "male" in score.lower()
+
+    def test_validation_errors(self) -> None:
+        """Test validation errors for missing required fields."""
+        user = UserInput(
+            demographics=Demographics(
+                age_years=65,
+                sex=Sex.MALE,
+                ethnicity=Ethnicity.WHITE,
+                anthropometrics=Anthropometrics(height_cm=175.0, weight_kg=80.0),
+            ),
+            lifestyle=Lifestyle(
+                smoking=SmokingHistory(status=SmokingStatus.NEVER, pack_years=0.0),
+            ),
+            personal_medical_history=PersonalMedicalHistory(),
+            family_history=[],
+            clinical_tests=ClinicalTests(),
+        )
+
+        score = self.model.compute_score(user)
+        assert "N/A" in score
+        assert "Invalid" in score
+
+    def test_age_out_of_range(self) -> None:
+        """Test age outside validated range raises error."""
+        user = UserInput(
+            demographics=Demographics(
+                age_years=30,
+                sex=Sex.MALE,
+                ethnicity=Ethnicity.WHITE,
+                anthropometrics=Anthropometrics(height_cm=175.0, weight_kg=80.0),
+            ),
+            lifestyle=Lifestyle(
+                smoking=SmokingHistory(status=SmokingStatus.NEVER, pack_years=0.0),
+            ),
+            personal_medical_history=PersonalMedicalHistory(
+                prostate_cancer_grade_group=2,
+                prostate_cancer_t_stage=1,
+            ),
+            family_history=[],
+            clinical_tests=ClinicalTests(
+                psa=PSATest(value_ng_ml=5.0),
+            ),
+        )
+
+        score = self.model.compute_score(user)
+        assert "N/A" in score
+
+    def test_psa_validation(self) -> None:
+        """Test PSA value validation at boundary values."""
+        user = UserInput(
+            demographics=Demographics(
+                age_years=65,
+                sex=Sex.MALE,
+                ethnicity=Ethnicity.WHITE,
+                anthropometrics=Anthropometrics(height_cm=175.0, weight_kg=80.0),
+            ),
+            lifestyle=Lifestyle(
+                smoking=SmokingHistory(status=SmokingStatus.NEVER, pack_years=0.0),
+            ),
+            personal_medical_history=PersonalMedicalHistory(
+                prostate_cancer_grade_group=2,
+                prostate_cancer_t_stage=1,
+            ),
+            family_history=[],
+            clinical_tests=ClinicalTests(),
+        )
+
+        score = self.model.compute_score(user)
+        assert "N/A" in score
+
+    def test_competing_risks_consistency(self) -> None:
+        """Test competing risks sum correctly to overall mortality."""
+        user = UserInput(
+            demographics=Demographics(
+                age_years=65,
+                sex=Sex.MALE,
+                ethnicity=Ethnicity.WHITE,
+                anthropometrics=Anthropometrics(height_cm=175.0, weight_kg=80.0),
+            ),
+            lifestyle=Lifestyle(
+                smoking=SmokingHistory(status=SmokingStatus.NEVER, pack_years=0.0),
+            ),
+            personal_medical_history=PersonalMedicalHistory(
+                prostate_cancer_grade_group=3,
+                prostate_cancer_t_stage=2,
+                charlson_comorbidity_score=1,
+            ),
+            family_history=[],
+            clinical_tests=ClinicalTests(
+                psa=PSATest(value_ng_ml=10.0),
+            ),
+        )
+
+        risks = self.model.absolute_risk(user, years=15)
+        total = risks["pcsm"] + risks["npcm"]
+        assert total == pytest.approx(risks["overall"], abs=0.5)
+
+    def test_different_time_horizons(self) -> None:
+        """Test model predictions for different time horizons."""
+        user = UserInput(
+            demographics=Demographics(
+                age_years=65,
+                sex=Sex.MALE,
+                ethnicity=Ethnicity.WHITE,
+                anthropometrics=Anthropometrics(height_cm=175.0, weight_kg=80.0),
+            ),
+            lifestyle=Lifestyle(
+                smoking=SmokingHistory(status=SmokingStatus.NEVER, pack_years=0.0),
+            ),
+            personal_medical_history=PersonalMedicalHistory(
+                prostate_cancer_grade_group=2,
+                prostate_cancer_t_stage=1,
+            ),
+            family_history=[],
+            clinical_tests=ClinicalTests(
+                psa=PSATest(value_ng_ml=5.0),
+            ),
+        )
+
+        risk_5yr = self.model.absolute_risk(user, years=5)
+        risk_10yr = self.model.absolute_risk(user, years=10)
+        risk_15yr = self.model.absolute_risk(user, years=15)
+
+        assert risk_5yr["pcsm"] < risk_10yr["pcsm"] < risk_15yr["pcsm"]
+        assert risk_5yr["npcm"] < risk_10yr["npcm"] < risk_15yr["npcm"]
+        assert risk_5yr["overall"] < risk_10yr["overall"] < risk_15yr["overall"]
+
+    def test_treatment_effect_radical_vs_conservative(self) -> None:
+        """Test radical treatment reduces PCSM compared to conservative treatment."""
+        base_input = {
+            "demographics": Demographics(
+                age_years=65,
+                sex=Sex.MALE,
+                ethnicity=Ethnicity.WHITE,
+                anthropometrics=Anthropometrics(height_cm=175.0, weight_kg=80.0),
+            ),
+            "lifestyle": Lifestyle(
+                smoking=SmokingHistory(status=SmokingStatus.NEVER, pack_years=0.0),
+            ),
+            "family_history": [],
+            "clinical_tests": ClinicalTests(
+                psa=PSATest(value_ng_ml=10.0),
+            ),
+        }
+
+        user_conservative = UserInput(
+            **base_input,
+            personal_medical_history=PersonalMedicalHistory(
+                prostate_cancer_grade_group=3,
+                prostate_cancer_t_stage=2,
+                charlson_comorbidity_score=0,
+                prostate_cancer_treatment=ProstateCancerTreatment.CONSERVATIVE,
+            ),
+        )
+
+        user_radical = UserInput(
+            **base_input,
+            personal_medical_history=PersonalMedicalHistory(
+                prostate_cancer_grade_group=3,
+                prostate_cancer_t_stage=2,
+                charlson_comorbidity_score=0,
+                prostate_cancer_treatment=ProstateCancerTreatment.RADICAL,
+            ),
+        )
+
+        risk_conservative = self.model.absolute_risk(user_conservative, years=15)
+        risk_radical = self.model.absolute_risk(user_radical, years=15)
+
+        assert risk_radical["pcsm"] < risk_conservative["pcsm"]