@synsci/cli-darwin-x64-baseline 1.1.76 → 1.1.78

package/bin/skills/neurokit2/references/complexity.md

@@ -0,0 +1,715 @@
+# Complexity and Entropy Analysis
+
+## Overview
+
+Complexity measures quantify the irregularity, unpredictability, and multiscale structure of time series signals. NeuroKit2 provides comprehensive entropy, fractal dimension, and nonlinear dynamics measures for assessing physiological signal complexity.
+
+## Main Function
+
+### complexity()
+
+Compute multiple complexity metrics simultaneously for exploratory analysis.
+
+```python
+complexity_indices = nk.complexity(signal, sampling_rate=1000, show=False)
+```
+
+**Returns:**
+- DataFrame with numerous complexity measures across categories:
+  - Entropy indices
+  - Fractal dimensions
+  - Nonlinear dynamics measures
+  - Information-theoretic metrics
+
+**Use case:**
+- Exploratory analysis to identify relevant measures
+- Comprehensive signal characterization
+- Comparative studies across signals
+
+## Parameter Optimization
+
+Before computing complexity measures, optimal embedding parameters should be determined:
+
+### complexity_delay()
+
+Determine optimal time delay (τ) for phase space reconstruction.
+
+```python
+optimal_tau = nk.complexity_delay(signal, delay_max=100, method='fraser1986', show=False)
+```
+
+**Methods:**
+- `'fraser1986'`: Mutual information first minimum
+- `'theiler1990'`: Autocorrelation first zero crossing
+- `'casdagli1991'`: Cao's method
+
+**Use for:** Embedding delay in entropy, attractor reconstruction
+
+### complexity_dimension()
+
+Determine optimal embedding dimension (m).
+
+```python
+optimal_m = nk.complexity_dimension(signal, delay=None, dimension_max=20,
+                                    method='afn', show=False)
+```
+
+**Methods:**
+- `'afn'`: Average False Nearest Neighbors
+- `'fnn'`: False Nearest Neighbors
+- `'correlation'`: Correlation dimension saturation
+
+**Use for:** Entropy calculations, phase space reconstruction
+
+### complexity_tolerance()
+
+Determine optimal tolerance (r) for entropy measures.
+
+```python
+optimal_r = nk.complexity_tolerance(signal, method='sd', show=False)
+```
+
+**Methods:**
+- `'sd'`: Standard deviation-based (0.1-0.25 × SD typical)
+- `'maxApEn'`: Maximize ApEn
+- `'recurrence'`: Based on recurrence rate
+
+**Use for:** Approximate entropy, sample entropy
+
+### complexity_k()
+
+Determine optimal k parameter for Higuchi fractal dimension.
+
+```python
+optimal_k = nk.complexity_k(signal, k_max=20, show=False)
+```
+
+**Use for:** Higuchi fractal dimension calculation
+
+## Entropy Measures
+
+Entropy quantifies randomness, unpredictability, and information content.
+
+### entropy_shannon()
+
+Shannon entropy - classical information-theoretic measure.
+
+```python
+shannon_entropy = nk.entropy_shannon(signal)
+```
+
+**Interpretation:**
+- Higher: more random, less predictable
+- Lower: more regular, predictable
+- Units: bits (information)
+
+**Use cases:**
+- General randomness assessment
+- Information content
+- Signal irregularity
+
+### entropy_approximate()
+
+Approximate Entropy (ApEn) - regularity of patterns.
+
+```python
+apen = nk.entropy_approximate(signal, delay=1, dimension=2, tolerance='sd')
+```
+
+**Parameters:**
+- `delay`: Time delay (τ)
+- `dimension`: Embedding dimension (m)
+- `tolerance`: Similarity threshold (r)
+
+**Interpretation:**
+- Lower ApEn: more regular, self-similar patterns
+- Higher ApEn: more complex, irregular
+- Sensitive to signal length (≥100-300 points recommended)
+
+**Physiological applications:**
+- HRV: reduced ApEn in heart disease
+- EEG: altered ApEn in neurological disorders
+
+### entropy_sample()
+
+Sample Entropy (SampEn) - improved ApEn.
+
+```python
+sampen = nk.entropy_sample(signal, delay=1, dimension=2, tolerance='sd')
+```
+
+**Advantages over ApEn:**
+- Less dependent on signal length
+- More consistent across recordings
+- No self-matching bias
+
+**Interpretation:**
+- Same as ApEn but more reliable
+- Preferred in most applications
+
+**Typical values:**
+- HRV: 0.5-2.5 (context-dependent)
+- EEG: 0.3-1.5
+
+### entropy_multiscale()
+
+Multiscale Entropy (MSE) - complexity across temporal scales.
+
+```python
+mse = nk.entropy_multiscale(signal, scale=20, dimension=2, tolerance='sd',
+                            method='MSEn', show=False)
+```
+
+**Methods:**
+- `'MSEn'`: Multiscale Sample Entropy
+- `'MSApEn'`: Multiscale Approximate Entropy
+- `'CMSE'`: Composite Multiscale Entropy
+- `'RCMSE'`: Refined Composite Multiscale Entropy
+
+**Interpretation:**
+- Entropy at different coarse-graining scales
+- Healthy/complex systems: high entropy across multiple scales
+- Diseased/simpler systems: reduced entropy, especially at larger scales
+
+**Use cases:**
+- Distinguish true complexity from randomness
+- White noise: constant across scales
+- Pink noise/complexity: structured variation across scales
+
+### entropy_fuzzy()
+
+Fuzzy Entropy - uses fuzzy membership functions.
+
+```python
+fuzzen = nk.entropy_fuzzy(signal, delay=1, dimension=2, tolerance='sd', r=0.2)
+```
+
+**Advantages:**
+- More stable with noisy signals
+- Fuzzy boundaries for pattern matching
+- Better performance with short signals
+
+### entropy_permutation()
+
+Permutation Entropy - based on ordinal patterns.
+
+```python
+perment = nk.entropy_permutation(signal, delay=1, dimension=3)
+```
+
+**Method:**
+- Encodes signal into ordinal patterns (permutations)
+- Counts pattern frequencies
+- Robust to noise and non-stationarity
+
+**Interpretation:**
+- Lower: more regular ordinal structure
+- Higher: more random ordering
+
+**Use cases:**
+- EEG analysis
+- Anesthesia depth monitoring
+- Fast computation
+
+### entropy_spectral()
+
+Spectral Entropy - based on power spectrum.
+
+```python
+spec_ent = nk.entropy_spectral(signal, sampling_rate=1000, bands=None)
+```
+
+**Method:**
+- Normalized Shannon entropy of power spectrum
+- Quantifies frequency distribution regularity
+
+**Interpretation:**
+- 0: Single frequency (pure tone)
+- 1: White noise (flat spectrum)
+
+**Use cases:**
+- EEG: spectral distribution changes with states
+- Anesthesia monitoring
+
+### entropy_svd()
+
+Singular Value Decomposition Entropy.
+
+```python
+svd_ent = nk.entropy_svd(signal, delay=1, dimension=2)
+```
+
+**Method:**
+- SVD on trajectory matrix
+- Entropy of singular value distribution
+
+**Use cases:**
+- Attractor complexity
+- Deterministic vs. stochastic dynamics
+
+### entropy_differential()
+
+Differential Entropy - continuous analog of Shannon entropy.
+
+```python
+diff_ent = nk.entropy_differential(signal)
+```
+
+**Use for:** Continuous probability distributions
+
+### Other Entropy Measures
+
+**Tsallis Entropy:**
+```python
+tsallis = nk.entropy_tsallis(signal, q=2)
+```
+- Generalized entropy with parameter q
+- q=1 reduces to Shannon entropy
+
+**Rényi Entropy:**
+```python
+renyi = nk.entropy_renyi(signal, alpha=2)
+```
+- Generalized entropy with parameter α
+
+**Additional specialized entropies:**
+- `entropy_attention()`: Attention entropy
+- `entropy_grid()`: Grid-based entropy
+- `entropy_increment()`: Increment entropy
+- `entropy_slope()`: Slope entropy
+- `entropy_dispersion()`: Dispersion entropy
+- `entropy_symbolicdynamic()`: Symbolic dynamics entropy
+- `entropy_range()`: Range entropy
+- `entropy_phase()`: Phase entropy
+- `entropy_quadratic()`, `entropy_cumulative_residual()`, `entropy_rate()`: Specialized variants
+
+## Fractal Dimension Measures
+
+Fractal dimensions characterize self-similarity and roughness.
+
+### fractal_katz()
+
+Katz Fractal Dimension - waveform complexity.
+
+```python
+kfd = nk.fractal_katz(signal)
+```
+
+**Interpretation:**
+- 1: straight line
+- >1: increasing roughness and complexity
+- Typical range: 1.0-2.0
+
+**Advantages:**
+- Simple, fast computation
+- No parameter tuning
+
+### fractal_higuchi()
+
+Higuchi Fractal Dimension - self-similarity.
+
+```python
+hfd = nk.fractal_higuchi(signal, k_max=10)
+```
+
+**Method:**
+- Constructs k new time series from original
+- Estimates dimension from length-scale relationship
+
+**Interpretation:**
+- Higher HFD: more complex, irregular
+- Lower HFD: smoother, more regular
+
+**Use cases:**
+- EEG complexity
+- HRV analysis
+- Epilepsy detection
+
+### fractal_petrosian()
+
+Petrosian Fractal Dimension - rapid estimation.
+
+```python
+pfd = nk.fractal_petrosian(signal)
+```
+
+**Advantages:**
+- Fast computation
+- Direct calculation (no curve fitting)
+
+### fractal_sevcik()
+
+Sevcik Fractal Dimension - normalized waveform complexity.
+
+```python
+sfd = nk.fractal_sevcik(signal)
+```
+
+### fractal_nld()
+
+Normalized Length Density - curve length-based measure.
+
+```python
+nld = nk.fractal_nld(signal)
+```
+
+### fractal_psdslope()
+
+Power Spectral Density Slope - frequency-domain fractal measure.
+
+```python
+slope = nk.fractal_psdslope(signal, sampling_rate=1000)
+```
+
+**Method:**
+- Linear fit to log-log power spectrum
+- Slope β relates to fractal dimension
+
+**Interpretation:**
+- β ≈ 0: White noise (random)
+- β ≈ -1: Pink noise (1/f, complex)
+- β ≈ -2: Brown noise (Brownian motion)
+
+### fractal_hurst()
+
+Hurst Exponent - long-range dependence.
+
+```python
+hurst = nk.fractal_hurst(signal, show=False)
+```
+
+**Interpretation:**
+- H < 0.5: Anti-persistent (mean-reverting)
+- H = 0.5: Random walk (white noise)
+- H > 0.5: Persistent (trending, long-memory)
+
+**Use cases:**
+- Assess long-term correlations
+- Financial time series
+- HRV analysis
+
+### fractal_correlation()
+
+Correlation Dimension - attractor dimensionality.
+
+```python
+corr_dim = nk.fractal_correlation(signal, delay=1, dimension=10, radius=64)
+```
+
+**Method:**
+- Grassberger-Procaccia algorithm
+- Estimates dimension of attractor in phase space
+
+**Interpretation:**
+- Low dimension: deterministic, low-dimensional chaos
+- High dimension: high-dimensional chaos or noise
+
+### fractal_dfa()
+
+Detrended Fluctuation Analysis - scaling exponent.
+
+```python
+dfa_alpha = nk.fractal_dfa(signal, multifractal=False, q=2, show=False)
+```
+
+**Interpretation:**
+- α < 0.5: Anti-correlated
+- α = 0.5: Uncorrelated (white noise)
+- α = 1.0: 1/f noise (pink noise, healthy complexity)
+- α = 1.5: Brownian noise
+- α > 1.0: Persistent long-range correlations
+
+**HRV applications:**
+- α1 (short-term, 4-11 beats): Reflects autonomic regulation
+- α2 (long-term, >11 beats): Long-range correlations
+- Reduced α1: Cardiac pathology
+
+### fractal_mfdfa()
+
+Multifractal DFA - multiscale fractal properties.
+
+```python
+mfdfa_results = nk.fractal_mfdfa(signal, q=None, show=False)
+```
+
+**Method:**
+- Extends DFA to multiple q-orders
+- Characterizes multifractal spectrum
+
+**Returns:**
+- Generalized Hurst exponents h(q)
+- Multifractal spectrum f(α)
+- Width indicates multifractality strength
+
+**Use cases:**
+- Detect multifractal structure
+- HRV multifractality in health vs. disease
+- EEG multiscale dynamics
+
+### fractal_tmf()
+
+Multifractal Nonlinearity - deviation from monofractal.
+
+```python
+tmf = nk.fractal_tmf(signal)
+```
+
+**Interpretation:**
+- Quantifies departure from simple scaling
+- Higher: more multifractal structure
+
+### fractal_density()
+
+Density Fractal Dimension.
+
+```python
+density_fd = nk.fractal_density(signal)
+```
+
+### fractal_linelength()
+
+Line Length - total variation measure.
+
+```python
+linelength = nk.fractal_linelength(signal)
+```
+
+**Use case:**
+- Simple complexity proxy
+- EEG seizure detection
+
+## Nonlinear Dynamics
+
+### complexity_lyapunov()
+
+Largest Lyapunov Exponent - chaos and divergence.
+
+```python
+lyap = nk.complexity_lyapunov(signal, delay=None, dimension=None,
+                              sampling_rate=1000, show=False)
+```
+
+**Interpretation:**
+- λ < 0: Stable fixed point
+- λ = 0: Periodic orbit
+- λ > 0: Chaotic (nearby trajectories diverge exponentially)
+
+**Use cases:**
+- Detect chaos in physiological signals
+- HRV: positive Lyapunov suggests nonlinear dynamics
+- EEG: epilepsy detection (decreased λ before seizure)
+
+### complexity_lempelziv()
+
+Lempel-Ziv Complexity - algorithmic complexity.
+
+```python
+lz = nk.complexity_lempelziv(signal, symbolize='median')
+```
+
+**Method:**
+- Counts number of distinct patterns
+- Coarse-grained measure of randomness
+
+**Interpretation:**
+- Lower: repetitive, predictable patterns
+- Higher: diverse, unpredictable patterns
+
+**Use cases:**
+- EEG: consciousness levels, anesthesia
+- HRV: autonomic complexity
+
+### complexity_rqa()
+
+Recurrence Quantification Analysis - phase space recurrences.
+
+```python
+rqa_indices = nk.complexity_rqa(signal, delay=1, dimension=3, tolerance='sd')
+```
+
+**Metrics:**
+- **Recurrence Rate (RR)**: Percentage of recurrent states
+- **Determinism (DET)**: Percentage of recurrent points in lines
+- **Laminarity (LAM)**: Percentage in vertical structures (laminar states)
+- **Trapping Time (TT)**: Average vertical line length
+- **Longest diagonal/vertical**: System predictability
+- **Entropy (ENTR)**: Shannon entropy of line length distribution
+
+**Interpretation:**
+- High DET: deterministic dynamics
+- High LAM: system trapped in specific states
+- Low RR: random, non-recurrent dynamics
+
+**Use cases:**
+- Detect transitions in system dynamics
+- Physiological state changes
+- Nonlinear time series analysis
+
+### complexity_hjorth()
+
+Hjorth Parameters - time-domain complexity.
+
+```python
+hjorth = nk.complexity_hjorth(signal)
+```
+
+**Metrics:**
+- **Activity**: Variance of signal
+- **Mobility**: Proportion of standard deviation of derivative to signal
+- **Complexity**: Change in mobility with derivative
+
+**Use cases:**
+- EEG feature extraction
+- Seizure detection
+- Signal characterization
+
+### complexity_decorrelation()
+
+Decorrelation Time - memory duration.
+
+```python
+decorr_time = nk.complexity_decorrelation(signal, show=False)
+```
+
+**Interpretation:**
+- Time lag where autocorrelation drops below threshold
+- Shorter: rapid fluctuations, short memory
+- Longer: slow fluctuations, long memory
+
+### complexity_relativeroughness()
+
+Relative Roughness - smoothness measure.
+
+```python
+roughness = nk.complexity_relativeroughness(signal)
+```
+
+## Information Theory
+
+### fisher_information()
+
+Fisher Information - measure of order.
+
+```python
+fisher = nk.fisher_information(signal, delay=1, dimension=2)
+```
+
+**Interpretation:**
+- High: ordered, structured
+- Low: disordered, random
+
+**Use cases:**
+- Combine with Shannon entropy (Fisher-Shannon plane)
+- Characterize system complexity
+
+### fishershannon_information()
+
+Fisher-Shannon Information Product.
+
+```python
+fs = nk.fishershannon_information(signal)
+```
+
+**Method:**
+- Product of Fisher information and Shannon entropy
+- Characterizes order-disorder balance
+
+### mutual_information()
+
+Mutual Information - shared information between variables.
+
+```python
+mi = nk.mutual_information(signal1, signal2, method='knn')
+```
+
+**Methods:**
+- `'knn'`: k-nearest neighbors (nonparametric)
+- `'kernel'`: Kernel density estimation
+- `'binning'`: Histogram-based
+
+**Use cases:**
+- Coupling between signals
+- Feature selection
+- Nonlinear dependence
+
+## Practical Considerations
+
+### Signal Length Requirements
+
+| Measure | Minimum Length | Optimal Length |
+|---------|---------------|----------------|
+| Shannon entropy | 50 | 200+ |
+| ApEn, SampEn | 100-300 | 500-1000 |
+| Multiscale entropy | 500 | 1000+ per scale |
+| DFA | 500 | 1000+ |
+| Lyapunov | 1000 | 5000+ |
+| Correlation dimension | 1000 | 5000+ |
+
+### Parameter Selection
+
+**General guidelines:**
+- Use parameter optimization functions first
+- Or use conventional defaults:
+  - Delay (τ): 1 for HRV, autocorrelation first minimum for EEG
+  - Dimension (m): 2-3 typical
+  - Tolerance (r): 0.2 × SD common
+
+**Sensitivity:**
+- Results can be parameter-sensitive
+- Report parameters used
+- Consider sensitivity analysis
+
+### Normalization and Preprocessing
+
+**Standardization:**
+- Many measures sensitive to signal amplitude
+- Z-score normalization often recommended
+- Detrending may be necessary
+
+**Stationarity:**
+- Some measures assume stationarity
+- Check with statistical tests (e.g., ADF test)
+- Segment non-stationary signals
+
+### Interpretation
+
+**Context-dependent:**
+- No universal "good" or "bad" complexity
+- Compare within-subject or between groups
+- Consider physiological context
+
+**Complexity vs. randomness:**
+- Maximum entropy ≠ maximum complexity
+- True complexity: structured variability
+- White noise: high entropy but low complexity (MSE distinguishes)
+
+## Applications
+
+**Cardiovascular:**
+- HRV complexity: reduced in heart disease, aging
+- DFA α1: prognostic marker post-MI
+
+**Neuroscience:**
+- EEG complexity: consciousness, anesthesia depth
+- Entropy: Alzheimer's, epilepsy, sleep stages
+- Permutation entropy: anesthesia monitoring
+
+**Psychology:**
+- Complexity loss in depression, anxiety
+- Increased regularity under stress
+
+**Aging:**
+- "Complexity loss" with aging across systems
+- Reduced multiscale complexity
+
+**Critical transitions:**
+- Complexity changes before state transitions
+- Early warning signals (critical slowing down)
+
+## References
+
+- Pincus, S. M. (1991). Approximate entropy as a measure of system complexity. Proceedings of the National Academy of Sciences, 88(6), 2297-2301.
+- Richman, J. S., & Moorman, J. R. (2000). Physiological time-series analysis using approximate entropy and sample entropy. American Journal of Physiology-Heart and Circulatory Physiology, 278(6), H2039-H2049.
+- Peng, C. K., et al. (1995). Quantification of scaling exponents and crossover phenomena in nonstationary heartbeat time series. Chaos, 5(1), 82-87.
+- Costa, M., Goldberger, A. L., & Peng, C. K. (2005). Multiscale entropy analysis of biological signals. Physical review E, 71(2), 021906.
+- Grassberger, P., & Procaccia, I. (1983). Measuring the strangeness of strange attractors. Physica D: Nonlinear Phenomena, 9(1-2), 189-208.