Stop Invalid NumPy Division Before Selecting Results

A ratio array can be completely finite and still come from an implementation that performed divisions the contract meant to exclude. The familiar expression np.where(mask, numerator / denominator, fallback) makes that possible. The final selection may replace every inf or nan produced at a false-mask position, leaving only ordinary numbers and a fallback marker. The warnings, however, reveal that the quotient expression had already been evaluated.

Changing to np.divide(numerator, denominator, where=mask) addresses only half of the problem. A masked universal function, or ufunc, does not automatically invent the correct value for positions where its mask is false. With a supplied out, those positions keep what was already there. Without a supplied out, they remain uninitialized. Reusing a finite buffer can therefore yield a quiet, finite, stale result.

This article qualifies both responsibilities: where division occurs and how every output slot gets its current value. The evidence is a deterministic twelve-case CPU laboratory using finite one-dimensional float64 arrays, an independent literal oracle, scoped floating-point policies, deliberate buffer reuse, and negative controls. The commissioning record reports PASS_12_CASES on October 10, 2026; no new execution is claimed here. Even a successful implementation test does not decide whether ratios with excluded denominators may enter a business report. Arithmetic qualification and domain permission remain separate decisions.

1. Declare the quotient and exclusion contract

Start with five stable row identities, q0 through q4. Each row has a finite float64 numerator and denominator. The calculation rule is intentionally narrow:

• calculate numerator / denominator only where denominator != 0;

• place -999.0 at every excluded position;

• retain the Boolean mask with the output;

• reject inputs outside the declared shape, dtype, and finiteness boundary.

Under that rule, a calculated quotient is a value written by division at a true-mask position. An excluded position is not a failed quotient repaired afterward. It is a position at which this implementation is not authorized to perform the division and whose output must receive the declared marker by initialization.

The marker is useful because it is visibly outside this fixture’s valid quotient set. It is not a universal missing-value convention, and it cannot replace the mask. Another dataset could legitimately produce -999.0. The durable artifact therefore needs both the numerical array and the exclusion evidence. A reviewable record should also bind those fields to row identity and implementation revision. Otherwise, a later consumer may know which positions contain markers but not which source rows they describe or which rule produced them.

This is the same discipline as defining a data-quality rule before changing values: state what the source means, which transformation is permitted, and how exceptions remain visible. The laboratory qualifies an implementation of that rule. It does not admit the source rows to downstream analytics. A domain owner must separately decide what a zero denominator means and whether an all-excluded dataset is publishable.

2. Follow argument evaluation before selection

Consider the expression:

np.where(denominator != 0, numerator / denominator, fallback)

The NumPy 2.3 numpy.where reference describes the three-argument form as choosing elements from x or y according to a condition. That selection contract does not make the x expression lazy. Python’s call-expression rules state that argument expressions are evaluated before the call is attempted. Consequently, numerator / denominator must produce an argument value before np.where(...) can select from it.

With NumPy’s warning policy, the quotient can produce inf and nan, emit warnings, and then be hidden by the final selection. With a raising policy, evaluation of that quotient can raise FloatingPointError; the outer np.where call may never occur. The false entries in the condition cannot retroactively cancel arithmetic that already happened while constructing an argument. The condition expression, quotient expression, and fallback expression are all ordinary call arguments. In this fixture the condition and scalar fallback are harmless; the quotient is the dangerous argument. Reordering the visual layout across multiple lines does not change that boundary.

This also explains why an exception policy is such a useful diagnostic. If N / D raises while arguments are being built, there is no selected array to inspect, no fallback application to approve, and no basis for claiming that the outer selection handled the invalid positions. The failure occurred before selection could establish its result.

This is an evaluation-order statement, not an instruction trace or a performance claim. It establishes the program-level reason the prohibited quotient expression can execute. It does not claim that every processor, build, or optimization exposes identical low-level behavior.

Distinguish the two meanings of where

np.where(condition, x, y) is a selection function. By contrast, np.divide(x1, x2, out=out, where=mask) passes where to the division ufunc itself. In the second form, true positions identify where that ufunc calculates and writes; false positions leave the output alone under NumPy’s documented ufunc contract. The shared word where does not make the APIs interchangeable.

The condition-only form of np.where returns indices and is outside this experiment. The relevant comparison is strictly between three-argument selection after operand evaluation and a mask attached directly to the division operation.

3. Freeze the environment and literal oracle

The supplied commissioning run began at 2026-10-10T06:27:55.281776+00:00 and ended at 2026-10-10T06:27:55.348171+00:00. It recorded Python 3.12.14, NumPy 2.3.5, and Linux-6.18.44-x86_64-with-glibc2.39. The fixture identity was numpy-where-v1; the exact source SHA-256 was a9af803f73714a1eb37ab1f796f856c091a3f7b0cbef019e40803693bdadd73a. These timestamps identify evidence; they are not benchmark measurements.

The documentation references deliberately use the NumPy 2.3 branch. The Python language reference used for the commissioning packet was the 3.12 branch and identified documentation version 3.12.15, while the historical test interpreter was 3.12.14. Documentation identity and execution identity should remain separate. A new run must record its own Python, NumPy, platform, source hash, start and finish times, manifest, inputs, sign bits, warnings, exceptions, and output arrays rather than borrowing this provenance.

The five-row mixed fixture is:

Thus the literal mask is [false, true, false, false, true], and the mixed oracle is [-999, 2, -999, -999, 0]. The all-zero control expects five markers. The all-nonzero comparison uses denominators [2, -4, 3, -2, 2] and expects [3, -2, 0, 1.5, 0]. These values are exactly representable in binary floating point, so exact comparison is appropriate for this fixture; that choice does not establish a tolerance policy for unrelated numerical work.

The oracle is deliberately literal rather than generated by the implementation under test. If the expected array were computed by another call to the same quotient path, the test could repeat the defect and certify itself. Here, IDs, mask, mixed output, all-zero output, valid comparison, initialized-sentinel output, and stale-output control are written independently in MANIFEST. A new run should first reconcile those literals with the review contract, then compare the program’s observations against them.

The broader skills behind this inspection connect to numerical Python foundations in the data scientist’s toolkit, but this laboratory stays with one bounded arithmetic contract.

Include both zero-over-zero and signed-zero denominators

The fixture distinguishes three excluded forms: 6/+0, 0/+0, and -3/-0. The denominator != 0 rule excludes both positive and negative zero. The report also stores np.signbit(D) so the negative-zero input remains visible instead of being silently normalized in prose or evidence. This is enough to prove the intended mask over the chosen inputs; it is not a complete treatment of IEEE 754 arithmetic.

4. Run the complete twelve-case laboratory

Save the following file as numpy_where_fixture.py in a writable local directory, install or activate the intended Python and NumPy environment, and run:

python numpy_where_fixture.py

The program creates a uniquely named result directory beside the script and prints the path to results.json. To reproduce the supplied source hash, preserve the file exactly. Any edit creates a different fixture and requires its own hash and execution record.

"""CPU-only known-answer lab; no deployment or business-data acceptance."""
import hashlib
import json
import platform
import tempfile
import warnings
from datetime import datetime, timezone
from pathlib import Path

import numpy as np

FILL = -999.0
N = np.array([6., 8., 0., -3., 0.], dtype=np.float64)
D = np.array([0., 4., 0., -0., 2.], dtype=np.float64)
Z = np.zeros(5, dtype=np.float64)
MANIFEST = {
    "ids": ["q0", "q1", "q2", "q3", "q4"],
    "mask": [False, True, False, False, True],
    "mixed": [-999., 2., -999., -999., 0.],
    "all_zero": [-999., -999., -999., -999., -999.],
    "valid": [3., -2., 0., 1.5, 0.],
    "sentinel": [123., 2., 123., 123., 0.],
    "stale": [7., 2., 7., 7., 0.],
}


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


def matches(value, expected):
    require(value.shape == (len(expected),), "Unexpected output shape")
    require(value.dtype == np.dtype("float64"), "Unexpected output dtype")
    require(np.isfinite(value).all(), "Unexpected non-finite output")
    np.testing.assert_allclose(value, expected, rtol=0, atol=0,
                               equal_nan=False, strict=True)


def guarded(numerator, denominator):
    for value in (numerator, denominator):
        if (type(value) is not np.ndarray or value.ndim != 1 or
                value.size == 0 or value.dtype != np.dtype("float64") or
                not np.isfinite(value).all()):
            raise ValueError("Expected nonempty finite float64 vector")
    if numerator.shape != denominator.shape:
        raise ValueError("Expected equal vector shapes")
    out = np.full(numerator.shape, FILL, dtype=np.float64)
    mask = denominator != 0
    with np.errstate(all="raise"):
        np.divide(numerator, denominator, out=out, where=mask)
    require(np.isfinite(out).all(), "Computed output must be finite")
    return out


def observed(row, operation, mode, expected=None, exception=None,
             warnings_expected=False):
    prior = np.geterr().copy()
    result = None
    caught = None
    with warnings.catch_warnings(record=True) as captured:
        warnings.simplefilter("always")
        try:
            with np.errstate(all=mode):
                result = operation()
        except Exception as error:
            caught = error
        finally:
            row["warnings"] = [{"category": w.category.__name__,
                                 "message": str(w.message)} for w in captured]
            row["exception"] = None if caught is None else {
                "type": type(caught).__name__, "message": str(caught)}
    row["error_policy_restored"] = np.geterr() == prior
    require(row["error_policy_restored"], "errstate leaked")
    if exception is not None:
        require(type(caught) is exception, "Wrong or missing exception")
        require(result is None, "An exceptional call returned a result")
    else:
        require(caught is None, "Unexpected exception: " + repr(caught))
        row["output"] = result.tolist()
        matches(result, expected)
    if warnings_expected:
        require(any(issubclass(w.category, RuntimeWarning) for w in captured),
                "Expected floating-point warning missing")
    else:
        require(not captured, "Unexpected warning")


def main():
    destination = Path(tempfile.mkdtemp(prefix="numpy-where-", dir=Path(__file__).parent))
    report = {"fixture": "numpy-where-v1", "status": "FAIL", "cases": [],
              "started_utc": datetime.now(timezone.utc).isoformat(),
              "python": platform.python_version(), "numpy": np.__version__,
              "platform": platform.platform(), "manifest": MANIFEST,
              "numerator": N.tolist(), "denominator": D.tolist(),
              "denominator_signbit": np.signbit(D).tolist(),
              "source_sha256": hashlib.sha256(Path(__file__).read_bytes()).hexdigest()}

    def case(identity, operation):
        row = {"id": identity, "status": "FAIL"}
        report["cases"].append(row)
        operation(row)
        row["status"] = "PASS"

    try:
        require((D != 0).tolist() == MANIFEST["mask"], "Mask mismatch")
        case("C1_eager_mixed_warn", lambda r: observed(r,
             lambda: np.where(D != 0, N / D, FILL), "warn",
             MANIFEST["mixed"], warnings_expected=True))
        case("C2_eager_mixed_raise", lambda r: observed(r,
             lambda: np.where(D != 0, N / D, FILL), "raise",
             exception=FloatingPointError))
        case("C3_eager_all_zero_warn", lambda r: observed(r,
             lambda: np.where(Z != 0, N / Z, FILL), "warn",
             MANIFEST["all_zero"], warnings_expected=True))
        case("C4_masked_mixed", lambda r: observed(r,
             lambda: guarded(N, D), "raise", MANIFEST["mixed"]))
        case("C5_masked_all_zero", lambda r: observed(r,
             lambda: guarded(N, Z), "raise", MANIFEST["all_zero"]))
        case("C6_all_nonzero", lambda r: observed(r,
             lambda: guarded(N, np.array([2., -4., 3., -2., 2.])),
             "raise", MANIFEST["valid"]))
        case("C7_preserve_initialized_slots", lambda r: observed(r,
             lambda: np.divide(N, D, out=np.full(5, 123.), where=D != 0),
             "raise", MANIFEST["sentinel"]))

        def reused(row):
            out = guarded(np.full(5, 14.), np.full(5, 2.))
            matches(out, [7., 7., 7., 7., 7.])
            row["before"] = out.tolist()
            observed(row, lambda: np.divide(N, D, out=out, where=D != 0),
                     "raise", MANIFEST["stale"])
            row["current_fallback_contract_matches"] = False
            require(not np.array_equal(out, MANIFEST["mixed"]),
                    "Stale-output negative control did not fail")
            fresh = guarded(N, D)
            matches(fresh, MANIFEST["mixed"])
            row["fresh_repair"] = fresh.tolist()
        case("C8_reused_output_then_fresh_repair", reused)

        def ignored(row):
            def operation():
                intermediate = N / D
                row["intermediate_isfinite"] = np.isfinite(intermediate).tolist()
                row["intermediate_isnan"] = np.isnan(intermediate).tolist()
                row["intermediate_isinf"] = np.isinf(intermediate).tolist()
                require(row["intermediate_isfinite"] == MANIFEST["mask"],
                        "Intermediate non-finite locations changed")
                return np.where(D != 0, intermediate, FILL)
            observed(row, operation, "ignore", MANIFEST["mixed"])
        case("C9_ignore_does_not_prevent_division", ignored)
        case("C10_eager_operand_before_masked_ufunc", lambda r: observed(r,
             lambda: np.divide(N / D, 1., out=np.full(5, FILL), where=D != 0),
             "raise", exception=FloatingPointError))

        def rejected(row):
            row["controls"] = []
            for name, n, d in [
                ("shape", N, D[:, None]),
                ("dtype", N.astype(np.int64), D),
                ("nonfinite", np.array([6., 8., np.nan, -3., 0.]), D)]:
                control = {"id": name}
                row["controls"].append(control)
                observed(control, lambda: guarded(n, d), "raise", exception=ValueError)
        case("C11_reject_out_of_contract_inputs", rejected)
        case("C12_nonzero_denominator_can_overflow", lambda r: observed(r,
             lambda: guarded(np.array([1e308]), np.array([1e-308])),
             "raise", exception=FloatingPointError))
        require(len(report["cases"]) == 12, "Incomplete case set")
        report["status"] = "PASS_12_CASES"
    except Exception as error:
        report["error"] = {"type": type(error).__name__, "message": str(error)}
        raise
    finally:
        report["finished_utc"] = datetime.now(timezone.utc).isoformat()
        path = destination / "results.json"
        path.write_text(json.dumps(report, indent=2, allow_nan=False) + "\n")
        print(path)


if name == "__main__":
    main()

The report starts in FAIL, and each case starts in FAIL; a case changes to PASS only after its assertions complete. require checks the literal mask, output shape, dtype, finiteness, warning expectations, exception type, restored error policy, negative controls, and complete case count. matches compares against independent manifest literals with zero relative and absolute tolerance.

Warnings are captured as category and message, while exceptions are recorded by type and message. The test relies only on the relevant warning category rather than universal warning text or ordering. allow_nan=False prevents non-finite evidence from being serialized silently as non-standard JSON values.

Each invocation receives a fresh tempfile.mkdtemp directory, so it does not overwrite an earlier record. The finally block writes the report even after an unexpected error, preserving partial evidence. That design does not establish atomic rollback, and the failure-writing path was not separately fault-injected in the supplied commissioning run.

5. Read the eager warning and exception controls

C1 evaluates the mixed expression under warn. The supplied October 10 commissioning record shows the selected output [-999, 2, -999, -999, 0], exactly as the manifest requires. It also records divide-by-zero and invalid-operation RuntimeWarning text. Those warnings correspond to prohibited intermediate arithmetic at excluded positions; they do not mean the selected values at q1 and q4 are wrong.

C2 runs the same expression under raise. The NumPy 2.3 seterr reference documents warn as emitting a RuntimeWarning and raise as raising FloatingPointError; it separately classifies division by zero, overflow, underflow, and invalid operations. The commissioning observation is the expected FloatingPointError, with no result returned by the outer expression. Passing C2 means the exceptional control detected the eager operation. It does not mean a usable transformation completed. This vocabulary matters in test reports: an expected exception can make the case pass while the candidate expression remains unacceptable as a data-producing implementation.

C3 strengthens the diagnosis with an all-zero denominator. Its condition is false everywhere, so the intended selected array is five fallback markers. The supplied run returned that finite array in warning mode while still recording the relevant division-by-zero and invalid-operation warnings. Even when not one quotient is authorized for publication, the quotient argument was evaluated before selection.

This distinction resembles why a finite R² can conceal an undefined score: a finite presentation layer is not, by itself, complete evidence about the calculation that preceded it. Here the issue is not model scoring but arithmetic execution.

A finite selected array is incomplete evidence

C9 makes the hidden intermediate explicit. Under ignore, it stores:

• intermediate_isfinite = [false, true, false, false, true];

• intermediate_isnan = [false, false, true, false, false];

• intermediate_isinf = [true, false, false, true, false].

It then selects the finite mixed oracle. Suppression changed the reporting policy, not the operation. A quiet log cannot prove that excluded division was prevented, and this laboratory makes no performance comparison between the two implementations.

6. Put the mask on the division ufunc

The repair moves conditionality onto the arithmetic operation:

out = np.full(numerator.shape, -999.0, dtype=np.float64)
mask = denominator != 0
with np.errstate(all="raise"):
    np.divide(numerator, denominator, out=out, where=mask)

The NumPy 2.3 numpy.divide reference says that true where locations are set to the ufunc result while other locations retain the original out value. The general ufunc contract describes true positions as locations at which to calculate the ufunc and false positions as locations that leave the output alone. That is the semantic boundary this implementation needs. It is not an instruction-level trace.

The guarded helper first enforces the experiment’s narrow preconditions: exact ndarray objects, one nonempty dimension, float64, finite values, and equal shapes. It then creates fresh storage already containing the fallback, derives the mask, and performs only the authorized division under a raising error policy.

C4 applies that helper to the mixed fixture and returns [-999, 2, -999, -999, 0] without warnings. C5 passes an all-zero denominator and returns five markers without warnings. C6 uses all nonzero denominators, including negative values, and returns [3, -2, 0, 1.5, 0]. Together they cover mixed exclusion, total exclusion, and ordinary quotient calculation.

The helper’s postcondition, np.isfinite(out).all(), is intentionally secondary. The stronger evidence is how each slot obtained its value: initialization for excluded rows and division for included rows. Finiteness catches an unexpected surviving non-finite value, but it cannot replace mask reconciliation or prove that a value belongs to the current calculation.

The repair is also bounded to this direct division. It does not authorize arbitrary eager expressions in either operand, change NumPy’s broadcasting rules, or guarantee safety for every finite nonzero pair. C10 and C12 remain necessary because operand evaluation and overflow are separate failure paths.

An all-marker result is successful implementation evidence: every position followed the exclusion rule. It contains no calculated ratios. Whether a downstream report can use an artifact with no authorized quotient is a separate domain decision.

7. Initialize every output position deliberately

A ufunc mask governs where the ufunc writes; it does not define the current value of every false-mask slot. C7 makes that rule observable by supplying an output initialized to 123.0:

np.divide(N, D, out=np.full(5, 123.0), where=D != 0)

The expected and observed array is [123, 2, 123, 123, 0]. Positions q1 and q4 were written by the current division. Positions q0, q2, and q3 retained their initial values. That is correct NumPy behavior and an incorrect result only when the application contract requires -999.0 there.

Initialization must also establish storage type deliberately. The helper uses np.full(..., dtype=np.float64), matching the source contract and quotient result. It does not derive output storage from an integer convenience array, depend on an unsafe cast, or assume NumPy will convert every supplied out to whatever type the application intended. Output ownership includes dtype, shape, initial values, and reuse policy. It also includes timing: initialization must belong to the same logical calculation as the true-mask writes. A buffer initialized correctly yesterday is not initialized correctly for today’s fallback rule merely because its dtype and shape still match.

The right review question is therefore not merely, “Did the true-mask quotients match?” It is, “For every row, which current operation or initialization rule assigned the value now present?” C7 proves that false slots have provenance too: their provenance is prior initialization, not division.

Omitted output has no deterministic fallback

When out=None, np.divide allocates an output. NumPy’s divide and ufunc documentation warns that false-mask positions in such an output remain uninitialized. The contract does not promise zeros, nan, a previous array’s values, or any stable “garbage” pattern. Code must not inspect one local allocation and turn allocator residue into an oracle.

That is why the laboratory uses a deterministic initialized sentinel for comparison. For an application fallback, either supply correctly initialized output or assign all excluded positions through another explicit current rule. Checking only the true-mask slice is inadequate because it excludes precisely the slots whose ownership is under review.

8. Reproduce stale values when the buffer is reused

C8 demonstrates why warning-free masked division can still violate the output contract. It first calls guarded with five numerators of 14.0 and five denominators of 2.0. Every mask entry is true, so the newly allocated output becomes [7, 7, 7, 7, 7]. That array is then deliberately reused:

np.divide(N, D, out=out, where=D != 0)

The current mixed operation writes 2.0 at q1 and 0.0 at q4. It leaves the false-mask positions alone, producing [7, 2, 7, 7, 0]. The result is finite, raises no floating-point warning, and contains correct values at both calculated positions. It nevertheless fails the current fallback contract because three sevens belong to an earlier calculation.

The case records current_fallback_contract_matches = False and requires the stale array not to equal the mixed manifest. This is an intentional negative control, not a failed laboratory. Only after preserving that mismatch does C8 call guarded(N, D) again. Fresh output initialization repairs the artifact to [-999, 2, -999, -999, 0].

A system could instead reinitialize the necessary slots in an owned buffer before reuse, provided that rule is explicit and tested. This driver chooses fresh local storage because it makes ownership simple. It does not convert NumPy’s preservation behavior into a promise of transactional mutation, arbitrary alias safety, or rollback after an exception.

The operational lesson is precise: numpy divide where out is safe for this bounded contract only when out already contains the correct current values everywhere the mask is false. Merely observing finite output and an empty warning stream is insufficient.

This defect is especially easy to miss in reusable pipelines because stale values may look plausible. The sevens are ordinary finite numbers, not conspicuous allocator residue, and two current quotients are correct. A summary such as “all values finite” or “two rows calculated” would therefore pass while three row-level values belonged to another invocation. The negative control preserves the full array so reviewers can see the ownership failure directly.

9. Keep the error policy scoped and bounded

Floating-point policy is process behavior, so the fixture changes it only around the operation under test. The NumPy 2.3 errstate reference documents that the selected settings apply on entry and the previous settings are restored on exit. Every observed call captures np.geterr() before opening a fresh context and requires equality afterward.

The three policies have different diagnostic effects. warn reports a floating-point event and may still return an array. raise converts the event into FloatingPointError. ignore takes no reporting action. None of those policies, by itself, prevents arithmetic. Prevention comes from applying the mask to the dangerous ufunc call.

C12 sets a finite numerator of 1e308 and a finite, nonzero denominator of 1e-308. The zero-denominator mask is true, but the quotient is too large for float64. Under all="raise", the supplied record reports the expected FloatingPointError. This proves that denominator != 0 addresses the selected zero policy, not every possible floating-point failure. NumPy documents overflow independently from division by zero and invalid operation.

An exception is an operational signal. It should route the candidate to review, retry, quarantine, or rejection according to pipeline policy; it is not an implicit fallback array. The helper does not return its fresh local buffer when division raises. That containment does not prove that a ufunc using supplied storage performed no partial writes; callers must not assume atomic mutation.

A masked ufunc still receives eagerly evaluated operands

C10 evaluates this expression under raise:

np.divide(N / D, 1.0, out=np.full(5, FILL), where=D != 0)

The outer ufunc has a mask, but N / D is an argument expression. Python evaluates it before attempting the outer call, so it raises first. The repair must reach the dangerous division itself; wrapping an already eager quotient inside another masked operation is not sufficient.

10. Reject inputs outside the declared laboratory

C11 supplies three small negative controls to guarded:

• a column-shaped denominator D[:, None];

• an integer numerator created with N.astype(np.int64);

• a numerator containing nan.

Each is expected to raise ValueError before division, and the supplied commissioning record reports those expected controls. The helper also rejects empty vectors, dimensions other than one, unequal shapes, non-ndarray objects, non-float64 data, and any non-finite source value.

These are fixture preconditions, not universal judgments about NumPy. NumPy can broadcast arrays, operate across many dtypes, and represent non-finite values. This implementation refuses to guess how those capabilities should alter the business contract. A column vector might trigger broadcasting; an integer array might require a deliberate conversion and casting policy; a source nan might require a separately authorized missingness rule. None is silently repaired here. Rejecting them early keeps the evidence interpretable: a ValueError means the candidate never entered this laboratory’s division contract, rather than leaving reviewers to infer whether NumPy broadcast, cast, or propagated a non-finite source.

The boundary also protects the interpretation of the literal oracle. A one-dimensional five-row output is straightforward to reconcile against q0 through q4. Broadening shapes or coercions inside the same test would make it unclear whether a failure concerned conditional division, schema adaptation, or source cleaning.

For a dedicated shape failure workflow, see validating NumPy shapes before calculating paired MSE. This article intentionally does not repeat residual matrices, squeezing, or shape-adapter design. The boundary checks support the division experiment rather than becoming a second schema tutorial.

11. Reconcile the evidence case by case

The manifest binds outputs to IDs q0–q4, not merely to a count of finite values. The table below separates the code’s expected contract from observations explicitly supplied by the October 10, 2026 commissioning run. It does not claim a new execution, per-case timestamps, universal warning wording, or a separately generated report in this writing session.

PASS_12_CASES is meaningful only when all twelve rows are present, their individual assertions passed, the error policy was restored, and version and source identity accompany the record. A missing case, changed manifest, contradictory result, or unknown source revision is HOLD for a new implementation-qualification claim. Lack of a fresh run in this writing session does not erase the supplied historical record; it simply must not be misrepresented as new evidence.

12. Decide whether to accept, repair or hold

Apply decisions to the specific object under review: implementation, evidence, or downstream data use.

A passing C5 does not automatically authorize an all-zero-denominator dataset. It says the code handled total exclusion according to its technical contract. The domain may still prohibit publishing an artifact that contains no calculated ratios.

A marker does not define the business meaning

-999.0 is unambiguous only inside this tiny fixture because its valid quotient set is known. It may be legitimate data elsewhere. Keep the mask, row identities, source inputs, and exclusion rule alongside the output. Obtain an explicit domain decision rather than silently replacing excluded ratios with zero, dropping rows, changing denominators, or averaging only convenient entries.

Implementation acceptance and business admission are therefore independent. The first asks whether the code performed and stored the authorized calculation. The second asks whether the authorized policy produces a meaningful publishable artifact for this dataset.

13. Recover derived arrays and assign ownership

When a reviewed implementation replaces an eager expression or a stale-buffer path, preserve the original numerators, denominators, row IDs, mask rule, initialization rule, implementation revision, and environment record. Recompute trustworthy inputs into a new derived artifact. Keep the old array and its provenance as evidence rather than overwriting it and implying that historical consumers saw the repaired values.

Recovery differs by defect. An eager np.where path may have produced selected numerical values identical to the repaired array, while still violating the no-excluded-division requirement. Those values can be recalculated and requalified, but the old execution record remains technically noncompliant. A reused buffer can change the selected artifact itself: [7,2,7,7,0] is not the current fallback array. That output must not be relabeled without recomputation.

When provenance cannot establish whether a result came from eager selection, correctly initialized masked division, omitted output, or reused storage, hold the affected claim. Finiteness cannot reconstruct execution history. A code deployment also does not rewrite reports, caches, files, or external decisions already produced from an earlier artifact. Rollback restores a reviewed implementation path; it does not retract consumed results.

Recovery should therefore produce a small lineage bundle: source artifact identifier, row IDs, numerator and denominator hashes or immutable references, mask, fallback rule, code revision, runtime versions, old derived artifact, new derived artifact, and disposition of downstream consumers. The laboratory does not prescribe a storage platform; it defines the minimum questions that evidence must answer. Where those links are unavailable, HOLD is more defensible than reconstructing provenance from values alone.

Assign responsibilities explicitly:

• the numerical maintainer owns expression placement, dtype, mask application, output initialization, warning policy, and test evidence;

• the domain owner defines denominator meaning, exclusions, marker collision risk, and whether an all-excluded dataset is meaningful;

• the pipeline owner decides admission, artifact versioning, downstream invalidation, and recovery scope.

That separation parallels preserving feature identity beyond numerical agreement: matching numbers are not enough when the path and identity contract are unknown.

Rerun this focused protocol after changes to NumPy, Python, dtype, input expressions, mask construction, fallback policy, or output reuse. Record a new hash and environment. Do not transplant the historical PASS_12_CASES label onto edited source.

14. Build the numerical foundations behind the review

Reading a numerical API contract, controlling floating-point failures, and preserving evidence depend on strong Python, NumPy, statistical, and data-transformation foundations. The Refonte Learning Data Science & AI programme, according to the supplied programme-page inspection dated October 10, 2026, lists a three-month, 12–14-hours-per-week format, Python Data Science, statistical and predictive modelling, optimization, applied projects, and tools including NumPy. The page also presents a potential internship rather than a placement guarantee. Check the current syllabus to determine whether it covers this specialist ufunc and error-policy laboratory; the supplied inspection does not establish that specific coverage.

Whatever learning path you use, carry the same operational habit into production review: qualify the expression that performs the arithmetic, establish the current value of every output slot, preserve the mask, and obtain domain approval before admitting the resulting ratios.