Domain: Math — Numerical Analysis of Chaotic Dynamical Systems

Problem:
# Determination of the Maximal Return-Map Ordinate for the Rössler Attractor

Consider the continuous-time dynamical system defined by the **Rössler equations**:

\\[ \begin{cases} \dot{x} = -y - z, \\ \dot{y} = x + a y, \\ \dot{z} = b + z (x - c), \end{cases} \\]

where the parameters are fixed as

\\[a = 0.2, \qquad b = 0.2, \qquad c = 5.7. \\]

---

## **Objective**

Determine the **maximum value of the return-map ordinate**

\\[ M = \max_n z_{n+1}, \\]

where the ordered sequence \\( \{z_n\} \\) consists of the **strict local maxima** of the scalar time series \\( z(t) \\) obtained from the solution of the Rössler system.

Each local maximum \\( z_n = z(t_n) \\) corresponds to a time \\( t_n \\) satisfying

\\[\dot{z}(t_n) = 0, \qquad \ddot{z}(t_n) < 0,\\]

and the **return map** is defined by the set of points

\\[\{(z_n, z_{n+1}) : n \ge 0\}.\\]

---

## **Numerical Setup and Required Constants**

The following parameters must be used to obtain the result:

- System parameters: \\( a = 0.2, \; b = 0.2, \; c = 5.7. \\)
- Initial condition: \\( (x(0), y(0), z(0)) = (0.1, 0.0, 0.0). \\)
- Total integration time: \\( T_{\mathrm{total}} = 10000. \\)
- Transient removal time: \\( T_{\mathrm{trans}} = 2000. \\)
- Numerical tolerances: \\( \mathrm{rtol} = 10^{-11}, \; \mathrm{atol} = 10^{-11}. \\)

---

**Round the maximum value of the return-map, \(M\), to three decimal places.**
## **Note**
- No theoretical or previously known value should be assumed.
- All numerical parameters and constants listed above must be used exactly as specified.
- Provide both the **Python code in one cell** that performs the computation and the **final numerical result**.

Answer: 22.851

Solution code:
import numpy as np
from scipy.integrate import solve_ivp
from scipy.signal import find_peaks

# Define the Rössler system
def rossler(t, state, a, b, c):
    x, y, z = state
    dx = -y - z
    dy = x + a*y
    dz = b + z*(x - c)
    return [dx, dy, dz]

# Parameters
a = 0.2
b = 0.2
c = 5.7

# Initial conditions
initial_state = [0.1, 0.0, 0.0]

# Time parameters
T_total = 10000
T_trans = 2000

# Numerical tolerances
rtol = 1e-11
atol = 1e-11

# Create a fine time grid for accurate peak detection
t_eval = np.linspace(0, T_total, 1000000)

# Integrate the system
sol = solve_ivp(rossler, [0, T_total], initial_state,
                args=(a, b, c),
                method='DOP853',
                rtol=rtol, atol=atol,
                t_eval=t_eval,
                max_step=0.01)

# Extract time and z component
t = sol.t
z_series = sol.y[2]

# Remove transient
mask = t >= T_trans
t_steady = t[mask]
z_steady = z_series[mask]

# Find local maxima using scipy's find_peaks
# Use a minimum distance to avoid duplicate detections
peaks, _ = find_peaks(z_steady, distance=100)
z_maxima = z_steady[peaks]

# Verify we have enough maxima
print(f"Number of maxima found: {len(z_maxima)}")

# Create return map: pairs (z_n, z_{n+1})
z_n = z_maxima[:-1]
z_n_plus_1 = z_maxima[1:]

# Find maximum value of z_{n+1}
M = np.max(z_n_plus_1)

# Round to three decimal places
M_rounded = round(M, 3)

print(f"\nMaximum value of return-map ordinate M = {M_rounded}")