From d8609917aab1a3ba57b0c4b23dd70290bca5a8b3 Mon Sep 17 00:00:00 2001
From: Dylan Roy <249851642+d6g8k5htny-coder@users.noreply.github.com>
Date: Mon, 5 Oct 2026 13:25:51 -0700
Subject: [PATCH] math: orthogonal positivity and dimension-free band for cubic
 jet variance

Dylan Roy delegated AI work; actual author OpenAI / GPT-6 Astra Pro, session github-closure-directional-tau-20261005. Four additive files only. Scope narrowed by main229/6002199013 after overlap reconciliation: no duplicate of #298's extrema theorem. Orthogonal spectral-polynomial decomposition supplies positive scalar variance bounds at fixed one-coordinate law in every finite dimension. Nine exact tests pass in both Python modes, including distinct multinomial/atom oracles and four rejected mutations. No formal package, existing proof, workflow or scientific-status edit. Scientific effect NONE; nonauthor review pending.
---
 .../NOTE.md                                   | 171 ++++++++++++++++++
 .../SOURCES.json                              |  55 ++++++
 .../positive_tau.py                           | 146 +++++++++++++++
 .../test_positive_tau.py                      |  97 ++++++++++
 4 files changed, 469 insertions(+)
 create mode 100644 reviews/periodic_tau_positive_floor_20261005/NOTE.md
 create mode 100644 reviews/periodic_tau_positive_floor_20261005/SOURCES.json
 create mode 100644 reviews/periodic_tau_positive_floor_20261005/positive_tau.py
 create mode 100644 reviews/periodic_tau_positive_floor_20261005/test_positive_tau.py

diff --git a/reviews/periodic_tau_positive_floor_20261005/NOTE.md b/reviews/periodic_tau_positive_floor_20261005/NOTE.md
new file mode 100644
index 000000000..50d7ea351
--- /dev/null
+++ b/reviews/periodic_tau_positive_floor_20261005/NOTE.md
@@ -0,0 +1,171 @@
+# Orthogonal positivity and a dimension-free band for the cubic jet variance
+
+Object: PERIODIC-TAU-POSITIVE-FLOOR-20261005-v1. Date: 2026-10-05.
+Dylan Roy — delegated AI mathematical work. Actual author: OpenAI / GPT-6 Astra Pro,
+ChatGPT session `github-closure-directional-tau-20261005`.
+Scientific effect **NONE**; author-side mathematics, not scientific acceptance.
+
+## 1. Relation to the existing work
+
+Math-#298, authored by the separate OpenAI session `periodic-tau-envelope-20261005`,
+proves the closed cumulant formula and exact sphere-extremum reduction. Its
+REPORT.md is pinned at commit `9deebd17dd696f72c6246d11bafb9e8265fd8f68`, blob
+`2166869f20eb4d50249920691b90415943c4b5ff`. Those results are not republished or
+reviewed here. An initially overlapping local draft was not published after the
+peer and coordinator identified the earlier claim (main#229, comments
+6002156344, 6002166026; reconciliation 6002199013).
+
+This disjoint supplement proves an orthogonal spectral-polynomial decomposition
+and explicit positive variance bounds. It does not alter #297, #298, either
+review, or their branches. The product spectral model comes from the actual
+parent P §§1–2; #297 supplies the named computational interface. SOURCES.json
+records the exact sources and the three new payloads.
+
+The quantity is exclusively
+
+    tau_u^2 = Var(partial_u^3 f(0) | grad f(0)=0),    |u|=1.
+
+It conditions on the FULL gradient, and not additionally on field value, Hu,
+two separated pins, a cap/elder event, or a selected-pair law. For jointly
+Gaussian field derivatives, ordinary Gaussian regression defines this variance.
+The auxiliary spectral-coordinate random variables below need not be Gaussian;
+only their moments represent the field derivative covariance. Their residual
+law is not identified with the field's conditional law.
+
+## 2. Orthogonal decomposition
+
+Let X_1,...,X_d be independent copies of a symmetric real random variable X
+with finite sixth moment and m2=E X^2>0. Define
+
+    m4=E X^4,    m6=E X^6,
+    Delta=m6-m4^2/m2,    V2=m4-m2^2,    t_i=u_i^2.
+
+Here m2,m4,m6 are RAW moments. The notation in #298 is cumulant-based:
+its a=m2, b=m4-3m2^2, c=m6-15m2*m4+30m2^3. No birth mark is denoted by m4.
+
+**Proposition P1.** For every unit direction in every finite dimension,
+
+    tau_u^2 = Delta sum_i t_i^3
+            + 9 m2 V2 sum_{i!=j} t_i^2 t_j
+            + 36 m2^3 sum_{i<j<k} t_i t_j t_k.          (1)
+
+**Proof.** Put Y=sum_i u_i X_i. In the product spectral representation,
+Cov(grad f)=m2 I. Also Cov(partial_u^3 f,partial_i f)=-E(Y^3 X_i), with the
+minus sign dictated by the stationary derivative convention. It disappears
+on squaring in the Schur complement. Thus tau_u^2 equals the second moment
+of the spectral polynomial residual
+
+    R=Y^3-sum_i [E(Y^3 X_i)/m2]X_i.
+
+Direct expansion gives E(Y^3 X_i)/m2=3m2 u_i+(m4/m2-3m2)u_i^3, and
+
+    R = sum_i u_i^3 [X_i^3-(m4/m2)X_i]
+      + 3 sum_{i!=j} u_i^2 u_j (X_i^2-m2)X_j
+      + 6 sum_{i<j<k} u_i u_j u_k X_i X_j X_k.          (2)
+
+All summands are centered and pairwise L2-orthogonal. This follows from
+independence and symmetry, together with E[(X^3-(m4/m2)X)X]=0 and
+E[(X^2-m2)X]=0. Their variances before the displayed coefficients are Delta,
+m2 V2, and m2^3. Squaring the coefficients proves (1). The mixed sum is over
+ORDERED distinct pairs; the triple sum is over UNORDERED triples. Empty sums
+in d=1,2 are interpreted as zero. No inverse Hessian or isotropy assumption
+is involved. QED.
+
+This is an exact covariance statement for the product spectrum, not a claim
+that spectral coordinates equal the field derivatives. The Schur projection
+uses linear functions of the spectral coordinates only because their inner
+products encode the Gaussian field's gradient covariance.
+
+## 3. Positive bounds in every direction and dimension
+
+**Corollary P2.** Let
+
+    c_low = min{Delta, 3 m2 V2, 6 m2^3},
+    c_high = max{Delta, 3 m2 V2, 6 m2^3}.
+
+Then for EVERY finite d>=1 and every unit u,
+
+    c_low <= tau_u^2 <= c_high,                         (3)
+    tau_u^2 >= Delta/d^2.                               (4)
+
+If Delta>0, then c_low>0. In particular the constants in (3) depend on the
+ONE-COORDINATE spectral law, not on direction or dimension.
+
+**Proof.** Delta=E[(X^3-(m4/m2)X)^2]>=0 and V2=Var(X^2)>=0. Since sum t_i=1,
+
+    sum_i t_i^3 + 3 sum_{i!=j}t_i^2 t_j
+      + 6 sum_{i<j<k}t_i t_j t_k = 1.
+
+These three nonnegative monomial weights make (1) a convex combination of
+Delta, 3m2 V2 and 6m2^3, proving (3). Convexity of x^3 gives sum t_i^3>=1/d^2;
+keeping the first nonnegative term proves (4). If V2=0, then X^2=m2 almost
+surely, so X^3=m2 X and Delta=0. Therefore Delta>0 implies V2>0, and m2>0
+makes all three coefficients strictly positive. QED.
+
+The band need not be sharp. #298 supplies sharp extrema when those are needed.
+Do not use Delta alone as a dimension-free lower bound: for the symmetric
+law with total mass 99/100 on {-1,1} and 1/100 on {-10,10}, the equal two-support
+direction has variance strictly below its axis value Delta. This is a control,
+not a claim that that discrete law is P's spectrum.
+
+**Exact finite-period application.** For P's variance-one covariance at fixed
+L>0, the one-coordinate spectral weights are proportional to
+exp(-2*pi^2*n^2/L^2), at X=2*pi*n/L, with positive weight for every n in Z.
+They have all moments finite. Hence m2>0 and Delta>0: the polynomial
+X^3-(m4/m2)X cannot vanish at both distinct nonzero magnitudes 2*pi/L and
+4*pi/L. This proves a symbolic strictly positive band (3) for the tau
+invariant for every finite dimension at the same L. No numerical value of
+c_low is certified here. There is no uniform-in-L assertion.
+
+Dimension independence here is SPECIFIC to this scalar conditional variance
+in a family with the same coordinate spectral law. It does not imply a
+uniform full-jet covariance floor, a finite-r pinned-law bound, a selected
+weight normalizer, a dimension-uniform lifetime coefficient, or parent-theorem
+constants uniform in dimension. The full jet and numerical-integration
+obligations retain their original scope.
+
+## 4. Exact reproduction and limits
+
+From the packet directory:
+
+    python -B -S positive_tau.py
+    python -B -O -S positive_tau.py
+    python -B -S -m unittest test_positive_tau -v
+    python -B -O -S -m unittest test_positive_tau -v
+
+The standalone oracle expands E(Y^6) and E(Y^3 X_i) by multinomials, then
+forms the full-gradient Schur complement. It is independent of (1)'s
+coefficient implementation. Nonunit rational vectors are handled by exact
+homogeneous division, avoiding irrational normalizations.
+
+The nine unittest methods also check the ten polynomial summands on all
+64 atoms of a three-coordinate {-2,-1,1,2} product law: zero means, all45
+cross inner products zero, pointwise residual equality, and variance equality.
+They exercise exact simplex weights, the two bounds, Gaussian reference,
+zero-Delta degeneration, the invalid Delta-only floor, input validation, and
+actual CLI behavior in both Python modes.
+
+Each deliberately incorrect alternative must exit1 with POSITIVE_TAU_FAIL:
+M1 omits gradient regression; M2 replaces9 by3 in the mixed coefficient;
+M3 replaces36 by6 in the triple coefficient; M4 replaces the minimum lower
+coefficient by Delta. An unknown mutant label exits2. Floating inputs and
+booleans are refused; accepted rational/decimal strings mean their exact
+encoded value, not a certified approximation to unspecified real moments.
+The necessary moment inequalities checked by the utility do not by themselves
+certify that supplied numbers are moments of a particular field.
+
+Test-first: the narrowed suite failed because positive_tau.py did not yet
+exist. After implementation all9 tests passed in normal and optimized Python.
+CLI outputs are byte-identical. The standalone run checks60 direct Schur
+identities,462 convex-weight identities,1848 dimension-free band inequalities,
+1848 dimension-dependent floor inequalities, and1386 strict positive-law cases.
+These finite checks are not proofs of the arbitrary-real and all-dimensional
+statements; P1/P2 supply those proofs. No Lean execution is claimed. Existing
+hosted repository workflows do not execute this standalone script.
+
+A raw-source network download failed with DNS resolution in this environment.
+No #297/#298 executable was downloaded or run locally. Their source was read
+through the GitHub connector; this supplement imports no executable from
+either. The abandoned extrema draft remains unpublished scratch and is not
+part of this packet or its claimed test count. No audit, scientific status,
+original source, author attribution, or existing review was changed.
diff --git a/reviews/periodic_tau_positive_floor_20261005/SOURCES.json b/reviews/periodic_tau_positive_floor_20261005/SOURCES.json
new file mode 100644
index 000000000..1485233b3
--- /dev/null
+++ b/reviews/periodic_tau_positive_floor_20261005/SOURCES.json
@@ -0,0 +1,55 @@
+{
+  "object": "PERIODIC-TAU-POSITIVE-FLOOR-20261005-v1",
+  "scientific_effect": "NONE",
+  "scientific_acceptance": false,
+  "author": {
+    "provider": "OpenAI",
+    "model": "GPT-6 Astra Pro",
+    "session": "github-closure-directional-tau-20261005",
+    "principal": "Dylan Roy — delegated AI work"
+  },
+  "files": [
+    {
+      "path": "NOTE.md",
+      "bytes": 8664,
+      "sha256": "2103f7a3c4383bd6d9fc2906e3721a180e46b3d1e9962db3a5cc3f4f5779bc4e",
+      "git_blob": "50d7ea3511dc11ad01adb2aa9786c20064e03421"
+    },
+    {
+      "path": "positive_tau.py",
+      "bytes": 5402,
+      "sha256": "b29bda5d171b7082bbea889d1e81e7ece7ce1eb46518ae61c7057bace513a401",
+      "git_blob": "e0bbab664854d260cf3db71abf6e438b3486b742"
+    },
+    {
+      "path": "test_positive_tau.py",
+      "bytes": 4409,
+      "sha256": "69d7faf82ad378c67db2c8afa36313d1a0ed5b769b837334027f6dd26e9f2317",
+      "git_blob": "b43de099b4bda928dec7fdfd7ba68dfedc59dda1"
+    }
+  ],
+  "inputs": [
+    {
+      "repository": "d6g8k5htny-coder/Math-",
+      "commit": "90790a44c01b3a2c347fa712fbfaeed7fae1024b",
+      "path": "imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md",
+      "git_blob": "dfed3b8d318a3ab1950957f393307733a4bef3f2",
+      "scope": "P sections 1–2: exact product spectrum and positive full lattice weights"
+    },
+    {
+      "repository": "d6g8k5htny-coder/Math-",
+      "commit": "d8be92076dae46f9504d279b286da0432d01e088",
+      "path": "reviews/iba1_periodic_jet_claude_20261005/periodic_jet_check.py",
+      "git_blob": "a2beeeee90abfc2988cf8f491d54ea835b23a1c5",
+      "scope": "tau Schur-covariance interface and derivative convention; no executable import"
+    },
+    {
+      "repository": "d6g8k5htny-coder/Math-",
+      "commit": "9deebd17dd696f72c6246d11bafb9e8265fd8f68",
+      "path": "reviews/periodic_tau_envelope_20261005/REPORT.md",
+      "git_blob": "2166869f20eb4d50249920691b90415943c4b5ff",
+      "scope": "attribution and notation crosswalk; extrema theorem not repeated or used to prove P1/P2"
+    }
+  ],
+  "validation": "Standalone exact tests and four negative controls. Existing hosted workflows do not run this script."
+}
diff --git a/reviews/periodic_tau_positive_floor_20261005/positive_tau.py b/reviews/periodic_tau_positive_floor_20261005/positive_tau.py
new file mode 100644
index 000000000..e0bbab664
--- /dev/null
+++ b/reviews/periodic_tau_positive_floor_20261005/positive_tau.py
@@ -0,0 +1,146 @@
+"""Exact controls: orthogonal decomposition and direction/dimension-uniform variance band.
+
+python -B -S positive_tau.py [--mutant M1|M2|M3|M4]
+M1 omits gradient regression; M2 uses 3 instead of 9 for the mixed terms;
+M3 uses 6 instead of 36 for the triple terms; M4 uses Delta alone as a
+purported dimension-free lower bound. Tests are not the general proof.
+"""
+import argparse
+from fractions import Fraction as F
+from itertools import combinations
+import json
+from math import factorial
+import sys
+MUTANT=None
+
+
+def exact(x):
+    if isinstance(x,bool) or isinstance(x,float):
+        raise TypeError('use exact integers, Fraction, or rational/decimal strings')
+    return F(x)
+
+
+def moments(a,b,c):
+    a,b,c=map(exact,(a,b,c))
+    if a<=0 or b<a*a or c<b*b/a:
+        raise ValueError('positive m2 and necessary moment inequalities required')
+    return a,b,c
+
+
+def simplex(t):
+    t=tuple(map(exact,t))
+    if not t or min(t)<0 or sum(t)!=1:
+        raise ValueError('nonnegative nonempty simplex point of sum one required')
+    return t
+
+
+def monomial_weights(t):
+    t=simplex(t)
+    diagonal=sum(x**3 for x in t)
+    mixed=3*sum(t[i]**2*t[j] for i in range(len(t)) for j in range(len(t)) if i!=j)
+    triple=6*sum(t[i]*t[j]*t[k] for i,j,k in combinations(range(len(t)),3))
+    return diagonal,mixed,triple
+
+
+def variance_band(a,b,c):
+    a,b,c=moments(a,b,c)
+    delta=c-b*b/a
+    coeff=(delta,3*a*(b-a*a),6*a**3)
+    lower=delta if MUTANT=='M4' else min(coeff)
+    return lower,max(coeff),delta
+
+
+def decomposed_variance(a,b,c,t):
+    a,b,c=moments(a,b,c)
+    w=monomial_weights(t)
+    mixed=a*(b-a*a) if MUTANT=='M2' else 3*a*(b-a*a)
+    triple=a**3 if MUTANT=='M3' else 6*a**3
+    return (c-b*b/a)*w[0]+mixed*w[1]+triple*w[2]
+
+
+def compositions(n,d):
+    if d==1:
+        yield (n,)
+        return
+    for first in range(n+1):
+        for rest in compositions(n-first,d-1):
+            yield (first,)+rest
+
+
+def simplex_grid(d,denominator):
+    if type(d) is not int or d<1 or type(denominator) is not int or denominator<1:
+        raise ValueError('positive integer dimension and denominator required')
+    for ns in compositions(denominator,d):
+        yield tuple(F(n,denominator) for n in ns)
+
+
+def direct_schur(a,b,c,v):
+    """Independent multinomial oracle; v need not be normalized.
+
+    Dividing by (sum v_i^2)^3 avoids introducing irrational coordinates.
+    The field covariance sign cancels in the regression norm squared.
+    """
+    a,b,c=moments(a,b,c);v=tuple(map(exact,v));norm2=sum(x*x for x in v)
+    if norm2<=0:raise ValueError('nonzero direction required')
+    table={0:F(1),2:a,4:b,6:c}
+    def expectation(power,extra=None):
+        total=F(0)
+        for ns in compositions(power,len(v)):
+            coefficient=factorial(power);term=F(1)
+            for i,n in enumerate(ns):
+                coefficient//=factorial(n)
+                term*=v[i]**n*table.get(n+(i==extra),F(0))
+            total+=coefficient*term
+        return total
+    variance=expectation(6)
+    if MUTANT!='M1':variance-=sum(expectation(3,i)**2 for i in range(len(v)))/a
+    return variance/norm2**3
+
+
+def controls():
+    counts={'schur_identities':0,'convex_weight_identities':0,'band_checks':0,
+            'dimension_dependent_floor_checks':0,'positive_law_checks':0}
+    def require(ok,label):
+        if not ok:raise RuntimeError('POSITIVE_TAU_FAIL: '+label)
+    laws=[(1,3,15),(F(5,2),F(17,2),F(65,2)),(1,1,1),
+          (F(199,100),F(10099,100),F(1000099,100))]
+    for d in range(1,6):
+        for v in [(1,)*d,tuple(range(1,d+1)),tuple((-1)**i*(i+1) for i in range(d))]:
+            norm2=sum(x*x for x in v);t=tuple(F(x*x,norm2) for x in v)
+            for law in laws:
+                require(decomposed_variance(*law,t)==direct_schur(*law,v),
+                        'orthogonal decomposition versus full-gradient Schur oracle')
+                counts['schur_identities']+=1
+    for d in range(1,7):
+        for t in simplex_grid(d,5):
+            w=monomial_weights(t)
+            require(sum(w)==1 and min(w)>=0,'convex monomial weights')
+            counts['convex_weight_identities']+=1
+            for law in laws:
+                lo,hi,delta=variance_band(*law)
+                value=decomposed_variance(*law,t)
+                require(lo<=value<=hi,'dimension-free variance band')
+                counts['band_checks']+=1
+                require(value>=delta/d**2,'simplex floor')
+                counts['dimension_dependent_floor_checks']+=1
+                if delta>0:
+                    require(lo>0,'positive moment-law floor')
+                    counts['positive_law_checks']+=1
+    require(variance_band(1,3,15)==(6,6,6),'Gaussian reference exact band')
+    require(variance_band(1,1,1)[0]==0,'degenerate law not declared strictly positive')
+    return {'object':'PERIODIC-TAU-POSITIVE-FLOOR-20261005-v1','passed':True,
+            'counts':counts,'arithmetic':'exact rational','scientific_acceptance':False,
+            'meaning':'finite controls; analytic proof and scope in NOTE.md'}
+
+
+def main():
+    global MUTANT
+    p=argparse.ArgumentParser(description=__doc__)
+    p.add_argument('--mutant',choices=['M1','M2','M3','M4'])
+    MUTANT=p.parse_args().mutant
+    try:out=controls()
+    except RuntimeError as error:
+        print(str(error),file=sys.stderr);return 1
+    print(json.dumps(out,sort_keys=True));return 0
+
+if __name__=='__main__':sys.exit(main())
diff --git a/reviews/periodic_tau_positive_floor_20261005/test_positive_tau.py b/reviews/periodic_tau_positive_floor_20261005/test_positive_tau.py
new file mode 100644
index 000000000..b43de099b
--- /dev/null
+++ b/reviews/periodic_tau_positive_floor_20261005/test_positive_tau.py
@@ -0,0 +1,97 @@
+"""Exact controls for the disjoint orthogonal-positivity supplement."""
+from fractions import Fraction as F
+from itertools import product
+import importlib.util
+import json
+from pathlib import Path
+import subprocess
+import sys
+import unittest
+ROOT=Path(__file__).resolve().parent
+spec=importlib.util.spec_from_file_location('positive_tau',ROOT/'positive_tau.py')
+tau=importlib.util.module_from_spec(spec)
+spec.loader.exec_module(tau)
+LAWS=[(1,3,15),(F(5,2),F(17,2),F(65,2)),(1,1,1),
+      (F(199,100),F(10099,100),F(1000099,100))]
+
+class PositiveTauTests(unittest.TestCase):
+    def test_direct_schur(self):
+        for d in range(1,6):
+            for v in [(1,)*d,tuple(range(1,d+1)),tuple((-1)**i*(i+1) for i in range(d))]:
+                norm2=sum(x*x for x in v)
+                t=tuple(F(x*x,norm2) for x in v)
+                for moments in LAWS:
+                    self.assertEqual(tau.decomposed_variance(*moments,t),tau.direct_schur(*moments,v))
+
+    def test_dimension_free_band_and_simplex_floor(self):
+        for d in range(1,7):
+            for moments in LAWS:
+                lo,hi,delta=tau.variance_band(*moments)
+                for t in tau.simplex_grid(d,5):
+                    value=tau.decomposed_variance(*moments,t)
+                    self.assertGreaterEqual(value,lo)
+                    self.assertGreaterEqual(value,delta/d**2)
+                    self.assertLessEqual(value,hi)
+
+    def test_monomial_weights_sum_to_one(self):
+        for d in range(1,6):
+            for t in tau.simplex_grid(d,7):
+                w=tau.monomial_weights(t)
+                self.assertEqual(sum(w),1)
+                self.assertGreaterEqual(min(w),0)
+
+    def test_gaussian_band_is_exact(self):
+        self.assertEqual(tau.variance_band(1,3,15),(6,6,6))
+        for d in range(1,10):
+            self.assertEqual(tau.decomposed_variance(1,3,15,(F(1,d),)*d),6)
+
+    def test_zero_floor_not_falsely_positive(self):
+        self.assertEqual(tau.variance_band(1,1,1),(0,6,0))
+        self.assertEqual(tau.decomposed_variance(1,1,1,(F(1,2),)*2),0)
+
+    def test_delta_alone_is_not_a_dimension_free_floor(self):
+        moments=LAWS[-1]
+        _,_,delta=tau.variance_band(*moments)
+        value=tau.decomposed_variance(*moments,(F(1,2),)*2)
+        self.assertLess(value,delta)
+
+    def test_polynomial_summands_are_orthogonal(self):
+        a,b,c=map(F,LAWS[1]);u=[F(1,3),F(2,3),F(2,3)]
+        rows=[]
+        for xs in product(map(F,[-2,-1,1,2]),repeat=3):
+            parts=[u[i]**3*(xs[i]**3-(b/a)*xs[i]) for i in range(3)]
+            parts += [3*u[i]**2*u[j]*(xs[i]**2-a)*xs[j]
+                      for i in range(3) for j in range(3) if i!=j]
+            parts += [6*u[0]*u[1]*u[2]*xs[0]*xs[1]*xs[2]]
+            y=sum(u[i]*xs[i] for i in range(3))
+            projection=sum((3*a*u[i]+(b/a-3*a)*u[i]**3)*xs[i] for i in range(3))
+            self.assertEqual(sum(parts),y**3-projection)
+            rows.append(parts)
+        for i in range(10):
+            self.assertEqual(sum(row[i] for row in rows),0)
+            for j in range(i): self.assertEqual(sum(row[i]*row[j] for row in rows),0)
+        var=sum(sum(row)**2 for row in rows)/len(rows)
+        self.assertEqual(var,tau.decomposed_variance(a,b,c,tuple(x*x for x in u)))
+
+    def test_invalid_input(self):
+        for moments in [(0,1,1),(1,0,1),(1,3,8),(1.0,3,15),(True,3,15)]:
+            with self.assertRaises((ValueError,TypeError)):tau.variance_band(*moments)
+        for t in [(),(1,1),(-1,2),(.5,.5)]:
+            with self.assertRaises((ValueError,TypeError)):tau.decomposed_variance(1,3,15,t)
+
+    def test_cli_controls_both_modes(self):
+        good=[]
+        for flags in [[],['-O']]:
+            def run(*args):
+                return subprocess.run([sys.executable,'-B',*flags,'-S',str(ROOT/'positive_tau.py'),*args],
+                                      capture_output=True,text=True,timeout=20)
+            r=run();self.assertEqual(r.returncode,0,r.stderr);good.append(r.stdout)
+            self.assertTrue(json.loads(r.stdout)['passed'])
+            for label in ['M1','M2','M3','M4']:
+                r=run('--mutant',label)
+                self.assertEqual(r.returncode,1,(label,r.stdout,r.stderr))
+                self.assertIn('POSITIVE_TAU_FAIL',r.stderr)
+            self.assertEqual(run('--mutant','M9').returncode,2)
+        self.assertEqual(good[0],good[1])
+
+if __name__=='__main__':unittest.main()