stireg 0.1.0__tar.gz

stireg-0.1.0/.gitignore

@@ -0,0 +1,11 @@
+.DS_Store
+.pytest_cache/
+__pycache__/
+*.py[cod]
+.venv/
+.venv-py39/
+build/
+dist/
+*.egg-info/
+data/raw/global_fire_atlas_v20240409/SHP_ignitions.zip
+manuscript/rendered/

stireg-0.1.0/CHANGELOG.md

@@ -0,0 +1,23 @@
+# Changelog
+
+All notable research-software changes are documented here. Versions before 1.0 are research prototypes and may change their statistical interface.
+
+## 0.1.0 - 2026-10-03
+
+- Promoted the first submission-ready public API and aligned version metadata across the package, source distribution, and citation file.
+- Added an executable manuscript workflow with recorded output.
+- Expanded software documentation, API contracts, failure modes, bootstrap details, and the replication map for JSS review.
+- Clarified the package name as *spatio-temporal interaction regime* while retaining a narrow single-change estimand.
+
+## 0.0.1.dev0 - 2026-09-28
+
+- Established a new project independent of ST-SCKM and rejected the original clustering-like regime-label formulation.
+- Added validated rectangular event-pattern data structures.
+- Added exact within-block border exposure and inverse-intensity weighted pair scores.
+- Added indexed and brute-force pair enumeration with agreement tests.
+- Added a maximum-CUSUM single-change test with complete-vector multiplier resampling.
+- Added Poisson, clustered-snapshot, interaction-change, and independent-thinning simulators.
+- Added pair-information diagnostics.
+- Added deterministic calibration and robustness scripts with stored results.
+- Added reproducible acquisition and preprocessing for a fixed USGS ComCat application.
+- Recorded the unresolved limits on plug-in intensity, sparse components, multiple changes, and non-Poisson temporal dependence.

stireg-0.1.0/CITATION.cff

@@ -0,0 +1,17 @@
+cff-version: 1.2.0
+message: "If you use this research software, cite the archived release and associated article when available."
+title: "stireg: Scale-resolved pair-interaction change detection for spatio-temporal point patterns"
+type: software
+authors:
+  - family-names: Idris
+    given-names: Muh Akbar
+    orcid: "https://orcid.org/0009-0000-2995-1975"
+version: 0.1.0
+date-released: 2026-10-03
+license: MIT
+abstract: >-
+  Research software for estimating intensity-reweighted, scale-resolved
+  spatio-temporal event-pair scores and testing a retrospective change in
+  their blockwise means. The current version has a deliberately restricted
+  scope and should not be described as a general-purpose interaction-regime
+  detector.

stireg-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Muh Akbar Idris
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

stireg-0.1.0/PKG-INFO

@@ -0,0 +1,171 @@
+Metadata-Version: 2.5
+Name: stireg
+Version: 0.1.0
+Summary: Scale-resolved pair-interaction change detection for spatio-temporal point patterns
+Author: Muh Akbar Idris
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: numpy>=1.24
+Requires-Dist: scipy>=1.10
+Provides-Extra: applications
+Requires-Dist: pandas>=2.0; extra == 'applications'
+Requires-Dist: pyproj>=3.6; extra == 'applications'
+Requires-Dist: pyshp>=2.3; extra == 'applications'
+Provides-Extra: test
+Requires-Dist: pytest-cov>=5; extra == 'test'
+Requires-Dist: pytest>=8; extra == 'test'
+Description-Content-Type: text/markdown
+
+# stireg
+
+`stireg` is research software for retrospective analysis of changes in localized, scale-resolved second-order interaction in spatio-temporal event patterns. It is independent of ST-SCKM and does not use a clustering objective, centroid update, or graph penalty.
+
+The broad “interaction regime” label remains provisional. A 2026 preprint named ST-Score already addresses sequential change detection and continuous-region localization for spatio-temporal point processes. This project therefore targets a narrower estimand: changes in intensity-reweighted event-pair projections indexed by prespecified spatial cells and spatial-temporal lag bins.
+
+## Current statistical scope
+
+The implemented software supports one unmarked continuous event pattern in a rectangular planar window. Both events in each pair must lie in the same temporal block, cells must be inside the window eroded by the maximum spatial lag, and intensities must be known or supplied at the event locations. The change procedure tests one retrospective mean change in the complete vector of blockwise pair scores.
+
+The following are not yet validated: automatic intensity estimation, arbitrary polygonal windows, marks, multiple changes, simultaneous affected-support confidence sets, and general cross-block dependence. These are research tasks, not hidden package options.
+
+## Installation for development
+
+Create an isolated environment and install the package from this checkout:
+
+```bash
+python3.12 -m venv .venv
+source .venv/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e ".[test,applications]"
+```
+
+Alternatively, create the recorded Conda environment:
+
+```bash
+conda env create -f environment.yml
+conda activate stireg-research
+```
+
+The package has not been released to PyPI. Do not use `pip install stireg` as a replication instruction unless an archived release is created later.
+
+## Quick start
+
+```python
+import numpy as np
+
+from stireg import (
+    RectWindow,
+    block_pair_scores,
+    information_report,
+    regular_cells,
+    simulate_snapshot_cluster_change,
+    single_change_test,
+)
+
+window = RectWindow(0, 1, 0, 1, 0, 41)
+simulation_blocks = np.arange(0, 42)
+analysis_blocks = np.arange(1, 42)
+
+events = simulate_snapshot_cluster_change(
+    window,
+    block_edges=simulation_blocks,
+    change_block=21,
+    target_rate=200,
+    parent_rate_after=20,
+    cluster_sigma_after=0.02,
+    mean_offspring_after=10,
+    random_state=20260928,
+)
+
+interior = window.eroded(0.15)
+x_edges, y_edges = regular_cells(interior, nx=2, ny=2)
+scores = block_pair_scores(
+    events,
+    block_edges=analysis_blocks,
+    x_edges=x_edges,
+    y_edges=y_edges,
+    spatial_lags=[0, 0.05, 0.10, 0.15],
+    temporal_lags=[0, 0.5, 1.0],
+)
+
+diagnostics = information_report(scores)
+result = single_change_test(
+    scores.matrix(),
+    min_segment=8,
+    n_bootstrap=499,
+    bootstrap_block_length=1,
+    random_state=20260928,
+)
+
+print(result.change_index, result.p_value)
+print(diagnostics.n_low_information, diagnostics.n_components)
+```
+
+The result reports the estimated split in units of temporal blocks, the maximum statistic, its bootstrap p-value, and the component with the largest standardized contrast. The component is diagnostic and is not a multiplicity-adjusted affected-support estimate.
+
+## Mathematical overview
+
+For events \(z_i=(s_i,t_i)\) with intensity \(\lambda(z_i)\), each block-cell-lag score has the form
+
+\[
+Y_{bp}=\frac{1}{E_{bp}}
+\sum_{i\ne j}
+\frac{f_{bp}(z_i,z_j)}{\lambda(z_i)\lambda(z_j)}-1,
+\]
+
+where \(f_{bp}\) selects one temporal block, interior spatial cell, spatial annulus, and positive temporal-lag bin. The denominator \(E_{bp}\) is an exact geometric exposure for the restricted rectangular design. The second-order Campbell formula shows that the population mean is a bin average of the pair correlation minus one, so first-order intensity cancels when the supplied intensity is correct.
+
+The retrospective test computes standardized CUSUM contrasts over candidate split times and components, then calibrates their maximum with whole-block multipliers. Under a Poisson reference, within-block pair construction prevents event sharing across temporal blocks. It does not guarantee independence for self-exciting or Cox processes.
+
+## API overview
+
+- `RectWindow` and `EventPattern`: validated event data and observation geometry.
+- `regular_cells`: regular rectangular cell boundaries.
+- `block_pair_scores`: indexed pair enumeration, exact exposure, scores, and raw pair counts.
+- `information_report`: transparent sparsity diagnostics based only on pair counts.
+- `single_change_test`: one-change maximum-CUSUM test and multiplier calibration.
+- `simulate_piecewise_poisson`: known-intensity piecewise Poisson simulation.
+- `simulate_snapshot_cluster` and `simulate_snapshot_cluster_change`: independent clustered-snapshot null and interaction-change generators.
+- `thin_pattern`: independent thinning with retained-process intensity updates.
+
+All public functions include type hints, validation, and deterministic behavior when a random seed is supplied.
+
+## Validation status
+
+The initial 200-replicate known-intensity experiment produced rejection rates of 0.020 under stationary Poisson data and 0.025 under a pure intensity change, with detection 0.890 for a Poisson-to-cluster change. A separate 200-replicate robustness experiment produced rejection 0.045 under stationary clustered snapshots and 0.010 under an independent retention change. Detection was 0.115 at low event density and 0.920 at high density. These values describe the recorded designs only.
+
+## Real-data acquisition
+
+The USGS application is reproducible with:
+
+```bash
+python scripts/acquire_usgs_ridgecrest.py
+python scripts/preprocess_usgs_ridgecrest.py
+```
+
+The query, retrieval time, checksums, coordinate reference systems, and attrition are recorded under `data/`. Global Fire Atlas acquisition uses the versioned Zenodo record DOI `10.5281/zenodo.11400062`. The large archive remains external to any JSS upload.
+
+## Reproducing the article
+
+Run unit tests first:
+
+```bash
+python -m pytest
+```
+
+Regenerate the tests, 999-bootstrap real-data analyses, manuscript tables, and
+figures with the single replication entry point:
+
+```bash
+python run_all.py
+```
+
+To rerun all four 200-replicate calibrated simulation studies before rebuilding
+the downstream artifacts, use `python run_all.py --full`. The default mode uses
+the committed calibrated simulation outputs so that routine replication does
+not silently overwrite a long-running experiment.
+
+## Citation and license
+
+Author information, ORCID, version, and citation guidance are in `CITATION.cff`. The software is distributed under the MIT License, which is GPL-compatible for JSS submission purposes. Dataset licenses and citations remain separate and are recorded with each acquisition script.

stireg-0.1.0/README.md

@@ -0,0 +1,152 @@
+# stireg
+
+`stireg` is research software for retrospective analysis of changes in localized, scale-resolved second-order interaction in spatio-temporal event patterns. It is independent of ST-SCKM and does not use a clustering objective, centroid update, or graph penalty.
+
+The broad “interaction regime” label remains provisional. A 2026 preprint named ST-Score already addresses sequential change detection and continuous-region localization for spatio-temporal point processes. This project therefore targets a narrower estimand: changes in intensity-reweighted event-pair projections indexed by prespecified spatial cells and spatial-temporal lag bins.
+
+## Current statistical scope
+
+The implemented software supports one unmarked continuous event pattern in a rectangular planar window. Both events in each pair must lie in the same temporal block, cells must be inside the window eroded by the maximum spatial lag, and intensities must be known or supplied at the event locations. The change procedure tests one retrospective mean change in the complete vector of blockwise pair scores.
+
+The following are not yet validated: automatic intensity estimation, arbitrary polygonal windows, marks, multiple changes, simultaneous affected-support confidence sets, and general cross-block dependence. These are research tasks, not hidden package options.
+
+## Installation for development
+
+Create an isolated environment and install the package from this checkout:
+
+```bash
+python3.12 -m venv .venv
+source .venv/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e ".[test,applications]"
+```
+
+Alternatively, create the recorded Conda environment:
+
+```bash
+conda env create -f environment.yml
+conda activate stireg-research
+```
+
+The package has not been released to PyPI. Do not use `pip install stireg` as a replication instruction unless an archived release is created later.
+
+## Quick start
+
+```python
+import numpy as np
+
+from stireg import (
+    RectWindow,
+    block_pair_scores,
+    information_report,
+    regular_cells,
+    simulate_snapshot_cluster_change,
+    single_change_test,
+)
+
+window = RectWindow(0, 1, 0, 1, 0, 41)
+simulation_blocks = np.arange(0, 42)
+analysis_blocks = np.arange(1, 42)
+
+events = simulate_snapshot_cluster_change(
+    window,
+    block_edges=simulation_blocks,
+    change_block=21,
+    target_rate=200,
+    parent_rate_after=20,
+    cluster_sigma_after=0.02,
+    mean_offspring_after=10,
+    random_state=20260928,
+)
+
+interior = window.eroded(0.15)
+x_edges, y_edges = regular_cells(interior, nx=2, ny=2)
+scores = block_pair_scores(
+    events,
+    block_edges=analysis_blocks,
+    x_edges=x_edges,
+    y_edges=y_edges,
+    spatial_lags=[0, 0.05, 0.10, 0.15],
+    temporal_lags=[0, 0.5, 1.0],
+)
+
+diagnostics = information_report(scores)
+result = single_change_test(
+    scores.matrix(),
+    min_segment=8,
+    n_bootstrap=499,
+    bootstrap_block_length=1,
+    random_state=20260928,
+)
+
+print(result.change_index, result.p_value)
+print(diagnostics.n_low_information, diagnostics.n_components)
+```
+
+The result reports the estimated split in units of temporal blocks, the maximum statistic, its bootstrap p-value, and the component with the largest standardized contrast. The component is diagnostic and is not a multiplicity-adjusted affected-support estimate.
+
+## Mathematical overview
+
+For events \(z_i=(s_i,t_i)\) with intensity \(\lambda(z_i)\), each block-cell-lag score has the form
+
+\[
+Y_{bp}=\frac{1}{E_{bp}}
+\sum_{i\ne j}
+\frac{f_{bp}(z_i,z_j)}{\lambda(z_i)\lambda(z_j)}-1,
+\]
+
+where \(f_{bp}\) selects one temporal block, interior spatial cell, spatial annulus, and positive temporal-lag bin. The denominator \(E_{bp}\) is an exact geometric exposure for the restricted rectangular design. The second-order Campbell formula shows that the population mean is a bin average of the pair correlation minus one, so first-order intensity cancels when the supplied intensity is correct.
+
+The retrospective test computes standardized CUSUM contrasts over candidate split times and components, then calibrates their maximum with whole-block multipliers. Under a Poisson reference, within-block pair construction prevents event sharing across temporal blocks. It does not guarantee independence for self-exciting or Cox processes.
+
+## API overview
+
+- `RectWindow` and `EventPattern`: validated event data and observation geometry.
+- `regular_cells`: regular rectangular cell boundaries.
+- `block_pair_scores`: indexed pair enumeration, exact exposure, scores, and raw pair counts.
+- `information_report`: transparent sparsity diagnostics based only on pair counts.
+- `single_change_test`: one-change maximum-CUSUM test and multiplier calibration.
+- `simulate_piecewise_poisson`: known-intensity piecewise Poisson simulation.
+- `simulate_snapshot_cluster` and `simulate_snapshot_cluster_change`: independent clustered-snapshot null and interaction-change generators.
+- `thin_pattern`: independent thinning with retained-process intensity updates.
+
+All public functions include type hints, validation, and deterministic behavior when a random seed is supplied.
+
+## Validation status
+
+The initial 200-replicate known-intensity experiment produced rejection rates of 0.020 under stationary Poisson data and 0.025 under a pure intensity change, with detection 0.890 for a Poisson-to-cluster change. A separate 200-replicate robustness experiment produced rejection 0.045 under stationary clustered snapshots and 0.010 under an independent retention change. Detection was 0.115 at low event density and 0.920 at high density. These values describe the recorded designs only.
+
+## Real-data acquisition
+
+The USGS application is reproducible with:
+
+```bash
+python scripts/acquire_usgs_ridgecrest.py
+python scripts/preprocess_usgs_ridgecrest.py
+```
+
+The query, retrieval time, checksums, coordinate reference systems, and attrition are recorded under `data/`. Global Fire Atlas acquisition uses the versioned Zenodo record DOI `10.5281/zenodo.11400062`. The large archive remains external to any JSS upload.
+
+## Reproducing the article
+
+Run unit tests first:
+
+```bash
+python -m pytest
+```
+
+Regenerate the tests, 999-bootstrap real-data analyses, manuscript tables, and
+figures with the single replication entry point:
+
+```bash
+python run_all.py
+```
+
+To rerun all four 200-replicate calibrated simulation studies before rebuilding
+the downstream artifacts, use `python run_all.py --full`. The default mode uses
+the committed calibrated simulation outputs so that routine replication does
+not silently overwrite a long-running experiment.
+
+## Citation and license
+
+Author information, ORCID, version, and citation guidance are in `CITATION.cff`. The software is distributed under the MIT License, which is GPL-compatible for JSS submission purposes. Dataset licenses and citations remain separate and are recorded with each acquisition script.

stireg-0.1.0/examples/manuscript_workflow.py

@@ -0,0 +1,40 @@
+"""Executable version of the complete worked example in the JSS manuscript."""
+
+import numpy as np
+
+from stireg import RectWindow, block_pair_scores, information_report
+from stireg import regular_cells, simulate_snapshot_cluster_change
+from stireg import single_change_test
+
+
+window = RectWindow(0, 1, 0, 1, 0, 41)
+events = simulate_snapshot_cluster_change(
+    window,
+    block_edges=np.arange(0, 42),
+    change_block=21,
+    target_rate=200,
+    parent_rate_after=20,
+    cluster_sigma_after=0.02,
+    mean_offspring_after=10,
+    random_state=20260928,
+)
+interior = window.eroded(0.15)
+x_edges, y_edges = regular_cells(interior, nx=2, ny=2)
+cube = block_pair_scores(
+    events,
+    block_edges=np.arange(1, 42),
+    x_edges=x_edges,
+    y_edges=y_edges,
+    spatial_lags=[0, 0.05, 0.10, 0.15],
+    temporal_lags=[0, 0.5, 1.0],
+)
+diagnostic = information_report(cube)
+fit = single_change_test(
+    cube.matrix(),
+    min_segment=8,
+    n_bootstrap=499,
+    bootstrap_block_length=1,
+    random_state=20260928,
+)
+print(cube.values.shape, diagnostic.n_low_information)
+print(fit.change_index, fit.component_index, fit.p_value)

stireg-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "stireg"
+version = "0.1.0"
+description = "Scale-resolved pair-interaction change detection for spatio-temporal point patterns"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+authors = [
+  {name = "Muh Akbar Idris"}
+]
+dependencies = [
+  "numpy>=1.24",
+  "scipy>=1.10"
+]
+
+[project.optional-dependencies]
+test = ["pytest>=8", "pytest-cov>=5"]
+applications = ["pandas>=2.0", "pyproj>=3.6", "pyshp>=2.3"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/stireg"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "/src",
+  "/tests",
+  "/examples",
+  "/README.md",
+  "/LICENSE",
+  "/CITATION.cff",
+  "/CHANGELOG.md",
+  "/requirements.txt",
+  "/pyproject.toml",
+]
+
+[tool.pytest.ini_options]
+addopts = "-ra"
+testpaths = ["tests"]

stireg-0.1.0/requirements.txt

@@ -0,0 +1,10 @@
+numpy>=1.24
+scipy>=1.10
+pandas>=2.0
+pyproj>=3.6
+pyshp>=2.3
+matplotlib>=3.7
+pytest>=8
+pytest-cov>=5
+build>=1.2
+twine>=5

stireg-0.1.0/src/stireg/__init__.py

@@ -0,0 +1,42 @@
+"""Research implementation of localized interaction-change inference."""
+
+from .change import SingleChangeResult, single_change_test
+from .data import EventPattern, RectWindow, regular_cells
+from .diagnostics import InformationReport, information_report
+from .interaction import ScoreCube, block_pair_scores
+from .intensity import (
+    ConditionalIntensityEstimate,
+    conditional_histogram_intensity,
+    conditional_spatial_histogram_intensity,
+)
+from .simulation import (
+    simulate_piecewise_poisson,
+    simulate_piecewise_two_zone_poisson,
+    simulate_local_cluster_change,
+    simulate_snapshot_cluster,
+    simulate_snapshot_cluster_change,
+    thin_pattern,
+)
+
+__all__ = [
+    "EventPattern",
+    "ConditionalIntensityEstimate",
+    "InformationReport",
+    "RectWindow",
+    "ScoreCube",
+    "SingleChangeResult",
+    "block_pair_scores",
+    "conditional_spatial_histogram_intensity",
+    "conditional_histogram_intensity",
+    "information_report",
+    "regular_cells",
+    "simulate_piecewise_poisson",
+    "simulate_piecewise_two_zone_poisson",
+    "simulate_local_cluster_change",
+    "simulate_snapshot_cluster",
+    "simulate_snapshot_cluster_change",
+    "single_change_test",
+    "thin_pattern",
+]
+
+__version__ = "0.1.0"

stireg-0.1.0/src/stireg/change.py

@@ -0,0 +1,105 @@
+"""Single-change inference for blockwise interaction scores."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+from numpy.typing import ArrayLike, NDArray
+
+
+FloatArray = NDArray[np.float64]
+
+
+@dataclass(frozen=True)
+class SingleChangeResult:
+    statistic: float
+    p_value: float
+    change_index: int
+    component_index: int
+    component_statistics: FloatArray
+    bootstrap_statistics: FloatArray
+    n_blocks: int
+    min_segment: int
+
+
+def _cusum_tensor(x: FloatArray, min_segment: int, scale: FloatArray) -> tuple[FloatArray, NDArray[np.int64]]:
+    n, _ = x.shape
+    candidates = np.arange(min_segment, n - min_segment + 1, dtype=np.int64)
+    prefix = np.vstack([np.zeros((1, x.shape[1])), np.cumsum(x, axis=0)])
+    left = prefix[candidates] / candidates[:, None]
+    right = (prefix[n] - prefix[candidates]) / (n - candidates)[:, None]
+    factor = np.sqrt(candidates * (n - candidates) / n)[:, None]
+    return factor * (left - right) / scale[None, :], candidates
+
+
+def _dependent_multipliers(n: int, block_length: int, rng: np.random.Generator) -> FloatArray:
+    noise = rng.normal(size=n + block_length - 1)
+    kernel = np.ones(block_length) / np.sqrt(block_length)
+    multipliers = np.convolve(noise, kernel, mode="valid")
+    multipliers -= multipliers.mean()
+    sd = multipliers.std(ddof=1)
+    return multipliers / sd if sd > 0 else multipliers
+
+
+def single_change_test(
+    scores: ArrayLike,
+    *,
+    min_segment: int = 4,
+    n_bootstrap: int = 499,
+    bootstrap_block_length: int = 2,
+    random_state: int | np.random.Generator | None = None,
+) -> SingleChangeResult:
+    """Test for one change in a block-by-component score matrix.
+
+    A dependent multiplier bootstrap calibrates the maximum over candidate
+    times and components. The returned change index is the number of blocks on
+    the left side of the estimated split.
+    """
+
+    x = np.asarray(scores, dtype=float)
+    if x.ndim != 2 or x.shape[1] < 1:
+        raise ValueError("scores must be a two-dimensional block-by-component array")
+    if not np.all(np.isfinite(x)):
+        raise ValueError("scores must contain only finite values")
+    n, _ = x.shape
+    if not isinstance(min_segment, int) or min_segment < 2 or 2 * min_segment > n:
+        raise ValueError("min_segment must be at least 2 and fit twice within the series")
+    if not isinstance(n_bootstrap, int) or n_bootstrap < 19:
+        raise ValueError("n_bootstrap must be an integer of at least 19")
+    if not isinstance(bootstrap_block_length, int) or not 1 <= bootstrap_block_length <= n:
+        raise ValueError("bootstrap_block_length must be between 1 and the number of blocks")
+
+    scale = x.std(axis=0, ddof=1)
+    informative = scale > np.sqrt(np.finfo(float).eps)
+    if not np.any(informative):
+        raise ValueError("at least one score component must vary over time")
+    x_use = x[:, informative]
+    scale_use = scale[informative]
+    observed, candidates = _cusum_tensor(x_use, min_segment, scale_use)
+    abs_observed = np.abs(observed)
+    flat_index = int(np.argmax(abs_observed))
+    time_pos, component_pos = np.unravel_index(flat_index, abs_observed.shape)
+    statistic = float(abs_observed[time_pos, component_pos])
+
+    rng = random_state if isinstance(random_state, np.random.Generator) else np.random.default_rng(random_state)
+    centered = x_use - x_use.mean(axis=0, keepdims=True)
+    boot = np.empty(n_bootstrap, dtype=float)
+    for b in range(n_bootstrap):
+        xi = _dependent_multipliers(n, bootstrap_block_length, rng)
+        sample = centered * xi[:, None]
+        boot_cusum, _ = _cusum_tensor(sample, min_segment, scale_use)
+        boot[b] = np.max(np.abs(boot_cusum))
+    p_value = (1.0 + np.count_nonzero(boot >= statistic)) / (n_bootstrap + 1.0)
+    original_components = np.flatnonzero(informative)
+    return SingleChangeResult(
+        statistic=statistic,
+        p_value=float(p_value),
+        change_index=int(candidates[time_pos]),
+        component_index=int(original_components[component_pos]),
+        component_statistics=observed[time_pos],
+        bootstrap_statistics=boot,
+        n_blocks=n,
+        min_segment=min_segment,
+    )
+