Formalization: Exact Randomized Designs for Two-Block Interference Experiments
The complete Lean development behind this paper — every definition, lemma, and theorem of its module, including helpers the paper text never cites. Identifiers link within this page, into the Causalean library, or out to the official Mathlib docs. Note: this index was generated at a different commit than the paper's audited pin (c3c6187) — statements may have moved since the audit.
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Basic 45 declarations All certificates live on the reduced triangle T_m in the spectral coordinates (x,y,z) produced by lem:block-spectral-coordinates; the objective there is the linear-plus-weighted-Frobenius form phi.
Environment S2 — reduced spectral-coordinate world (real objective geometry)
All certificates live on the reduced triangle T_m in the spectral coordinates
(x,y,z) produced by lem:block-spectral-coordinates; the objective there is the
linear-plus-weighted-Frobenius form phi. These are the shared reduced primitives.
Reduced multiplicity weight q = 2(m-1) (block-contrast eigenspace multiplicity; a derived constant, NOT the core tradeoff ratio r).
Definition (Lean source)
The reduced triangle T_m = {x,y,z ≥ 0 : q x + y + z = 2m}. @realizes X(u,v)(reduced coordinates x,y,z on T_m)
Definition (Lean source)
The reduced objective φ(x,y,z) = c_x x + c_y y + c_z z + κ √(q x² + y² + z²). @realizes F_{r,kappa}(X)(reduced form c_x x + c_y y + c_z z + κ‖·‖) @realizes kappa(carrier ℝ; robustness weight on the Frobenius term κ√(q x²+y²+z²); range [0,∞) pinned by the 0 ≤ kappa premises threaded through the consuming theorems/lemmas)
Definition (Lean source)
Reduced linear coefficient on x: c_x = q((a+b) + r/(a+b)). @realizes F_{r,kappa}(X)(c_x = q((a+b)+r/(a+b))) @realizes r(carrier ℝ; tradeoff ratio entering c_x via the r/(a+b) term) @realizes a(within-block weight in a+b and r/(a+b)) @realizes b(cross-block weight in a+b and r/(a+b))
Definition (Lean source)
Reduced linear coefficient on y: c_y = 2b + r/(2b). @realizes F_{r,kappa}(X)(c_y = 2b + r/(2b)) @realizes r(carrier ℝ; tradeoff ratio entering c_y via the r/(2b) term) @realizes b(cross-block weight in 2b and r/(2b))
Definition (Lean source)
Reduced linear coefficient on z: c_z = 2m. @realizes F_{r,kappa}(X)(c_z = 2m)
Definition (Lean source)
Parity feasibility threshold d_m = 0 (m even), 2/m (m odd).
Definition (Lean source)
Frobenius (Schatten-2) norm ‖X‖_{S_2} = √(∑ᵢⱼ Xᵢⱼ²). @realizes F_{r,kappa}(X)(κ‖X‖_{S_2}, Frobenius norm)
The all-ones matrix J_n = 1_n 1_nᵀ. @realizes J_n(all-ones matrix)
The community sign vector s_m (+1 on block A_m = {i : i < m}, −1 on B_m). @realizes s_m(sign vector +1 on A_m, −1 on B_m)
Definition (Lean source)
Orthogonal projection onto span 1_n, i.e. J_n / n.
Orthogonal projection onto span s_m, i.e. s_m s_mᵀ / n.
The block-symmetric matrix X(u,v): diagonal 1, common within-block off-diagonal entry u, common across-block entry v. @realizes X(u,v)(diag 1, within-block u, across-block v)
The weighted two-block homophily adjacency W: a/m within a block, b/m across blocks, 0 on the diagonal. @realizes G_m(a,b)(within-block a/m, across-block b/m, diag 0) @realizes a(within-block edge weight a/m; range 0<b<a pinned by TwoBlockHomophily) @realizes b(cross-block edge weight b/m; range 0<b pinned by TwoBlockHomophily) @realizes A_m, B_m(two communities via block membership i.val < m, |A_m|=|B_m|=m)
The graph Laplacian L_m = D − W of the two-block graph (D the degree diagonal). @realizes L_m(graph Laplacian of G_m(a,b))
Definition (Lean source)
The Moore–Penrose pseudoinverse L_m^†, realized by its spectral action: eigenvalues 1/(a+b) on the block-contrast subspace, 1/(2b) on span s_m, 0 on span 1_n (the only way it is consumed downstream). @realizes L_m^dagger(pseudoinverse via spectral action 1/(a+b), 1/(2b), 0)
The cut covariance X_cut = s_m s_mᵀ. @realizes X_cut(s_m s_mᵀ)
The spread covariance X_spread with reduced coordinates (m/(m-1), 0, 0) (the u = -1/(m-1), v = 0 block-symmetric point).
Definition (Lean source)
The normalized design objective F_{r,κ}(X) = Tr(L_m X) + r Tr(L_m^† X) + κ ‖X‖_{S_2} + Tr(J_n X). @realizes F_{r,kappa}(X)(Tr(L_m X) + r Tr(L_m^† X) + κ‖X‖ + Tr(J_n X)) @realizes r(carrier ℝ; homophily tradeoff weight on the r * Tr(L^† X) term) @realizes kappa(carrier ℝ; robustness weight on the Schatten-2 penalty κ‖X‖_{S_2}; range [0,∞) pinned by the 0 ≤ kappa premises threaded through the consuming theorems/lemmas)
Definition (Lean source)
Two-block homophily: m ≥ 2 and a > b > 0 (within-block weight strictly dominates the positive cross-block weight).
Definition (Lean source)
Low-scale two-block normalization a + 3b < 2m (ensures D = 2m − a − 3b > 0).
Definition (Lean source)
Odd community size (parity feasibility: forces S_A, S_B odd, so y + z ≥ 2/m).
Definition (Lean source)
Membership witness for the block-symmetric elliptope slice E_m^blk, over the two-block homophily regime. Its member atom is ass:two-block-homophily; the three inequalities are exactly the PSD constraints of the spectral coordinates x = 1−u, y = 1+(m−1)u−mv, z = 1+(m−1)u+mv.
Definition (Lean source)
x = 1 − u ≥ 0.
y = 1 + (m−1)u − m v ≥ 0.
z = 1 + (m−1)u + m v ≥ 0.
The block-symmetric elliptope slice E_m^blk as a set of matrices. @realizes E_m^blk(set of PSD block-symmetric correlation matrices X(u,v))
Definition (Lean source)
The ±1 sign vector of an assignment z (true ↦ +1, false ↦ −1). @realizes Z(±1 assignment sign vector)
The cut assignment s_m (treat block A_m, control block B_m).
The reversed cut assignment −s_m.
The assignment second-moment matrix X(P) = E_P[Z Zᵀ]. @realizes X(P)(second-moment matrix E_P[Z Zᵀ]) @realizes P(design-law argument D : FiniteDesign (Fin (2*m) → Bool), the law over which the second moment is taken)
The cut design P_cut: mass 1/2 on s_m and 1/2 on −s_m. @realizes P_cut(½ δ_{s_m} + ½ δ_{−s_m}) @realizes P(cluster member — CONCRETE CARRIER+CONSTRAINTS instance: a FiniteDesign (Fin (2*m) → Bool), i.e. a probability law on {-1,1}^n, whose p_nonneg/p_sum fields below discharge the PMF constraints that pin the symbol's space)
Definition (Lean source)
The iid Rademacher design P_iid: uniform on {-1,1}^n. @realizes P_iid(uniform Rademacher design) @realizes P(cluster member — CONCRETE CARRIER+CONSTRAINTS instance: a FiniteDesign (Fin (2*m) → Bool), i.e. a probability law on {-1,1}^n, whose p_nonneg/p_sum fields below discharge the PMF constraints that pin the symbol's space)
Definition (Lean source)
Balanced sign-symmetric design: P(Z = z) = P(Z = −z) for all z (global sign symmetry, implying zero one-point margins). @realizes P(design-law argument D : FiniteDesign (Fin (2*m) → Bool), the probability law on {-1,1}^n this predicate constrains)
Definition (Lean source)
The balanced design class P_m^bal, bundling the single sign-symmetry atom. @realizes P_m^bal(designs with global sign symmetry) @realizes P(cluster member: the bundled law D : FiniteDesign (Fin (2*m) → Bool), a probability law on {-1,1}^n via the carrier's p_nonneg/p_sum fields)
Definition (Lean source)
A permutation of the units is a two-block automorphism: it either preserves both blocks setwise or swaps them.
The block-exchangeable design class P_m^sym: laws in P_m^bal invariant under permutations within A_m, within B_m, and under the community swap (the full two-block automorphism group). (D0.R provisional revision carried as revised.) @realizes P_m^sym(balanced designs invariant under the two-block automorphism group) @realizes P(cluster member: this Set (FiniteDesign (Fin (2*m) → Bool)) is the class of probability laws P consumed downstream by implementableCovarianceClass/ implementabilityGap; each element is a probability law via the carrier's PMF fields)
Definition (Lean source)
The implementable covariance class C_m^pm = { X(P) : P ∈ P_m^sym }. @realizes C_m^pm(second moments of block-exchangeable designs) @realizes P(cluster member: the bound design law D ∈ blockExchangeableDesignClass m ranges over the probability laws P whose second moment X(P) defines this class)
Definition (Lean source)
Community sum S_A = ∑_{i ∈ A_m} Z_i (integer-valued). @realizes A_m, B_m(community A_m = {i : i.val < m}, cardinality m)
Community sum S_B = ∑_{i ∈ B_m} Z_i (integer-valued). @realizes A_m, B_m(community B_m = {i : ¬ i.val < m}, cardinality m)
The block-sum law handle B(P): the joint pmf of the two community sums (S_A, S_B) under P (the OEQ parity handle). @realizes B(P)(joint law of the two community sums)
Definition (Lean source)
The implementability gap Δ_m^±(r,κ) = inf_{P ∈ P_m^sym} F(X(P)) − inf_{X ∈ E_m^blk} F(X), as an sInf difference over the objective images. @realizes Delta_m^pm(r,kappa)(implementable inf − relaxed inf; CARRIER of the gap. The bare sInf − sInf real difference is a plain ℝ; its core-declared range [0,∞) is NOT carried by this def alone but by the CONJUNCTION of this carrier with the companion range lemma implementabilityGap_nonneg in Helpers/GapReduction.lean, which pins 0 ≤ Δ_m^± via the reduced constrained-minus-unconstrained identity.) @realizes P(cluster member — AUTHORITATIVE link into the sharp_rho_star target block: the implementable sInf is taken over designObjective … '' implementableCovarianceClass m, i.e. over the second moments X(P) of the probability laws P ∈ P_m^sym; this is the decl through which the P realization cluster enters thm:sharp-rho-star) @realizes kappa(carrier ℝ; robustness argument of the gap; range [0,∞) pinned by the 0 ≤ kappa premises of the consuming theorems sharp_rho_star/rounding_gap_reduction)
Definition (Lean source)
The relaxed reduced value min_{T_m} φ.
Definition (Lean source)
The implementable reduced value min_{T_m ∩ {y+z ≥ d_m}} φ.
Definition (Lean source)
The tight rounding-loss certificate ρ_⋆, realized as the reduced-coordinate implementable-minus-relaxed value (proved equal to Δ_m^± by rounding_gap_reduction). The bare implementableReducedValue − relaxedReducedValue real difference is a plain ℝ; its core-declared range [0,∞) is NOT carried by this def alone but by the CONJUNCTION of this carrier with the companion range lemma roundingLossCertificate_nonneg below, which pins 0 ≤ ρ_⋆ (the constrained reduced value dominating the unconstrained one, exactly as Δ_m^± is pinned nonnegative by implementabilityGap_nonneg). @realizes rho_star(m,a,b,r,kappa)(reduced constrained-minus-unconstrained value; CARRIER of the certificate, range [0,∞) pinned via the companion lemma below)
Definition (Lean source)
Range lemma for ρ_⋆. The rounding-loss certificate lands in its core-declared space [0,∞): 0 ≤ ρ_⋆(m,a,b,r,κ). This holds because the implementable reduced value (the constrained sInf over T_m ∩ {y+z ≥ d_m}) dominates the relaxed reduced value (the unconstrained sInf over the larger set T_m), the implementable feasible set being a subset of the relaxed one. Together with the roundingLossCertificate carrier def above, this lemma IS the realization of the symbol's standing range condition (the bare sInf − sInf real difference does not by itself guarantee nonnegativity). @realizes rho_star(m,a,b,r,kappa)(range [0,∞) pinned via {y+z ≥ d_m}-constrained inf ≥ unconstrained inf ⇒ implementable reduced value ≥ relaxed reduced value)
Formal statement
Proof (Lean source)
Sharp cut-break exactness boundary r_⋆(m,a,b,κ) — the HONEST-OPEN frontier symbol (open_phase_boundary role; it has NO statement node and NO closed form by design; its clean/set-valued shape is deliberately left open, see honest scope). This predicate is the dedicated carrier that realizes the symbol's [0,∞) SPACE together with its defining boundary role: rStar is a nonnegative ratio (its [0,∞) space) below which the rounding loss vanishes — i.e. it lower-bounds a zero-loss r-region [0, rStar), the "cut-break ratio separating zero implementability loss from positive loss". No existence, uniqueness, or exact value of such an rStar is asserted anywhere (honest open scope); only the space and the separating role are pinned here. @realizes r_star(m,a,b,kappa)(carrier/predicate for the open boundary object; its [0,∞) space is pinned by the 0 ≤ rStar conjunct, its separating role by the zero-loss clause)
Definition (Lean source)
iid-exactness frontier κ_iid(m,a,b,r) — the dedicated carrier that realizes the symbol's [0,∞) SPACE together with its defining frontier role (iid_exactness_frontier, role derived_phase_boundary). κ_iid is the smallest nonnegative robustness weight from which the iid covariance I_n = X(P_iid) remains optimal over the block-symmetric elliptope slice E_m^blk, and it dominates the cut frontier κ_cut(m,a,b) = max 0 (min (a−b) (2(m−b))) (the core relation κ_iid ≥ κ_cut). This predicate is that carrier: the 0 ≤ κ_iid conjunct pins the [0,∞) space, the κ_cut ≤ κ_iid conjunct records the core ordering, and the trailing clause pins the frontier role — above the frontier weight, I_n minimizes F_{r,κ} on E_m^blk. No existence, uniqueness, or closed form of such a κ_iid is asserted here (the iid frontier, like r_⋆, is bound only as a symbol; robust_corner_exactness supplies the finiteness criterion for its EXISTENCE — a finite frontier exists iff the affine-balanced locus holds — not its value). Mirrors the IsSharpExactnessBoundary carrier for r_⋆. @realizes kappa_iid(m,a,b,r)(carrier/predicate for the iid-exactness frontier; its [0,∞) space is pinned by the 0 ≤ κ_iid conjunct, the κ_iid ≥ κ_cut ordering by the second conjunct, and its frontier role by the optimality clause)
Definition (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.BlockPairSums 3 declarations Finite pair-count identities over A_m and B_m, used by the spectral-coordinate trace and Frobenius calculations.
Pair counts for the balanced two-block partition
Finite pair-count identities over A_m and B_m, used by the spectral-coordinate
trace and Frobenius calculations.
Sum a two-valued function over a finite set when one distinguished point takes the diagonal value.
Formal statement
Proof (Lean source)
Pair count over the two equal blocks: diagonal pairs contribute d, same-community off-diagonal pairs contribute s, and cross-community pairs contribute c.
Formal statement
Proof (Lean source)
The same pair count with a community-sign multiplier. Same-community pairs have sign product +1, and cross-community pairs have sign product -1.
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.FrobeniusCenter 3 declarations Frobenius-center certificate on the reduced triangle
Frobenius-center certificate on the reduced triangle
Along the tangent (x,y,z) = (1+t, 1-q t, 1), the Frobenius term has zero first derivative at the center, so the objective derivative is c_x - q c_y.
Formal statement
Proof (Lean source)
Along the tangent (x,y,z) = (1, 1+t, 1-t), the Frobenius term has zero first derivative at the center, so the objective derivative is c_y - c_z.
Formal statement
Proof (Lean source)
Frobenius-center certificate: (1,1,1) uniquely minimizes the weighted Frobenius term on T_m; it minimizes the full objective for finite κ only if c_x/q = c_y = c_z, and under that equality with κ > 0 it is the unique minimizer.
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.GapReduction 12 declarations Assembles prop:symmetry-reduction, lem:block-spectral-coordinates, and lem:pm-reduced-slice-characterization into the reduced-coordinate identity for the implementability gap: Δ_m^± = min_{T_m ∩ {y+z ≥ d_m}} φ − min_{T_m
Rounding-gap reduction
Assembles prop:symmetry-reduction, lem:block-spectral-coordinates, and
lem:pm-reduced-slice-characterization into the reduced-coordinate identity for
the implementability gap: Δ_m^± = min_{T_m ∩ {y+z ≥ d_m}} φ − min_{T_m} φ.
The implementability gap equals the reduced-coordinate implementable-minus-relaxed value: Δ_m^±(r,κ) = implementableReducedValue − relaxedReducedValue.
Formal statement
Proof (Lean source)
Range lemma for Δ_m^±. The implementability gap lands in its core-declared space [0,∞): 0 ≤ Δ_m^±(r,κ). The reduction lemma identifies it with the reduced constrained-minus-unconstrained value, whose nonnegativity is proved by roundingLossCertificate_nonneg. @realizes Delta_m^pm(r,kappa)(range [0,∞) pinned via the reduced constrained-minus-unconstrained identity)
Formal statement
Proof (Lean source)
If the relaxed reduced objective has a unique minimizer outside the implementable parity slice, and the implementable reduced problem is attained, then the implementability gap is strictly positive.
Formal statement
Proof (Lean source)
If a reduced triangle point globally minimizes the relaxed reduced objective, then the sInf defining relaxedReducedValue is its objective value.
Formal statement
Proof (Lean source)
If a reduced triangle point globally minimizes the parity-truncated reduced objective, then the sInf defining implementableReducedValue is its objective value.
Formal statement
Proof (Lean source)
The relaxed reduced problem attains its minimum: some point of the reduced triangle minimizes the reduced objective over the whole triangle. This is the existence statement behind the relaxed value being a genuine minimum rather than only an infimum; it is proved by transporting the triangle to the weighted simplex, where the linear-plus-weighted-norm objective has an explicit minimizer (an active-set point when the robustness weight is positive, an exposed-face vertex when it is zero).
Formal statement
Proof (Lean source)
The implementable reduced problem attains its minimum: some point of the reduced triangle satisfies the parity constraint and minimizes the reduced objective over all triangle points that satisfy it. This is the parity-truncated counterpart of exists_relaxed_reduced_minimizer, and it is what makes the implementability gap a difference of two attained minima.
Formal statement
Proof (Lean source)
The implementability gap is never negative: restricting a design to be realizable by an actual ±1 assignment law can only raise the achievable objective value. Formally, both reduced problems attain their minima and the implementable problem optimizes over a subset of the relaxed feasible set, so its minimum dominates. This is the range condition for Δ_m^± promised in the definition of implementabilityGap.
Formal statement
Proof (Lean source)
Zero implementability gap is equivalent to the relaxed argmin set meeting the implementable parity slice.
Formal statement
Proof (Lean source)
In the unique-relaxed-minimizer case (in particular the κ > 0 active-set case), zero gap is equivalent to that unique minimizer lying in the parity slice.
Formal statement
Proof (Lean source)
Unique-minimizer form matching the sharp_rho_star clause: with a unique relaxed minimizer, zero gap is equivalent to every relaxed minimizer lying in the parity slice.
Formal statement
Proof (Lean source)
At κ = 0, if the exposed relaxed min-face is disjoint from the implementable slice, then the implementability gap is strictly positive.
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.ParitySlice 3 declarations After full two-block symmetrization, the ±1 covariance image in spectral coordinates is T_m (m even) or T_m ∩ {y+z ≥ 2/m} (m odd), via y + z = m⁻¹ E[S_A² + S_B²] and the parity bound S_A², S_B² ≥ 1 for odd m.
±1 reduced-slice characterization (parity content)
After full two-block symmetrization, the ±1 covariance image in spectral
coordinates is T_m (m even) or T_m ∩ {y+z ≥ 2/m} (m odd), via
y + z = m⁻¹ E[S_A² + S_B²] and the parity bound S_A², S_B² ≥ 1 for odd m.
The ±1 covariance image of the block-exchangeable class in spectral coordinates is exactly the reduced triangle truncated by the parity threshold d_m (0 for even m, 2/m for odd m). In particular, for odd m the spread vertex (m/(m−1), 0, 0) is not implementable, while for even m the whole slice is.
Formal statement
Proof (Lean source)
For even m, the whole block elliptope slice is implementable.
Formal statement
Proof (Lean source)
For odd m ≥ 2, the spread covariance is not ±1 implementable.
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.ParitySliceDesigns 2 declarations Every point of the parity-truncated reduced triangle is the second moment of a block-exchangeable ±1 design.
±1 reduced-slice characterization: the backward (sufficiency) direction
Every point of the parity-truncated reduced triangle is the second moment of a
block-exchangeable ±1 design. For even m the point is the barycentric mixture
(y/2m)·cut + (z/2m)·all + (x·(m−1)/m)·spread of the three triangle vertices; for
odd m the origin is unavailable and the region is a quadrilateral cut off at
y+z = 2/m, handled by pm_slice_backward_odd.
Backward direction, even m: the barycentric 3-vertex mixture.
Formal statement
Proof (Lean source)
Backward (sufficiency) direction. Any parity-truncated reduced-triangle point is realized by a block-exchangeable ±1 design.
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.ParitySliceForward 16 declarations If a ±1 design D realizes the block-symmetric second moment X(u,v) (i.e.
±1 reduced-slice characterization: the forward (necessity) direction
If a ±1 design D realizes the block-symmetric second moment X(u,v) (i.e.
E_D[Z Zᵀ] = X(u,v)), then its reduced spectral coordinates
x = 1−u, y = 1+(m−1)u−mv, z = 1+(m−1)u+mv are nonnegative (PSD of a Gram
matrix) and satisfy the parity bound y + z ≥ d_m (0 for even m, 2/m for
odd m). The whole argument is elementary second-moment algebra: reading the
matrix entries 1 (diagonal), u (within-block), v (across-block), the block
sums S_A = ∑_{i∈A} Z_i, S_B = ∑_{i∈B} Z_i satisfy
E[S_A²] = E[S_B²] = m + m(m−1)u, E[S_A S_B] = m² v, whence
E[(S_A−S_B)²] = 2m·y ≥ 0, E[(S_A+S_B)²] = 2m·z ≥ 0, and for odd m the
parity S_A, S_B odd forces E[S_A²], E[S_B²] ≥ 1, so y+z = (E[S_A²]+E[S_B²])/m ≥ 2/m.
Community A_m = {i : i.val < m} as a Finset.
Community B_m = {i : ¬ i.val < m} as a Finset.
The real community sum S_A(z) = ∑_{i ∈ A_m} Z_i.
The real community sum S_B(z) = ∑_{i ∈ B_m} Z_i.
Each ±1 sign squares to 1.
Formal statement
|A_m| = m.
Formal statement
Proof (Lean source)
|B_m| = m.
Formal statement
Proof (Lean source)
The design second-moment entries read off from X(u,v): the (i,j) entry is 1 on the diagonal, u within a block, v across blocks.
Formal statement
Proof (Lean source)
E[S_A²] = m + m(m−1) u (and identically E[S_B²]).
Formal statement
Proof (Lean source)
E[S_B²] = m + m(m−1) u: whenever a design's assignment second moment is the block-symmetric matrix X(u,v), the mean square of the community-B sign sum depends only on the common within-block correlation u (not on the across-block entry v), and equals the corresponding community-A quantity. The two blocks have the same size m, so this is the mirror image of E_sumAr_sq.
Formal statement
Proof (Lean source)
E[S_A S_B] = m² v.
Formal statement
Proof (Lean source)
The within-block second moment u ≤ 1 (from E[(Z_i − Z_j)²] ≥ 0 for a within-block pair, available since m ≥ 2).
Formal statement
Proof (Lean source)
For odd m, the integer block sum S_A is odd for every assignment.
Formal statement
Proof (Lean source)
For odd m, E[S_A²] ≥ 1.
Formal statement
Proof (Lean source)
For odd m, E[S_B²] ≥ 1 under every design. Community B has an odd number m of units, so its sign sum is an odd integer for every assignment and therefore has square at least one; averaging preserves the bound. This is the parity obstruction that keeps the odd-m reduced slice away from the spread vertex.
Formal statement
Proof (Lean source)
Forward (necessity) direction. A design realizing X(u,v) has reduced spectral coordinates in the parity-truncated triangle.
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.ParitySliceMixture 13 declarations Reusable primitives for the sufficiency direction: * uniformOnDesign — the uniform law on a nonempty finset of assignments, with membership in the block-exchangeable class whenever the support is invariant under global n
Mixture designs and block-symmetry of second moments (backward-direction core)
Reusable primitives for the sufficiency direction:
* uniformOnDesign — the uniform law on a nonempty finset of assignments, with
membership in the block-exchangeable class whenever the support is invariant
under global negation and the two-block automorphism group;
* mixtureDesign — a finite convex mixture of designs, its expectation
(E) linearity, its membership in the class, and the affine action on the
block-symmetric second moment X(u,v);
* secondMoment_blockSym_of_exchangeable — the second moment of any
block-exchangeable design is block-symmetric (= X(u,v) for the reference-pair
values u,v), proved by transporting pair expectations along block automorphisms.
Reindex an assignment z by a permutation σ: (R σ z) i = z (σ i).
Change of variables: for a design invariant under the block-automorphism σ (D.p (reindexBy σ z) = D.p z), expectation is invariant under precomposition by reindexBy σ.
Formal statement
Proof (Lean source)
The pointwise sign transports under reindexing: signOf (R σ z) i = signOf z (σ i).
Formal statement
Pair-expectation transport: if D is invariant under the block-automorphism σ then E[Z_{σ i} Z_{σ j}] = E[Z_i Z_j].
Formal statement
Proof (Lean source)
A within-block transposition (swap two indices of block A, fixing everything else) is a two-block automorphism.
Formal statement
Proof (Lean source)
The block-symmetry general lemma. For a block-exchangeable design D, its second moment is block-symmetric: it equals X(u,v) with u = E[Z_{i₀} Z_{j₀}] the within-block reference-pair value and v = E[Z_{i₀} Z_{k₀}] the cross-block reference-pair value.
Formal statement
Proof (Lean source)
The uniform law on a nonempty finset S of assignments.
Definition (Lean source)
If the support S is invariant under global negation and under reindexing by every two-block automorphism, the uniform design lies in the block-exchangeable class.
Formal statement
Proof (Lean source)
A finite convex mixture ∑ᵢ wᵢ Dᵢ of designs.
Definition (Lean source)
Expectation of a mixture is the convex combination of expectations.
Formal statement
Proof (Lean source)
A mixture of block-exchangeable designs is block-exchangeable.
Formal statement
Proof (Lean source)
Averaging block-symmetric matrices with weights summing to 1.
Formal statement
Proof (Lean source)
The second moment of a mixture whose components have block-symmetric second moments X(uᵢ,vᵢ) is X(∑ wᵢ uᵢ, ∑ wᵢ vᵢ).
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.ParitySliceParity 17 declarations For odd m the spread origin (0,0) is not implementable (parity forces S_A, S_B odd, hence y+z ≥ 2/m).
Odd-m parity vertex designs and the quadrilateral backward direction
For odd m the spread origin (0,0) is not implementable (parity forces
S_A, S_B odd, hence y+z ≥ 2/m). The feasible region is the quadrilateral with
the two extra parity vertices
pcutVDesign—X(−1/m, −1/m²), reduced(2/m, 0)(block sums(±1, ∓1));pallVDesign—X(−1/m, 1/m²), reduced(0, 2/m)(block sums(±1, ±1)).
An arbitrary quadrilateral point is the convex combination of the four vertices
cut, all, pcut, pall with the outer/inner-edge weights `λμ, λ(1−μ), (1−λ)μ,
(1−λ)(1−μ), μ = y/(y+z), λ = ((y+z)−2/m)/(2m−2/m)`.
The (±1, ∓1) block-sum support (pcut).
The (±1, ±1) block-sum support (pall).
An assignment with S_A = 1, S_B = -1 (odd m): (m+1)/2 true on block A, (m-1)/2 true on block B.
An assignment with S_A = 1, S_B = 1 (odd m).
For odd m some assignment has community sign sums (1, −1), so the pcut parity support is nonempty and the uniform law on it is well defined. When m is odd each community sum is an odd integer, so (±1, ∓1) is the closest an oppositely-signed pair of communities can come to being balanced.
Formal statement
Proof (Lean source)
For odd m some assignment has community sign sums (1, 1), so the pall parity support is nonempty and the uniform law on it is well defined. This is the companion of pcutSupport_nonempty for the equally-signed parity vertex.
Formal statement
Proof (Lean source)
The pcut parity design.
Definition (Lean source)
The pall parity design.
Definition (Lean source)
For odd m, the pcut parity design — uniform over the assignments whose community sign sums are (1, −1) or (−1, 1) — belongs to the block-exchangeable design class. Negating an assignment swaps the two cases, and a two-block automorphism either fixes the pair of community sums or transposes it, so the support is invariant either way.
Formal statement
Proof (Lean source)
For odd m, the pall parity design — uniform over the assignments whose community sign sums are (1, 1) or (−1, −1) — belongs to the block-exchangeable design class, by the same negation and two-block-automorphism invariance of its support.
Formal statement
Proof (Lean source)
On pcutSupport, S_A² = 1, so E[S_A²] = 1.
Formal statement
Proof (Lean source)
On pcutSupport, S_A S_B = -1.
Formal statement
Proof (Lean source)
Under the pall parity design the community-A sign sum has mean square 1, because every assignment in its support has that sum equal to +1 or −1.
Formal statement
Proof (Lean source)
Under the pall parity design the two community sign sums have cross moment +1: they always carry the same sign, both +1 or both −1. This is the sign flip of the corresponding pcut value and is what separates the two parity vertices.
Formal statement
Proof (Lean source)
For odd m ≥ 2 the pcut parity design has assignment second moment X(−1/m, −1/m²): units in the same community carry correlation −1/m, units in opposite communities −1/m². Its reduced spectral coordinates are y = 2/m, z = 0, so it sits exactly on the parity threshold y + z = 2/m — one of the two extra vertices that odd community size creates.
Formal statement
Proof (Lean source)
For odd m ≥ 2 the pall parity design has assignment second moment X(−1/m, 1/m²): units in the same community carry correlation −1/m, units in opposite communities +1/m². Its reduced spectral coordinates are y = 0, z = 2/m, the second parity vertex, again sitting exactly on the threshold y + z = 2/m.
Formal statement
Proof (Lean source)
Backward direction, odd m: the 4-vertex quadrilateral mixture.
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.ParitySliceVertices 19 declarations Explicit block-exchangeable designs realizing the triangle vertices: * cutVDesign — X(1,−1), reduced (0, 2m, 0) (uniform on {s_m, −s_m}); * allVDesign — X(1, 1), reduced (0, 0, 2m) (uniform on {1, −1} assignments); * spr
Vertex designs for the backward direction
Explicit block-exchangeable designs realizing the triangle vertices:
* cutVDesign — X(1,−1), reduced (0, 2m, 0) (uniform on {s_m, −s_m});
* allVDesign — X(1, 1), reduced (0, 0, 2m) (uniform on {1, −1} assignments);
* spreadVDesign (even m) — X(−1/(m−1), 0), reduced (2m/q, 0, 0) (uniform on
the balanced-in-each-block assignments, second moment via block symmetry and the
deterministic block sums S_A = S_B = 0).
The block-sum transport lemmas (blockSumA under negation and block automorphism)
supply the support-invariance the class membership needs.
Negating an assignment negates each community sum.
Formal statement
Negating an assignment negates the community-B sign sum, the mirror of blockSumA_neg. Together the two make every sign-symmetric support closed under global negation, which is what the balanced-design membership proofs need.
Formal statement
Under a block-automorphism σ, the pair of community sums of reindexBy σ z is either (S_A, S_B) (block-preserving) or (S_B, S_A) (block-swapping).
Formal statement
Proof (Lean source)
Expectation under the uniform law on a two-element support {z₁, z₂}.
Formal statement
Proof (Lean source)
The cut vertex design ½δ_{s_m} + ½δ_{−s_m}.
Definition (Lean source)
The all-ones vertex design ½δ_{1} + ½δ_{−1}.
Definition (Lean source)
The cut vertex design — a fair coin between "treat community A, control community B" and its reverse — belongs to the block-exchangeable design class: its two-point support is closed under global sign flip and under every two-block automorphism (relabelling units inside a community fixes each of the two assignments, swapping the communities exchanges them).
Formal statement
Proof (Lean source)
The all-ones vertex design — a fair coin between "treat everyone" and "control everyone" — belongs to the block-exchangeable design class: its two-point support is closed under global sign flip, and both constant assignments are fixed by every permutation of the units, hence by every two-block automorphism.
Formal statement
Proof (Lean source)
The cut vertex design has assignment second moment X(1,−1): two units in the same community always receive the same sign, and two units in opposite communities always receive opposite signs. In the reduced spectral coordinates this is the triangle vertex (0, 2m, 0).
Formal statement
Proof (Lean source)
The all-ones vertex design has assignment second moment X(1,1): every pair of units always receives the same sign, whether or not they share a community. In the reduced spectral coordinates this is the triangle vertex (0, 0, 2m).
Formal statement
Proof (Lean source)
The balanced-in-each-block support {z : S_A(z) = 0 ∧ S_B(z) = 0}.
For even m, an explicit balanced-in-each-block assignment (true on the first half of each block).
For even m, the explicit half-and-half assignment (treat the first half of each community, control the second half) really is balanced in each block: both community sign sums are zero.
Formal statement
Proof (Lean source)
For even m at least one assignment has both community sign sums equal to zero, so the balanced-in-each-block support is nonempty and the uniform law on it is well defined. Evenness is essential: for odd m each community sum is an odd integer and this support is empty.
Formal statement
Proof (Lean source)
The spread vertex design (even m).
Definition (Lean source)
For even m, the spread vertex design — uniform over the assignments that are exactly balanced inside each community — belongs to the block-exchangeable design class. Negating an assignment and relabelling units by a two-block automorphism both leave the pair of community sign sums at (0,0), so the support is invariant.
Formal statement
Proof (Lean source)
On the spread support the real community sums vanish, so E[S_A²]=E[S_A S_B]=0.
Formal statement
Proof (Lean source)
Under the spread vertex design the two community sign sums have zero cross moment, since every assignment in its support has both sums equal to zero pointwise. With the companion spreadVDesign_sumAr_zero this pins the design's reduced coordinates.
Formal statement
Proof (Lean source)
For even m ≥ 2 the spread vertex design has assignment second moment X(−1/(m−1), 0): units in different communities are uncorrelated, and units in the same community carry the small negative correlation −1/(m−1) forced by the community sign sum being identically zero. These are the reduced coordinates (2m/q, 0, 0) — the spread vertex of the triangle — so for even m the spread covariance is implementable.
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.ReducedSimplexBridge 4 declarations Bridge between reduced triangle coordinates and weighted-simplex coordinates
Bridge between reduced triangle coordinates and weighted-simplex coordinates
The change of variables t = (q x, y, z) sends the reduced triangle to Δ_{2m}.
Formal statement
Proof (Lean source)
The inverse change of variables x = t_x/q, y = t_y, z = t_z.
Formal statement
Proof (Lean source)
Under t = (q x, y, z), the reduced objective is the weighted-simplex objective with α = (c_x/q, c_y, c_z) and β = (1/q, 1, 1).
Formal statement
Proof (Lean source)
The inverse form of reducedObjective_eq_wsObj, for a simplex point t.
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.RobustConvergence 2 declarations
The reduced Frobenius square at X(u,v) is the identity square plus the two off-diagonal block contributions.
Formal statement
Proof (Lean source)
Any choice of relaxed minimizers converges entrywise to the identity as κ → ∞.
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.RobustCorner 10 declarations Robust-corner helper lemmas
Robust-corner helper lemmas
Under the uniform iid sign law, the raw sum of two distinct coordinate signs is zero.
Formal statement
Proof (Lean source)
The iid Rademacher design has identity second-moment matrix.
Formal statement
Proof (Lean source)
The identity covariance is the block-symmetric center (u,v)=(0,0), hence lies in E_m^blk under two-block homophily.
Formal statement
Proof (Lean source)
The center first-order equality c_x/q = c_y forces r = 2b(a+b).
Formal statement
Proof (Lean source)
The two center coefficient equalities are equivalent to the affine-balanced locus.
Formal statement
Proof (Lean source)
On the affine-balanced locus, the reduced linear coefficients are all equal.
Formal statement
Proof (Lean source)
Inverse map from reduced coordinates to block-symmetric (u,v) coordinates.
Formal statement
Proof (Lean source)
The matrix objective at I_n is the reduced objective at (1,1,1).
Formal statement
Proof (Lean source)
If I_n minimizes the matrix objective on the block elliptope, the reduced center first-order coefficient equalities hold.
Formal statement
Proof (Lean source)
On the affine-balanced locus and for κ>0, I_n is the strict relaxed minimizer over the block elliptope.
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.SharpActive 1 declarations Sharp-certificate active-set assembly helpers
Sharp-certificate active-set assembly helpers
For κ > 0, the active-set SOCP certificate gives the unique relaxed minimizer in reduced coordinates and the relaxed value formula.
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.SharpTrunc 2 declarations Sharp-certificate truncation helpers
Sharp-certificate truncation helpers
If no relaxed minimizer meets the parity slice, the implementable reduced value is the weighted-simplex truncation value at the selector.
Formal statement
Proof (Lean source)
For even community size, the parity threshold is zero, so every relaxed minimizer already lies in the implementable reduced slice.
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.SharpZero 3 declarations Sharp-certificate zero-loss and exposed-face helpers
Sharp-certificate zero-loss and exposed-face helpers
The rounding-loss carrier has zero value exactly when a relaxed reduced minimizer meets the parity slice.
Formal statement
Proof (Lean source)
In the unique-relaxed-minimizer case, zero rounding loss is equivalent to every relaxed minimizer lying in the parity slice.
Formal statement
Proof (Lean source)
At κ = 0, reduced minimizers are exactly the exposed face of the minimum coordinates of α = (c_x/q, c_y, c_z).
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.SimplexActiveSet 1 declarations This file packages the active-set/KKT solution of the linear-plus-weighted-norm second-order cone program min_{t ∈ Δ_M} Σ αᵢ tᵢ + κ √(Σ βᵢ tᵢ²) over the three-point simplex.
Weighted-simplex active-set SOCP
This file packages the active-set/KKT solution of the linear-plus-weighted-norm
second-order cone program
min_{t ∈ Δ_M} Σ αᵢ tᵢ + κ √(Σ βᵢ tᵢ²) over the three-point simplex. Strict
convexity for κ > 0 gives a unique minimizer, realized by the admissible
support/multiplier pair; for κ = 0, the minimizer set is the exposed
α-minimizing face. The headline theorem is weighted_simplex_active_set.
The shared definitions live in SimplexActiveSetDefs; the analytic content lives
in WeightedSimplexKKT (κ > 0 optimality), WeightedSimplexExists (admissible
support existence), and WeightedSimplexFace (κ = 0 face).
Weighted-simplex active-set solution. Fix a positive total simplex mass M, linear weights α, coordinate weights β that are all strictly positive, and a nonnegative regularization parameter κ, and consider minimizing the second-order-cone objective Σ αᵢtᵢ + κ·√(Σβᵢtᵢ²) over the three-point simplex Δ_M of total mass M. Then the following two facts hold: whenever κ is strictly positive, there is a unique admissible support/multiplier pair (S, λ), its induced active-set point lies in Δ_M and is the unique global minimizer of the objective, with optimal value the closed form M · λ; and whenever κ equals zero, a point of Δ_M minimizes the objective exactly when it lies on the exposed α-minimizing face. This encodes the displayed KKT coordinate formula, the uniqueness of the admissible support, the value formula, and the κ = 0 face clause.
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.SimplexActiveSetDefs 5 declarations This file contains the shared definitions for the linear-plus-weighted-norm second-order cone program min_{t ∈ Δ_M} Σ αᵢ tᵢ + κ √(Σ βᵢ tᵢ²) over the three-point simplex.
Weighted-simplex active-set SOCP: shared definitions
This file contains the shared definitions for the linear-plus-weighted-norm
second-order cone program
min_{t ∈ Δ_M} Σ αᵢ tᵢ + κ √(Σ βᵢ tᵢ²) over the three-point simplex. It defines
the objective wsObj, simplex membership InSimplex, KKT support data
IsAdmissibleSupport, the induced active-set point activeSetPoint, and the
κ = 0 exposed minimizer face exposedMinFace.
Given three linear coefficients and three weights, a real scale, and a three-coordinate allocation, the weighted-simplex objective value is the linear weighted sum of the allocation plus the scale times the square root of the weighted sum of squared coordinates.
For a real total mass and a three-coordinate allocation, the scaled three-point simplex membership condition holds exactly when every coordinate is nonnegative and the three coordinates sum to the total mass.
Definition (Lean source)
Given three linear coefficients and three weights, a scale, a set of selected coordinates, and a real multiplier, the admissible-support condition holds exactly when the selected set is nonempty, its summed squared multiplier gaps divided by their weights equal the squared scale, every selected coefficient is strictly below the multiplier, and every unselected coefficient is at least the multiplier.
Given a total mass, three linear coefficients and three weights, a selected coordinate set, and a multiplier, the active-set allocation assigns each selected coordinate the total mass times its multiplier gap divided by its weight and by the sum of those ratios, and assigns every unselected coordinate zero.
Given a total mass and three linear coefficients, the exposed minimum face is the set of three-coordinate allocations that belong to the scaled simplex and have every nonzero coordinate's coefficient no larger than every coefficient.
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.SimplexTruncation 2 declarations This file gives conditional transfer rules for the weighted-simplex SOCP over the parity-truncated simplex K_d = {t ∈ Δ_M : t_y + t_z ≥ d}.
Weighted-simplex truncation
This file gives conditional transfer rules for the weighted-simplex SOCP over
the parity-truncated simplex K_d = {t ∈ Δ_M : t_y + t_z ≥ d}. Given a
relaxed minimizer over Δ_M, if it is feasible then it is also optimal over
K_d; otherwise the explicit endpoint/interior selector sStar from the 1-D
convex slice is optimal on K_d. The theorem weighted_simplex_truncation
specializes this transfer to supplied positive-scale active-set data or a
supplied zero-scale exposed-face point; it does not choose either witness.
trunc_from_minimizer is the reusable relaxed-minimizer dichotomy.
The definitions (InTruncSimplex, truncSegPoint, truncSelector) live in
SimplexTruncationDefs; the convexity/boundary-reduction step in
SimplexTruncationConvex; the 1-D slice minimization in SimplexTruncationSlice;
and the relaxed-optimum global-minimizer certificates in
SimplexTruncationMinimizers. This file glues them into conditional transfer
lemmas for supplied relaxed-minimizer data.
Truncation dichotomy from a relaxed minimizer. Fix a truncation threshold d at most the total simplex mass M, a linear weighting α, coordinate weights β with its zeroth entry nonnegative and its remaining two entries fixed equal to 1, and a nonnegative regularization parameter κ. Given a point t_rel of the simplex Δ_M that globally minimizes the weighted objective wsObj over Δ_M, then the constrained problem over the truncated simplex K_d = {t ∈ Δ_M : t₁ + t₂ ≥ d} splits into two cases: if t_rel already satisfies the truncation constraint, it remains a global minimizer over K_d; otherwise, the face selector point truncSegPoint M d sStar is feasible for K_d and is a global minimizer over K_d. This is the κ-agnostic core shared by the κ > 0 and κ = 0 branches of the headline lemma.
Formal statement
Proof (Lean source)
Conditional weighted-simplex truncation transfer. For total mass M with positive mass, threshold d at most M, linear weights α, coordinate weights β that are everywhere strictly positive with their last two entries equal to 1, and regularization parameter κ that is nonnegative, two conditional rules transfer relaxed optimality to the truncated simplex: at positive κ, every supplied admissible active-set point either remains optimal when feasible or yields the explicit boundary selector when infeasible; at zero κ, the same alternatives hold for every supplied point of the exposed minimizing face.
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.SimplexTruncationConvex 4 declarations Two-point convexity of the SOCP objective wsObj (linear term plus a nonnegative multiple of the weighted ℓ² norm), and the geometric consequence that on the truncated simplex K_d any feasible point is dominated in object
Weighted-simplex truncation: convexity and boundary reduction
Two-point convexity of the SOCP objective wsObj (linear term plus a nonnegative
multiple of the weighted ℓ² norm), and the geometric consequence that on the
truncated simplex K_d any feasible point is dominated in objective value by a
point of the truncation face H_d, once the relaxed global minimizer is known to
be infeasible (t_rel_y + t_rel_z < d).
The weighted Euclidean root-mean-square of a convex combination is no larger than the same convex combination of the two weighted root-mean-squares.
Formal statement
Proof (Lean source)
A three-coordinate vector with total mass M whose last two coordinates sum to d is the corresponding point on the truncation segment, indexed by its second coordinate.
Formal statement
Proof (Lean source)
Two-point convexity of the weighted-simplex objective. For nonnegative coordinate weights β and a nonnegative SOCP scale κ, if θ lies between 0 and 1 then the objective evaluated at the convex combination of two points is at most the same convex combination of the objective values at and at .
Formal statement
Proof (Lean source)
Boundary reduction onto the truncation face. Fix nonnegative coordinate weights β and a nonnegative SOCP scale κ. If t_rel lies in the three-coordinate simplex and globally minimizes the objective over that simplex, while t_rel fails the parity cut defining the truncated sub-simplex, since its last two coordinates sum to strictly less than , then for every point t of the truncated sub-simplex , there is some between and such that the boundary point of the truncation face attains an objective value no larger than the objective at t.
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.SimplexTruncationDefs 3 declarations The parity-truncated simplex K_d, its boundary segment H_d (truncSegPoint), and the endpoint/interior selector s⋆ (truncSelector).
Weighted-simplex truncation: shared definitions
The parity-truncated simplex K_d, its boundary segment H_d (truncSegPoint),
and the endpoint/interior selector s⋆ (truncSelector). Split out of the main
truncation file so both the convexity/reduction helper and the 1-D slice helper can
reference them.
For a total mass and truncation threshold and a three-coordinate allocation, the truncated-simplex membership condition holds exactly when the allocation belongs to the scaled three-point simplex and its second and third coordinates sum to at least the threshold.
For a total mass, threshold, and segment coordinate, the truncation-boundary point is the three-coordinate allocation whose first coordinate is the total mass minus the threshold, whose second coordinate is the segment coordinate, and whose third coordinate is the threshold minus that coordinate.
Definition (Lean source)
Given a total mass and threshold, three linear coefficients and three weights, and a scale, the boundary-segment selector first sets the difference of the second and third coefficients to as its first intermediate quantity and the weighted squared first coordinate to as its second intermediate quantity; it then returns zero when is at least , returns when is at most its negative, and otherwise returns .
Definition (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.SimplexTruncationMinimizers 2 declarations Self-contained proofs that the two relaxed-optimum descriptions used by the truncation lemma really are global minimizers of wsObj over the full simplex Δ_M, so the truncation argument does not depend on weighted_simplex
Weighted-simplex truncation: relaxed global minimizers
Self-contained proofs that the two relaxed-optimum descriptions used by the
truncation lemma really are global minimizers of wsObj over the full simplex
Δ_M, so the truncation argument does not depend on weighted_simplex_active_set:
* activeSetPoint_isMinimizer (κ > 0): any KKT-admissible support/multiplier pair
induces a simplex point that globally minimizes wsObj. The optimality is a
Cauchy–Schwarz (weighted ℓ²) certificate: κ β_i t*_i / ‖t*‖_β = λ − α_i on the
support and α_j ≥ λ off it, so the first-order (subgradient) inequality collapses
to λ·(Σ s − M) = 0.
* exposedMinFace_isMinimizer (κ = 0): a point of the exposed α-minimizing face
minimizes the (now purely linear) objective, since its mass sits on argmin α.
KKT admissible ⟹ global minimizer (κ > 0). For a positive total mass M, positive coordinate weights β, a positive SOCP scale κ, and a KKT-admissible support/multiplier pair (S, λ): a nonempty index set S with , strict activity on S, and inactivity off S, the induced active-set point lies in the simplex and globally minimizes the objective over that simplex.
Formal statement
Proof (Lean source)
Exposed face ⟹ global minimizer (κ = 0). If t_rel lies in the simplex and every coordinate at which it is nonzero attains the minimum value of α, then t_rel globally minimizes the purely linear objective — wsObj at — over the whole simplex.
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.SimplexTruncationSlice 6 declarations On the truncation face H_d the objective restricts to the 1-D convex function g_d(σ) = α_x(M−d) + α_y σ + α_z(d−σ) + κ √(A + σ² + (d−σ)²), with A = β_x(M−d)².
Weighted-simplex truncation: the 1-D boundary slice
On the truncation face H_d the objective restricts to the 1-D convex function
g_d(σ) = α_x(M−d) + α_y σ + α_z(d−σ) + κ √(A + σ² + (d−σ)²), with A = β_x(M−d)².
This file computes that restriction (wsObj_truncSeg_eq), shows the selector s⋆
lands in [0,d] (truncSelector_mem), and proves g_d is minimized at s⋆
(truncSeg_selector_le) via the tangent-line inequality of the convex slice.
For a nonnegative baseline component, the inner product of two three-dimensional boundary vectors is no greater than the product of their Euclidean norms.
Formal statement
Proof (Lean source)
If the truncation offset lies strictly between the two interior guard bounds, then its squared size times the radicand is strictly smaller than the squared truncation scale times the squared interval width.
Formal statement
Proof (Lean source)
Under the selector's strict interior guard inequalities, a positive interval width, and nonnegative baseline and scale, the squared-scale denominator minus half the squared offset is positive.
Formal statement
Proof (Lean source)
Objective on the truncation face. For a total budget M and a truncation level d, a linear weight vector α and a quadratic weight vector β, and a curvature coefficient kappa and a face coordinate σ, evaluating the weighted-simplex objective at the truncation-face point (M−d, σ, d−σ) gives the explicit one-dimensional form α₀(M−d) + α₁σ + α₂(d−σ) + κ√(β₀(M−d)² + β₁σ² + β₂(d−σ)²).
Formal statement
Proof (Lean source)
The selector lands in [0,d]. The endpoint/interior selector truncSelector satisfies 0 ≤ s⋆ ≤ d: the two endpoint branches give 0 and d directly, and in the interior branch the guard failures |δ| < κ d / √(A + d²) force δ²(A + d²) < κ² d², whence |s⋆ − d/2| < d/2.
Formal statement
Proof (Lean source)
The selector minimizes the boundary slice. Suppose the truncation width is positive, the first-coordinate weight is nonnegative while the other two weights both equal 1, and the SOCP scale is nonnegative. Then for every offset between and , the objective wsObj evaluated at the boundary point truncSegPoint M d applied to the selector truncSelector M d α β κ is at most its value at the boundary point for .
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.SpectralCoordinates 3 declarations The four-way orthogonal eigendecomposition of ℝⁿ (span 1_n, span s_m, the within-A and within-B contrast subspaces) reads off the eigenvalues of X(u,v) as x = 1−u, y = 1+(m−1)u−mv, z = 1+(m−1)u+mv, converts elliptope mem
Block spectral coordinates
The four-way orthogonal eigendecomposition of ℝⁿ (span 1_n, span s_m, the
within-A and within-B contrast subspaces) reads off the eigenvalues of X(u,v)
as x = 1−u, y = 1+(m−1)u−mv, z = 1+(m−1)u+mv, converts elliptope membership
into the reduced triangle, and gives the closed-form objective φ.
The cut covariance is the block-symmetric point X(1,−1), with spectral coordinates (0, 2m, 0).
Formal statement
Proof (Lean source)
The identity I_n is the block-symmetric point X(0,0), with spectral coordinates (1, 1, 1).
Formal statement
Proof (Lean source)
X(u,v) lies in E_m^blk iff its spectral coordinates lie in the reduced triangle T_m, and the design objective equals the reduced form φ with c_x = q((a+b)+r/(a+b)), c_y = 2b + r/(2b), c_z = 2m and q = 2(m−1). The last two conjuncts record the corner coordinate readings the note states: X_cut = X(1,−1) has spectral coordinates (0, 2m, 0) and I_n = X(0,0) has spectral coordinates (1, 1, 1).
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.SpectralMembership 1 declarations Membership algebra for block spectral coordinates
Membership algebra for block spectral coordinates
For m ≥ 2, membership of the concrete block-symmetric matrix X(u,v) in E_m^blk is equivalent to the three reduced-coordinate PSD inequalities plus the trace identity q x + y + z = 2m.
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.SpreadGap 1 declarations Turns a reduced-coordinate spread-vertex certificate into the matrix relaxed minimizer statement and the strict implementability gap in the odd-community slice.
Spread-vertex gap assembly
Turns a reduced-coordinate spread-vertex certificate into the matrix relaxed minimizer statement and the strict implementability gap in the odd-community slice.
Suppose the community size is odd and, in reduced spectral coordinates, the spread vertex is the strict minimizer of the reduced objective over the reduced triangle. Then three things follow at the matrix level: the spread covariance lies in the relaxed block-symmetric elliptope slice and is its unique minimizer of the design objective; it is not the second moment of any block-exchangeable ±1 design; and the implementability gap is strictly positive.
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.SymRedDesign 22 declarations The block-automorphism group H acts on sign assignments by pull-back (σ · z) i = z (σ i).
Design-side symmetry reduction (orbit averaging over the automorphism group)
The block-automorphism group H acts on sign assignments by pull-back
(σ · z) i = z (σ i). Averaging a balanced law D over H gives
D'.p z = |H|⁻¹ ∑_{σ∈H} D.p (z∘σ), a genuine PMF that is balanced and
H-invariant, hence block-exchangeable, with zero one-point margins. Its second
moment is the orbit average X(D')ᵢⱼ = |H|⁻¹ ∑_σ X(D)_{σi,σj}. Because each σ∈H
permutes the within/cross pair-Finsets, the block sums are preserved
(Ssame(X(D')) = Ssame(X(D)), likewise Scross), so every trace term is unchanged,
while the Frobenius norm drops by convexity — giving a no-worse block-exchangeable law.
The pull-back action of a permutation on sign assignments.
The block-automorphism group as a Finset of permutations.
Definition (Lean source)
The identity is a block automorphism.
Formal statement
Proof (Lean source)
blockAutoFinset is nonempty (so |H| > 0).
Formal statement
Proof (Lean source)
The block-automorphism set is closed under composition.
Formal statement
Proof (Lean source)
The block-automorphism set is closed under inverse.
Formal statement
Proof (Lean source)
A block automorphism maps within-community pairs to within-community pairs (and preserves distinctness); i.e. it permutes sameOffPairs.
Formal statement
Proof (Lean source)
A block automorphism permutes crossPairs.
Formal statement
Proof (Lean source)
The orbit-averaged design D'.p z = |H|⁻¹ ∑_{σ∈H} D.p (z∘σ).
Definition (Lean source)
The orbit average of a balanced design is balanced.
Formal statement
Proof (Lean source)
The orbit average is invariant under the block-automorphism group.
Formal statement
Proof (Lean source)
A balanced design has zero one-point margins.
Formal statement
Proof (Lean source)
The orbit average lands in the block-exchangeable class.
Formal statement
Proof (Lean source)
Second moments are symmetric.
Formal statement
Proof (Lean source)
Second moments have unit diagonal.
Formal statement
Proof (Lean source)
Second moments are positive semidefinite (Gram matrix E[Z Zᵀ]).
Formal statement
Proof (Lean source)
The uniform iid Rademacher design is block-exchangeable (a nonempty witness).
Formal statement
Proof (Lean source)
The second moment of the orbit average is the orbit average of the second moment: X(D')ᵢⱼ = |H|⁻¹ ∑_{σ∈H} X(D)_{σi,σj}.
Formal statement
Proof (Lean source)
Orbit averaging preserves the within-community entry sum.
Formal statement
Proof (Lean source)
Orbit averaging preserves the cross-community entry sum.
Formal statement
Proof (Lean source)
Orbit averaging weakly decreases the Frobenius norm of the second moment.
Formal statement
Proof (Lean source)
Design-side symmetry reduction (master export). For every balanced design D, its orbit average orbitAvgDesign m D over the full two-block automorphism group is the witness: it is block-exchangeable, has the same zero one-point margins, and has a weakly smaller objective.
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.SymRedMatrix 28 declarations The objective matrices L_m, L_m^†, J_n are all block-constant: their entries depend only on the pair type (diagonal / within-community / cross-community).
Matrix-side symmetry reduction (block-constant averaging, no group action)
The objective matrices L_m, L_m^†, J_n are all block-constant: their
entries depend only on the pair type (diagonal / within-community / cross-community).
For a block-constant M and a symmetric X,
Tr(M X) = d·∑ᵢ Xᵢᵢ + w·Ssame(X) + c·Scross(X),
where Ssame/Scross are the within/cross off-diagonal entry sums. Setting
u = Ssame(X)/Nsame, v = Scross(X)/Ncross (the block averages) makes the block
sums of X(u,v) match those of X, so every trace term is exactly preserved,
while the Frobenius term drops by Cauchy–Schwarz ((∑x)² ≤ N·∑x²). PSD unit-diagonal
X further forces X(u,v) ∈ E_m^blk via the quadratic forms 1ᵀX1 ≥ 0, sᵀXs ≥ 0,
(eᵢ−eⱼ)ᵀX(eᵢ−eⱼ) ≥ 0. Hence orbit-averaging never worsens the objective — with no
group machinery.
Block-constant matrix G(d,w,c): entry d on the diagonal, w within a community, c across communities. blockSymMatrix m u v = blockConstMat m 1 u v.
The within-community off-diagonal ordered pairs.
The cross-community ordered pairs.
The within-community entry sum ∑_{same, i≠j} Xᵢⱼ.
Definition (Lean source)
The cross-community entry sum ∑_{cross} Xᵢⱼ.
Definition (Lean source)
Number of within-community off-diagonal ordered pairs = 2m(m−1).
Definition (Lean source)
Number of cross-community ordered pairs = 2m².
Definition (Lean source)
The block average u of X.
The block average v of X.
blockSymMatrix is the d = 1 block-constant matrix.
Formal statement
Proof (Lean source)
A block-constant matrix is symmetric.
Formal statement
Proof (Lean source)
|sameOffPairs m| = 2m(m−1).
Formal statement
Proof (Lean source)
|crossPairs m| = 2m².
Formal statement
Proof (Lean source)
Master trace decomposition. For block-constant M = G(d,w,c) and symmetric X, the trace splits into the diagonal, within, and cross sums.
Formal statement
Proof (Lean source)
Ssame of a block-symmetric matrix X(u',v') is Nsame · u'.
Formal statement
Proof (Lean source)
Scross of a block-symmetric matrix X(u',v') is Ncross · v'.
Formal statement
Proof (Lean source)
Diagonal sum of a unit-diagonal matrix is 2m.
Formal statement
Proof (Lean source)
Trace preservation. For block-constant M and symmetric unit-diagonal X, symmetrizing to the block averages preserves the trace Tr(M X).
Formal statement
Proof (Lean source)
twoBlockLaplacian is block-constant.
Formal statement
Proof (Lean source)
twoBlockLaplacianPinv is block-constant.
Formal statement
Proof (Lean source)
allOnesMatrix is block-constant G(1,1,1).
Formal statement
Proof (Lean source)
Frobenius drop. Symmetrizing weakly decreases the Frobenius norm.
Formal statement
Proof (Lean source)
Unified objective comparison. If Y matches X on the block sums and has no larger Frobenius norm, then Y has no larger objective. Both the matrix-side and the design-side symmetrizations feed through this lemma.
Formal statement
Proof (Lean source)
Off-diagonal entries of a PSD unit-diagonal matrix are bounded by 1.
Formal statement
Proof (Lean source)
Objective bounded below on the elliptope.
Formal statement
Proof (Lean source)
Generic sInf reduction. If T ⊆ S, T is nonempty, f '' S is bounded below, and every point of S is dominated by some point of T, then the two infima of f over S and T coincide.
Formal statement
Proof (Lean source)
Membership. The block averages of a PSD unit-diagonal X land in E_m^blk.
Formal statement
Proof (Lean source)
Matrix-side symmetry reduction (master export). For PSD unit-diagonal X, the block-average point X(uOf X, vOf X) is an elliptope point with weakly smaller objective.
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.SymRedPSD 6 declarations The block-symmetric matrix X(u,v) has the orthogonal eigendecomposition X(u,v) = x • (1 − P₁ − P_s) + y • P_s + z • P₁, with x = 1−u, y = 1+(m−1)u−mv, z = 1+(m−1)u+mv, where P₁ = J/2m (projection onto span 1) and P_s = s
PSD of block-symmetric elliptope points
The block-symmetric matrix X(u,v) has the orthogonal eigendecomposition
X(u,v) = x • (1 − P₁ − P_s) + y • P_s + z • P₁,
with x = 1−u, y = 1+(m−1)u−mv, z = 1+(m−1)u+mv, where P₁ = J/2m (projection
onto span 1) and P_s = s sᵀ/2m (projection onto span s). Each of P₁, P_s,
1 − P₁ − P_s is PSD, so nonnegative spectral coordinates force X(u,v) PSD. This
supplies the inclusion E_m^blk ⊆ {PSD, diag 1} used by the sInf reductions.
The quadratic form of X(u,v) on a vector w: wᵀ X(u,v) w = x·(Q − P²/2m − D²/2m) + y·(D²/2m) + z·(P²/2m) with Q = ∑ wᵢ², P = ∑ wᵢ, D = ∑ sᵢ wᵢ.
Formal statement
Proof (Lean source)
signProj = s sᵀ / 2m is PSD.
Formal statement
Proof (Lean source)
The complementary projection 1 − P₁ − P_s is PSD.
Formal statement
Proof (Lean source)
Spectral decomposition of the block-symmetric matrix.
Formal statement
Proof (Lean source)
PSD from nonnegative spectral coordinates.
Formal statement
Proof (Lean source)
Block-symmetric elliptope points are PSD with unit diagonal: E_m^blk ⊆ {X : PSD ∧ diag 1}.
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.SymmetryReduction 1 declarations Orbit-averaging over the finite group H generated by within-A_m, within-B_m permutations and the community swap: convexity of the PSD cone, H-invariance of L_m, L_m^†, J_n, and orthogonal-invariance/convexity of the Frob
Symmetry reduction (orbit averaging over the two-block automorphism group)
Orbit-averaging over the finite group H generated by within-A_m, within-B_m
permutations and the community swap: convexity of the PSD cone, H-invariance of
L_m, L_m^†, J_n, and orthogonal-invariance/convexity of the Frobenius norm
give a no-worse H-symmetrized point/law. Hence the relaxed and implementable
infima are attained on the block-symmetric slices.
Symmetry reduction. The orbit-average over the full two-block automorphism group (permutations within A_m, within B_m, and the community swap) is the explicit, named no-worse witness — not merely some existing block-symmetric point (the note's load-bearing clauses):
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.VertexCertificates 3 declarations Three elementary linear-plus-weighted-Frobenius optimality certificates over T_m: the cut vertex (0,2m,0), the spread vertex (2m/q,0,0), and the Frobenius center (1,1,1).
Vertex certificates on the reduced triangle
Three elementary linear-plus-weighted-Frobenius optimality certificates over
T_m: the cut vertex (0,2m,0), the spread vertex (2m/q,0,0), and the
Frobenius center (1,1,1). The 0 < qParam m side-condition is the
non-degeneracy m ≥ 2 regularity premise.
Cut-vertex certificate: on T_m, if κ ≥ 0, c_x/q > c_y + κ and c_z > c_y + κ then (0, 2m, 0) is the unique minimizer of φ.
Formal statement
Proof (Lean source)
Algebraic difference identity used by the spread-vertex certificate after multiplying through by sqrt q.
Formal statement
Proof (Lean source)
Spread-vertex certificate: on T_m, if κ ≥ 0, c_y > c_x/q + κ/√q and c_z > c_x/q + κ/√q then (2m/q, 0, 0) is the unique minimizer of φ.
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.WeightedSimplexCS 2 declarations Cauchy–Schwarz for the weighted inner product ⟨s,t⟩_β = Σ βᵢ sᵢ tᵢ on a finite index type, in the squared form weighted_cs_sq and the strict simplex-slice form weighted_cs_simplex_strict.
Weighted Cauchy–Schwarz on the three-point simplex
Cauchy–Schwarz for the weighted inner product ⟨s,t⟩_β = Σ βᵢ sᵢ tᵢ on a finite index type,
in the squared form weighted_cs_sq and the strict simplex-slice form
weighted_cs_simplex_strict. The strict version is used to prove uniqueness for
the weighted-simplex SOCP: on the affine slice Σ sᵢ = Σ tᵢ = M > 0, distinct
points are not positive scalar multiples of each other, so equality in
Cauchy–Schwarz cannot occur.
The squared form is the arbitrary-finite-index
Causalean.Mathlib.Analysis.weighted_inner_sq_le; only the strict version is genuinely
three-dimensional (its proof uses the explicit Lagrange identity).
Weighted Cauchy–Schwarz (squared form). For finitely many coordinates weighted by nonnegative masses β, the square of the weighted inner product of two vectors and is at most the product of their weighted sums of squares .
Formal statement
Proof (Lean source)
Strict weighted Cauchy–Schwarz on the simplex slice. For a nonzero total mass M and positive coordinate weights β, if the coordinates of sum to , the coordinates of sum to , and and are distinct vectors, then the weighted inner product is strictly less than the product of the weighted Euclidean norms .
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.WeightedSimplexExists 6 declarations For κ > 0 there is an admissible support/multiplier pair (S, λ).
Existence of an admissible support (κ > 0)
For κ > 0 there is an admissible support/multiplier pair (S, λ). Constructed by the
intermediate value theorem applied to the continuous threshold function
G(λ) = Σᵢ (max(λ − αᵢ, 0))² / βᵢ: G is continuous with G(min α) = 0 < κ² and
G large for λ large, so some λ has G(λ) = κ²; then S = {i : αᵢ < λ} is
admissible (the truncation makes the sum over S agree with G(λ), and off S,
αⱼ ≥ λ).
Given three linear coefficients and three weights and a real multiplier, the active-set threshold value is the sum over the three coordinates of the squared positive part of the multiplier minus the coefficient, divided by the corresponding weight.
The active-set threshold function varies continuously with the multiplier because the weights are fixed real coefficients.
Formal statement
Proof (Lean source)
The active-set threshold is nonnegative when every coordinate has a nonnegative weight, because it sums squared multiplier gaps divided by those weights.
Formal statement
Proof (Lean source)
The active-set threshold is zero when the multiplier is no larger than every coefficient.
Formal statement
Proof (Lean source)
Summing squared multiplier gaps only over coordinates whose coefficients lie below the multiplier gives exactly the active-set threshold.
Formal statement
Proof (Lean source)
Existence of an admissible support/multiplier pair (κ > 0). For positive coordinate weights β and a positive SOCP scale κ, there exists a nonempty index set S and a multiplier λ such that , with on S and off S.
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.WeightedSimplexFace 2 declarations At κ = 0 the objective wsObj α β 0 is the linear functional Σ αᵢ tᵢ, whose minimizers over Δ_M are exactly the exposed α-minimizing face exposedMinFace.
The κ = 0 exposed face
At κ = 0 the objective wsObj α β 0 is the linear functional Σ αᵢ tᵢ, whose
minimizers over Δ_M are exactly the exposed α-minimizing face exposedMinFace.
At κ = 0 the weighted-simplex objective collapses to the linear form Σ αᵢ tᵢ.
Proof (Lean source)
The κ = 0 minimizer set is the exposed α-minimizing face. For a simplex budget M, a linear weight vector α, and a candidate point t, t lies in the simplex of budget M and minimizes the linear objective Σᵢ αᵢtᵢ over that simplex if and only if t belongs to the exposed α-minimizing face of the simplex.
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Helpers.WeightedSimplexKKT 6 declarations Given admissible support/multiplier data (S, λ) for the weighted-simplex SOCP with κ > 0, the induced activeSetPoint lies in Δ_M, has support exactly S, weighted squared norm (Mκ / D)² with D = Σ_{h∈S}(λ−αₕ)/βₕ, objectiv
Active-set KKT lemmas (κ > 0)
Given admissible support/multiplier data (S, λ) for the weighted-simplex SOCP with
κ > 0, the induced activeSetPoint lies in Δ_M, has support exactly S, weighted
squared norm (Mκ / D)² with D = Σ_{h∈S}(λ−αₕ)/βₕ, objective value M·λ, and is the
strict minimizer of the SOCP over Δ_M.
The active-set denominator D = Σ_{h∈S} (λ−αₕ)/βₕ is strictly positive: S is nonempty and each summand is positive (λ > αₕ on S, βₕ > 0).
Formal statement
Proof (Lean source)
The active-set point has support exactly S: on S its coordinate is positive, off S it is 0.
Formal statement
Proof (Lean source)
The active-set point lies in the simplex Δ_M.
Formal statement
Proof (Lean source)
Weighted squared norm of the active-set point: Σ βᵢ tᵢ² = (Mκ)² / D², using the admissibility identity Σ_{i∈S}(λ−αᵢ)²/βᵢ = κ².
Formal statement
Proof (Lean source)
Objective value of the active-set point. For a nonnegative total mass M, positive weights on the support S, a positive SOCP scale κ, a nonempty support S, strict activity on S, and the admissibility identity , the objective wsObj evaluated at the induced active-set point equals the closed form .
Formal statement
Proof (Lean source)
Strict minimality of the active-set point (κ > 0). For a positive total mass M, positive coordinate weights β, a positive SOCP scale κ, and a KKT-admissible support/multiplier pair (S, λ), every other point of the simplex has strictly larger objective value than the induced active-set point.
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Tcut 5 declarations For 0 ≤ r < r_cut, X_cut = s_m s_mᵀ is the unique minimizer of F over E_m^blk, the implementability gap vanishes, and the cut design P_cut ∈ P_m^sym attains the implementable optimum.
Sharp cut-corner exactness (thm:cut-corner-exactness)
For 0 ≤ r < r_cut, X_cut = s_m s_mᵀ is the unique minimizer of F over
E_m^blk, the implementability gap vanishes, and the cut design P_cut ∈ P_m^sym
attains the implementable optimum.
The core cutDesign is the same two-point law as the vertex-design helper.
Formal statement
Proof (Lean source)
If x0 is a minimizer of f on S, then the infimum of the objective image is f x0.
Formal statement
Proof (Lean source)
The cut-exactness frontier r_cut(m,a,b,κ) = max 0 (min{2b(a+b)(1 − κ/(a−b)), 2b(2m−2b−κ)}): the largest ratio up to which X_cut stays optimal on the block-symmetric slice, taken as a nonnegative frontier (= 0 on the vacuous cells where the cut region is empty). @realizes r_cut(m,a,b,kappa)(closed form min{2b(a+b)(1−κ/(a−b)), 2b(2m−2b−κ)}; the declared [0,∞) space is PINNED BY CONSTRUCTION via the outer max 0 clamp, so r_cut ∈ [0,∞) holds unconditionally — not merely under the homophily regime. Given 0 ≤ r, the consuming cut region r < r_cut is equivalent to r < min{…}, so the clamp leaves cut_corner_exactness unchanged in strength.) @realizes kappa(carrier ℝ argument kappa; robustness weight entering both branches of the cut frontier; range [0,∞) pinned by 0 ≤ kappa on the consuming theorem cut_corner_exactness)
The low-robustness cut frontier κ_cut(m,a,b) = max 0 (min{a−b, 2(m−b)}): the largest robustness weight below which the cut-exactness region [0, r_cut(m,a,b,κ)) stays nonempty, taken as a nonnegative frontier. @realizes kappa_cut(m,a,b)(AUTHORITATIVE closed form min{a−b, 2(m−b)} clamped by an outer max 0; the derived-phase [0,∞) space is PINNED BY CONSTRUCTION via that clamp, so κ_cut ∈ [0,∞) holds unconditionally — = 0 exactly on the vacuous cells where no cut-exactness region persists (a ≤ b or b ≥ m), and = min{a−b, 2(m−b)} > 0 under the homophily regime with b < m. The range no longer depends on the regime holding.)
Cut-corner exactness. Under two-block homophily, for 0 ≤ r < r_cut(m,a,b,κ) the cut covariance X_cut is the unique minimizer of F_{r,κ} over E_m^blk; the implementability gap is zero; X_cut is the unique minimizer over C_m^pm; and the cut design P_cut ∈ P_m^sym realizes it with X(P_cut) = X_cut. (The ass:balanced-sign-design atom is realized through membership in the block-exchangeable class C_m^pm/P_m^sym, which bundles BalancedDesignClass.)
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Tgap 8 declarations For 0 ≤ κ < κ_gap and r ∈ (r_gap^-, r_gap^+) the spread vertex is the unique relaxed minimizer but violates y+z ≥ 2/m, so Δ_m^± > 0.
Odd-m positive-gap window (thm:gap-window)
For 0 ≤ κ < κ_gap and r ∈ (r_gap^-, r_gap^+) the spread vertex is the unique
relaxed minimizer but violates y+z ≥ 2/m, so Δ_m^± > 0. Even m makes the whole
slice implementable, so the positive gap fails (parity necessity).
The low-robustness gap ceiling κ_gap(m,a,b) = ((2m−a−3b)(a−b)√q)/(a+b).
The cut-frontier value at the gap scale r_cut_gap(m,a,b,κ) = max 0 (2b(a+b)(1 − κ/(a−b))) (the closed form is independent of m); this is the first ((a−b)) branch of the cut-exactness frontier r_cut(m,a,b,κ), active in the low-scale gap regime, taken as a nonnegative frontier. @realizes r_cut(m,a,b,kappa)(gap-scale branch 2b(a+b)(1−κ/(a−b)); the declared [0,∞) space is PINNED BY CONSTRUCTION via the outer max 0 clamp, so r_cut_gap ∈ [0,∞) holds unconditionally, consistent with the r_cut cluster in Tcut.lean.)
Definition (Lean source)
Lower spread frontier R_x^-(m,a,b,κ) = 2b(a+b)(1 + κ/((a−b)√q)).
Upper spread frontier R_x^+(m,a,b,κ) = (a+b)(2m−a−b−κ/√q).
Lower gap-window frontier r_gap^-(m,a,b,κ) = (R_x^- + R_x^+)/2. @realizes r_gap^-(m,a,b,kappa), r_gap^+(m,a,b,kappa)(AUTHORITATIVE carrier of the FIRST component r_gap^- of the pair symbol whose declared space is [0,∞)^2; closed form (R_x^- + R_x^+)/2 with R_x^- = 2b(a+b)(1+κ/((a−b)√q)) and R_x^+ = (a+b)(2m−a−b−κ/√q). The bare closed form is a plain ℝ, NOT nonnegative by construction; the FIRST factor of the [0,∞)^2 range is carried by the CONJUNCTION of this carrier with the companion range lemma rGapFrontiers_nonneg below — which pins 0 ≤ r_gap^- on the consuming window 0 ≤ κ < κ_gap via r_cut_gap = max 0 (…) ≥ 0 < r_gap^- — exactly as implementabilityGap/roundingLossCertificate pair with their *_nonneg lemmas in Basic.lean.)
Upper gap-window frontier r_gap^+(m,a,b,κ) = R_x^+. @realizes r_gap^-(m,a,b,kappa), r_gap^+(m,a,b,kappa)(AUTHORITATIVE carrier of the SECOND component r_gap^+ of the pair symbol whose declared space is [0,∞)^2; closed form R_x^+ = (a+b)(2m−a−b−κ/√q). The bare closed form is a plain ℝ, NOT nonnegative by construction; the SECOND factor of the [0,∞)^2 range is carried by the CONJUNCTION of this carrier with the companion range lemma rGapFrontiers_nonneg below, which pins 0 ≤ r_gap^+ on the consuming window 0 ≤ κ < κ_gap via r_gap^- < r_gap^+ (placing the open gap interval (r_gap^-, r_gap^+) ⊂ [0,∞)).)
Definition (Lean source)
Range lemma for the gap-window frontier pair (r_gap^-, r_gap^+). On the consuming window 0 ≤ κ < κ_gap, under two-block homophily and the low-scale normalization, the frontier pair lands in its core-declared space [0,∞)^2: 0 ≤ r_gap^- and 0 ≤ r_gap^+. This holds because r_cut_gap = max 0 (…) ≥ 0 and the window strictly orders the frontiers r_cut_gap < r_gap^- < r_gap^+ (the ordering proved by gap_window), so both frontiers are positive. Together with the rGapMinus/rGapPlus carrier defs above, this lemma IS the realization of the pair's standing [0,∞)^2 range condition (the bare (R_x^- + R_x^+)/2 and R_x^+ closed forms are plain ℝ, not nonnegative by construction), exactly mirroring how implementabilityGap_nonneg / roundingLossCertificate_nonneg pin the Δ_m^± / ρ_⋆ ranges in Basic.lean. @realizes r_gap^-(m,a,b,kappa), r_gap^+(m,a,b,kappa)(AUTHORITATIVE range clause for the pair symbol's declared space [0,∞)^2: the conjunction 0 ≤ r_gap^- ∧ 0 ≤ r_gap^+ pins BOTH factors on the consuming window 0 ≤ κ < κ_gap, via r_cut_gap = max 0 (…) ≥ 0 < r_gap^- < r_gap^+. This lemma, together with the rGapMinus/rGapPlus carrier defs above, IS the realizing cluster of the pair's standing [0,∞)^2 range condition.)
Formal statement
Proof (Lean source)
Positive-gap window. Under two-block homophily and low-scale: if m is odd, then for every 0 ≤ κ < κ_gap the frontiers are strictly ordered r_cut_gap < r_gap^- < r_gap^+, and for r ∈ (r_gap^-, r_gap^+) the spread vertex is the unique relaxed minimizer of F over E_m^blk but is not ±1 implementable, so Δ_m^±(r,κ) > 0. The oddness is necessary as a separate even-m case (NOT nested under the odd hypothesis, so it does not fire vacuously): for even m the whole block elliptope slice is implementable, hence the claimed positive gap is false.
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Trobust 1 declarations Finite-κ iid exactness holds iff on the affine-balanced locus a+3b=2m, r=2b(a+b).
Robust-corner exactness (thm:robust-corner-exactness)
Finite-κ iid exactness holds iff on the affine-balanced locus a+3b=2m,
r=2b(a+b). On the locus, for every κ > 0, I_n is the unique relaxed minimizer
attained by P_iid; off the locus, I_n is never a finite-κ minimizer but
minimizers converge to I_n as κ → ∞.
Robust-corner exactness. Under two-block homophily: I_n is a minimizer of F_{r,κ} over E_m^blk for some finite κ iff a+3b=2m and r=2b(a+b); on this locus, for every κ > 0, I_n is the unique relaxed minimizer and P_iid ∈ P_m^sym attains it with X(P_iid)=I_n; off the locus I_n is never a finite-κ minimizer, though relaxed minimizers converge (entrywise) to I_n as κ → ∞.
Formal statement
Proof (Lean source)
CausalSmith.Experimentation.EXP_DesignPm1ExactnessBoundaryV1_Research.Tsharp 3 declarations The tight certificate ρ_⋆ = Δ_m^±, computed by the active-set SOCP over the reduced triangle, with the exact zero-loss criterion ρ_⋆ = 0 iff the relaxed argmin meets the implementable slice {y+z ≥ d_m}.
Headline rounding-loss certificate (thm:sharp-rho-star)
The tight certificate ρ_⋆ = Δ_m^±, computed by the active-set SOCP over the
reduced triangle, with the exact zero-loss criterion ρ_⋆ = 0 iff the relaxed
argmin meets the implementable slice {y+z ≥ d_m}. No exact r_star frontier is
asserted (honest open scope).
Reduced-coordinate active-set data α = (c_x/q, c_y, c_z) for the linear change of variables t = (q x, y, z) that carries the reduced triangle T_m onto the scaled simplex Δ_M (M = 2m) and φ onto wsObj α β κ. This is the α fed to lem:weighted-simplex-active-set / lem:weighted-simplex-truncation.
Reduced-coordinate weights β = (1/q, 1, 1) (so β_y = β_z = 1), the β fed to lem:weighted-simplex-active-set / lem:weighted-simplex-truncation under the change of variables t = (q x, y, z).
Sharp ρ_⋆ certificate. Under two-block homophily, the rounding-loss certificate equals the implementability gap (ρ_⋆ = Δ_m^±); the gap is nonnegative (Δ_m^± ≥ 0, its definitional domain [0,∞)); ρ_⋆ = 0 iff the relaxed argmin over T_m meets the implementable slice {y+z ≥ d_m}; for κ > 0 the relaxed minimizer over T_m is unique (active-set uniqueness), and equivalently ρ_⋆ = 0 iff that unique minimizer satisfies y+z ≥ d_m; for κ = 0 the relaxed argmin set is the exposed face on the per-unit α-minimizing coordinates (α = (c_x/q, c_y, c_z)); and for even m (d_m = 0) the certificate vanishes identically. No r_star frontier is characterized.