qoraphase 0.1.0__tar.gz

qoraphase-0.1.0/.gitignore

@@ -0,0 +1,13 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# Design specs (local only)
+QoraPhase 설계 명세서*.md

qoraphase-0.1.0/CITATION.cff

@@ -0,0 +1,20 @@
+cff-version: 1.2.0
+message: "If you use this software, please cite it as below."
+type: software
+title: "QoraPhase: A JAX-native, composable phase-retrieval framework for coherent diffraction imaging"
+authors:
+  - family-names: Yong
+    given-names: Isaac
+    email: isaacyong@naver.com
+    affiliation: "Sogang University"
+license: MIT
+repository-code: "https://github.com/NaNIsaac/QoraPhase"
+abstract: "A JAX-native, composable phase-retrieval framework for coherent diffraction imaging: an intensity array goes in, a reconstruction object comes out."
+keywords:
+  - "phase retrieval"
+  - "coherent diffraction imaging"
+  - "CDI"
+  - "JAX"
+  - "X-ray"
+version: "0.1.0"
+date-released: "2026-08-28"

qoraphase-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Isaac Yong
+
+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.

qoraphase-0.1.0/PKG-INFO

@@ -0,0 +1,193 @@
+Metadata-Version: 2.5
+Name: qoraphase
+Version: 0.1.0
+Summary: A JAX-native, composable phase-retrieval framework for coherent diffraction imaging
+Project-URL: Homepage, https://github.com/NaNIsaac/QoraPhase
+Project-URL: Repository, https://github.com/NaNIsaac/QoraPhase
+Project-URL: Issues, https://github.com/NaNIsaac/QoraPhase/issues
+Author-email: Isaac Yong <isaacyong@naver.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: CDI,coherent diffraction imaging,jax,phase retrieval,x-ray imaging
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.12
+Requires-Dist: jax>=0.11.1
+Requires-Dist: matplotlib>=3.11.1
+Requires-Dist: numpy>=2.5.2
+Description-Content-Type: text/markdown
+
+# QoraPhase
+
+A JAX-native, composable phase-retrieval framework for coherent diffraction imaging.
+
+**Array in → reconstruction out.** QoraPhase does not read files. You bring a
+`numpy` or `jax` array; it gives you back an object.
+
+## Install
+
+```bash
+pip install qoraphase
+```
+
+## Quick start
+
+```python
+import qoraphase as qp
+
+result = qp.reconstruct(intensity, support=support)
+result.plot()
+```
+
+## Array conventions (read this first)
+
+These three are the source of nearly every phase-retrieval bug, so they are part
+of the API contract, not an implementation detail.
+
+| | |
+|---|---|
+| **Origin** | Every public array is **center-origin**: index `n // 2` is q=0. `ifftshift` is internal; never call it yourself. |
+| **`intensity`** | A measured **intensity**, not an amplitude. Internally `sqrt(clip(intensity, 0))`. |
+| **`mask`** | `True` marks an **unusable** pixel (beamstop, hot, saturated). Masked pixels are left unconstrained — never forced to zero. |
+| **`support`** | `True` is inside the object. Omit it and an autocorrelation support is derived (loose; pass a real one when you have it). |
+
+## Composing a reconstruction
+
+Code order is execution order. There is no operator-overloading DSL.
+
+```python
+problem = qp.CDI(intensity=intensity, support=support, mask=mask)
+
+recipe = qp.Recipe(
+    qp.repeat(10, qp.RAAR(50, beta=0.9), qp.Shrinkwrap()),
+    qp.ER(200),
+)
+
+result = problem.reconstruct(recipe)
+```
+
+The first positional argument of an algorithm is always its iteration count.
+
+`qp.detwin(...)` runs its body against a support cut in half at the object's
+centre of mass, then restores the full support. That cut is not centrosymmetric,
+so it fits only one of the two conjugate solutions and biases the run into a
+branch. The default recipe places it a quarter of the way through the RAAR
+cycles, where PyNX puts it. It is measurably useful when the support is
+symmetric and the run would otherwise stall, and harmless when it is not — but
+a support with the right shape is worth far more than any detwinning.
+
+`qp.Shrinkwrap(threshold, sigma, method)` takes `method="max"` (classic, relative
+to the peak amplitude) or `method="rms"` (relative to the rms inside the current
+support, less easily thrown off by a hot pixel). The thresholds are on different
+scales: the classic `"max"` value is 0.2, PyNX uses 0.28 for `"rms"`.
+
+The defaults are `0.3, 1.0` rather than the classic `0.2, 2.0`. Starting from an
+autocorrelation support — the case that actually needs shrinkwrap — 0.2 / 2.0
+never converged in testing and 0.3 / 1.0 did, on every object tried. That is a
+measurement on synthetic data, not a law. **These two numbers are the first thing
+to re-tune on a real dataset.**
+
+## Multi-start
+
+Multi-start is a core feature, not an add-on — for a support with awkward
+symmetry it is the difference between converging and not.
+
+```python
+ensemble = problem.reconstruct(recipe, starts=32, batch=4)
+best = ensemble.best
+```
+
+`vmap` holds every start in memory at once. `batch` chunks that: lower it if a
+large 3D volume runs out of GPU memory.
+
+## Swapping the forward model
+
+Algorithms never name an FFT, so the physics is replaceable without touching
+them:
+
+```python
+qp.CDI(intensity, support=support, model=MyPropagator())
+```
+
+A model needs `forward` / `adjoint` and should be unitary. A *wrong* model fails
+silently — it can fit the data perfectly and return the wrong object — so this
+is worth getting right. See `tests/test_forward_model.py`.
+
+## Before you trust a reconstruction
+
+Check the measurement against the assumptions the library makes about it:
+
+```python
+print(qp.diagnose(intensity, mask=mask, support=support))
+```
+
+It reports the centring offset two ways (brightest pixel, and Friedel symmetry,
+which resolves half a pixel and works on patterns with no dominant peak), how
+much of the array the autocorrelation fills, the negative and masked fractions,
+and warns about each. An off-centre pattern is the failure that costs the most
+and shows the least.
+
+`examples/diagnose.py` does the same from the command line, then reconstructs
+and reports whether independent starts agree:
+
+```
+python examples/diagnose.py scan.npz --key intensity --support sup.npy --starts 8
+```
+
+A low Fourier error says a run fits the data. Agreement between starts, after
+alignment, is what says the answer is determined — they are different claims and
+only the second one is worth much.
+
+## Combining runs
+
+A reconstruction is determined only up to a global phase, a translation, and a
+conjugate flip. No iteration can remove those — they are exact symmetries of the
+constraints — so they are resolved afterwards:
+
+```python
+aligned = ensemble.align()      # every run brought onto the best one
+mean = ensemble.average()       # coherent mean of the aligned runs
+
+```
+
+**Never average runs without aligning them.** Each carries its own global phase,
+so a raw mean interferes destructively — in practice it throws away about two
+thirds of the amplitude. The direction survives, so a similarity score will not
+warn you; only the amplitude shows it.
+
+`align()` picks a *convention*, not the truth. It adopts whichever conjugate
+branch the best run happens to be in — enough to combine runs, and no claim
+about which branch is real. Nothing in the data distinguishes them: `conj(obj(-r))`
+reproduces the measured intensity exactly. What breaks the tie is the support
+you supply. Hand the solver a reflected support and every start converges just
+as cleanly on the mirrored object, with a flawless error metric and no warning.
+The handedness of your support is an assumption, not a result.
+
+Alignment works to whole pixels.
+
+`result.phase` still carries whatever linear phase the measurement geometry put
+there, and QoraPhase does not remove it. Doing that properly needs the
+diffraction geometry, which arrives with BCDI in v0.3; short of that, any
+"correction" is a guess.
+
+If the twin branch matters to you, break the symmetry during the run rather than
+after it — see `qp.detwin` below.
+
+## What this does not do
+
+- No phase-ramp removal, no sub-pixel alignment, no clustering, no PRTF.
+- No positivity/reality constraint — the object is complex here.
+- No file I/O, no BCDI geometry, no NUFFT, no strain, no autodiff optimisers.
+
+## Development
+
+```bash
+uv sync --all-groups
+uv run pytest
+```

qoraphase-0.1.0/README.md

@@ -0,0 +1,168 @@
+# QoraPhase
+
+A JAX-native, composable phase-retrieval framework for coherent diffraction imaging.
+
+**Array in → reconstruction out.** QoraPhase does not read files. You bring a
+`numpy` or `jax` array; it gives you back an object.
+
+## Install
+
+```bash
+pip install qoraphase
+```
+
+## Quick start
+
+```python
+import qoraphase as qp
+
+result = qp.reconstruct(intensity, support=support)
+result.plot()
+```
+
+## Array conventions (read this first)
+
+These three are the source of nearly every phase-retrieval bug, so they are part
+of the API contract, not an implementation detail.
+
+| | |
+|---|---|
+| **Origin** | Every public array is **center-origin**: index `n // 2` is q=0. `ifftshift` is internal; never call it yourself. |
+| **`intensity`** | A measured **intensity**, not an amplitude. Internally `sqrt(clip(intensity, 0))`. |
+| **`mask`** | `True` marks an **unusable** pixel (beamstop, hot, saturated). Masked pixels are left unconstrained — never forced to zero. |
+| **`support`** | `True` is inside the object. Omit it and an autocorrelation support is derived (loose; pass a real one when you have it). |
+
+## Composing a reconstruction
+
+Code order is execution order. There is no operator-overloading DSL.
+
+```python
+problem = qp.CDI(intensity=intensity, support=support, mask=mask)
+
+recipe = qp.Recipe(
+    qp.repeat(10, qp.RAAR(50, beta=0.9), qp.Shrinkwrap()),
+    qp.ER(200),
+)
+
+result = problem.reconstruct(recipe)
+```
+
+The first positional argument of an algorithm is always its iteration count.
+
+`qp.detwin(...)` runs its body against a support cut in half at the object's
+centre of mass, then restores the full support. That cut is not centrosymmetric,
+so it fits only one of the two conjugate solutions and biases the run into a
+branch. The default recipe places it a quarter of the way through the RAAR
+cycles, where PyNX puts it. It is measurably useful when the support is
+symmetric and the run would otherwise stall, and harmless when it is not — but
+a support with the right shape is worth far more than any detwinning.
+
+`qp.Shrinkwrap(threshold, sigma, method)` takes `method="max"` (classic, relative
+to the peak amplitude) or `method="rms"` (relative to the rms inside the current
+support, less easily thrown off by a hot pixel). The thresholds are on different
+scales: the classic `"max"` value is 0.2, PyNX uses 0.28 for `"rms"`.
+
+The defaults are `0.3, 1.0` rather than the classic `0.2, 2.0`. Starting from an
+autocorrelation support — the case that actually needs shrinkwrap — 0.2 / 2.0
+never converged in testing and 0.3 / 1.0 did, on every object tried. That is a
+measurement on synthetic data, not a law. **These two numbers are the first thing
+to re-tune on a real dataset.**
+
+## Multi-start
+
+Multi-start is a core feature, not an add-on — for a support with awkward
+symmetry it is the difference between converging and not.
+
+```python
+ensemble = problem.reconstruct(recipe, starts=32, batch=4)
+best = ensemble.best
+```
+
+`vmap` holds every start in memory at once. `batch` chunks that: lower it if a
+large 3D volume runs out of GPU memory.
+
+## Swapping the forward model
+
+Algorithms never name an FFT, so the physics is replaceable without touching
+them:
+
+```python
+qp.CDI(intensity, support=support, model=MyPropagator())
+```
+
+A model needs `forward` / `adjoint` and should be unitary. A *wrong* model fails
+silently — it can fit the data perfectly and return the wrong object — so this
+is worth getting right. See `tests/test_forward_model.py`.
+
+## Before you trust a reconstruction
+
+Check the measurement against the assumptions the library makes about it:
+
+```python
+print(qp.diagnose(intensity, mask=mask, support=support))
+```
+
+It reports the centring offset two ways (brightest pixel, and Friedel symmetry,
+which resolves half a pixel and works on patterns with no dominant peak), how
+much of the array the autocorrelation fills, the negative and masked fractions,
+and warns about each. An off-centre pattern is the failure that costs the most
+and shows the least.
+
+`examples/diagnose.py` does the same from the command line, then reconstructs
+and reports whether independent starts agree:
+
+```
+python examples/diagnose.py scan.npz --key intensity --support sup.npy --starts 8
+```
+
+A low Fourier error says a run fits the data. Agreement between starts, after
+alignment, is what says the answer is determined — they are different claims and
+only the second one is worth much.
+
+## Combining runs
+
+A reconstruction is determined only up to a global phase, a translation, and a
+conjugate flip. No iteration can remove those — they are exact symmetries of the
+constraints — so they are resolved afterwards:
+
+```python
+aligned = ensemble.align()      # every run brought onto the best one
+mean = ensemble.average()       # coherent mean of the aligned runs
+
+```
+
+**Never average runs without aligning them.** Each carries its own global phase,
+so a raw mean interferes destructively — in practice it throws away about two
+thirds of the amplitude. The direction survives, so a similarity score will not
+warn you; only the amplitude shows it.
+
+`align()` picks a *convention*, not the truth. It adopts whichever conjugate
+branch the best run happens to be in — enough to combine runs, and no claim
+about which branch is real. Nothing in the data distinguishes them: `conj(obj(-r))`
+reproduces the measured intensity exactly. What breaks the tie is the support
+you supply. Hand the solver a reflected support and every start converges just
+as cleanly on the mirrored object, with a flawless error metric and no warning.
+The handedness of your support is an assumption, not a result.
+
+Alignment works to whole pixels.
+
+`result.phase` still carries whatever linear phase the measurement geometry put
+there, and QoraPhase does not remove it. Doing that properly needs the
+diffraction geometry, which arrives with BCDI in v0.3; short of that, any
+"correction" is a guess.
+
+If the twin branch matters to you, break the symmetry during the run rather than
+after it — see `qp.detwin` below.
+
+## What this does not do
+
+- No phase-ramp removal, no sub-pixel alignment, no clustering, no PRTF.
+- No positivity/reality constraint — the object is complex here.
+- No file I/O, no BCDI geometry, no NUFFT, no strain, no autodiff optimisers.
+
+## Development
+
+```bash
+uv sync --all-groups
+uv run pytest
+```

qoraphase-0.1.0/examples/diagnose.py

@@ -0,0 +1,140 @@
+"""Run QoraPhase against a real measurement and report whether to believe it.
+
+    python examples/diagnose.py scan.npz --key intensity --mask-key mask
+
+The library never touches files, so the loading lives here.  What the
+script adds on top of ``qp.diagnose`` is the check that synthetic data can never
+provide: whether independent random starts, once aligned, actually agree with
+each other.  A low Fourier error only says a run fits the data; agreement across
+starts is what says the answer is determined.
+
+    --no-run    stop after the pre-flight report
+    --plot out.png   save amplitude/phase panels and the convergence curves
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+import numpy as np
+
+import qoraphase as qp
+
+
+def load(path: Path, key: str | None):
+    """Read one array from .npy, .npz, .mat-style HDF5 or .h5/.cxi."""
+    suffix = path.suffix.lower()
+    if suffix == ".npy":
+        return np.load(path)
+    if suffix == ".npz":
+        with np.load(path) as archive:
+            names = list(archive.files)
+            if key is None:
+                if len(names) != 1:
+                    raise SystemExit(f"{path} holds {names}; pick one with --key")
+                key = names[0]
+            return archive[key]
+    if suffix in (".h5", ".hdf5", ".cxi", ".nxs"):
+        try:
+            import h5py
+        except ImportError:
+            raise SystemExit("reading HDF5 needs h5py: uv pip install h5py") from None
+        if key is None:
+            raise SystemExit(f"--key is required for {suffix} files")
+        with h5py.File(path, "r") as handle:
+            return handle[key][()]
+    raise SystemExit(f"unsupported file type: {suffix}")
+
+
+def agreement(ensemble):
+    """Pairwise similarity between runs, after resolving the ambiguities.
+
+    Each run is aligned onto the first, then compared by normalised overlap.
+    Runs that solved the same problem land on the same answer; runs that found
+    different local minima do not, however good their individual error looks.
+    """
+    reference = np.asarray(ensemble[0].object)
+    aligned = [np.asarray(qp.align_to(run.object, ensemble[0].object)) for run in ensemble]
+    scores = []
+    for i, a in enumerate(aligned):
+        for b in aligned[i + 1 :]:
+            overlap = abs(np.vdot(a, b)) / (np.linalg.norm(a) * np.linalg.norm(b))
+            scores.append(float(overlap))
+    return np.array(scores) if scores else np.array([1.0])
+
+
+def plot(result, ensemble, path):
+    import matplotlib
+
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+
+    figure = plt.figure(figsize=(14, 4))
+    panels = figure.subplots(1, 3)
+    result.plot(axes=panels[:2] if result.object.ndim == 2 else None)
+    for run in ensemble:
+        panels[2].semilogy(np.asarray(run.metrics), lw=0.8)
+    panels[2].set_title("Fourier error")
+    panels[2].set_xlabel("iteration")
+    figure.tight_layout()
+    figure.savefig(path, dpi=120)
+    print(f"\nwrote {path}")
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("path", type=Path)
+    parser.add_argument("--key", help="dataset name inside .npz / .h5")
+    parser.add_argument("--mask", type=Path, help="mask file; True marks bad pixels")
+    parser.add_argument("--mask-key")
+    parser.add_argument("--support", type=Path)
+    parser.add_argument("--support-key")
+    parser.add_argument("--starts", type=int, default=8)
+    parser.add_argument("--batch", type=int)
+    parser.add_argument("--seed", type=int, default=0)
+    parser.add_argument("--no-run", action="store_true")
+    parser.add_argument("--plot", type=Path)
+    args = parser.parse_args(argv)
+
+    intensity = load(args.path, args.key)
+    mask = None if args.mask is None else load(args.mask, args.mask_key).astype(bool)
+    support = (
+        None if args.support is None else load(args.support, args.support_key).astype(bool)
+    )
+
+    report = qp.diagnose(intensity, mask=mask, support=support)
+    print(report)
+    if args.no_run:
+        return 0
+    if report.warnings:
+        print("\ncontinuing anyway -- read the warnings above before trusting this")
+
+    print(f"\nreconstructing, {args.starts} starts ...")
+    ensemble = qp.reconstruct(
+        intensity,
+        support=support,
+        mask=mask,
+        starts=args.starts,
+        batch=args.batch,
+        seed=args.seed,
+    )
+    if args.starts == 1:
+        ensemble = qp.Ensemble((ensemble,))
+
+    errors = np.array([run.error for run in ensemble])
+    scores = agreement(ensemble)
+    print(f"final error   best {errors.min():.3e}   worst {errors.max():.3e}")
+    print(f"run agreement min {scores.min():.3f}   median {np.median(scores):.3f}")
+    if scores.min() < 0.9:
+        print(
+            "!! the starts did not converge on the same object. A low error on a "
+            "single run means it fits the data, not that the answer is determined."
+        )
+
+    if args.plot:
+        plot(ensemble.best, ensemble, args.plot)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

qoraphase-0.1.0/pyproject.toml

@@ -0,0 +1,47 @@
+[project]
+name = "qoraphase"
+version = "0.1.0"
+description = "A JAX-native, composable phase-retrieval framework for coherent diffraction imaging"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE*"]
+authors = [{ name = "Isaac Yong", email = "isaacyong@naver.com" }]
+requires-python = ">=3.12"
+keywords = ["phase retrieval", "coherent diffraction imaging", "CDI", "jax", "x-ray imaging"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Scientific/Engineering :: Physics",
+    "Topic :: Scientific/Engineering :: Image Processing",
+]
+dependencies = [
+    "jax>=0.11.1",
+    "matplotlib>=3.11.1",
+    "numpy>=2.5.2",
+]
+
+[project.urls]
+Homepage = "https://github.com/NaNIsaac/QoraPhase"
+Repository = "https://github.com/NaNIsaac/QoraPhase"
+Issues = "https://github.com/NaNIsaac/QoraPhase/issues"
+
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/qoraphase"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/qoraphase", "tests", "examples", "README.md", "LICENSE", "CITATION.cff"]
+
+[dependency-groups]
+dev = ["pytest>=8"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]

qoraphase-0.1.0/src/qoraphase/__init__.py

@@ -0,0 +1,48 @@
+"""QoraPhase -- a JAX-native, composable phase-retrieval framework for CDI.
+
+Array in, reconstruction out::
+
+    import qoraphase as qp
+    result = qp.reconstruct(intensity, support=support)
+
+All public arrays are center-origin, ``mask=True`` means an unusable pixel, and
+``intensity`` is a measured intensity (not an amplitude).  See spec section 4.
+"""
+
+from .algorithms.er import ER
+from .algorithms.hio import HIO
+from .algorithms.raar import RAAR
+from .api import default_recipe, reconstruct
+from .core.ensemble import Ensemble
+from .core.problem import CDI
+from .core.result import Reconstruction
+from .core.state import ReconState
+from .diagnostics import Diagnosis, diagnose
+from .models.fft import FFT
+from .operators.modulus import ModulusProjection
+from .operators.shrinkwrap import Shrinkwrap
+from .operators.support import SupportProjection
+from .postprocess import align_to
+from .recipes.recipe import Recipe, detwin, repeat
+
+__all__ = [
+    "CDI",
+    "Diagnosis",
+    "ER",
+    "FFT",
+    "HIO",
+    "RAAR",
+    "Ensemble",
+    "ModulusProjection",
+    "ReconState",
+    "Reconstruction",
+    "Recipe",
+    "Shrinkwrap",
+    "SupportProjection",
+    "align_to",
+    "default_recipe",
+    "detwin",
+    "diagnose",
+    "reconstruct",
+    "repeat",
+]

qoraphase-0.1.0/src/qoraphase/algorithms/er.py

@@ -0,0 +1,22 @@
+"""Error Reduction."""
+
+from dataclasses import dataclass
+
+import jax
+
+from ..operators.modulus import modulus_project
+from ..operators.support import support_project
+from ..recipes.recipe import Iterative
+
+
+@dataclass(frozen=True)
+class ER(Iterative):
+    """``x <- P_S P_M x``.  Monotone in the Fourier error, and slow."""
+
+    def step(self, state, problem):
+        projected, err = modulus_project(state.obj, problem)
+        obj = support_project(projected, state.support)
+        return state._replace(obj=obj, iteration=state.iteration + 1), err
+
+
+jax.tree_util.register_dataclass(ER, data_fields=[], meta_fields=["n"])