Fractional relaxation

Fractional relaxation D^alpha x = -lambda x, which decays as the Mittag-Leffler function E_alpha.

• Name: fractional_relaxation
• Field: mathematics/fractional_dynamics
• Formalism: fractional differential equations
• References: Podlubny 1999; Trzaska 2023

Factory

@register_model(
    field='mathematics/fractional_dynamics',
    tags=('fractional', 'memory', 'anomalous relaxation'),
    references=('Podlubny 1999', 'Trzaska 2023'),
    defaults={'until': 20.0, 'dt': 0.1},
)
def fractional_relaxation(x: float = 1.0, *, order: float = 0.6, lam: float = 1.0) -> System:
    """Return fractional relaxation `D^alpha x = -lambda x`, which decays as the Mittag-Leffler function `E_alpha`.

    The solution `x(0) E_alpha(-lambda t^alpha)` decays slower than any exponential, as the power law `t^(-alpha)` at
    long times, since the Caputo derivative keeps the memory of the whole past. Order 1 gives exponential decay.

    Args:
        x:
            The initial value.

        order:
            The order `alpha` of the Caputo derivative, in `(0, 1]`.

        lam:
            The relaxation rate.

    Returns:
        system:
            The model, with the state `relaxation.x`.

    Examples:
        >>> from skcomplex.models.mathematics.fractional_dynamics import fractional_relaxation
        >>> fractional_relaxation(order=0.5).elements[0].lam
        1.0
    """
    return System(elements=[relaxation_type(float(order))('relaxation', x=x, lam=lam)])

Components

    class FractionalElement(RelaxationElement):
        def __init__(
            self,
            label: str,
            visual: VisualSpec | None = None,
            *,
            x: Annotated[float, StateSpec(order=order)] = 1.0,
            lam: float = 1.0,
        ) -> None:
            super().__init__(label, visual=visual, x=x, lam=lam)

Equations

relaxation.x: caputo(x_relaxation(t), t, 3/5) == -lam_relaxation*x_relaxation(t)