Documentation

LeanPool.AsymptoticTrianglePacking.Internal.Tight.SharpRound

LeanPool.AsymptoticTrianglePacking.Internal — the tight round with CONCRETE parameters #

LeanPool.AsymptoticTrianglePacking.Internal.exists_tight_round (in LeanPool.AsymptoticTrianglePacking.Internal.Tight.TightRound) is stated with abstract moment bounds Vb, Pb and an abstract coverage rate qlo. Here those abstract data are instantiated in terms of the hypergraph parameters only:

The resulting statement LeanPool.AsymptoticTrianglePacking.Internal.exists_tight_round_of_params is the tight nibble round in the form in which the iteration consumes it: one round, one outcome, a two-sided band around the SAME centre for all but a vertices, and a guaranteed coverage fraction.

placeholder-free and axiom-clean [propext, Classical.choice, Quot.sound].

Concrete moment bounds #

theorem LeanPool.AsymptoticTrianglePacking.Internal.prob_two_covered_le_params {V : Type u_1} [DecidableEq V] {Ω : Type u_2} [MeasureTheory.MeasureSpace Ω] [MeasureTheory.IsProbabilityMeasure MeasureTheory.volume] {H : Finset (Finset V)} {p : ℝ} {Δ κ : ℕ} (ρ : BernoulliRetention H p) (hp0 : 0 ≤ p) (hΔ : ∀ (y : V), Hypergraph.degree H y ≤ Δ) (hκ : ∀ (y z : V), y ≠ z → Hypergraph.codegree H y z ≤ κ) (u u' : V) (huu' : u ≠ u') :
MeasureTheory.volume.real ({ω : Ω | u ∈ Hypergraph.covered (retainedSet H ρ ω)} ∩ {ω : Ω | u' ∈ Hypergraph.covered (retainedSet H ρ ω)}) ≤ ↑Δ ^ 2 * p ^ 2 + ↑κ * p

The uniform pair bound: two vertices are simultaneously covered with probability at most Δ²p² + κp.

theorem LeanPool.AsymptoticTrianglePacking.Internal.centered_second_moment_le_params {V : Type u_1} [DecidableEq V] [Fintype V] {Ω : Type u_2} [MeasureTheory.MeasureSpace Ω] [MeasureTheory.IsProbabilityMeasure MeasureTheory.volume] {H : Finset (Finset V)} {p : ℝ} {r Δ κ : ℕ} (ρ : BernoulliRetention H p) (hp0 : 0 ≤ p) (hp1 : p ≤ 1) (hr1 : 1 ≤ r) (hr : Hypergraph.IsUniform H r) (hΔ : ∀ (y : V), Hypergraph.degree H y ≤ Δ) (hκ : ∀ (y z : V), y ≠ z → Hypergraph.codegree H y z ≤ κ) (v : V) :
∫ (ω : Ω), (lossWeight ρ v ω - lossWeightMean H p v) ^ 2 ≤ ↑κ * ((↑r - 1) * ↑Δ) * (↑Δ * p) + (↑Δ ^ 2 * p ^ 2 + ↑κ * p) * ((↑r - 1) * ↑Δ) ^ 2

The variance of the loss weight in terms of the hypergraph parameters.

theorem LeanPool.AsymptoticTrianglePacking.Internal.integral_pairCount_le_params {V : Type u_1} [DecidableEq V] {Ω : Type u_2} [MeasureTheory.MeasureSpace Ω] [MeasureTheory.IsProbabilityMeasure MeasureTheory.volume] {H : Finset (Finset V)} {p : ℝ} {r Δ κ : ℕ} (ρ : BernoulliRetention H p) (hp0 : 0 ≤ p) (hr1 : 1 ≤ r) (hr : Hypergraph.IsUniform H r) (hΔ : ∀ (y : V), Hypergraph.degree H y ≤ Δ) (hκ : ∀ (y z : V), y ≠ z → Hypergraph.codegree H y z ≤ κ) (v : V) :
∫ (ω : Ω), pairCount ρ v ω ≤ ↑Δ * (↑r - 1) ^ 2 * (↑Δ ^ 2 * p ^ 2 + ↑κ * p)

The mean of the pair count in terms of the hypergraph parameters.

The tight round with concrete parameters #

theorem LeanPool.AsymptoticTrianglePacking.Internal.exists_tight_round_of_params {V : Type u_1} [DecidableEq V] [Fintype V] {Ω : Type u_2} [MeasureTheory.MeasureSpace Ω] [MeasureTheory.IsProbabilityMeasure MeasureTheory.volume] {H : Finset (Finset V)} {p : ℝ} {r Δ δ κ : ℕ} (ρ : BernoulliRetention H p) (hp0 : 0 ≤ p) (hp1 : p ≤ 1) (hr1 : 1 ≤ r) (hr : Hypergraph.IsUniform H r) (hΔ : ∀ (y : V), Hypergraph.degree H y ≤ Δ) (hδ : ∀ (y : V), δ ≤ Hypergraph.degree H y) (hκ : ∀ (y z : V), y ≠ z → Hypergraph.codegree H y z ≤ κ) {t s a : ℝ} (ht : 0 < t) (hs : 0 < s) (ha : 0 < a) (hN : 0 < Fintype.card V) (hsmall : ↑(Fintype.card V) * ((↑κ * ((↑r - 1) * ↑Δ) * (↑Δ * p) + (↑Δ ^ 2 * p ^ 2 + ↑κ * p) * ((↑r - 1) * ↑Δ) ^ 2) / t ^ 2 + ↑Δ * (↑r - 1) ^ 2 * (↑Δ ^ 2 * p ^ 2 + ↑κ * p) / s) * (2 - ↑δ * (p * (1 - p) ^ (r * Δ))) < a * (↑δ * (p * (1 - p) ^ (r * Δ)))) :
∃ (ω : Ω) (B : Finset V), ↑B.card < a ∧ (∀ v ∉ B, ↑(Hypergraph.degree H v) - lossWeightMean H p v - t ≤ ↑(safeDegree H (Hypergraph.covered (retainedSet H ρ ω)) v) ∧ ↑(safeDegree H (Hypergraph.covered (retainedSet H ρ ω)) v) ≤ ↑(Hypergraph.degree H v) - lossWeightMean H p v + t + s) ∧ ↑(Fintype.card V) * (↑δ * (p * (1 - p) ^ (r * Δ))) / 2 < ↑(Hypergraph.covered (retainedSet H ρ ω)).card

The tight nibble round, concrete form.

For an r-uniform hypergraph whose degrees lie in [δ, Δ] and whose codegrees are at most κ, one Bernoulli round with retention probability p admits an outcome which

  • covers more than a qlo/2-fraction of the vertex set, where qlo = δ·p·(1−p)^{rΔ}, and
  • leaves every vertex outside an exceptional set of size < a with its safe degree inside the two-sided band deg(v) − 𝔼[loss(v)] ± (t, t+s).

All the moment data are explicit functions of r, Δ, κ, p; the only requirement is the smallness condition hsmall, which in the nibble regime p = γ/Δ is satisfied for t ≍ ξ γ Δ, s ≍ ξ γ Δ and a = θ·|V| once γ is small.

LeanPool.AsymptoticTrianglePacking.Internal — one round preserves a TIGHT degree band on the #

residual

LeanPool.AsymptoticTrianglePacking.Internal.exists_tight_round_of_params produces, for one Bernoulli round, an outcome whose SAFE degrees sit in a two-sided band around deg(v) − 𝔼[loss(v)]. Here that is converted into the form the iteration needs: a bound on the DEGREES OF THE RESIDUAL HYPERGRAPH, valid for every uncovered vertex outside a small exceptional set, with the band expressed purely in the parameters r, Δ, δ, κ, p.

The two ingredients are

The resulting band has width (Δ − δ) + ((r−1)Δq_hi − (r−1)δq_lo) + 2t + s. In the nibble regime p = γ/Δ, Δ ≤ (1+μ)δ with μ, γ → 0 this is (1 + o(1)) times the new mean degree — i.e. the round MAINTAINS near-regularity, which is exactly what the refuted wide-band (U/L ≤ 8) peeling cannot do.

placeholder-free and axiom-clean [propext, Classical.choice, Quot.sound].

Squeezing the mean loss #

theorem LeanPool.AsymptoticTrianglePacking.Internal.lossWeightMean_le {V : Type u_1} [DecidableEq V] [Fintype V] {H : Finset (Finset V)} {p : ℝ} {r : ℕ} {qhi : ℝ} (hr : Hypergraph.IsUniform H r) (hr1 : 1 ≤ r) (hqhi : ∀ (u : V), coverRate H p u ≤ qhi) (v : V) :
lossWeightMean H p v ≤ (↑r - 1) * ↑(Hypergraph.degree H v) * qhi

The mean loss is at most (r−1)·deg(v)·q_hi.

theorem LeanPool.AsymptoticTrianglePacking.Internal.lossWeightMean_ge {V : Type u_1} [DecidableEq V] [Fintype V] {H : Finset (Finset V)} {p : ℝ} {r : ℕ} {qlo : ℝ} (hr : Hypergraph.IsUniform H r) (hr1 : 1 ≤ r) (hqlo : ∀ (u : V), qlo ≤ coverRate H p u) (v : V) :
(↑r - 1) * ↑(Hypergraph.degree H v) * qlo ≤ lossWeightMean H p v

The mean loss is at least (r−1)·deg(v)·q_lo.

The residual band #

theorem LeanPool.AsymptoticTrianglePacking.Internal.exists_round_residual_band {V : Type u_1} [DecidableEq V] [Fintype V] {Ω : Type u_2} [MeasureTheory.MeasureSpace Ω] [MeasureTheory.IsProbabilityMeasure MeasureTheory.volume] {H : Finset (Finset V)} {p : ℝ} {r Δ δ κ : ℕ} (ρ : BernoulliRetention H p) (hp0 : 0 ≤ p) (hp1 : p ≤ 1) (hr1 : 1 ≤ r) (hr : Hypergraph.IsUniform H r) (hΔ : ∀ (y : V), Hypergraph.degree H y ≤ Δ) (hδ : ∀ (y : V), δ ≤ Hypergraph.degree H y) (hκ : ∀ (y z : V), y ≠ z → Hypergraph.codegree H y z ≤ κ) {t s a : ℝ} (ht : 0 < t) (hs : 0 < s) (ha : 0 < a) (hN : 0 < Fintype.card V) (hsmall : ↑(Fintype.card V) * ((↑κ * ((↑r - 1) * ↑Δ) * (↑Δ * p) + (↑Δ ^ 2 * p ^ 2 + ↑κ * p) * ((↑r - 1) * ↑Δ) ^ 2) / t ^ 2 + ↑Δ * (↑r - 1) ^ 2 * (↑Δ ^ 2 * p ^ 2 + ↑κ * p) / s) * (2 - ↑δ * (p * (1 - p) ^ (r * Δ))) < a * (↑δ * (p * (1 - p) ^ (r * Δ)))) :
∃ R' ⊆ H, ∃ (B : Finset V), ↑B.card < a ∧ (∀ v ∉ B, v ∉ Hypergraph.covered R' → ↑δ - (↑r - 1) * ↑Δ * (↑Δ * p) - t ≤ ↑(Hypergraph.degree (Hypergraph.residual H R') v) ∧ ↑(Hypergraph.degree (Hypergraph.residual H R') v) ≤ ↑Δ - (↑r - 1) * ↑δ * (↑δ * (p * (1 - p) ^ (r * Δ))) + t + s) ∧ ↑(Fintype.card V) * (↑δ * (p * (1 - p) ^ (r * Δ))) / 2 < ↑(Hypergraph.covered R').card

One round maintains a tight degree band.

For an r-uniform hypergraph with degrees in [δ, Δ] and codegrees ≤ κ, there is a retained subfamily R' ⊆ H (an outcome of the Bernoulli round) and an exceptional set B of size < a such that every vertex that is left uncovered and lies outside B has its degree in the RESIDUAL hypergraph inside the explicit band

δ − (r−1)Δq_hi − t ≤ deg_res(v) ≤ Δ − (r−1)δq_lo + t + s,

with q_hi = Δp and q_lo = δp(1−p)^{rΔ}; moreover the round covers more than a q_lo/2-fraction of the vertex set.

LeanPool.AsymptoticTrianglePacking.Internal — the tight round with a CHEBYSHEV coverage guarantee #

LeanPool.AsymptoticTrianglePacking.Internal.exists_tight_round_on extracts a good outcome by making two failure probabilities add up to less than one:

Because the second bound is only 1 − q/2, the first has to be < q/2 ≈ γ/2; with a = θN this forces Vb/t² + Pb/s ≤ θγ, hence (since Pb ≈ Δγ²) s ≳ γΔ/θ. A band of width ≍ γΔ cannot be iterated: over the ≍ γ^{-1}log(1/β) rounds of a nibble it accumulates to a relative error ≍ log(1/β)/θ ≫ 1.

Here the coverage is instead controlled by CHEBYSHEV, using the variance bound LeanPool.AsymptoticTrianglePacking.Internal.coveredCount_variance_le. The coverage failure probability becomes 4·Var/Q², which is ≤ 1/2 under hypotheses on the vertex count and the codegree ALONE. The badness budget is then a constant rather than γ, so Vb/t² + Pb/s ≤ θ/2 suffices and one may take

s ≍ Δγ²/θ and t ≍ γ²Δ,

i.e. deviations of relative size γ², whose accumulation over γ^{-1}log(1/β) rounds is ≍ γ·log(1/β) → 0. This is the form of the round the iteration needs.

placeholder-free and axiom-clean [propext, Classical.choice, Quot.sound].

theorem LeanPool.AsymptoticTrianglePacking.Internal.safeDegree_band_of_tolerances {V : Type u_1} [DecidableEq V] [Fintype V] {Ω : Type u_2} [MeasureTheory.MeasureSpace Ω] {H : Finset (Finset V)} {p : ℝ} (ρ : BernoulliRetention H p) (v : V) (ω : Ω) {t s : ℝ} (hloss : |lossWeight ρ v ω - lossWeightMean H p v| < t) (hpair : pairCount ρ v ω < s) :

The deterministic band. If the loss weight of v is within t of its mean and the pair count of v is below s, then the safe degree of v lies in the two-sided band of width 2t + s around deg(v) − 𝔼[loss(v)].

theorem LeanPool.AsymptoticTrianglePacking.Internal.exists_tight_round_cheb {V : Type u_1} [DecidableEq V] [Fintype V] {Ω : Type u_2} [MeasureTheory.MeasureSpace Ω] [MeasureTheory.IsProbabilityMeasure MeasureTheory.volume] {H : Finset (Finset V)} {p : ℝ} (ρ : BernoulliRetention H p) {t s a Vb Pb Q Cvar : ℝ} (ht : 0 < t) (hs : 0 < s) (ha : 0 < a) (hQ : 0 < Q) (hVb : ∀ (v : V), ∫ (ω : Ω), (lossWeight ρ v ω - lossWeightMean H p v) ^ 2 ≤ Vb) (hPb : ∀ (v : V), ∫ (ω : Ω), pairCount ρ v ω ≤ Pb) (hmean : Q ≤ ∑ v : V, coverRate H p v) (hvar : ∫ (ω : Ω), (↑(Hypergraph.covered (retainedSet H ρ ω)).card - ∑ v : V, coverRate H p v) ^ 2 ≤ Cvar) (hsmall : ↑(Fintype.card V) * (Vb / t ^ 2 + Pb / s) / a + Cvar / (Q / 2) ^ 2 < 1) :
∃ (ω : Ω) (B : Finset V), ↑B.card < a ∧ (∀ v ∉ B, ↑(Hypergraph.degree H v) - lossWeightMean H p v - t ≤ ↑(safeDegree H (Hypergraph.covered (retainedSet H ρ ω)) v) ∧ ↑(safeDegree H (Hypergraph.covered (retainedSet H ρ ω)) v) ≤ ↑(Hypergraph.degree H v) - lossWeightMean H p v + t + s) ∧ Q / 2 < ↑(Hypergraph.covered (retainedSet H ρ ω)).card

The tight round with Chebyshev coverage.

There is an outcome of the nibble round which

  • leaves fewer than a vertices outside the two-sided safe-degree band of width 2t + s around deg(v) − 𝔼[loss(v)], and
  • covers more than Q/2 vertices,

provided the Markov badness bound N(Vb/t² + Pb/s)/a and the Chebyshev coverage bound Cvar/(Q/2)² add up to less than 1.

Compared with LeanPool.AsymptoticTrianglePacking.Internal.exists_tight_round_on, the coverage failure probability is Cvar/(Q/2)² instead of 1 − q/2: the badness budget is a constant instead of O(q).

LeanPool.AsymptoticTrianglePacking.Internal — the Chebyshev tight round in explicit hypergraph #

parameters

This file instantiates LeanPool.AsymptoticTrianglePacking.Internal.exists_tight_round_cheb with the codegree-tightened moment data of LeanPool.AsymptoticTrianglePacking.Internal.Tight.PairExcessCodegree and converts it into the form the iteration consumes: a bound on the DEGREES OF THE RESIDUAL hypergraph for every uncovered vertex outside a small exceptional set, together with a coverage guarantee.

Writing N = |V|, q_lo = δ·p(1−p)^{rΔ}, q_hi = Δp and

ε₂ = κp + 4r²κΔ²p³, Vb = κ(r−1)Δ·Δp + ε₂·((r−1)Δ)², Pb = Δ(r−1)²(Δ²p² + κp), Cvar = N·q_hi + N²·ε₂,

the single hypothesis is

N(Vb/t² + Pb/s)/a + Cvar/(N q_lo/2)² < 1.

In the nibble regime p = γ/((r−1)Δ), κ = μΔ, Δ ≍ δ ≍ d, a = θN, t = s = γ²d:

All four terms are < 1/4 once μ ≤ c(r)θγ³, d ≥ d₀(r, θ) and N ≥ 16/γ — and the tolerances t = s = γ²d are SECOND order in γ, hence summable over the ≍ γ^{-1}log(1/β) rounds of a nibble. This is exactly what the Markov-coverage round LeanPool.AsymptoticTrianglePacking.Internal.exists_round_residual_band cannot provide (there s ≳ γd/θ, first order in γ).

placeholder-free and axiom-clean [propext, Classical.choice, Quot.sound].

theorem LeanPool.AsymptoticTrianglePacking.Internal.exists_tight_round_cheb_of_params {V : Type u_1} [DecidableEq V] [Fintype V] {Ω : Type u_2} [MeasureTheory.MeasureSpace Ω] [MeasureTheory.IsProbabilityMeasure MeasureTheory.volume] {H : Finset (Finset V)} {p : ℝ} {r Δ δ κ : ℕ} (ρ : BernoulliRetention H p) (hp0 : 0 < p) (hp1 : p < 1) (hr1 : 1 ≤ r) (hr : Hypergraph.IsUniform H r) (hΔ : ∀ (y : V), Hypergraph.degree H y ≤ Δ) (hδ : ∀ (y : V), δ ≤ Hypergraph.degree H y) (hδ0 : 0 < δ) (hκ : ∀ (y z : V), y ≠ z → Hypergraph.codegree H y z ≤ κ) {t s a : ℝ} (ht : 0 < t) (hs : 0 < s) (ha : 0 < a) (hN : 0 < Fintype.card V) (hsmall : ↑(Fintype.card V) * ((↑κ * ((↑r - 1) * ↑Δ) * (↑Δ * p) + (↑κ * p + 4 * ↑r ^ 2 * ↑κ * ↑Δ ^ 2 * p ^ 3) * ((↑r - 1) * ↑Δ) ^ 2) / t ^ 2 + ↑Δ * (↑r - 1) ^ 2 * (↑Δ ^ 2 * p ^ 2 + ↑κ * p) / s) / a + (↑(Fintype.card V) * (↑Δ * p) + ↑(Fintype.card V) ^ 2 * (↑κ * p + 4 * ↑r ^ 2 * ↑κ * ↑Δ ^ 2 * p ^ 3)) / (↑(Fintype.card V) * (↑δ * (p * (1 - p) ^ (r * Δ))) / 2) ^ 2 < 1) :
∃ (ω : Ω) (B : Finset V), ↑B.card < a ∧ (∀ v ∉ B, ↑(Hypergraph.degree H v) - lossWeightMean H p v - t ≤ ↑(safeDegree H (Hypergraph.covered (retainedSet H ρ ω)) v) ∧ ↑(safeDegree H (Hypergraph.covered (retainedSet H ρ ω)) v) ≤ ↑(Hypergraph.degree H v) - lossWeightMean H p v + t + s) ∧ ↑(Fintype.card V) * (↑δ * (p * (1 - p) ^ (r * Δ))) / 2 < ↑(Hypergraph.covered (retainedSet H ρ ω)).card

The Chebyshev tight round in explicit parameters. For an r-uniform hypergraph with degrees in [δ, Δ] and codegrees ≤ κ, one Bernoulli round with retention probability p has an outcome covering more than N·q_lo/2 vertices and leaving all but < a vertices with a safe degree in the band deg(v) − 𝔼[loss(v)] ± (t, t+s).

theorem LeanPool.AsymptoticTrianglePacking.Internal.exists_round_residual_band_cheb {V : Type u_1} [DecidableEq V] [Fintype V] {Ω : Type u_2} [MeasureTheory.MeasureSpace Ω] [MeasureTheory.IsProbabilityMeasure MeasureTheory.volume] {H : Finset (Finset V)} {p : ℝ} {r Δ δ κ : ℕ} (ρ : BernoulliRetention H p) (hp0 : 0 < p) (hp1 : p < 1) (hr1 : 1 ≤ r) (hr : Hypergraph.IsUniform H r) (hΔ : ∀ (y : V), Hypergraph.degree H y ≤ Δ) (hδ : ∀ (y : V), δ ≤ Hypergraph.degree H y) (hδ0 : 0 < δ) (hκ : ∀ (y z : V), y ≠ z → Hypergraph.codegree H y z ≤ κ) {t s a : ℝ} (ht : 0 < t) (hs : 0 < s) (ha : 0 < a) (hN : 0 < Fintype.card V) (hsmall : ↑(Fintype.card V) * ((↑κ * ((↑r - 1) * ↑Δ) * (↑Δ * p) + (↑κ * p + 4 * ↑r ^ 2 * ↑κ * ↑Δ ^ 2 * p ^ 3) * ((↑r - 1) * ↑Δ) ^ 2) / t ^ 2 + ↑Δ * (↑r - 1) ^ 2 * (↑Δ ^ 2 * p ^ 2 + ↑κ * p) / s) / a + (↑(Fintype.card V) * (↑Δ * p) + ↑(Fintype.card V) ^ 2 * (↑κ * p + 4 * ↑r ^ 2 * ↑κ * ↑Δ ^ 2 * p ^ 3)) / (↑(Fintype.card V) * (↑δ * (p * (1 - p) ^ (r * Δ))) / 2) ^ 2 < 1) :
∃ R' ⊆ H, ∃ (B : Finset V), ↑B.card < a ∧ (∀ v ∉ B, v ∉ Hypergraph.covered R' → ↑δ - (↑r - 1) * ↑Δ * (↑Δ * p) - t ≤ ↑(Hypergraph.degree (Hypergraph.residual H R') v) ∧ ↑(Hypergraph.degree (Hypergraph.residual H R') v) ≤ ↑Δ - (↑r - 1) * ↑δ * (↑δ * (p * (1 - p) ^ (r * Δ))) + t + s) ∧ ↑(Fintype.card V) * (↑δ * (p * (1 - p) ^ (r * Δ))) / 2 < ↑(Hypergraph.covered R').card

One Chebyshev round maintains a tight degree band on the residual.

Every vertex left uncovered and outside an exceptional set of size < a has its residual degree in the band

δ − (r−1)Δq_hi − t ≤ deg_res(v) ≤ Δ − (r−1)δq_lo + t + s,

and the round covers more than N·q_lo/2 vertices.

LeanPool.AsymptoticTrianglePacking.Internal — existence of a Bernoulli retention space #

Standalone, Mathlib-only. The measure-theoretic prerequisite for the nibble iteration (step 2): for any finite hypergraph H on a finite vertex type and any retention probability p ∈ [0,1], there EXISTS a probability space carrying a BernoulliRetention on H at p — an independent family of events A e (e retained) each of probability p.

Standard construction: Ω := Finset V → Bool (finite, since V is a Fintype) with the product Bernoulli(p) measure Measure.pi (fun _ => (Bernoulli) p); A e := {ω | ω e = true}. The coordinate events are independent (product measure) and each has probability p.

Must be placeholder-free and axiom-clean [propext, Classical.choice, Quot.sound].

Existence of a Bernoulli retention. For any finite hypergraph H on a finite vertex type and any p ∈ [0,1], there is a probability space carrying a BernoulliRetention on H at p.

LeanPool.AsymptoticTrianglePacking.Internal — a nibble round with FULLY EXPLICIT parameters #

LeanPool.AsymptoticTrianglePacking.Internal.exists_round_residual_band_cheb produces a good round outcome under one smallness hypothesis relating the tolerances t, s, the exceptional budget a and the moment data. Here that hypothesis is DISCHARGED for a concrete parameter choice, giving an unconditional round.

For a round parameter γ ∈ (0, 1/2] and an exceptional fraction θ ∈ (0,1] put

p = γ/(rΔ), t = γ²Δ, s = 16γ²Δ/θ, a = θN.

If the hypergraph is r-uniform (r ≥ 2) with degrees in [δ, Δ], 1 ≤ δ, Δ ≤ 2δ, codegrees at most κ ≤ θγ³Δ/(1280 r) and N = |V| ≥ 512r/γ, then the Markov badness bound and the Chebyshev coverage bound add up to at most 3/4 (cheb_smallness_explicit), so one round leaves all but < θN of the surviving vertices with residual degree in

[δ − γΔ − γ²Δ, Δ − (r−1)δγ/(4r) + γ²Δ + 16γ²Δ/θ]

while covering more than Nγ/(8r) vertices (exists_round_explicit).

The point is that BOTH tolerances are of second order in γ (γ²Δ, up to the constant 16/θ), whereas the first-order drop is ≍ γΔ. That is what makes the round iterable: over the ≍ γ^{-1}log(1/β) rounds of a nibble the tolerances accumulate to ≍ γ·log(1/β)/θ → 0, while with the Markov-coverage round (LeanPool.AsymptoticTrianglePacking.Internal.exists_round_residual_band) the tolerance s is necessarily first order in γ and the accumulation does not vanish.

placeholder-free and axiom-clean [propext, Classical.choice, Quot.sound].

The arithmetic core #

All the estimates below are inequalities between real numbers; R is the uniformity, D the degree ceiling, dd the degree floor, k the codegree ceiling, N the number of vertices and L = (1−p)^{rΔ} the conflict factor of the covering rate.

theorem LeanPool.AsymptoticTrianglePacking.Internal.cheb_qlo_explicit {R D dd γ L p : ℝ} (hR : 2 ≤ R) (hD : 1 ≤ D) (hdd1 : 1 ≤ dd) (hDdd : D ≤ 2 * dd) (hγ0 : 0 < γ) (hL0 : 1 / 2 ≤ L) (hp : p = γ / (R * D)) :
γ / (4 * R) ≤ dd * (p * L)

The covering-rate floor for the explicit parameters: δ·p·L ≥ γ/(4r).

theorem LeanPool.AsymptoticTrianglePacking.Internal.cheb_smallness_explicit {R D dd k N γ θ L p t s a : ℝ} (hR : 2 ≤ R) (hD : 1 ≤ D) (hdd1 : 1 ≤ dd) (hDdd : D ≤ 2 * dd) (hk0 : 0 ≤ k) (hγ0 : 0 < γ) (hγ1 : γ ≤ 1 / 2) (hθ0 : 0 < θ) (hθ1 : θ ≤ 1) (hL0 : 1 / 2 ≤ L) (hk : k ≤ θ * γ ^ 3 * D / (1280 * R)) (hN : 512 * R / γ ≤ N) (hp : p = γ / (R * D)) (ht : t = γ ^ 2 * D) (hs : s = 16 * γ ^ 2 * D / θ) (ha : a = θ * N) :
N * ((k * ((R - 1) * D) * (D * p) + (k * p + 4 * R ^ 2 * k * D ^ 2 * p ^ 3) * ((R - 1) * D) ^ 2) / t ^ 2 + D * (R - 1) ^ 2 * (D ^ 2 * p ^ 2 + k * p) / s) / a + (N * (D * p) + N ^ 2 * (k * p + 4 * R ^ 2 * k * D ^ 2 * p ^ 3)) / (N * (dd * (p * L)) / 2) ^ 2 < 1

The smallness condition of the Chebyshev round holds for the explicit parameter choice. The Markov badness bound is at most 1/4 and the Chebyshev coverage bound at most 1/2.

The round #

theorem LeanPool.AsymptoticTrianglePacking.Internal.exists_round_explicit {V : Type u} [Fintype V] [DecidableEq V] {H : Finset (Finset V)} {r Δ δ κ : ℕ} {γ θ : ℝ} (hr2 : 2 ≤ r) (hγ0 : 0 < γ) (hγ1 : γ ≤ 1 / 2) (hθ0 : 0 < θ) (hθ1 : θ ≤ 1) (hr : Hypergraph.IsUniform H r) (hΔ : ∀ (y : V), Hypergraph.degree H y ≤ Δ) (hδ : ∀ (y : V), δ ≤ Hypergraph.degree H y) (hδ1 : 1 ≤ δ) (hΔδ : ↑Δ ≤ 2 * ↑δ) (hκ : ∀ (y z : V), y ≠ z → Hypergraph.codegree H y z ≤ κ) (hκsmall : ↑κ ≤ θ * γ ^ 3 * ↑Δ / (1280 * ↑r)) (hNbig : 512 * ↑r / γ ≤ ↑(Fintype.card V)) :
∃ R' ⊆ H, ∃ (B : Finset V), ↑B.card < θ * ↑(Fintype.card V) ∧ (∀ v ∉ B, v ∉ Hypergraph.covered R' → ↑δ - γ * ↑Δ - γ ^ 2 * ↑Δ ≤ ↑(Hypergraph.degree (Hypergraph.residual H R') v) ∧ ↑(Hypergraph.degree (Hypergraph.residual H R') v) ≤ ↑Δ - (↑r - 1) * ↑δ * (γ / (4 * ↑r)) + γ ^ 2 * ↑Δ + 16 * γ ^ 2 * ↑Δ / θ) ∧ ↑(Fintype.card V) * γ / (8 * ↑r) < ↑(Hypergraph.covered R').card

A nibble round with explicit parameters.

For r ≥ 2, γ ∈ (0,1/2], θ ∈ (0,1], an r-uniform hypergraph with degrees in [δ, Δ], 1 ≤ δ, Δ ≤ 2δ, codegrees ≤ κ ≤ θγ³Δ/(1280r) and |V| ≥ 512r/γ, there is a retained subfamily R' ⊆ H and an exceptional set B of fewer than θ|V| vertices such that

  • every vertex outside B that the round leaves uncovered has residual degree in [δ − γΔ − γ²Δ, Δ − (r−1)δγ/(4r) + γ²Δ + 16γ²Δ/θ], and
  • the round covers more than |V|γ/(8r) vertices.

Iterable tight-band round #

This module establishes the one-round estimates used by the finite near-regular hypergraph nibble. It packages retention, concentration, degree-band, codegree, and cover-rate bounds in a form that can be iterated by the schedule.

The iterable (sharp) nibble round.

For uniformity r ≥ 2 and free parameters

  • γ — the round rate (retention p = γ/(rΔ)),
  • ε — the relative tolerance: both band tolerances are ε·γΔ, a factor ε below the first-order per-round gain ≍ γΔ,
  • θ — the exceptional fraction: at most θ|V| vertices leave the band,
  • α — the guaranteed relative size of the live set A,

there are a degree threshold D₀ and a codegree factor c₀ such that every r-uniform hypergraph K with

  • a GLOBAL degree ceiling Δ,
  • a degree floor δ on the live set A, with Δ ≤ 2δ,
  • codegrees at most κ ≤ c₀Δ,
  • Δ ≥ D₀, |V| ≥ D₀ and |A| ≥ α|V|,

admits a retained set R' ⊆ K and an exceptional set B, |B| ≤ θ|V|, such that

  • every live, uncovered v ∉ B has residual degree at least δ − ((r−1)/r)γΔ − εγΔ and at most Δ − ((r−1)/r)·γ·(δ − lost(v))·δ·(1−γ)/Δ + εγΔ, where lost(v) = lostDegree K Aᶜ v counts the edges at v leaving A, and
  • the round covers at least a γ/(8r) fraction of A.
Equations
  • One or more equations did not get rendered due to their size.
Instances For

    The iterable (sharp) nibble round, packaged: for every uniformity and every choice of the four free parameters there are a degree threshold D₀ and a codegree factor c₀ for which LeanPool.AsymptoticTrianglePacking.Internal.SharpRoundFor holds.

    Equations
    • One or more equations did not get rendered due to their size.
    Instances For