Fractional Lorenz

The fractional Lorenz flow of Grigorenko and Grigorenko, chaotic for orders close enough to 1.

• Name: fractional_lorenz
• Field: mathematics/fractional_dynamics
• Formalism: fractional differential equations
• References: Grigorenko and Grigorenko 2003; Trzaska 2023

Factory

@register_model(
    field='mathematics/fractional_dynamics',
    tags=('fractional', 'memory', 'chaos', 'strange attractor'),
    references=('Grigorenko and Grigorenko 2003', 'Trzaska 2023'),
    defaults={'until': 30.0, 'dt': 0.05},
)
def fractional_lorenz(
    x: float = 1.0,
    y: float = 1.0,
    z: float = 1.0,
    *,
    order: float = 0.995,
    sigma: float = 10.0,
    rho: float = 28.0,
    beta: float = 8 / 3,
) -> System:
    """Return the fractional Lorenz flow of Grigorenko and Grigorenko, chaotic for orders close enough to 1.

    Grigorenko and Grigorenko report chaos down to the total order 2.97. With Caputo derivatives from rest and the
    predictor-corrector, the flow is chaotic for the order 0.995 of every state, a total of 2.985, and settles on a
    fixed point of the two wings for 0.99 after a chaotic transient.

    Args:
        x:
            The initial convection intensity.

        y:
            The initial temperature difference between rising and falling currents.

        z:
            The initial deviation of the vertical temperature profile.

        order:
            The order `q` of the Caputo derivatives of all three states, in `(0, 1]`.

        sigma:
            The Prandtl number.

        rho:
            The Rayleigh number relative to its critical value.

        beta:
            The geometric factor.

    Returns:
        system:
            The model, with the states `lorenz.x`, `lorenz.y`, and `lorenz.z`.

    Examples:
        >>> from skcomplex.models.mathematics.fractional_dynamics import fractional_lorenz
        >>> fractional_lorenz(rho=20.0).elements[0].rho
        20.0
    """
    flow = lorenz_type(float(order))('lorenz', x=x, y=y, z=z, sigma=sigma, rho=rho, beta=beta)
    return System(elements=[flow])

Components

    class FractionalElement(LorenzElement):
        def __init__(
            self,
            label: str,
            visual: VisualSpec | None = None,
            *,
            x: Annotated[float, StateSpec(order=order)] = 1.0,
            y: Annotated[float, StateSpec(order=order)] = 1.0,
            z: Annotated[float, StateSpec(order=order)] = 1.0,
            sigma: float = 10.0,
            rho: float = 28.0,
            beta: float = 8 / 3,
        ) -> None:
            super().__init__(label, visual=visual, x=x, y=y, z=z, sigma=sigma, rho=rho, beta=beta)

Equations

lorenz.x: caputo(x_lorenz(t), t, 199/200) == -sigma_lorenz*(x_lorenz(t) - y_lorenz(t))
lorenz.y: caputo(y_lorenz(t), t, 199/200) == (rho_lorenz - z_lorenz(t))*x_lorenz(t) - y_lorenz(t)
lorenz.z: caputo(z_lorenz(t), t, 199/200) == x_lorenz(t)*y_lorenz(t) - beta_lorenz*z_lorenz(t)