pygeoinf 1.2.1__tar.gz → 1.2.3__tar.gz

{pygeoinf-1.2.1 → pygeoinf-1.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pygeoinf
-Version: 1.2.1
+Version: 1.2.3
 Summary: A package for solving geophysical inference and inverse problems
 License: BSD-3-Clause
 Author: David Al-Attar and Dan Heathcote

pygeoinf-1.2.3/pygeoinf/backus_gilbert.py

@@ -0,0 +1,120 @@
+"""
+Module for Backus-Gilbert like methods for solving inference problems. To be done...
+"""
+
+from .hilbert_space import HilbertSpace, Vector
+from .linear_operators import LinearOperator
+from .nonlinear_forms import NonLinearForm
+
+
+class HyperEllipsoid:
+    """
+    A class for hyper-ellipsoids in a Hilbert Space. Such sets occur within
+    the context of Backus-Gilbert methods, both in terms of prior constraints
+    and posterior bounds on the property space.
+
+    The hyper-ellipsoid is defined through the inequality
+
+    (A(x-x_0), x-x_0)_{X} <= r**2,
+
+    where A is a self-adjoint linear operator on the space, X, x is an arbitrary vector, x_0 is the
+    centre, and r the radius.
+    """
+
+    def __init__(
+        self,
+        space: HilbertSpace,
+        radius: float,
+        /,
+        *,
+        centre: Vector = None,
+        operator: LinearOperator = None,
+    ) -> None:
+        """
+        Args:
+            space (HilbertSpace): The Hilbert space in which the hyper-ellipsoid is defined.
+            radius (float): The radius of the hyper-ellipsoid.
+            centre (Vector); The centre of the hyper-ellipsoid. The default is None which corresponds to
+                the zero-vector.
+            operator (LinearOperator): A self-adjoint operator on the space defining the hyper-ellipsoid.
+                The default is None which corresponds to the identity operator.
+        """
+
+        if not isinstance(space, HilbertSpace):
+            raise ValueError("Input space must be a HilbertSpace")
+        self._space = space
+
+        if not radius > 0:
+            raise ValueError("Input radius must be positive.")
+        self._radius = radius
+
+        if operator is None:
+            self._operator = space.identity_operator()
+        else:
+            if not (operator.domain == space and operator.is_automorphism):
+                raise ValueError("Operator is not of the appropriate form.")
+            self._operator = operator
+
+        if centre is None:
+            self._centre = space.zero
+        else:
+            if not space.is_element(centre):
+                raise ValueError("The input centre does not lie in the space.")
+            self._centre = centre
+
+    @property
+    def space(self) -> HilbertSpace:
+        """
+        Returns the HilbertSpace the hyper-ellipsoid is defined on.
+        """
+        return self._space
+
+    @property
+    def radius(self) -> float:
+        """
+        Returns the radius of the hyper-ellipsoid.
+        """
+        return self._radius
+
+    @property
+    def operator(self) -> LinearOperator:
+        """
+        Returns the operator for the hyper-ellipsoid.
+        """
+        return self._operator
+
+    @property
+    def centre(self) -> Vector:
+        """
+        Returns the centre of the hyper-ellipsoid.
+        """
+        return self._centre
+
+    @property
+    def quadratic_form(self) -> NonLinearForm:
+        """
+        Returns the mapping x -> (A(x-x_0), x-x_0)_{X} as a NonLinearForm.
+        """
+
+        space = self.space
+        x0 = self.centre
+        A = self.operator
+
+        def mapping(x: Vector) -> float:
+            d = space.subtract(x, x0)
+            return space.inner_product(A(d), d)
+
+        def gradient(x: Vector) -> Vector:
+            d = space.subtract(x, x0)
+            return space.multiply(2, A(d))
+
+        def hessian(_: Vector) -> LinearOperator:
+            return A
+
+        return NonLinearForm(space, mapping, gradient=gradient, hessian=hessian)
+
+    def is_point(self, x: Vector) -> bool:
+        """
+        True if x lies in the hyper-ellipsoid.
+        """
+        return self.quadratic_form(x) <= self.radius**2

{pygeoinf-1.2.1 → pygeoinf-1.2.3}/pygeoinf/direct_sum.py

@@ -116,6 +116,16 @@ class HilbertSpaceDirectSum(HilbertSpace):
 
         return self.subspaces == other.subspaces
 
+    def is_element(self, xs: Any) -> bool:
+        """
+        Checks if a list of vectors is a valid element of the direct sum space.
+        """
+        if not isinstance(xs, list):
+            return False
+        if len(xs) != self.number_of_subspaces:
+            return False
+        return all(space.is_element(x) for space, x in zip(self._spaces, xs))
+
     @property
     def subspaces(self) -> List[HilbertSpace]:
         """Returns the list of subspaces that form the direct sum."""

{pygeoinf-1.2.1 → pygeoinf-1.2.3}/pygeoinf/forward_problem.py

@@ -24,12 +24,14 @@ from scipy.stats import chi2
 
 from .gaussian_measure import GaussianMeasure
 from .direct_sum import ColumnLinearOperator
+from .linear_operators import LinearOperator
+
 
 # This block only runs for type checkers, not at runtime, to prevent
 # circular import errors while still allowing type hints.
 if TYPE_CHECKING:
     from .hilbert_space import HilbertSpace, Vector
-    from .linear_operators import LinearOperator
+    from .nonlinear_operators import NonLinearOperator
 
 
 class ForwardProblem:
@@ -43,10 +45,10 @@ class ForwardProblem:
 
     def __init__(
         self,
-        forward_operator: LinearOperator,
+        forward_operator: NonLinearOperator,
         /,
         *,
-        data_error_measure: Optional["GaussianMeasure"] = None,
+        data_error_measure: Optional[GaussianMeasure] = None,
     ) -> None:
         """Initializes the ForwardProblem.
 
@@ -57,8 +59,8 @@ class ForwardProblem:
                 from which data errors are assumed to be drawn. If None, the
                 data is considered to be error-free.
         """
-        self._forward_operator: LinearOperator = forward_operator
-        self._data_error_measure: Optional["GaussianMeasure"] = data_error_measure
+        self._forward_operator: NonLinearOperator = forward_operator
+        self._data_error_measure: Optional[GaussianMeasure] = data_error_measure
         if self.data_error_measure_set:
             if self.data_space != data_error_measure.domain:
                 raise ValueError(
@@ -76,7 +78,7 @@ class ForwardProblem:
         return self._data_error_measure is not None
 
     @property
-    def data_error_measure(self) -> "GaussianMeasure":
+    def data_error_measure(self) -> GaussianMeasure:
         """The measure from which data errors are drawn."""
         if not self.data_error_measure_set:
             raise AttributeError("Data error measure has not been set.")
@@ -101,10 +103,31 @@ class LinearForwardProblem(ForwardProblem):
     and `e` is a random error drawn from a Gaussian distribution.
     """
 
+    def __init__(
+        self,
+        forward_operator: LinearOperator,
+        /,
+        *,
+        data_error_measure: Optional[GaussianMeasure] = None,
+    ) -> None:
+        """
+        Args:
+            forward_operator: The operator that maps from the model space to the
+                data space.
+            data_error_measure: A Gaussian measure representing the distribution
+                from which data errors are assumed to be drawn. If None, the
+                data is considered to be error-free.
+        """
+
+        if not isinstance(forward_operator, LinearOperator):
+            raise ValueError("Forward operator must be a linear operator.")
+
+        super().__init__(forward_operator, data_error_measure=data_error_measure)
+
     @staticmethod
     def from_direct_sum(
-        forward_problems: List["LinearForwardProblem"],
-    ) -> "LinearForwardProblem":
+        forward_problems: List[LinearForwardProblem],
+    ) -> LinearForwardProblem:
         """
         Forms a joint forward problem from a list of separate problems.
 
@@ -144,7 +167,7 @@ class LinearForwardProblem(ForwardProblem):
             joint_forward_operator, data_error_measure=data_error_measure
         )
 
-    def data_measure(self, model: "Vector") -> "GaussianMeasure":
+    def data_measure(self, model: Vector) -> GaussianMeasure:
         """
         Returns the Gaussian measure for the data, given a specific model.
 
@@ -165,7 +188,7 @@ class LinearForwardProblem(ForwardProblem):
             translation=self.forward_operator(model)
         )
 
-    def synthetic_data(self, model: "Vector") -> "Vector":
+    def synthetic_data(self, model: Vector) -> Vector:
         """
         Generates a synthetic data vector for a given model.
 
@@ -180,9 +203,7 @@ class LinearForwardProblem(ForwardProblem):
         """
         return self.data_measure(model).sample()
 
-    def synthetic_model_and_data(
-        self, prior: "GaussianMeasure"
-    ) -> Tuple["Vector", "Vector"]:
+    def synthetic_model_and_data(self, prior: GaussianMeasure) -> Tuple[Vector, Vector]:
         """
         Generates a random model and corresponding synthetic data.
 
@@ -216,7 +237,7 @@ class LinearForwardProblem(ForwardProblem):
         """
         return chi2.ppf(significance_level, self.data_space.dim)
 
-    def chi_squared(self, model: "Vector", data: "Vector") -> float:
+    def chi_squared(self, model: Vector, data: Vector) -> float:
         """
         Calculates the chi-squared statistic for a given model and data.
 
@@ -250,7 +271,7 @@ class LinearForwardProblem(ForwardProblem):
             return self.data_space.squared_norm(residual)
 
     def chi_squared_test(
-        self, significance_level: float, model: "Vector", data: "Vector"
+        self, significance_level: float, model: Vector, data: Vector
     ) -> bool:
         """
         Performs a chi-squared test for goodness of fit.

{pygeoinf-1.2.1 → pygeoinf-1.2.3}/pygeoinf/hilbert_space.py

@@ -504,6 +504,14 @@ class DualHilbertSpace(HilbertSpace):
             return NotImplemented
         return self.underlying_space == other.underlying_space
 
+    def is_element(self, x: Any) -> bool:
+        """
+        Checks if an object is a valid element of the dual space.
+        """
+        from .linear_forms import LinearForm
+
+        return isinstance(x, LinearForm) and x.domain == self.underlying_space
+
     @final
     def duality_product(self, xp: LinearForm, x: Vector) -> float:
         """
@@ -583,6 +591,12 @@ class EuclideanSpace(HilbertSpace):
             return NotImplemented
         return self.dim == other.dim
 
+    def is_element(self, x: Any) -> bool:
+        """
+        Checks if an object is a valid element of the space.
+        """
+        return isinstance(x, np.ndarray) and len(x) == self.dim
+
 
 class MassWeightedHilbertSpace(HilbertSpace):
     """
@@ -678,6 +692,40 @@ class MassWeightedHilbertSpace(HilbertSpace):
             and (self.inverse_mass_operator == other.inverse_mass_operator)
         )
 
+    def is_element(self, x: Any) -> bool:
+        """
+        Checks if an object is a valid element of the space.
+        """
+        return self.underlying_space.is_element(x)
+
+    def add(self, x: Vector, y: Vector) -> Vector:
+        """Computes the sum of two vectors. Defaults to `x + y`."""
+        return self.underlying_space.add(x, y)
+
+    def subtract(self, x: Vector, y: Vector) -> Vector:
+        """Computes the difference of two vectors. Defaults to `x - y`."""
+        return self.underlying_space.subtract(x, y)
+
+    def multiply(self, a: float, x: Vector) -> Vector:
+        """Computes scalar multiplication. Defaults to `a * x`."""
+        return self.underlying_space.multiply(a, x)
+
+    def negative(self, x: Vector) -> Vector:
+        """Computes the additive inverse of a vector. Defaults to `-1 * x`."""
+        return self.underlying_space.negative(x)
+
+    def ax(self, a: float, x: Vector) -> None:
+        """Performs in-place scaling `x := a*x`. Defaults to `x *= a`."""
+        self.underlying_space.ax(a, x)
+
+    def axpy(self, a: float, x: Vector, y: Vector) -> None:
+        """Performs in-place operation `y := y + a*x`. Defaults to `y += a*x`."""
+        self.underlying_space.axpy(a, x, y)
+
+    def copy(self, x: Vector) -> Vector:
+        """Returns a deep copy of a vector. Defaults to `x.copy()`."""
+        return self.underlying_space.copy(x)
+
 
 class MassWeightedHilbertModule(MassWeightedHilbertSpace, HilbertModule):
     """

pygeoinf-1.2.3/pygeoinf/inversion.py

@@ -0,0 +1,177 @@
+"""
+Provides the abstract base class for all inversion algorithms.
+
+This module defines the `Inversion` class, which serves as a common
+foundation for various methods that solve an inverse problem. Its primary role
+is to maintain a reference to the `ForwardProblem` being solved, providing a
+consistent interface and convenient access to the problem's core components like
+the model space and data space.
+
+It also includes helper methods to assert preconditions required by different
+inversion techniques, such as the existence of a data error measure.
+"""
+
+from __future__ import annotations
+
+
+from .hilbert_space import HilbertSpace
+from .nonlinear_operators import NonLinearOperator
+from .linear_operators import LinearOperator
+from .forward_problem import LinearForwardProblem, ForwardProblem
+
+
+class Inversion:
+    """
+    A base class for inversion methods.
+
+    This class provides a common structure for different inversion and inference algorithms
+    (e.g., Bayesian, Least Squares). Its main purpose is to hold a reference
+    to the forward problem being solved and provide convenient access to its
+    properties. Subclasses should inherit from this class to implement a
+    specific inversion algorithm.
+    """
+
+    def __init__(self, forward_problem: ForwardProblem, /) -> None:
+        """
+        Initializes the Inversion class.
+
+        Args:
+            forward_problem: An instance of a forward problem that defines the
+                relationship between model parameters and data.
+        """
+        self._forward_problem: ForwardProblem = forward_problem
+
+    @property
+    def forward_problem(self) -> ForwardProblem:
+        """The forward problem associated with this inversion."""
+        return self._forward_problem
+
+    @property
+    def model_space(self) -> HilbertSpace:
+        """The model space (domain) of the forward problem."""
+        return self.forward_problem.model_space
+
+    @property
+    def data_space(self) -> HilbertSpace:
+        """The data space (codomain) of the forward problem."""
+        return self.forward_problem.data_space
+
+    def assert_data_error_measure(self) -> None:
+        """
+        Checks if a data error measure is set in the forward problem.
+
+        This is a precondition for statistical inversion methods.
+
+        Raises:
+            AttributeError: If no data error measure has been set.
+        """
+        if not self.forward_problem.data_error_measure_set:
+            raise AttributeError(
+                "A data error measure is required for this inversion method."
+            )
+
+    def assert_inverse_data_covariance(self) -> None:
+        """
+        Checks if the data error measure has an inverse covariance.
+
+        This is a precondition for methods that require the data precision
+        matrix (the inverse of the data error covariance).
+
+        Raises:
+            AttributeError: If no data error measure is set, or if the measure
+                does not have an inverse covariance operator defined.
+        """
+        self.assert_data_error_measure()
+        if not self.forward_problem.data_error_measure.inverse_covariance_set:
+            raise AttributeError(
+                "An inverse data covariance (precision) operator is required for this inversion method."
+            )
+
+
+class LinearInversion(Inversion):
+    """
+    An abstract base class for linear inversion algorithms.
+    """
+
+    def __init__(self, forward_problem: LinearForwardProblem, /) -> None:
+        """
+        Initializes the LinearInversion class.
+
+        Args:
+            forward_problem: An instance of a linear forward problem.
+        """
+        if not isinstance(forward_problem, LinearForwardProblem):
+            raise ValueError("Forward problem must be a LinearForwardProblem.")
+        super().__init__(forward_problem)
+
+
+class Inference(Inversion):
+    """
+    A base class for inference algorithms. These methods inherit common functionality from
+    the inversion base class, but need not themselves derive from a specific inversion scheme.
+
+    Within an inference problem, the aim is to estimate some property of the unknown model,
+    and hence a property operator mapping from the model to a property space must be
+    specified.
+    """
+
+    def __init__(
+        self, forward_problem: ForwardProblem, property_operator: NonLinearOperator
+    ) -> None:
+        """
+        Initializes the Inference class.
+
+        Args:
+            forward_problem: An instance of a forward problem that defines the
+                relationship between model parameters and data.
+            property_operator: A mapping takes elements of the model space to
+                property vector of interest.
+        """
+
+        super().__init__(forward_problem)
+
+        if property_operator.domain != self.model_space:
+            raise ValueError("Property operator incompatible with model space")
+
+        self._property_operator = property_operator
+
+    @property
+    def property_operator(self) -> NonLinearOperator:
+        """
+        Returns the property operator.
+        """
+        return self._property_operator
+
+    @property
+    def property_space(self) -> HilbertSpace:
+        """
+        Returns the property space.
+        """
+        return self.property_operator.codomain
+
+
+class LinearInference(Inference):
+    """
+    A base class for linear inference algorithms.
+    """
+
+    def __init__(
+        self, forward_problem: LinearForwardProblem, property_operator: LinearOperator
+    ) -> None:
+        """
+        Initializes the LinearInference class.
+
+        Args:
+            forward_problem: An instance of a linear forward problem that defines the
+                relationship between model parameters and data.
+            property_operator: A linear mapping takes elements of the model space to
+                property vector of interest.
+        """
+
+        if not isinstance(forward_problem, LinearForwardProblem):
+            raise ValueError("Forward problem must be linear")
+
+        if not isinstance(property_operator, LinearOperator):
+            raise ValueError("Property mapping must be linear")
+
+        super().__init__(forward_problem, property_operator)

{pygeoinf-1.2.1 → pygeoinf-1.2.3}/pygeoinf/linear_bayesian.py

@@ -23,7 +23,7 @@ Key Classes
 from __future__ import annotations
 from typing import Optional
 
-from .inversion import Inversion
+from .inversion import LinearInversion
 from .gaussian_measure import GaussianMeasure
 
 
@@ -33,7 +33,7 @@ from .linear_solvers import LinearSolver, IterativeLinearSolver
 from .hilbert_space import HilbertSpace, Vector
 
 
-class LinearBayesianInversion(Inversion):
+class LinearBayesianInversion(LinearInversion):
     """
     Solves a linear inverse problem using Bayesian methods.
 

{pygeoinf-1.2.1 → pygeoinf-1.2.3}/pygeoinf/linear_optimisation.py

@@ -22,7 +22,7 @@ from __future__ import annotations
 from typing import Optional, Union
 
 from .nonlinear_operators import NonLinearOperator
-from .inversion import Inversion
+from .inversion import LinearInversion
 
 
 from .forward_problem import LinearForwardProblem
@@ -31,7 +31,7 @@ from .linear_solvers import LinearSolver, IterativeLinearSolver
 from .hilbert_space import Vector
 
 
-class LinearLeastSquaresInversion(Inversion):
+class LinearLeastSquaresInversion(LinearInversion):
     """
     Solves a linear inverse problem using Tikhonov-regularized least-squares.
 
@@ -89,7 +89,7 @@ class LinearLeastSquaresInversion(Inversion):
         /,
         *,
         preconditioner: Optional[LinearOperator] = None,
-    ) -> Union[Operator, LinearOperator]:
+    ) -> Union[NonLinearOperator, LinearOperator]:
         """
         Returns an operator that maps data to the least-squares solution.
 
@@ -137,7 +137,7 @@ class LinearLeastSquaresInversion(Inversion):
             return inverse_normal_operator @ forward_operator.adjoint
 
 
-class LinearMinimumNormInversion(Inversion):
+class LinearMinimumNormInversion(LinearInversion):
     """
     Finds a regularized solution using the discrepancy principle.
 
@@ -168,7 +168,7 @@ class LinearMinimumNormInversion(Inversion):
         maxiter: int = 100,
         rtol: float = 1.0e-6,
         atol: float = 0.0,
-    ) -> Union[Operator, LinearOperator]:
+    ) -> Union[NonLinearOperator, LinearOperator]:
         """
         Returns an operator that maps data to the minimum-norm solution.
 

{pygeoinf-1.2.1 → pygeoinf-1.2.3}/pygeoinf/nonlinear_forms.py

@@ -16,6 +16,7 @@ if TYPE_CHECKING:
     from .hilbert_space import HilbertSpace, Vector
     from .linear_forms import LinearForm
     from .linear_operators import LinearOperator
+    from .nonlinear_operators import NonLinearOperator
 
 
 class NonLinearForm:

{pygeoinf-1.2.1 → pygeoinf-1.2.3}/pygeoinf/nonlinear_operators.py

@@ -71,6 +71,13 @@ class NonLinearOperator:
         """True if the operator's domain and codomain have the same dimension."""
         return self.domain.dim == self.codomain.dim
 
+    @property
+    def has_derivative(self) -> bool:
+        """
+        Returns true if the operators derivative is implemented.
+        """
+        return self._derivative is not None
+
     def __call__(self, x: Any) -> Any:
         """Applies the operator's mapping to a vector."""
         return self._mapping(x)

{pygeoinf-1.2.1 → pygeoinf-1.2.3}/pygeoinf/nonlinear_optimisation.py

@@ -162,7 +162,7 @@ def line_search(
     # Wrap the function.
     def f(xc: np.ndarray) -> float:
         x = domain.from_components(xc)
-        return f(x)
+        return form(x)
 
     # Wrap the derivative. Note that this is given in
     # terms of the components of the derivative (i.e., an element

{pygeoinf-1.2.1 → pygeoinf-1.2.3}/pygeoinf/symmetric_space/circle.py

@@ -24,7 +24,7 @@ Key Classes
 
 from __future__ import annotations
 
-from typing import Callable, Tuple, Optional
+from typing import Callable, Tuple, Optional, Any
 import matplotlib.pyplot as plt
 import numpy as np
 from scipy.fft import rfft, irfft
@@ -336,6 +336,16 @@ class Lebesgue(CircleHelper, HilbertModule, AbstractInvariantLebesgueSpace):
 
         return self.kmax == other.kmax and self.radius == other.radius
 
+    def is_element(self, u: Any) -> bool:
+        """
+        Checks if an object is a valid element of the space.
+        """
+        if not isinstance(u, np.ndarray):
+            return False
+        if not u.shape == (self.dim,):
+            return False
+        return True
+
     def invariant_automorphism_from_index_function(self, g: Callable[[int], float]):
         """
         Implements an invariant automorphism of the form f(Δ) using Fourier

{pygeoinf-1.2.1 → pygeoinf-1.2.3}/pygeoinf/symmetric_space/sphere.py

@@ -448,6 +448,20 @@ class Lebesgue(SphereHelper, HilbertModule, AbstractInvariantLebesgueSpace):
 
         return self.lmax == other.lmax and self.radius == other.radius
 
+    def is_element(self, x: Any) -> bool:
+        """
+        Checks if an object is a valid element of the space.
+        """
+        if not isinstance(x, sh.SHGrid):
+            return False
+        if not x.lmax == self.lmax:
+            return False
+        if not x.grid == self._grid_name():
+            return False
+        if not x.extend == self.extend:
+            return False
+        return True
+
     def eigenfunction_norms(self) -> np.ndarray:
         """Returns a list of the norms of the eigenfunctions."""
         return np.fromiter(

{pygeoinf-1.2.1 → pygeoinf-1.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pygeoinf"
-version = "1.2.1"
+version = "1.2.3"
 description = "A package for solving geophysical inference and inverse problems"
 authors = ["David Al-Attar and Dan Heathcote"]
 readme = "README.md"

pygeoinf-1.2.1/pygeoinf/backus_gilbert.py

@@ -1,3 +0,0 @@
-"""
-Module for Backus-Gilbert like methods for solving inference problems. To be done...
-"""

pygeoinf-1.2.1/pygeoinf/inversion.py

@@ -1,85 +0,0 @@
-"""
-Provides the abstract base class for all inversion algorithms.
-
-This module defines the `Inversion` class, which serves as a common
-foundation for various methods that solve an inverse problem. Its primary role
-is to maintain a reference to the `ForwardProblem` being solved, providing a
-consistent interface and convenient access to the problem's core components like
-the model space and data space.
-
-It also includes helper methods to assert preconditions required by different
-inversion techniques, such as the existence of a data error measure.
-"""
-
-from __future__ import annotations
-
-from .forward_problem import LinearForwardProblem
-from .hilbert_space import HilbertSpace
-
-
-class Inversion:
-    """
-    An abstract base class for inversion methods.
-
-    This class provides a common structure for different inversion algorithms
-    (e.g., Bayesian, Least Squares). Its main purpose is to hold a reference
-    to the forward problem being solved and provide convenient access to its
-    properties. Subclasses should inherit from this class to implement a
-    specific inversion technique.
-    """
-
-    def __init__(self, forward_problem: "LinearForwardProblem", /) -> None:
-        """
-        Initializes the Inversion class.
-
-        Args:
-            forward_problem: An instance of a forward problem that defines the
-                relationship between model parameters and data.
-        """
-        self._forward_problem: "LinearForwardProblem" = forward_problem
-
-    @property
-    def forward_problem(self) -> "LinearForwardProblem":
-        """The forward problem associated with this inversion."""
-        return self._forward_problem
-
-    @property
-    def model_space(self) -> "HilbertSpace":
-        """The model space (domain) of the forward problem."""
-        return self.forward_problem.model_space
-
-    @property
-    def data_space(self) -> "HilbertSpace":
-        """The data space (codomain) of the forward problem."""
-        return self.forward_problem.data_space
-
-    def assert_data_error_measure(self) -> None:
-        """
-        Checks if a data error measure is set in the forward problem.
-
-        This is a precondition for statistical inversion methods.
-
-        Raises:
-            AttributeError: If no data error measure has been set.
-        """
-        if not self.forward_problem.data_error_measure_set:
-            raise AttributeError(
-                "A data error measure is required for this inversion method."
-            )
-
-    def assert_inverse_data_covariance(self) -> None:
-        """
-        Checks if the data error measure has an inverse covariance.
-
-        This is a precondition for methods that require the data precision
-        matrix (the inverse of the data error covariance).
-
-        Raises:
-            AttributeError: If no data error measure is set, or if the measure
-                does not have an inverse covariance operator defined.
-        """
-        self.assert_data_error_measure()
-        if not self.forward_problem.data_error_measure.inverse_covariance_set:
-            raise AttributeError(
-                "An inverse data covariance (precision) operator is required for this inversion method."
-            )