NumPy FFT Roundtrip: Why Odd-Length Signals Return Fewer Samples

Start with five real samples:

[1.0, 2.0, 3.0, 4.0, 5.0]

Transform them with numpy.fft.rfft, then call numpy.fft.irfft without an explicit output length. In the recorded synthetic reference run, the inverse returned four perfectly finite values:

[1.875, 2.6545225994110333, 4.375, 6.095477400588967]

Nothing crashed. The numbers are plausible. The coefficient array still contains three entries. Yet this is not restoration of the original five-sample record.

That is the operational problem behind an odd-length boundary in NumPy irfft: rfft stores only n//2 + 1 coefficients, and the same coefficient count can be compatible with both an odd and an even original length. When irfft is not told n, NumPy documents an even-length interpretation. For a three-bin spectrum, that default produces four samples, not five.

Restoration therefore means more than “the inverse completed.” It must recover the commissioned ordered record: the original sample count, sample identities, values, transform convention and relevant physical interpretation.

Three evidence classes stay separate throughout this playbook. Documented API behavior comes from the fixed NumPy v2.3 manual accessed October 27, 2026. Recorded observations come from the supplied synthetic CPython 3.12.14 / NumPy 2.3.5 fixture. Acceptance rules are the bounded operational policy proposed here. The manifest is treated as trusted provenance for this laboratory; it is not presented as an authentication system.

Define the original record before transforming it

The transform boundary should begin with a record contract, not with an FFT call. For this fixture, the approved source is the ordered float64 sequence [1, 2, 3, 4, 5], identified as synthetic-ramp-five, with sample IDs t0 through t4, n=5, axis=0, norm="backward" and sample spacing 0.25 seconds. The forward transform consumes all five source samples; it does not supply an n override.

That distinction matters because rfft uses the input length when n is omitted. The NumPy v2.3 rfft documentation explains that an n-sample real transform produces n//2 + 1 retained coefficients. Thus five source samples produce three coefficients, but four source samples also produce three. The spectrum's shape is therefore evidence about possible lengths, not a unique encoding of the original length.

For maintainers already comfortable with the broader scientific Python library foundations, this is a narrower contract question: what information must cross the boundary with a real FFT so that a later consumer can reconstruct the same record rather than merely some valid inverse? Refonte Learning's broader library page identifies NumPy and FFT functionality at toolkit level; it does not substitute for this reconstruction contract.

The producer-side evidence should retain, independently of the coefficient array:

This local dictionary is an assumption of trusted provenance. It does not prove who produced a packet, authenticate storage, establish file durability or validate an arbitrary spectrum.

Keep the sample count alongside the coefficients

The producer must retain the original count before the representation becomes ambiguous. The consumer must not manufacture an “approved n” from whatever length its own inverse happens to return.

For an rfft output containing m coefficients, the inverse default in the NumPy v2.3 irfft documentation is 2*(m-1). With three coefficients, that gives four. To request an odd output length such as five, n must be supplied explicitly. NumPy further warns that the correct Hermitian interpretation depends on the original data length and that the default assumes an even result.

So the consumer needs two independent facts:

len(spectrum) == original_n // 2 + 1

The second requirement is:

original_n == trusted capture record n

The first checks compatibility. The second chooses the commissioned interpretation.

A three-bin spectrum agreeing with n=5 is necessary evidence for this packet. It is not proof that five was the origin, because n=4 is also bin-count compatible. That ambiguity is demonstrated explicitly below rather than left as a theoretical warning.

Pin the runtime and run the complete reference fixture

The supplied reference execution is dated October 27, 2026. It started at 07:08:57.038488 UTC and finished at 07:08:57.077355 UTC, returned exit code 0, and reported PASS_13_CASES.

The recorded environment is:

• CPython 3.12.14

• NumPy 2.3.5

• Linux-6.18.55-x86_64-with-glibc2.39

• finite one-dimensional float64 source arrays

• complex128 real-FFT coefficients

• axis=0

• norm="backward"

• sample spacing 0.25 seconds

The supplied run record states that fft_length_fixture.py contains 211 lines and has SHA-256 58cf65b7b34364afd100ba3ca70d85c730a8f5a9fac2d2074a9eb21991fa9241. That digest identifies the recorded source bytes. It is not evidence authenticating an operational sensor, producer or dataset.

The following setup is an autonomous reproduction procedure, not a claim about how the recorded reference environment was originally created. Confirm the CPython patch version before treating a new run as comparable:

python3.12 -m venv .venv-fft-length
.venv-fft-length/bin/python -m pip install "numpy==2.3.5"
.venv-fft-length/bin/python fft_length_fixture.py > fft_length_results.json

Open fft_length_results.json afterward. A qualifying reproduction should report PASS_13_CASES, preserve the expected case decisions and record its actual interpreter, NumPy and platform strings. A nonzero exit code, changed case value or changed environment is new evidence requiring investigation; it should not be rewritten into the recorded result.

Save the complete fixture below as fft_length_fixture.py:

import cmath
import copy
import hashlib
import json
import math
import platform
import sys
from datetime import datetime, timezone
from pathlib import Path

import numpy as np

ODD = [1.0, 2.0, 3.0, 4.0, 5.0]
EVEN = [1.0, 2.0, 3.0, 4.0]
APPROVED = {"record_id": "synthetic-ramp-five", "n": 5, "axis": 0,
            "norm": "backward", "sample_spacing_seconds": 0.25,
            "sample_ids": ["t0", "t1", "t2", "t3", "t4"]}
ATOL = 1e-12
inverse_calls = 0


class ContractError(ValueError):
    pass


def require(condition, message):
    if not condition:
        raise RuntimeError(message)


def close(actual, expected):
    wanted = np.asarray(expected, dtype=actual.dtype)
    np.testing.assert_allclose(actual, wanted, rtol=0.0, atol=ATOL,
                               equal_nan=False, strict=True)


def direct_dft(values):
    n = len(values)
    return np.asarray([sum(value cmath.exp(-2j math.pi k t / n)
                           for t, value in enumerate(values))
                       for k in range(n // 2 + 1)], dtype=np.complex128)


def direct_real_inverse(bins, n):
    require(len(bins) == n // 2 + 1, "Oracle requires the exact bin count")
    positive = [complex(value) for value in bins]
    positive[0] = complex(positive[0].real, 0.0)
    if n % 2 == 0:
        positive[-1] = complex(positive[-1].real, 0.0)
        tail = [value.conjugate() for value in positive[-2:0:-1]]
    else:
        tail = [value.conjugate() for value in positive[:0:-1]]
    full = positive + tail
    require(len(full) == n, "Bad independent Hermitian expansion")
    return np.asarray([sum(value cmath.exp(2j math.pi k t / n)
                           for k, value in enumerate(full)).real / n
                       for t in range(n)], dtype=np.float64)


def bins_record(values):
    return [{"real": float(x.real), "imag": float(x.imag)} for x in values]


def restore(packet, approved):
    global inverse_calls
    metadata = packet["metadata"]
    for key in approved:
        if key not in metadata:
            raise ContractError("Missing transform metadata: " + key)
    if type(metadata["n"]) is not int or metadata["n"] < 2:
        raise ContractError("Unsupported original length")
    if metadata != approved:
        raise ContractError("Transform metadata conflicts with approved record")
    bins = packet["spectrum"]
    if type(bins) is not np.ndarray or bins.dtype != np.complex128 or bins.ndim != 1:
        raise ContractError("Spectrum must be one-dimensional complex128")
    if len(bins) != metadata["n"] // 2 + 1:
        raise ContractError("Spectrum bin count disagrees with original length")
    if not np.isfinite(bins).all():
        raise ContractError("Spectrum must be finite")
    inverse_calls += 1
    restored = np.fft.irfft(bins, n=metadata["n"], axis=metadata["axis"],
                            norm=metadata["norm"])
    require(restored.shape == (metadata["n"],), "Unexpected reconstructed shape")
    require(restored.dtype == np.float64 and np.isfinite(restored).all(),
            "Unexpected reconstructed values or dtype")
    return restored

def run(report):
    require(np.__version__ == "2.3.5", "Use NumPy 2.3.5 for this reference run")
    rows = report["cases"]
    odd = np.asarray(ODD, dtype=np.float64)
    even = np.asarray(EVEN, dtype=np.float64)
    odd_bins = np.fft.rfft(odd, norm="backward")
    even_bins = np.fft.rfft(even, norm="backward")
    oracle_bins = direct_dft(ODD)
    close(odd_bins, oracle_bins)
    close(even_bins, direct_dft(EVEN))
    report["baseline"] = {"approved": APPROVED, "odd_samples": ODD, "even_samples": EVEN,
                          "odd_spectrum": bins_record(odd_bins),
                          "direct_dft_spectrum": bins_record(oracle_bins),
                          "rtol": 0.0, "atol": ATOL}

    even_default = np.fft.irfft(even_bins, norm="backward")
    close(even_default, EVEN)
    rows.append({"case": "F1_even_default", "samples": even_default.tolist(),
                 "bin_count": len(even_bins), "decision": "ACCEPT_EVEN_CONTROL"})

    odd_default = np.fft.irfft(odd_bins, norm="backward")
    require(odd_default.shape == (4,), "Default inverse did not infer even length")
    close(odd_default, direct_real_inverse(oracle_bins, 4))
    require(not np.allclose(odd_default, odd[:4], rtol=0.0, atol=ATOL),
            "Counterexample must change values, not only discard a trailing sample")
    rows.append({"case": "F2_odd_default", "samples": odd_default.tolist(),
                 "bin_count": len(odd_bins), "decision": "REJECT_ORIGINAL_RECONSTRUCTION"})

    odd_explicit = np.fft.irfft(odd_bins, n=5, norm="backward")
    close(odd_explicit, ODD)
    close(odd_explicit, direct_real_inverse(oracle_bins, 5))
    rows.append({"case": "F3_odd_explicit", "samples": odd_explicit.tolist(),
                 "max_abs_error": float(np.max(np.abs(odd_explicit - odd))),
                 "decision": "ACCEPT_EXPLICIT_LENGTH_CONTROL"})

    impulse4 = np.asarray([1.0, 0.0, 0.0, 0.0], dtype=np.float64)
    impulse5 = np.asarray([1.0, 0.0, 0.0, 0.0, 0.0], dtype=np.float64)
    spectrum4 = np.fft.rfft(impulse4, norm="backward")
    spectrum5 = np.fft.rfft(impulse5, norm="backward")
    require(np.array_equal(spectrum4, np.ones(3, dtype=np.complex128)), "Wrong impulse spectrum")
    require(np.array_equal(spectrum4, spectrum5), "Impulse spectra must be identical")
    close(np.fft.irfft(spectrum4, n=4, norm="backward"), impulse4)
    close(np.fft.irfft(spectrum5, n=5, norm="backward"), impulse5)
    rows.append({"case": "F4_identical_spectra_different_lengths", "lengths": [4, 5],
                 "spectrum": bins_record(spectrum4), "decision": "HOLD_WITHOUT_ORIGINAL_LENGTH"})

    frequency4 = np.fft.rfftfreq(4, d=0.25)
    frequency5 = np.fft.rfftfreq(5, d=0.25)
    close(frequency4, [0.0, 1.0, 2.0])
    close(frequency5, [0.0, 0.8, 1.6])
    rows.append({"case": "F5_frequency_grid", "n4_hz": frequency4.tolist(),
                 "n5_hz": frequency5.tolist(), "decision": "REQUIRE_LENGTH_AND_SPACING"})

    late_spectrum = np.fft.rfft(odd_default, norm="backward")
    lost_oracle = oracle_bins.copy()
    lost_oracle[-1] = complex(lost_oracle[-1].real, 0.0)
    close(late_spectrum, lost_oracle)
    late = np.fft.irfft(late_spectrum, n=5, norm="backward")
    close(late, direct_real_inverse(lost_oracle, 5))
    require(late.shape == odd.shape and float(np.max(np.abs(late - odd))) > 0.1,
            "Late length restoration must fail the original-value contract")
    rows.append({"case": "F6_late_length_only_repair", "samples": late.tolist(),
                 "max_abs_error": float(np.max(np.abs(late - odd))),
                 "decision": "REJECT_SHAPE_ONLY_REPAIR"})

    packet = {"metadata": copy.deepcopy(APPROVED), "spectrum": odd_bins.copy()}
    original_bins = packet["spectrum"].copy()
    result = restore(packet, APPROVED)
    close(result, ODD)
    rows.append({"case": "F7_qualified_restore", "samples": result.tolist(),
                 "decision": "ACCEPT_BOUNDED_RECONSTRUCTION"})

    mutations = [
        ("F8_missing_length", lambda p: p["metadata"].pop("n"),
         "Missing transform metadata: n"),
        ("F9_conflicting_even_length", lambda p: p["metadata"].update(n=4),
         "Transform metadata conflicts with approved record"),
        ("F10_truncated_spectrum", lambda p: p.update(spectrum=p["spectrum"][:-1].copy()),
         "Spectrum bin count disagrees with original length"),
        ("F11_conflicting_normalization", lambda p: p["metadata"].update(norm="ortho"),
         "Transform metadata conflicts with approved record"),
        ("F12_nonfinite_spectrum", lambda p: p["spectrum"].__setitem__(1, complex(float("nan"), 0.0)),
         "Spectrum must be finite"),
    ]
    for name, mutate, message in mutations:
        candidate = copy.deepcopy(packet)
        mutate(candidate)
        before_calls = inverse_calls
        try:
            restore(candidate, APPROVED)
        except ContractError as error:
            require(str(error) == message, "Wrong rejection reason")
        else:
            raise RuntimeError(name + ": expected rejection did not occur")
        require(inverse_calls == before_calls, "Rejected candidate reached inverse FFT")
        rows.append({"case": name, "reason": message, "inverse_called": False,
                     "decision": "HOLD_BEFORE_INVERSE"})

    recovered = restore(packet, APPROVED)
    close(recovered, ODD)
    require(np.array_equal(packet["spectrum"], original_bins), "Source spectrum changed")
    require(packet["metadata"] == APPROVED, "Source metadata changed")
    rows.append({"case": "F13_recover_from_retained_spectrum", "samples": recovered.tolist(),
                 "source_preserved": True, "decision": "REPAIR_FROM_APPROVED_SOURCE"})
    require(len(rows) == 13 and inverse_calls == 2, "Wrong case or qualified-call count")
    report["qualified_inverse_calls"] = inverse_calls
    report["status"] = "PASS_13_CASES"


if name == "__main__":
    report = {"status": "FAIL", "started_utc": datetime.now(timezone.utc).isoformat(),
              "python": sys.version, "implementation": platform.python_implementation(),
              "numpy": np.__version__, "platform": platform.platform(),
              "source_sha256": hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
              "cases": []}
    try:
        run(report)
    except Exception as error:
        report["failure"] = {"type": type(error).__name__, "message": str(error)}
    report["finished_utc"] = datetime.now(timezone.utc).isoformat()
    print(json.dumps(report, indent=2, allow_nan=False))
    sys.exit(0 if report["status"] == "PASS_13_CASES" else 1)

The case ledger deliberately contains demonstrations that “pass” because the expected failure was reproduced. F2_odd_default, for example, is a successful test case but a rejected reconstruction. Likewise, F8 through F12 succeed as contract tests precisely because malformed or conflicting candidates are held before the qualified inverse.

The inverse_calls counter has similarly narrow meaning. Exactly two calls traverse restore() far enough to execute its qualified np.fft.irfft: F7 and F13. The fixture performs additional direct inverse calls in F1 through F6. “Two qualified inverse calls” must therefore not be rewritten as “two inverse FFT operations total.”

Build an independent numerical baseline

The fixture does not start by trusting the FFT implementation to validate itself. It fixes two literal source records:

ODD = [1, 2, 3, 4, 5]

EVEN = [1, 2, 3, 4]

It then computes small reference spectra using scalar complex exponentials in direct_dft. That implementation follows the NumPy v2.3 DFT conventions: the forward sum uses exp(-2πikt/n), while the inverse uses the opposite sign and a 1/n factor. Under norm="backward", NumPy documents the forward transform as unscaled and the inverse as scaled by 1/n.

Before the odd-length defect is demonstrated, the fixture therefore checks:

np.fft.rfft(ODD)  against  direct_dft(ODD)
np.fft.rfft(EVEN) against  direct_dft(EVEN)

For this bounded control, the comparison uses rtol=0, atol=1e-12, equal_nan=False and strict shape/dtype checking.

The same engineering instinct appears in independent NumPy shape and value checks: do not let a numerically executable operation define the application contract merely because it returned an array. That neighboring article concerns observation pairing and broadcasting, not FFT reconstruction; here the one-dimensional representation is already deliberate, and the issue is which original record the inverse represents.

Separate the oracle from the FFT under test

Calling np.fft.rfft twice and comparing the results would demonstrate repeatability of one implementation path, not provide much algorithmic independence.

direct_dft instead constructs each retained coefficient from scalar Python sums and cmath.exp. direct_real_inverse explicitly rebuilds the omitted negative-frequency half by Hermitian conjugation, choosing a different expansion for odd and even n, and then evaluates the inverse scalar sum.

For even n, the final retained coefficient is forced real before the conjugate tail is constructed because that endpoint represents the Nyquist term. For odd n, the final retained coefficient belongs to the largest positive frequency and its conjugate belongs at a distinct negative-frequency location. Those are the same conventions NumPy documents for real transforms.

This is strong evidence for these tiny authored arrays because the expected result comes from retained literal input and a separately written direct computation. It is not arbitrary-precision mathematics, a proof of every FFT length or an accuracy specification for operational telemetry.

Establish the even-length control

F1 prevents the test from treating all default inverses as suspicious.

The source is [1, 2, 3, 4], so n=4. rfft returns three coefficients. irfft receives those three coefficients without n; its documented default is 2*(3-1)=4. The recorded result is exactly the four source values in this fixture.

That outcome is consistent with NumPy's documented even-length default.

But F1 does not establish that m=3 implies n=4. The inverse default merely chooses four. A five-sample real input also produces three retained coefficients. The even control establishes that the baseline mechanics work for the case whose original length agrees with the default; it does not settle original parity for a later packet.

Reproduce the odd-length default failure

F2 changes only the source-length condition. The source is now the five-sample ramp:

[1, 2, 3, 4, 5]

The forward transform uses all five values. NumPy documents rfft output length as n//2 + 1, so 5//2 + 1 = 3 coefficients are retained.

The error enters when reconstruction omits n:

odd_default = np.fft.irfft(odd_bins, norm="backward")

For m=3 incoming coefficients, NumPy documents the default output length as:

2*(m-1) = 2*(3-1) = 4

NumPy also states that odd output lengths require explicit n.

The recorded result is:

[1.875,
 2.6545225994110333,
 4.375,
 6.095477400588967]

This is the decisive NumPy FFT roundtrip length mismatch control. The output is not [1,2,3,4,5], because it contains four samples. It is also not merely the first four source values: every displayed value differs from the corresponding first four source samples.

That matters operationally. The defect is not “one trailing value got clipped.” The consumer requested a different Hermitian interpretation of the same three coefficients, so the reconstructed sample values themselves changed.

Nothing about this result requires an exception or a NumPy bug. It is documented behavior applied without the missing original-length choice. The correct classification for this workflow is REJECT_ORIGINAL_RECONSTRUCTION.

Explain the final coefficient's changed interpretation

For the odd ramp, the recorded rfft spectrum is approximately:

15.0 + 0j
-2.5 + 3.440954801177934j
-2.5 + 0.8122992405822659j

The final coefficient is especially informative here.

For an even input length, the NumPy v2.3 rfft notes describe the final rfft coefficient as the term representing both positive and negative Nyquist frequency; for real input that endpoint must be purely real. For an odd length, there is no Nyquist sample at fs/2; the final retained coefficient represents the largest positive frequency and can generally be complex.

When irfft is called without n, it assumes an even output length. The NumPy v2.3 irfft notes explain that this places the final entry at Nyquist and treats it as purely real under Hermitian symmetry.

So the nonzero 0.8122992405822659j component in the odd ramp's last positive-frequency bin cannot participate in the same way under the four-sample interpretation. The forward FFT did not spontaneously “drop the fifth sample.” The ambiguity becomes consequential when the inverse is asked to interpret the compact spectrum without the original n.

Restore the odd record with its original n

F3 performs the operation that the original capture contract actually commissioned:

odd_explicit = np.fft.irfft(
    odd_bins,
    n=5,
    norm="backward",
)

NumPy's own irfft documentation describes the intended inverse relationship as irfft(rfft(a), len(a)) == a within numerical accuracy and specifically notes why len(a) matters.

The recorded fixture result is:

[1.0, 2.0, 3.0, 4.0, 5.0]

The observed maximum absolute error was 0.0 in the supplied CPython 3.12.14 / NumPy 2.3.5 reference run.

That exact zero is an observation about this small synthetic array, not a general promise about FFT arithmetic. Acceptance here has three parts: the result has shape (5,); the representation is finite float64 under the declared convention; and every value agrees with both the approved literal source and the independent direct Hermitian inverse under the fixture's numeric criterion.

That is the original-sample-count rule for rfft and irfft in operational form: carry the trusted original length into irfft, then reconcile the reconstructed record rather than merely accepting the requested shape.

Prove that the coefficients cannot always reveal original length

The ramp's complex final coefficient is diagnostically useful, but it must not become a heuristic for reconstructing missing metadata.

F4 supplies a stricter counterexample:

length-four source: [1, 0, 0, 0]
length-five source: [1, 0, 0, 0, 0]

Both produce exactly the same three complex128 coefficients in the recorded fixture:

[1+0j, 1+0j, 1+0j]

That is not surprising under the real-FFT size rule. Both n=4 and n=5 produce n//2+1 = 3 retained values. More importantly, this chosen pair makes the coefficient values identical as well as their shape. The spectrum therefore cannot tell the consumer which of these two source records was intended.

F4 is stronger than saying “parity might be hard to guess.” It provides a constructive example of odd/even rfft spectrum ambiguity where coefficient inspection has no numerical clue to recover the missing original count.

The acceptance consequence is direct: when trusted original-length metadata is absent, hold the reconstruction rather than infer provenance from coefficient count or appearance.

Use identical impulse spectra as the counterexample

With an explicit length, both records reconstruct correctly:

np.fft.irfft([1+0j, 1+0j, 1+0j], n=4)
# [1, 0, 0, 0]

np.fft.irfft([1+0j, 1+0j, 1+0j], n=5)
# [1, 0, 0, 0, 0]

The same stored three numbers therefore support two legitimate inverse interpretations.

This also bounds what can be inferred from the ramp's imaginary endpoint. A nonzero imaginary last coefficient can contradict an even-source interpretation under this convention, because an even real transform's Nyquist endpoint is real. But a real-valued endpoint cannot establish that the source was even: the five-sample impulse has a real final coefficient too.

Do not promote “inspect the last bin” into provenance recovery. Preserve n.

The decision for F4 is HOLD_WITHOUT_ORIGINAL_LENGTH, not because NumPy lacks a mathematical inverse for either candidate, but because the consumer lacks evidence about which commissioned source record it is authorized to reconstruct.

Reconstruct the frequency grid from length and spacing

Original length also affects the physical labels attached to the retained bins.

The NumPy v2.3 rfftfreq documentation describes rfftfreq(n, d) as returning frequencies in cycles per unit of the sample spacing, with formulas that depend explicitly on n. When d is seconds, those units are cycles per second, or hertz.

F5 uses d=0.25 seconds:

n=4 -> [0.0, 1.0, 2.0] Hz
n=5 -> [0.0, 0.8, 1.6] Hz

Both arrays contain three frequencies because both real spectra contain three coefficients. They are nevertheless different grids.

So retaining a metadata field for the original length of a real FFT is not merely about getting a time-domain array back. Together with sample spacing, n determines how the bins are interpreted physically. A downstream stage given “three bins, spacing 0.25 s” still cannot derive the correct frequency labels without the source window length.

This is why preserving positions and interpretation has to precede later event logic. The separate article on preserving sample positions in signal analysis addresses peak-selection order after positions already have meaning; this reconstruction boundary comes earlier and does not reuse that peak-selection algorithm.

For this article, F5 stops at that metadata consequence. It is not a frequency-analysis, peak-detection or resampling tutorial.

Demonstrate why a late shape repair still fails

F6 asks the question that often appears after the defect has already propagated: “We now know it should have had five samples. Can we simply request five on the next inverse?”

Not from the already altered four-sample record.

The fixture deliberately follows the damaged path in order:

1. Start with the original five-sample spectrum.

2. Reconstruct it incorrectly with default irfft, obtaining the four-value F2 output.

3. Apply rfft again to those four altered samples.

4. Only then call irfft(..., n=5).

The final five-value array is:

[1.0,
 2.190983005625053,
 2.690983005625053,
 4.3090169943749475,
 4.8090169943749475]

Its shape is (5,), but its recorded maximum absolute error from the original ramp is:

0.30901699437494745

F6 therefore rejects an attempt to restore an odd-length real signal by repairing only the dimension.

The causal evidence is visible in the endpoint coefficient. Under the original odd interpretation, the final coefficient contains -2.5+0.8122992405822659j. The four-sample inverse interprets that endpoint as a Nyquist term and effectively uses its real component for the even reconstruction. When those four samples are transformed again, the resulting even spectrum cannot regenerate the discarded endpoint imaginary contribution. That follows from the documented even-Nyquist convention as well as the independent fixture control.

Requesting n=5 later tells NumPy how many points to produce from the new spectrum. It does not recreate information that is no longer present in that spectrum.

Retain the original spectrum for a real recovery

There are therefore two materially different candidates:

retained original spectrum
    -> irfft(original_bins, n=5)
    -> original five-sample fixture

spectrum recomputed from incorrect four-sample output
    -> irfft(late_bins, n=5)
    -> five samples with wrong values

The second candidate is shape-correct but source-incorrect. This is precisely why inverse FFT shape and value checks must be separate.

A manifest recording the rfft spectrum length is useful only when it remains attached to the coefficients it describes. Recording n=5 after replacing the original spectrum with coefficients derived from an altered four-sample reconstruction does not turn those newer coefficients back into source evidence.

This article therefore does not propose fabricated recovery of missing information. If the original spectrum has been discarded and no other approved source record exists, hold. If a different five-point Fourier interpolation or deliberately changed output length is actually the commissioned operation, specify and validate that as a different task; do not call it restoration of the original five samples merely because NumPy permits the call. The irfft documentation explicitly permits other n choices and describes their high-frequency truncation or zero-padding semantics, so “another n” is not inherently invalid.

Validate the packet before calling the inverse

The restore() wrapper turns provenance assumptions into an executable boundary.

It does not begin with np.fft.irfft. It first asks whether the candidate packet agrees with the separately supplied approved record. In this fixture that means all expected metadata fields are present; n is an integer satisfying the laboratory's supported range; the complete metadata dictionary equals APPROVED; the spectrum is exactly a one-dimensional complex128 NumPy array; its bin count is compatible with the approved n; and every coefficient is finite.

Only then does the wrapper increment inverse_calls and execute:

np.fft.irfft(
    bins,
    n=metadata["n"],
    axis=metadata["axis"],
    norm=metadata["norm"],
)

The five mutation controls establish that rejection happens before that qualified call:

F9 is especially important. A three-bin spectrum is structurally compatible with n=4; 4//2+1 is three. Bin count therefore cannot expose this mutation. The rejection depends on the independently retained approved record saying that this packet belongs to a five-sample capture.

F11 likewise does not claim that "ortho" is an invalid NumPy normalization. NumPy documents "backward", "ortho" and "forward" modes. The packet is held because "ortho" conflicts with this record's approved "backward" convention.

The n >= 2 condition deserves similar restraint: it is a fixture policy in restore(), not a statement of NumPy's universal input restrictions.

Metadata checks also do not prove coefficient authenticity or correctness. A malicious, stale or simply wrong complex128 array could be finite, have three bins and carry perfectly matching metadata. For this synthetic fixture, value qualification comes from the independently retained source samples and DFT oracle. A real deployment must define its own authority for capture records, sample identities and spectral provenance.

Finally, exactly two calls, F7 and F13, cross this wrapper into its qualified inverse. F1 through F6 contain other direct NumPy inverse operations, so qualified_inverse_calls == 2 must not be confused with the total number of inverse operations performed by the test program.

Reconcile every reconstructed sample

F7 represents the first candidate that satisfies the bounded reconstruction policy end to end.

The packet contains a copy of the original odd spectrum and a copy of the approved metadata. restore() validates that metadata, representation, finite state and bin count before executing irfft(..., n=5, axis=0, norm="backward"). The fixture then compares the result with all five source values.

The recorded output is:

[1.0, 2.0, 3.0, 4.0, 5.0]

The decision was ACCEPT_BOUNDED_RECONSTRUCTION.

Acceptance is not based on “five finite numbers came back.” It requires evidence at several levels:

A matching average, matching first sample or matching count would be weaker evidence. F6 already proves that the count can be correct while multiple values are wrong. F2 proves that finite, smooth-looking values can be wrong in both count and content.

For an acquisition pipeline, the operational question is not whether a numeric vector “looks signal-like.” It is whether every reconstructed position has been reconciled with the source evidence authorized for that record.

Bound the numerical acceptance rule

The fixture's close() function uses:

np.testing.assert_allclose(
    actual,
    wanted,
    rtol=0.0,
    atol=1e-12,
    equal_nan=False,
    strict=True,
)

The NumPy v2.3 assert_allclose documentation describes strict=True as requiring matching shapes and dtypes rather than allowing mismatches that ordinary comparison behavior could otherwise accommodate.

rtol=0 makes this fixture use only its authored 1e-12 absolute allowance. equal_nan=False refuses to treat corresponding NaNs as accepted values. Those are deliberate controls for these small synthetic arrays; they are not a general scientific error budget or sensor-accuracy standard.

The distinction belongs in an explicit numerical-reference policy: numeric tolerances need a named purpose, units and authority rather than being copied from an unrelated test. That article examines reference direction and tolerance policy; this one uses a fixed assert_allclose rule only to qualify the FFT fixture.

The observed 0.0 maximum error in F3 is likewise just one recorded outcome. It should not be converted into a requirement that all FFT roundtrips be bit-exact.

Recover from preserved source evidence

F13 is the repair path that actually has the evidence required for restoration.

Crucially, it does not try to improve the F2 or F6 downstream arrays. The fixture goes back to packet, whose spectrum was copied from the original odd_bins before the mutation tests. It calls restore() again with the same approved five-sample metadata.

The result is again:

[1, 2, 3, 4, 5]

The fixture additionally checks:

np.array_equal(packet["spectrum"], original_bins)
packet["metadata"] == APPROVED

It also records "source_preserved": True.

That is a materially stronger recovery story than “we changed the array length until it looked right.” The original coefficients and trusted original n survived, so the consumer can rerun the intended inverse and reconcile all values against the approved source fixture.

The proposed operational rule is therefore: keep the last accepted downstream record in place while a repaired candidate is being evaluated; rebuild the candidate from retained original coefficients and trusted transform metadata; and promote it only after the complete reconstruction contract passes.

If the trusted length is missing, hold. If metadata contradicts the approved capture, hold. If the original coefficients were replaced with a spectrum computed from an already misinterpreted reconstruction, do not label a later length adjustment as recovery of the original record.

This laboratory stops at that evidence decision. Filesystem transactions, atomic publication, packet authentication, replicated storage and production rollout mechanics require separate engineering policies. The manifest used here demonstrates what the transform boundary needs to know; it does not make those surrounding systems trustworthy automatically.

Assign ownership to accept, rebuild and hold decisions

A reliable transform boundary works best when no one stage is allowed to infer all of its own evidence.

The producer owns capture-time facts such as record identity, original count and spacing. The transform boundary owns preservation of those facts alongside the coefficient representation. The consumer owns validation before reconstruction. The numerical owner owns the justified comparison rule and determines what “equivalent enough” means for the commissioned application.

That separation keeps fixture execution success from being confused with data acceptance. PASS_13_CASES means the supplied program observed all thirteen outcomes it expected, including several intentional rejection cases. It does not mean every packet in the ledger represents an accepted reconstruction.

The central decision is similarly narrow:

Accept F7/F13-style candidates after trusted metadata and complete source-value reconciliation.

Reject as original-record restoration the F2 odd default and F6 late shape-only repair.

Rebuild from retained original coefficients plus trusted original length when those inputs still exist.

Hold when the original length is absent, metadata conflicts or the packet fails structural checks.

And when someone deliberately asks irfft for a different n, treat that as a separately commissioned transform operation. NumPy supports such calls; the API itself is not the problem. The mistake would be silently changing the meaning from “produce a different-length inverse” to “prove we restored the original capture.”

Within the stated scope of one-dimensional finite real float64 data, complex128 rfft coefficients, axis 0 and backward normalization, that is the evidence threshold for FFT reconstruction sample validation. It does not imply production reliability, source authentication, calibration accuracy, file durability, generic resampling correctness or suitability for other transform conventions.

Build stronger numerical-Python validation skills

The most transferable lesson is not a Fourier identity; it is how to turn numerical assumptions into reproducible boundaries: preserve provenance before transformation, construct an independent reference for a small control, validate representation before execution, and reconcile the complete output before accepting it.

That practice sits naturally beside the wider data-science toolkit, while remaining much narrower than a general survey of Python, statistics or machine learning.

Refonte Learning's Data Science Program currently lists a three-month main Program Specifics format with 12 to 14 hours per week and names Python Data Science, Statistical Modelling, Model Optimization & Problem-Solving Techniques, Machine Learning and Predictive Modelling, and application to industry projects among its competencies. Its FAQ also explicitly lists tools including Python, Jupyter Notebook, Pandas and NumPy.

Those confirmed foundations are relevant to developing the habit used here: make numerical code demonstrate the exact claim you intend to accept. The verified program information does not establish that this particular rfft/irfft laboratory, NumPy 2.3.5 or a specific depth of FFT/DSP material is taught.

For details on the curriculum and current program terms, see the Data Science Program page above. The practical goal is broader than memorizing one irfft n parameter: learn to preserve the evidence that gives transformed arrays their meaning, and make reconstruction earn acceptance through reproducible shape, metadata and value checks.