diff --git a/changelog.d/+placeholders-own-observable.breaking.md b/changelog.d/+placeholders-own-observable.breaking.md
new file mode 100644
index 00000000..bdaea7f3
--- /dev/null
+++ b/changelog.d/+placeholders-own-observable.breaking.md
@@ -0,0 +1,8 @@
+PEtab v1 validation: `lint_problem` now reports an error for placeholder
+parameters that are model entities, condition table columns, mapping table
+entries or observable IDs, or that are used in another observable, the
+condition table or the measurement table, and for noise placeholders used in
+the observable formula
+(new `assert_placeholders_only_used_in_own_observable`).
+As `petab1to2` validates its input, it now rejects such problems
+([#605](https://github.com/PEtab-dev/libpetab-python/pull/605))
diff --git a/doc/example/example_Fujita/Fujita_model.xml b/doc/example/example_Fujita/Fujita_model.xml
index 0b1a6d60..804ffd1c 100644
--- a/doc/example/example_Fujita/Fujita_model.xml
+++ b/doc/example/example_Fujita/Fujita_model.xml
@@ -39,18 +39,6 @@
-
-
-
-
-
-
-
-
-
-
-
-
@@ -70,58 +58,6 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/petab/v1/lint.py b/petab/v1/lint.py
index d723f4a2..9d142af8 100644
--- a/petab/v1/lint.py
+++ b/petab/v1/lint.py
@@ -4,7 +4,7 @@
import logging
import numbers
import re
-from collections import Counter
+from collections import Counter, defaultdict
from collections.abc import Iterable
from typing import Any
@@ -35,6 +35,7 @@
"assert_parameter_prior_parameters_are_valid",
"assert_parameter_prior_type_is_valid",
"assert_parameter_scale_is_valid",
+ "assert_placeholders_only_used_in_own_observable",
"assert_unique_observable_ids",
"assert_unique_parameter_ids",
"check_condition_df",
@@ -349,6 +350,111 @@ def check_observable_df(observable_df: pd.DataFrame) -> None:
) from e
+def assert_placeholders_only_used_in_own_observable(
+ problem: "petab.Problem",
+) -> None:
+ """Check that placeholders are not defined or used elsewhere.
+
+ Placeholder parameters are overridden per measurement. A model entity,
+ a condition table column, a mapping table entry, or an observable with
+ the same ID conflicts with that, as does the use of the placeholder in
+ another observable, the condition table, or the measurement table.
+ Noise placeholders must not be used in the observable formula.
+ Missing tables or a missing model are skipped.
+
+ Arguments:
+ problem: PEtab problem to check
+
+ Raises:
+ AssertionError: in case of problems
+ """
+ from .observables import get_formula_placeholders
+
+ if (observable_df := problem.observable_df) is None:
+ return
+ model = problem.model
+ condition_df = problem.condition_df
+ mapping_df = problem.mapping_df
+ measurement_df = problem.measurement_df
+
+ def symbols(expression) -> set[str]:
+ if not isinstance(expression, str):
+ return set()
+ return {str(s) for s in sympify_petab(expression).free_symbols}
+
+ # placeholder -> ID of the observable that declares it
+ placeholders: dict[str, str] = {}
+ # ID -> (where it is used or defined, observable ID or None)
+ uses: dict[str, list[tuple[str, str | None]]] = defaultdict(list)
+
+ for observable_id, row in observable_df.iterrows():
+ uses[observable_id].append(("observable ID", None))
+ formula = row.get(OBSERVABLE_FORMULA)
+ noise_formula = row.get(NOISE_FORMULA)
+ formula_symbols = symbols(formula)
+ for symbol in formula_symbols | symbols(noise_formula):
+ uses[symbol].append(
+ (f"used in observable `{observable_id}`", observable_id)
+ )
+ noise_placeholders = get_formula_placeholders(
+ noise_formula, observable_id, "noise"
+ )
+ for placeholder in (
+ get_formula_placeholders(formula, observable_id, "observable")
+ + noise_placeholders
+ ):
+ placeholders[placeholder] = observable_id
+ for placeholder in formula_symbols.intersection(noise_placeholders):
+ uses[placeholder].append(("used in the observable formula", None))
+
+ if condition_df is not None:
+ for column in condition_df.columns.drop(
+ CONDITION_NAME, errors="ignore"
+ ):
+ uses[column].append(("condition table column", None))
+ for value in condition_df[column].unique():
+ for symbol in symbols(value):
+ uses[symbol].append(("used in the condition table", None))
+
+ if mapping_df is not None:
+ for petab_id in mapping_df.index:
+ uses[petab_id].append(("mapping table petabEntityId", None))
+
+ if measurement_df is not None:
+ for column in (OBSERVABLE_PARAMETERS, NOISE_PARAMETERS):
+ if column not in measurement_df:
+ continue
+ for value in measurement_df[column].unique():
+ for override in measurements.split_parameter_replacement_list(
+ value
+ ):
+ if isinstance(override, str):
+ uses[override].append(
+ ("used in the measurement table", None)
+ )
+
+ clashes = []
+ for placeholder, observable_id in placeholders.items():
+ where = [
+ use
+ for use, owner in dict.fromkeys(uses.get(placeholder, []))
+ if owner != observable_id
+ ]
+ if model is not None and model.has_entity_with_id(placeholder):
+ where.append("model entity")
+ if where:
+ clashes.append(
+ f"`{placeholder}` of observable `{observable_id}` "
+ f"({', '.join(where)})"
+ )
+
+ if clashes:
+ raise AssertionError(
+ "Placeholder parameters must only be used in their own "
+ "observable: " + "; ".join(clashes)
+ )
+
+
def assert_all_parameters_present_in_parameter_df(
parameter_df: pd.DataFrame,
model: Model,
@@ -929,6 +1035,11 @@ def lint_problem(problem: "petab.Problem") -> bool:
except AssertionError as e:
logger.error(e)
errors_occurred = True
+ try:
+ assert_placeholders_only_used_in_own_observable(problem)
+ except AssertionError as e:
+ logger.error(e)
+ errors_occurred = True
if problem.model is not None:
for obs_id in problem.observable_df.index:
if problem.model.has_entity_with_id(obs_id):
diff --git a/tests/v1/test_lint.py b/tests/v1/test_lint.py
index e0b6ae1c..e62b5505 100644
--- a/tests/v1/test_lint.py
+++ b/tests/v1/test_lint.py
@@ -610,6 +610,166 @@ def test_check_observable_df():
lint.check_observable_df(bad_observable_df)
+def _placeholder_problem(
+ model: str = "species x = 1; k = 1; p = 1",
+) -> petab.Problem:
+ """A valid problem with placeholders of observable `obs1`."""
+ from petab.v1.models.sbml_model import SbmlModel
+
+ return petab.Problem(
+ model=SbmlModel.from_antimony(model),
+ condition_df=pd.DataFrame(
+ {CONDITION_ID: ["c1"], "k": [1.0]}
+ ).set_index(CONDITION_ID),
+ observable_df=pd.DataFrame(
+ {
+ OBSERVABLE_ID: ["obs1"],
+ OBSERVABLE_FORMULA: ["observableParameter1_obs1 * x"],
+ NOISE_FORMULA: ["noiseParameter1_obs1"],
+ }
+ ).set_index(OBSERVABLE_ID),
+ measurement_df=pd.DataFrame(
+ {
+ OBSERVABLE_ID: ["obs1"],
+ SIMULATION_CONDITION_ID: ["c1"],
+ TIME: [1.0],
+ MEASUREMENT: [1.0],
+ OBSERVABLE_PARAMETERS: ["2"],
+ NOISE_PARAMETERS: ["1"],
+ }
+ ),
+ parameter_df=pd.DataFrame(
+ {
+ PARAMETER_ID: ["p"],
+ PARAMETER_SCALE: [LIN],
+ LOWER_BOUND: [0.0],
+ UPPER_BOUND: [10.0],
+ NOMINAL_VALUE: [1.0],
+ ESTIMATE: [1],
+ }
+ ).set_index(PARAMETER_ID),
+ )
+
+
+def _set_column(table: str, column: str, value):
+ """Get a function that sets a column of a table of a problem."""
+
+ def modify(problem):
+ getattr(problem, table)[column] = value
+
+ return modify
+
+
+def _add_observable(problem, observable_id, formula):
+ problem.observable_df.loc[observable_id] = [formula, "1"]
+
+
+@pytest.mark.parametrize(
+ "modify, expected",
+ [
+ (
+ lambda p: setattr(
+ p,
+ "model",
+ _placeholder_problem(
+ "species x = 1; k = 1; p = 1; noiseParameter1_obs1 = 1"
+ ).model,
+ ),
+ "`noiseParameter1_obs1` of observable `obs1` (model entity)",
+ ),
+ (
+ _set_column("condition_df", "observableParameter1_obs1", 1.0),
+ (
+ "`observableParameter1_obs1` of observable `obs1` "
+ "(condition table column)"
+ ),
+ ),
+ (
+ lambda p: setattr(
+ p,
+ "mapping_df",
+ pd.DataFrame(
+ {
+ PETAB_ENTITY_ID: ["observableParameter1_obs1"],
+ MODEL_ENTITY_ID: ["k"],
+ }
+ ).set_index(PETAB_ENTITY_ID),
+ ),
+ (
+ "`observableParameter1_obs1` of observable `obs1` "
+ "(mapping table petabEntityId)"
+ ),
+ ),
+ (
+ lambda p: _add_observable(p, "observableParameter1_obs1", "x"),
+ "`observableParameter1_obs1` of observable `obs1` (observable ID)",
+ ),
+ (
+ lambda p: _add_observable(p, "obs2", "noiseParameter1_obs1 * x"),
+ (
+ "`noiseParameter1_obs1` of observable `obs1` "
+ "(used in observable `obs2`)"
+ ),
+ ),
+ (
+ _set_column("condition_df", "k", "observableParameter1_obs1 + 1"),
+ (
+ "`observableParameter1_obs1` of observable `obs1` "
+ "(used in the condition table)"
+ ),
+ ),
+ (
+ _set_column(
+ "measurement_df", NOISE_PARAMETERS, "observableParameter1_obs1"
+ ),
+ (
+ "`observableParameter1_obs1` of observable `obs1` "
+ "(used in the measurement table)"
+ ),
+ ),
+ (
+ _set_column(
+ "observable_df",
+ OBSERVABLE_FORMULA,
+ "observableParameter1_obs1 * x * noiseParameter1_obs1",
+ ),
+ (
+ "`noiseParameter1_obs1` of observable `obs1` "
+ "(used in the observable formula)"
+ ),
+ ),
+ ],
+)
+def test_assert_placeholders_only_used_in_own_observable(modify, expected):
+ problem = _placeholder_problem()
+ lint.assert_placeholders_only_used_in_own_observable(problem)
+
+ modify(problem)
+ with pytest.raises(AssertionError) as excinfo:
+ lint.assert_placeholders_only_used_in_own_observable(problem)
+ assert str(excinfo.value).endswith(expected)
+
+
+def test_assert_placeholders_only_used_in_own_observable_missing_column():
+ problem = _placeholder_problem()
+ problem.observable_df = problem.observable_df.drop(columns=NOISE_FORMULA)
+ lint.assert_placeholders_only_used_in_own_observable(problem)
+
+
+def test_lint_problem_placeholders_only_used_in_own_observable():
+ assert lint.lint_problem(_placeholder_problem()) is False
+ problem = _placeholder_problem(
+ "species x = 1; k = 1; p = 1; observableParameter1_obs1 = 1"
+ )
+ with patch.object(lint.logger, "error") as error:
+ assert lint.lint_problem(problem) is True
+ assert any(
+ "`observableParameter1_obs1` of observable `obs1` (model entity)"
+ in str(call.args[0])
+ for call in error.call_args_list
+ )
+
+
def test_condition_ids_are_unique():
condition_df = pd.DataFrame(
data={