| """Young's convolution inequality quotient ||f*g||_r / (||f||_p ||g||_q) for non-negative step functions. |
| |
| f = sum_i a_i 1_[i, i+1), g = sum_j b_j 1_[j, j+1); then f*g is piecewise linear with knot values |
| (f*g)(k) = sum_{i+j=k-1} a_i b_j, so all three norms are integrated exactly (up to float64 rounding). |
| Upstream (classical_inequalities.ipynb) used np.convolve(mode="same") on samples of user callables, which |
| truncates the convolution's support; this closed form replaces it. |
| """ |
| import numpy as np |
|
|
| from run import Invalid, float_list |
|
|
|
|
| def _seg_power_integral(c0, c1, r): |
| """int_0^1 ((1-s) c0 + s c1)^r ds for non-negative c0, c1 (vectorised, cancellation-free).""" |
| hi, lo = np.maximum(c0, c1), np.minimum(c0, c1) |
| out = np.zeros_like(hi) |
| pos = hi > 0 |
| t = lo[pos] / hi[pos] |
| with np.errstate(divide="ignore"): |
| u = np.log(t) |
| num, den = np.expm1((r + 1) * u), np.expm1(u) |
| ratio = np.where(u == 0, r + 1, num / np.where(u == 0, 1.0, den)) |
| out[pos] = hi[pos] ** r * ratio / (r + 1) |
| return out |
|
|
|
|
| def _vec(v, name, max_len): |
| a = np.array(float_list(v, None, name)) |
| if not 1 <= len(a) <= max_len: |
| raise Invalid(f"need 1 <= len({name}) <= {max_len}") |
| if a.min() < 0 or a.max() > 1e6 or a.max() <= 0: |
| raise Invalid(f"{name}: entries must be in [0, 1e6] and not all zero") |
| return a / a.max() |
|
|
|
|
| def check(inst, ans): |
| p, q = inst["p"], inst["q"] |
| r = 1.0 / (1.0 / p + 1.0 / q - 1.0) |
| a = _vec(ans.get("f"), "f", inst["max_len"]) |
| b = _vec(ans.get("g"), "g", inst["max_len"]) |
| c = np.concatenate([[0.0], np.convolve(a, b), [0.0]]) |
| conv_r = float(np.sum(_seg_power_integral(c[:-1], c[1:], r))) ** (1.0 / r) |
| fp = float(np.sum(a ** p)) ** (1.0 / p) |
| gq = float(np.sum(b ** q)) ** (1.0 / q) |
| return conv_r / (fp * gq), {"r": r} |
|
|
