QZ-Guard / QZ-Envelope: narrow prior-art and release audit
Research date: 2026-10-03. Primary sources and software documentation were checked. This audit establishes important overlaps; it is not a comprehensive priority search. No new mathematical principle is claimed.
Recommended release claim
QZ-Guard is a specialized exact predicate for threshold decisions about interval-weighted averages. It implements the classical fractional-feasibility support test using exact dyadic arithmetic for finite binary64 inputs, and can return a checkable violating assignment. A single threshold needs no endpoint computation, sorting, iterative root solve, or general LP solver.
The software contribution can be useful: a small dependency-light API, an explicit arithmetic contract, rigorous edge handling, independently checkable witnesses, and measured improvements over more general exact implementations. The mathematical optimization, sign-sensitive endpoint selection, and robust threshold equivalence are inherited. There is presently no evidence supporting a world-first exact implementation or new asymptotic algorithm.
“Superior” must specify the task and comparator: exact threshold classification can be more reliable than an ordinary floating implementation, and a direct predicate can be cheaper than computing complete endpoints first. It cannot be claimed to have narrower true endpoints than correct Karnik–Mendel/EIASC solvers, since they solve the same optimization problem. Speed superiority over a direct vectorized floating support test is unlikely for a pure-Python integer implementation and must not be implied.
Optimization equivalence
For one coordinate, take
[ Y=\frac{N_0+\sum_{j=1}^{M}w_jv_j}{D_0+\sum_{j=1}^{M}w_j},\quad 0\le L_j\le w_j\le U_j,\quad l_j\le v_j\le h_j, \quad D_0+\sum_jL_j>0. ]
The positive-denominator assumption is indispensable. A natural release also requires (D_0\ge0). Known ((N_0,D_0)) contributes a fixed numerator/denominator pair; for (D_0>0), it can equivalently be regarded as a fixed-weight item with value (N_0/D_0). This does not create a distinct optimization class. The quotient must not be rounded before encoding that item if exact binary-input semantics are required.
For a finite threshold (T), define
[ S_+(T)=N_0-TD_0+ \sum_j\max{L_j(h_j-T),\ U_j(h_j-T)}, ]
[ S_-(T)=N_0-TD_0+ \sum_j\min{L_j(l_j-T),\ U_j(l_j-T)}. ]
Then
[ \sup Y\le T\iff S_+(T)\le0,\qquad \inf Y\ge T\iff S_-(T)\ge0. ]
These are standard positive-denominator fractional-programming feasibility transformations and support evaluations of a box. Values select their appropriate coordinate endpoints by monotonicity; weights select endpoints by the sign of the threshold-centered value. A positive (S_+), or negative (S_-), gives an attaining violating assignment. It need not maximize the quotient; it maximizes or minimizes its threshold residual, which is enough to witness violation.
For (p) coordinates, applying the predicate separately gives an exact test that the entire attainable set lies in a coordinate box. Coordinate witnesses may use different weights. The coordinate envelope is the smallest axis-aligned box, not the exact multidimensional feasible set or an attaining joint corner.
Nearest primary predecessors
Interval weighted averages and KM
Liu and Mendel's 2008 paper explicitly treats uncertain values and uncertain nonnegative unnormalized weights. It replaces values with lower endpoints for minimization and upper endpoints for maximization, then uses the same shared weights in numerator and denominator. Its derivation and switch-point algorithms are a direct equivalence, not a loose analogy. Karnik and Mendel's original centroid work, EKM, IASC, and EIASC are consequently mandatory related work.
- Liu and Mendel (2008), Aggregation Using the Fuzzy Weighted Average as Computed by the Karnik–Mendel Algorithms: primary source ; DOI DOI
- Karnik and Mendel (2001), Centroid of a Type-2 Fuzzy Set: DOI
- Wu and Mendel (2009), Enhanced Karnik–Mendel Algorithms: DOI
- Duran, Bernal, and Melgarejo (2008), IASC: DOI
- Wu and Nie (2011), EIASC and practical implementation comparison: DOI
Newer endpoint competitors should not be omitted. The primary publisher abstract for Liu and Lin (2021) describes binary algorithms with proven optimal outputs and compares complexity against KM, EKM, and EIASC. The 2025 Fuzzy Sets and Systems paper studies randomized optimum-computing algorithms, including negative weights. Full algorithm details of these two papers were not accessible in this audit; no specific unverified complexity or implementation claim is made here.
Fractional programming and robust expectations
Dinkelbach (1967) develops the relationship between fractional optimization and threshold-parameterized difference objectives, crediting Jagannathan (1966). The direct predicate is the feasibility/sign specialization of this inherited transformation. It should not be described as a discovery of normalization-free computation.
Primary reference: primary source
Benavoli and Zaffalon's primary author manuscript is an especially close cross-domain predecessor. Section 6, Eq. 18 expresses a lower expectation using a threshold-centered positive/negative-part equation. Their normalized density envelopes are bounded unnormalized measures; the manuscript notes that general intervals of measures need not have a constant lower/upper ratio. Their generalized Bayes rule also subtracts the candidate expectation before normalization. Testing the sign at a supplied threshold is a direct consequence of this established robust-expectation framework.
Primary author manuscript: primary source
Thus fuzzy aggregation and robust Bayesian/credal expectation both already contain the central support mechanism. A narrow API specializing threshold decisions may still have adoption value, but it does not separate the mathematics from those fields.
Exact arithmetic and numerical predicates
Finite binary64 values are exact dyadic rationals. Python's documented float.as_integer_ratio() exposes this representation. Integer accumulation can therefore decide (S_\pm)'s sign without overflow, underflow, or cancellation rounding, provided conversion precedes subtraction and multiplication. This is ordinary exact arithmetic, not a new number system.
Primary documentation: primary source
Neal's superaccumulator work demonstrates efficient exact floating-point summation and correctly rounded outputs; it is a clear precedent for integer/fixed-point accumulation. Exact products additionally require representing their unrounded product, rather than merely summing already-rounded products.
Primary paper and ancillary C sources: primary source
Shewchuk's adaptive robust predicates establish the larger software pattern: determine an exact sign of an expression on floating inputs, using cheap arithmetic when its error bound suffices and exact arithmetic near a decision boundary. The optional floating filter plus exact fallback in this release follows this known pattern.
Primary author page, paper, and public-domain code: primary source
General rigorous interval arithmetic and exact rational LP also predate this release. Arb supplies arbitrary-precision enclosures, and QSopt_ex supplies exact rational LP solutions. Certification itself is not a novel capability.
- Arb: primary source
- QSopt_ex author library: primary source
Actual package baselines
PyIT2FLS is an MIT NumPy/SciPy package with documented KM_algorithm, EKM_algorithm, and EIASC_algorithm. Its input is an ((M,4)) array whose first two columns are value endpoints and last two are weight endpoints; the result is a lower/upper tuple. These functions can directly serve as endpoint-then-threshold competitors for base-free tests. Its repository also advertises a faster typereduction subpackage; that path should be checked before claiming superiority over the package's Python routines.
MATLAB's maintained toolbox implements KM, EKM, IASC, and EIASC. Its documentation lists increasing efficiency across those methods. This is evidence that EIASC is a mature available competitor, not a reason to assume any one version always wins.
Official documentation: primary source
| Comparator | Contract | Required role |
|---|---|---|
| NumPy direct (S_\pm(T)) | Floating approximation, no exact-sign guarantee | Essential speed baseline; same task and same mathematical mechanism |
Direct Fraction support |
Exact dyadic inputs and products | Essential exact comparator; isolates integer representation/overhead improvements |
| Direct GMP rational/integer support, if available | Exact arithmetic | Strong exact-performance comparator; avoid relying solely on slow standard-library fractions |
| PyIT2FLS EKM/EIASC, then threshold | Complete endpoints in floating arithmetic | Real package competitor; include sorting/preparation cost and distinguish reused sorted inputs |
| Binary/prefix endpoint algorithm, then threshold | Complete sharp endpoints | Stronger algorithmic comparator than plain KM/bisection |
| Generic support bisection | Endpoints to specified tolerance | Secondary baseline only; near-threshold decisions can be unresolved |
| SciPy/HiGHS Charnes–Cooper LP | Floating LP optimum within solver tolerances | General formulation reference, not exact certification |
| QSopt_ex rational LP | Exact rational optimum | General exact reference where available; do not claim same setup cost as a specialized predicate |
| Independent numerator/denominator interval division | Conservative enclosure | Width/conservatism illustration; unsuitable as the sole performance baseline |
SciPy/HiGHS documentation: primary source
For Charnes–Cooper, use (t=1/(D_0+\sum w_j)), (z_j=t w_j), constraint (D_0t+\sum z_j=1), bounds (L_jt\le z_j\le U_jt), and objective (N_0t+\sum h_jz_j) or the lower-coordinate counterpart. This is an inherited linear-fractional transformation. Threshold-only tests should not pay for that full optimization if box support is available.
What can and cannot be better
Certification: exact dyadic predicates can give a definitive correct sign for every validated finite-binary64 input, including exact equality, extreme exponent ranges, and near cancellation. Ordinary floating endpoint/direct-support implementations may misclassify a boundary. A validated interval-support implementation can remain correct by returning “undetermined” near zero; compare its unresolved rate and latency rather than falsely calling it inaccurate.
Width: sharp coupled endpoints can be arbitrarily tighter than independent numerator/denominator division. Correct KM/EIASC already obtains those same sharp endpoints. The improvement is over dependency-losing interval evaluation, not over the strongest weighted-average mathematics. QZ-Guard returns a threshold decision, so “width improvement” is not its direct output metric.
Speed: one direct support scan avoids sorting and iterative endpoint solution for a single threshold. This saves unnecessary work relative to endpoint-first APIs, but the direct scan itself is classical. Exact integer arithmetic may outperform general rational arithmetic by avoiding repeated gcd reduction. It is not assured to beat optimized floating EIASC in wall time; it almost certainly will not beat a vectorized floating direct scan on well-separated ordinary instances.
Repeated thresholds: sorting once and compiling exact prefix sums permits support queries by binary search; endpoint computation may then be amortized and cached. Benchmark that reuse regime separately. A claim that unsorted one-shot predicates always dominate cached endpoint methods would be false.
Complexity: (O(Mp)) counts arithmetic operations for a direct guard. Python big integers are not unit-cost. Converting finite binary64 inputs to a common (2^{-1074}) scale can require about 2098 bits; products and support accumulation can require about 4196 bits plus (O(\log M)). Document bit-width dependence and conversion/precompilation costs. Endpoint sorting additionally contributes (O(Mp\log M)) comparisons for a straightforward coordinate implementation.
Smallest decisive numerical example
Take fixed weights ([1+2^{-52},1]), fixed values ([1-2^{-52},-1]), no base, and ask whether the weighted average is at least zero. Exact numerator is (-2^{-104}), so the answer is false. Ordinary binary64 product evaluation rounds the first product to one, and the numerator becomes zero, so a naive >= 0 predicate incorrectly accepts. This example is a test of exact-product sign correctness, not a novel optimization example.
Also test: smallest-subnormal products; overflow in (h-T) while the exact expression is finite rational; cancellation with varied summation order; zero lower weights with positive known base; exact threshold equality; duplicate values; negative values; degenerate value intervals; empty sets with positive base; invalid/nonfinite inputs; and zero possible denominator rejection.
Use exhaustive exact endpoint enumeration for small (M) as an independent oracle. Check every violating witness by separately recomputing its exact numerator, denominator, threshold difference, and bound membership. For full QZ-Envelope endpoints, compare rational extrema against that oracle and ensure outward float conversion contains them.
Benchmark acceptance and release boundary
Predeclare one-shot threshold workloads and repeated-threshold workloads. Include interval counts from 1 through large arrays, dimensions from scalar to modest vectors, broad exponent ranges, and thresholds both far from and extremely close to the exact endpoint. Time input conversion, construction, predicate evaluation, and witness production separately and end to end. Randomly ordered timer repeats do not replace independently generated input groups.
A defensible narrow success is: all exact oracle decisions and witnesses are correct; ordinary float failures are demonstrated; the implementation is materially faster than full exact endpoint computation or generic rational support at the declared one-shot sizes. Report the vectorized direct float comparator even when it is faster. If exact direct support is equally fast or faster, the release's remaining value is API/interoperability and verification ergonomics, not a superior algorithm.
This is a practical numerical component candidate. It is not the originally requested general attention breakthrough, and relabeling mature interval-weighted-average mathematics would obscure its actual contribution. Its strongest possible claim after implementation is a precise exact-input predicate contract plus measured software performance within a declared regime.
Adaptive filter boundary in the strengthened release
The optional NumPy fast path is an established adaptive exact-predicate architecture: evaluate a polynomial approximately, bound roundoff, accept a separated sign, and otherwise compute the exact sign. Jonathan Richard Shewchuk's Adaptive Precision Floating-Point Arithmetic and Fast Robust Geometric Predicates is a direct primary predecessor for that architecture. Standard deterministic gamma bounds for floating sums/products underpin its allowance; the specialization here conservatively uses a path length M+8, not an optimistic assumption of logarithmic reduction depth.
Guard applies this established architecture to interval weighted-mean support polynomials, with finite-binary64 input semantics, conversion-cost accounting, and exact integer fallback. Its outward magnitude correction and eligibility checks are necessary implementation details, not a claimed new numerical principle. Equivalent application-specific kernels may already exist in private or obscure implementations; this search does not prove a global priority claim.
Introduced by this release: an audited small Python API integrating exact robust threshold predicates, optional filtered signs, lazy rational margins and witnesses, sharp cached bounds, independent oracle tests and strong matched-contract benchmark comparisons.
Inherited: linear-fractional support signs, box separability, KM sorted switches, exact dyadic arithmetic, order-statistic deletion trimming, adaptive predicates, deterministic rounding-error bounds and directed adjacent-float enclosures.